blob: 3ce6b0d9785697d3f86fa44ed845edf4d73d0ca8 [file] [log] [blame]
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001/*
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
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080017#ifndef ANDROID_SERVERS_CAMERA3DEVICE_H
18#define ANDROID_SERVERS_CAMERA3DEVICE_H
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080019
20#include <utils/Condition.h>
21#include <utils/Errors.h>
22#include <utils/List.h>
23#include <utils/Mutex.h>
24#include <utils/Thread.h>
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070025#include <utils/KeyedVector.h>
26#include <hardware/camera3.h>
Jianing Weicb0652e2014-03-12 18:29:36 -070027#include <camera/CaptureResult.h>
Jianing Wei2d6bb3f2014-04-11 10:00:31 -070028#include <camera/camera2/ICameraDeviceUser.h>
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080029
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070030#include "common/CameraDeviceBase.h"
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -070031#include "device3/StatusTracker.h"
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080032
33/**
34 * Function pointer types with C calling convention to
35 * use for HAL callback functions.
36 */
37extern "C" {
38 typedef void (callbacks_process_capture_result_t)(
39 const struct camera3_callback_ops *,
40 const camera3_capture_result_t *);
41
42 typedef void (callbacks_notify_t)(
43 const struct camera3_callback_ops *,
44 const camera3_notify_msg_t *);
45}
46
47namespace android {
48
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070049namespace camera3 {
50
51class Camera3Stream;
52class Camera3ZslStream;
53class Camera3OutputStreamInterface;
54class Camera3StreamInterface;
55
56}
57
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080058/**
Zhijun He95dd5ba2014-03-26 18:18:00 -070059 * CameraDevice for HAL devices with version CAMERA_DEVICE_API_VERSION_3_0 or higher.
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080060 */
61class Camera3Device :
62 public CameraDeviceBase,
63 private camera3_callback_ops {
64 public:
Ruben Brunkc78ac262015-08-13 17:58:46 -070065
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080066 Camera3Device(int id);
67
68 virtual ~Camera3Device();
69
70 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080071 * CameraDeviceBase interface
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080072 */
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080073
Igor Murashkin71381052013-03-04 14:53:08 -080074 virtual int getId() const;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080075
76 // Transitions to idle state on success.
Yin-Chia Yehe074a932015-01-30 10:29:02 -080077 virtual status_t initialize(CameraModule *module);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080078 virtual status_t disconnect();
79 virtual status_t dump(int fd, const Vector<String16> &args);
80 virtual const CameraMetadata& info() const;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080081
82 // Capture and setStreamingRequest will configure streams if currently in
83 // idle state
Jianing Weicb0652e2014-03-12 18:29:36 -070084 virtual status_t capture(CameraMetadata &request, int64_t *lastFrameNumber = NULL);
85 virtual status_t captureList(const List<const CameraMetadata> &requests,
86 int64_t *lastFrameNumber = NULL);
87 virtual status_t setStreamingRequest(const CameraMetadata &request,
88 int64_t *lastFrameNumber = NULL);
89 virtual status_t setStreamingRequestList(const List<const CameraMetadata> &requests,
90 int64_t *lastFrameNumber = NULL);
91 virtual status_t clearStreamingRequest(int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080092
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080093 virtual status_t waitUntilRequestReceived(int32_t requestId, nsecs_t timeout);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080094
95 // Actual stream creation/deletion is delayed until first request is submitted
96 // If adding streams while actively capturing, will pause device before adding
Zhijun He28c9b6f2014-08-08 12:00:47 -070097 // stream, reconfiguring device, and unpausing.
Eino-Ville Talvala727d1722015-06-09 13:44:19 -070098 virtual status_t createStream(sp<Surface> consumer,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -080099 uint32_t width, uint32_t height, int format,
Yin-Chia Yehb97babb2015-03-12 13:42:44 -0700100 android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id);
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700101 virtual status_t createInputStream(
102 uint32_t width, uint32_t height, int format,
103 int *id);
Igor Murashkin2fba5842013-04-22 14:03:54 -0700104 virtual status_t createZslStream(
105 uint32_t width, uint32_t height,
106 int depth,
107 /*out*/
108 int *id,
109 sp<camera3::Camera3ZslStream>* zslStream);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800110 virtual status_t createReprocessStreamFromStream(int outputId, int *id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800111
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800112 virtual status_t getStreamInfo(int id,
Eino-Ville Talvalad46a6b92015-05-14 17:26:24 -0700113 uint32_t *width, uint32_t *height,
114 uint32_t *format, android_dataspace *dataSpace);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800115 virtual status_t setStreamTransform(int id, int transform);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800116
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800117 virtual status_t deleteStream(int id);
118 virtual status_t deleteReprocessStream(int id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800119
Zhijun He1fa89992015-06-01 15:44:31 -0700120 virtual status_t configureStreams(bool isConstraiedHighSpeed = false);
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700121 virtual status_t getInputBufferProducer(
122 sp<IGraphicBufferProducer> *producer);
Igor Murashkine2d167e2014-08-19 16:19:59 -0700123
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800124 virtual status_t createDefaultRequest(int templateId, CameraMetadata *request);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800125
126 // Transitions to the idle state on success
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800127 virtual status_t waitUntilDrained();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800128
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800129 virtual status_t setNotifyCallback(NotificationListener *listener);
Eino-Ville Talvala46910bd2013-07-18 19:15:17 -0700130 virtual bool willNotify3A();
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800131 virtual status_t waitForNextFrame(nsecs_t timeout);
Jianing Weicb0652e2014-03-12 18:29:36 -0700132 virtual status_t getNextResult(CaptureResult *frame);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800133
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800134 virtual status_t triggerAutofocus(uint32_t id);
135 virtual status_t triggerCancelAutofocus(uint32_t id);
136 virtual status_t triggerPrecaptureMetering(uint32_t id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800137
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800138 virtual status_t pushReprocessBuffer(int reprocessStreamId,
139 buffer_handle_t *buffer, wp<BufferReleasedListener> listener);
140
Jianing Weicb0652e2014-03-12 18:29:36 -0700141 virtual status_t flush(int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700142
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700143 virtual status_t prepare(int streamId);
144
Eino-Ville Talvalab25e3c82015-07-15 16:04:27 -0700145 virtual status_t tearDown(int streamId);
146
Ruben Brunkc78ac262015-08-13 17:58:46 -0700147 virtual status_t prepare(int maxCount, int streamId);
148
Zhijun He204e3292014-07-14 17:09:23 -0700149 virtual uint32_t getDeviceVersion();
150
Zhijun He28c9b6f2014-08-08 12:00:47 -0700151 virtual ssize_t getJpegBufferSize(uint32_t width, uint32_t height) const;
Eino-Ville Talvala95a1d0f2015-08-11 15:08:53 -0700152 ssize_t getPointCloudBufferSize() const;
Zhijun He28c9b6f2014-08-08 12:00:47 -0700153
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700154 // Methods called by subclasses
155 void notifyStatus(bool idle); // updates from StatusTracker
156
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800157 private:
Igor Murashkin1e479c02013-09-06 16:55:14 -0700158 static const size_t kDumpLockAttempts = 10;
159 static const size_t kDumpSleepDuration = 100000; // 0.10 sec
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700160 static const nsecs_t kShutdownTimeout = 5000000000; // 5 sec
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700161 static const nsecs_t kActiveTimeout = 500000000; // 500 ms
Chien-Yu Chenc96ac8d2015-08-12 16:46:24 -0700162 static const size_t kInFlightWarnLimit = 20;
163 static const size_t kInFlightWarnLimitHighSpeed = 256; // batch size 32 * pipe depth 8
164
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700165 struct RequestTrigger;
Zhijun Hef7da0962014-04-24 13:27:56 -0700166 // minimal jpeg buffer size: 256KB + blob header
167 static const ssize_t kMinJpegBufferSize = 256 * 1024 + sizeof(camera3_jpeg_blob);
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700168 // Constant to use for stream ID when one doesn't exist
169 static const int NO_STREAM = -1;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800170
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700171 // A lock to enforce serialization on the input/configure side
172 // of the public interface.
173 // Only locked by public methods inherited from CameraDeviceBase.
174 // Not locked by methods guarded by mOutputLock, since they may act
175 // concurrently to the input/configure side of the interface.
176 // Must be locked before mLock if both will be locked by a method
177 Mutex mInterfaceLock;
178
179 // The main lock on internal state
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800180 Mutex mLock;
181
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700182 // Camera device ID
183 const int mId;
184
Zhijun He1fa89992015-06-01 15:44:31 -0700185 // Flag indicating is the current active stream configuration is constrained high speed.
186 bool mIsConstrainedHighSpeedConfiguration;
187
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800188 /**** Scope for mLock ****/
189
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800190 camera3_device_t *mHal3Device;
191
192 CameraMetadata mDeviceInfo;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800193
Zhijun Hea1530f12014-09-14 12:44:20 -0700194 CameraMetadata mRequestTemplateCache[CAMERA3_TEMPLATE_COUNT];
195
Zhijun He204e3292014-07-14 17:09:23 -0700196 uint32_t mDeviceVersion;
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700197
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700198 struct Size {
199 uint32_t width;
200 uint32_t height;
201 Size(uint32_t w = 0, uint32_t h = 0) : width(w), height(h){}
202 };
203 // Map from format to size.
204 Vector<Size> mSupportedOpaqueInputSizes;
205
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700206 enum Status {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800207 STATUS_ERROR,
208 STATUS_UNINITIALIZED,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700209 STATUS_UNCONFIGURED,
210 STATUS_CONFIGURED,
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800211 STATUS_ACTIVE
212 } mStatus;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700213 Vector<Status> mRecentStatusUpdates;
214 Condition mStatusChanged;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800215
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700216 // Tracking cause of fatal errors when in STATUS_ERROR
217 String8 mErrorCause;
218
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800219 // Mapping of stream IDs to stream instances
Igor Murashkin2fba5842013-04-22 14:03:54 -0700220 typedef KeyedVector<int, sp<camera3::Camera3OutputStreamInterface> >
221 StreamSet;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800222
223 StreamSet mOutputStreams;
224 sp<camera3::Camera3Stream> mInputStream;
225 int mNextStreamId;
Eino-Ville Talvalaea26c772013-06-11 16:04:06 -0700226 bool mNeedConfig;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800227
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700228 int mDummyStreamId;
229
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700230 // Whether to send state updates upstream
231 // Pause when doing transparent reconfiguration
232 bool mPauseStateNotify;
233
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800234 // Need to hold on to stream references until configure completes.
Igor Murashkin2fba5842013-04-22 14:03:54 -0700235 Vector<sp<camera3::Camera3StreamInterface> > mDeletedStreams;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800236
Zhijun He204e3292014-07-14 17:09:23 -0700237 // Whether the HAL will send partial result
238 bool mUsePartialResult;
239
240 // Number of partial results that will be delivered by the HAL.
241 uint32_t mNumPartialResults;
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700242
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800243 /**** End scope for mLock ****/
244
Chien-Yu Chend196d612015-06-22 19:49:01 -0700245 typedef struct AeTriggerCancelOverride {
246 bool applyAeLock;
247 uint8_t aeLock;
248 bool applyAePrecaptureTrigger;
249 uint8_t aePrecaptureTrigger;
250 } AeTriggerCancelOverride_t;
251
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800252 class CaptureRequest : public LightRefBase<CaptureRequest> {
253 public:
254 CameraMetadata mSettings;
255 sp<camera3::Camera3Stream> mInputStream;
Chien-Yu Chenc2adf482015-05-27 14:27:49 -0700256 camera3_stream_buffer_t mInputBuffer;
Igor Murashkin2fba5842013-04-22 14:03:54 -0700257 Vector<sp<camera3::Camera3OutputStreamInterface> >
258 mOutputStreams;
Jianing Weicb0652e2014-03-12 18:29:36 -0700259 CaptureResultExtras mResultExtras;
Chien-Yu Chend196d612015-06-22 19:49:01 -0700260 // Used to cancel AE precapture trigger for devices doesn't support
261 // CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL
262 AeTriggerCancelOverride_t mAeTriggerCancelOverride;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800263 };
264 typedef List<sp<CaptureRequest> > RequestList;
265
Jianing Wei90e59c92014-03-12 18:29:36 -0700266 status_t checkStatusOkToCaptureLocked();
267
268 status_t convertMetadataListToRequestListLocked(
269 const List<const CameraMetadata> &metadataList,
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700270 /*out*/
271 RequestList *requestList);
Jianing Wei90e59c92014-03-12 18:29:36 -0700272
Jianing Weicb0652e2014-03-12 18:29:36 -0700273 status_t submitRequestsHelper(const List<const CameraMetadata> &requests, bool repeating,
274 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700275
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800276 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700277 * Get the last request submitted to the hal by the request thread.
278 *
279 * Takes mLock.
280 */
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700281 virtual CameraMetadata getLatestRequestLocked();
Igor Murashkin1e479c02013-09-06 16:55:14 -0700282
283 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700284 * Pause processing and flush everything, but don't tell the clients.
285 * This is for reconfiguring outputs transparently when according to the
286 * CameraDeviceBase interface we shouldn't need to.
287 * Must be called with mLock and mInterfaceLock both held.
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800288 */
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700289 status_t internalPauseAndWaitLocked();
290
291 /**
292 * Resume work after internalPauseAndWaitLocked()
293 * Must be called with mLock and mInterfaceLock both held.
294 */
295 status_t internalResumeLocked();
296
297 /**
298 * Wait until status tracker tells us we've transitioned to the target state
299 * set, which is either ACTIVE when active==true or IDLE (which is any
300 * non-ACTIVE state) when active==false.
301 *
302 * Needs to be called with mLock and mInterfaceLock held. This means there
303 * can ever only be one waiter at most.
304 *
305 * During the wait mLock is released.
306 *
307 */
308 status_t waitUntilStateThenRelock(bool active, nsecs_t timeout);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800309
310 /**
Zhijun He69a37482014-03-23 18:44:49 -0700311 * Implementation of waitUntilDrained. On success, will transition to IDLE state.
312 *
313 * Need to be called with mLock and mInterfaceLock held.
314 */
315 status_t waitUntilDrainedLocked();
316
317 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800318 * Do common work for setting up a streaming or single capture request.
319 * On success, will transition to ACTIVE if in IDLE.
320 */
321 sp<CaptureRequest> setUpRequestLocked(const CameraMetadata &request);
322
323 /**
324 * Build a CaptureRequest request from the CameraDeviceBase request
325 * settings.
326 */
327 sp<CaptureRequest> createCaptureRequest(const CameraMetadata &request);
328
329 /**
330 * Take the currently-defined set of streams and configure the HAL to use
331 * them. This is a long-running operation (may be several hundered ms).
332 */
333 status_t configureStreamsLocked();
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800334
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700335 /**
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700336 * Add a dummy stream to the current stream set as a workaround for
337 * not allowing 0 streams in the camera HAL spec.
338 */
339 status_t addDummyStreamLocked();
340
341 /**
342 * Remove a dummy stream if the current config includes real streams.
343 */
344 status_t tryRemoveDummyStreamLocked();
345
346 /**
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700347 * Set device into an error state due to some fatal failure, and set an
348 * error message to indicate why. Only the first call's message will be
349 * used. The message is also sent to the log.
350 */
351 void setErrorState(const char *fmt, ...);
352 void setErrorStateV(const char *fmt, va_list args);
353 void setErrorStateLocked(const char *fmt, ...);
354 void setErrorStateLockedV(const char *fmt, va_list args);
355
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700356 /**
357 * Debugging trylock/spin method
358 * Try to acquire a lock a few times with sleeps between before giving up.
359 */
360 bool tryLockSpinRightRound(Mutex& lock);
361
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700362 /**
363 * Helper function to determine if an input size for implementation defined
364 * format is supported.
365 */
366 bool isOpaqueInputSizeSupported(uint32_t width, uint32_t height);
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700367
368 /**
369 * Helper function to get the largest Jpeg resolution (in area)
370 * Return Size(0, 0) if static metatdata is invalid
371 */
372 Size getMaxJpegResolution() const;
373
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700374 struct RequestTrigger {
375 // Metadata tag number, e.g. android.control.aePrecaptureTrigger
376 uint32_t metadataTag;
377 // Metadata value, e.g. 'START' or the trigger ID
378 int32_t entryValue;
379
380 // The last part of the fully qualified path, e.g. afTrigger
381 const char *getTagName() const {
382 return get_camera_metadata_tag_name(metadataTag) ?: "NULL";
383 }
384
385 // e.g. TYPE_BYTE, TYPE_INT32, etc.
386 int getTagType() const {
387 return get_camera_metadata_tag_type(metadataTag);
388 }
389 };
390
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800391 /**
392 * Thread for managing capture request submission to HAL device.
393 */
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800394 class RequestThread : public Thread {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800395
396 public:
397
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800398 RequestThread(wp<Camera3Device> parent,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700399 sp<camera3::StatusTracker> statusTracker,
Chien-Yu Chenab5135b2015-06-30 11:20:58 -0700400 camera3_device_t *hal3Device,
401 bool aeLockAvailable);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800402
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700403 void setNotificationListener(NotificationListener *listener);
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700404
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800405 /**
406 * Call after stream (re)-configuration is completed.
407 */
408 void configurationComplete();
409
410 /**
411 * Set or clear the list of repeating requests. Does not block
412 * on either. Use waitUntilPaused to wait until request queue
413 * has emptied out.
414 */
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700415 status_t setRepeatingRequests(const RequestList& requests,
416 /*out*/
417 int64_t *lastFrameNumber = NULL);
418 status_t clearRepeatingRequests(/*out*/
419 int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800420
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700421 status_t queueRequestList(List<sp<CaptureRequest> > &requests,
422 /*out*/
423 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700424
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800425 /**
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700426 * Remove all queued and repeating requests, and pending triggers
427 */
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700428 status_t clear(NotificationListener *listener,
429 /*out*/
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700430 int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700431
432 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700433 * Queue a trigger to be dispatched with the next outgoing
434 * process_capture_request. The settings for that request only
435 * will be temporarily rewritten to add the trigger tag/value.
436 * Subsequent requests will not be rewritten (for this tag).
437 */
438 status_t queueTrigger(RequestTrigger trigger[], size_t count);
439
440 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800441 * Pause/unpause the capture thread. Doesn't block, so use
442 * waitUntilPaused to wait until the thread is paused.
443 */
444 void setPaused(bool paused);
445
446 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700447 * Wait until thread processes the capture request with settings'
448 * android.request.id == requestId.
449 *
450 * Returns TIMED_OUT in case the thread does not process the request
451 * within the timeout.
452 */
453 status_t waitUntilRequestProcessed(int32_t requestId, nsecs_t timeout);
454
Igor Murashkin1e479c02013-09-06 16:55:14 -0700455 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700456 * Shut down the thread. Shutdown is asynchronous, so thread may
457 * still be running once this method returns.
458 */
459 virtual void requestExit();
460
461 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700462 * Get the latest request that was sent to the HAL
463 * with process_capture_request.
464 */
465 CameraMetadata getLatestRequest() const;
466
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700467 /**
468 * Returns true if the stream is a target of any queued or repeating
469 * capture request
470 */
471 bool isStreamPending(sp<camera3::Camera3StreamInterface>& stream);
472
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800473 protected:
474
475 virtual bool threadLoop();
476
477 private:
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700478 static int getId(const wp<Camera3Device> &device);
479
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700480 status_t queueTriggerLocked(RequestTrigger trigger);
481 // Mix-in queued triggers into this request
482 int32_t insertTriggers(const sp<CaptureRequest> &request);
483 // Purge the queued triggers from this request,
484 // restoring the old field values for those tags.
485 status_t removeTriggers(const sp<CaptureRequest> &request);
486
Eino-Ville Talvala2f876f92013-09-13 11:39:24 -0700487 // HAL workaround: Make sure a trigger ID always exists if
488 // a trigger does
489 status_t addDummyTriggerIds(const sp<CaptureRequest> &request);
490
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800491 static const nsecs_t kRequestTimeout = 50e6; // 50 ms
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800492
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800493 // Waits for a request, or returns NULL if times out.
494 sp<CaptureRequest> waitForNextRequest();
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800495
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800496 // Return buffers, etc, for a request that couldn't be fully
497 // constructed. The buffers will be returned in the ERROR state
498 // to mark them as not having valid data.
499 // All arguments will be modified.
500 void cleanUpFailedRequest(camera3_capture_request_t &request,
501 sp<CaptureRequest> &nextRequest,
502 Vector<camera3_stream_buffer_t> &outputBuffers);
503
504 // Pause handling
505 bool waitIfPaused();
Eino-Ville Talvala26fe6c72013-08-29 12:46:18 -0700506 void unpauseForNewRequests();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800507
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700508 // Relay error to parent device object setErrorState
509 void setErrorState(const char *fmt, ...);
510
Yin-Chia Yeh8684b7f2014-06-13 14:53:05 -0700511 // If the input request is in mRepeatingRequests. Must be called with mRequestLock hold
512 bool isRepeatingRequestLocked(const sp<CaptureRequest>);
513
Chien-Yu Chend196d612015-06-22 19:49:01 -0700514 // Handle AE precapture trigger cancel for devices <= CAMERA_DEVICE_API_VERSION_3_2.
515 void handleAePrecaptureCancelRequest(sp<CaptureRequest> request);
516
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800517 wp<Camera3Device> mParent;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700518 wp<camera3::StatusTracker> mStatusTracker;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800519 camera3_device_t *mHal3Device;
520
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700521 NotificationListener *mListener;
522
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700523 const int mId; // The camera ID
524 int mStatusId; // The RequestThread's component ID for
525 // status tracking
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700526
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800527 Mutex mRequestLock;
528 Condition mRequestSignal;
529 RequestList mRequestQueue;
530 RequestList mRepeatingRequests;
Eino-Ville Talvalae74c2282015-05-27 14:46:23 -0700531 // The next request being prepped for submission to the HAL, no longer
532 // on the request queue. Read-only even with mRequestLock held, outside
533 // of threadLoop
534 sp<const CaptureRequest> mNextRequest;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800535
536 bool mReconfigured;
537
538 // Used by waitIfPaused, waitForNextRequest, and waitUntilPaused
539 Mutex mPauseLock;
540 bool mDoPause;
541 Condition mDoPauseSignal;
542 bool mPaused;
543 Condition mPausedSignal;
544
545 sp<CaptureRequest> mPrevRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700546 int32_t mPrevTriggers;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800547
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700548 uint32_t mFrameNumber;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700549
Igor Murashkin1e479c02013-09-06 16:55:14 -0700550 mutable Mutex mLatestRequestMutex;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700551 Condition mLatestRequestSignal;
552 // android.request.id for latest process_capture_request
553 int32_t mLatestRequestId;
Igor Murashkin1e479c02013-09-06 16:55:14 -0700554 CameraMetadata mLatestRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700555
556 typedef KeyedVector<uint32_t/*tag*/, RequestTrigger> TriggerMap;
557 Mutex mTriggerMutex;
558 TriggerMap mTriggerMap;
559 TriggerMap mTriggerRemovedMap;
560 TriggerMap mTriggerReplacedMap;
Yin-Chia Yehc00a25c2014-08-21 14:27:44 -0700561 uint32_t mCurrentAfTriggerId;
562 uint32_t mCurrentPreCaptureTriggerId;
Jianing Weicb0652e2014-03-12 18:29:36 -0700563
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700564 int64_t mRepeatingLastFrameNumber;
Chien-Yu Chend196d612015-06-22 19:49:01 -0700565
566 // Whether the device supports AE lock
567 bool mAeLockAvailable;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800568 };
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800569 sp<RequestThread> mRequestThread;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800570
571 /**
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700572 * In-flight queue for tracking completion of capture requests.
573 */
574
575 struct InFlightRequest {
576 // Set by notify() SHUTTER call.
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800577 nsecs_t shutterTimestamp;
578 // Set by process_capture_result().
579 nsecs_t sensorTimestamp;
Zhijun He1d1f8462013-10-02 16:29:51 -0700580 int requestStatus;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700581 // Set by process_capture_result call with valid metadata
582 bool haveResultMetadata;
583 // Decremented by calls to process_capture_result with valid output
Zhijun Hef0d962a2014-06-30 10:24:11 -0700584 // and input buffers
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700585 int numBuffersLeft;
Jianing Weicb0652e2014-03-12 18:29:36 -0700586 CaptureResultExtras resultExtras;
Zhijun Hec98bd8d2014-07-07 12:44:10 -0700587 // If this request has any input buffer
588 bool hasInputBuffer;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700589
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800590 // The last metadata that framework receives from HAL and
591 // not yet send out because the shutter event hasn't arrived.
592 // It's added by process_capture_result and sent when framework
593 // receives the shutter event.
594 CameraMetadata pendingMetadata;
595
596 // Buffers are added by process_capture_result when output buffers
597 // return from HAL but framework has not yet received the shutter
598 // event. They will be returned to the streams when framework receives
599 // the shutter event.
600 Vector<camera3_stream_buffer_t> pendingOutputBuffers;
601
Chien-Yu Chend196d612015-06-22 19:49:01 -0700602 // Used to cancel AE precapture trigger for devices doesn't support
603 // CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL
604 AeTriggerCancelOverride_t aeTriggerCancelOverride;
605
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800606
Zhijun He204e3292014-07-14 17:09:23 -0700607 // Fields used by the partial result only
608 struct PartialResultInFlight {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700609 // Set by process_capture_result once 3A has been sent to clients
610 bool haveSent3A;
611 // Result metadata collected so far, when partial results are in use
612 CameraMetadata collectedResult;
613
Zhijun He204e3292014-07-14 17:09:23 -0700614 PartialResultInFlight():
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700615 haveSent3A(false) {
616 }
Zhijun He204e3292014-07-14 17:09:23 -0700617 } partialResult;
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700618
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700619 // Default constructor needed by KeyedVector
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700620 InFlightRequest() :
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800621 shutterTimestamp(0),
622 sensorTimestamp(0),
Zhijun He1d1f8462013-10-02 16:29:51 -0700623 requestStatus(OK),
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700624 haveResultMetadata(false),
Zhijun Hec98bd8d2014-07-07 12:44:10 -0700625 numBuffersLeft(0),
Chien-Yu Chend196d612015-06-22 19:49:01 -0700626 hasInputBuffer(false),
627 aeTriggerCancelOverride({false, 0, false, 0}){
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700628 }
629
Chien-Yu Chend196d612015-06-22 19:49:01 -0700630 InFlightRequest(int numBuffers, CaptureResultExtras extras, bool hasInput,
631 AeTriggerCancelOverride aeTriggerCancelOverride) :
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800632 shutterTimestamp(0),
633 sensorTimestamp(0),
Jianing Weicb0652e2014-03-12 18:29:36 -0700634 requestStatus(OK),
635 haveResultMetadata(false),
636 numBuffersLeft(numBuffers),
Zhijun Hec98bd8d2014-07-07 12:44:10 -0700637 resultExtras(extras),
Chien-Yu Chend196d612015-06-22 19:49:01 -0700638 hasInputBuffer(hasInput),
639 aeTriggerCancelOverride(aeTriggerCancelOverride){
Zhijun Hec98bd8d2014-07-07 12:44:10 -0700640 }
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700641 };
642
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700643 // Map from frame number to the in-flight request state
644 typedef KeyedVector<uint32_t, InFlightRequest> InFlightMap;
645
646 Mutex mInFlightLock; // Protects mInFlightMap
647 InFlightMap mInFlightMap;
648
Jianing Weicb0652e2014-03-12 18:29:36 -0700649 status_t registerInFlight(uint32_t frameNumber,
Chien-Yu Chend196d612015-06-22 19:49:01 -0700650 int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput,
651 const AeTriggerCancelOverride_t &aeTriggerCancelOverride);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700652
653 /**
Zhijun He204e3292014-07-14 17:09:23 -0700654 * For the partial result, check if all 3A state fields are available
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700655 * and if so, queue up 3A-only result to the client. Returns true if 3A
656 * is sent.
657 */
Zhijun He204e3292014-07-14 17:09:23 -0700658 bool processPartial3AResult(uint32_t frameNumber,
Jianing Weicb0652e2014-03-12 18:29:36 -0700659 const CameraMetadata& partial, const CaptureResultExtras& resultExtras);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700660
661 // Helpers for reading and writing 3A metadata into to/from partial results
662 template<typename T>
663 bool get3AResult(const CameraMetadata& result, int32_t tag,
Jianing Weicb0652e2014-03-12 18:29:36 -0700664 T* value, uint32_t frameNumber);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700665
666 template<typename T>
667 bool insert3AResult(CameraMetadata &result, int32_t tag, const T* value,
Jianing Weicb0652e2014-03-12 18:29:36 -0700668 uint32_t frameNumber);
Chien-Yu Chend196d612015-06-22 19:49:01 -0700669
670 /**
671 * Override result metadata for cancelling AE precapture trigger applied in
672 * handleAePrecaptureCancelRequest().
673 */
674 void overrideResultForPrecaptureCancel(CameraMetadata* result,
675 const AeTriggerCancelOverride_t &aeTriggerCancelOverride);
676
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700677 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700678 * Tracking for idle detection
679 */
680 sp<camera3::StatusTracker> mStatusTracker;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700681
682 /**
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700683 * Thread for preparing streams
684 */
685 class PreparerThread : private Thread, public virtual RefBase {
686 public:
687 PreparerThread();
688 ~PreparerThread();
689
690 void setNotificationListener(NotificationListener *listener);
691
692 /**
Ruben Brunkc78ac262015-08-13 17:58:46 -0700693 * Queue up a stream to be prepared. Streams are processed by a background thread in FIFO
694 * order. Pre-allocate up to maxCount buffers for the stream, or the maximum number needed
695 * for the pipeline if maxCount is ALLOCATE_PIPELINE_MAX.
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700696 */
Ruben Brunkc78ac262015-08-13 17:58:46 -0700697 status_t prepare(int maxCount, sp<camera3::Camera3StreamInterface>& stream);
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700698
699 /**
700 * Cancel all current and pending stream preparation
701 */
702 status_t clear();
703
704 private:
705 Mutex mLock;
706
707 virtual bool threadLoop();
708
709 // Guarded by mLock
710
711 NotificationListener *mListener;
712 List<sp<camera3::Camera3StreamInterface> > mPendingStreams;
713 bool mActive;
714 bool mCancelNow;
715
716 // Only accessed by threadLoop and the destructor
717
718 sp<camera3::Camera3StreamInterface> mCurrentStream;
719 };
720 sp<PreparerThread> mPreparerThread;
721
722 /**
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -0700723 * Output result queue and current HAL device 3A state
724 */
725
726 // Lock for output side of device
727 Mutex mOutputLock;
728
729 /**** Scope for mOutputLock ****/
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700730 // the minimal frame number of the next non-reprocess result
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700731 uint32_t mNextResultFrameNumber;
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700732 // the minimal frame number of the next reprocess result
733 uint32_t mNextReprocessResultFrameNumber;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700734 uint32_t mNextShutterFrameNumber;
Jianing Weicb0652e2014-03-12 18:29:36 -0700735 List<CaptureResult> mResultQueue;
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -0700736 Condition mResultSignal;
737 NotificationListener *mListener;
738
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -0700739 /**** End scope for mOutputLock ****/
740
741 /**
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800742 * Callback functions from HAL device
743 */
744 void processCaptureResult(const camera3_capture_result *result);
745
746 void notify(const camera3_notify_msg *msg);
747
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700748 // Specific notify handlers
749 void notifyError(const camera3_error_msg_t &msg,
750 NotificationListener *listener);
751 void notifyShutter(const camera3_shutter_msg_t &msg,
752 NotificationListener *listener);
753
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800754 // helper function to return the output buffers to the streams.
755 void returnOutputBuffers(const camera3_stream_buffer_t *outputBuffers,
756 size_t numBuffers, nsecs_t timestamp);
757
758 // Insert the capture result given the pending metadata, result extras,
759 // partial results, and the frame number to the result queue.
760 void sendCaptureResult(CameraMetadata &pendingMetadata,
761 CaptureResultExtras &resultExtras,
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700762 CameraMetadata &collectedPartialResult, uint32_t frameNumber,
Chien-Yu Chend196d612015-06-22 19:49:01 -0700763 bool reprocess, const AeTriggerCancelOverride_t &aeTriggerCancelOverride);
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800764
765 /**** Scope for mInFlightLock ****/
766
767 // Remove the in-flight request of the given index from mInFlightMap
768 // if it's no longer needed. It must only be called with mInFlightLock held.
769 void removeInFlightRequestIfReadyLocked(int idx);
770
771 /**** End scope for mInFlightLock ****/
772
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800773 /**
774 * Static callback forwarding methods from HAL to instance
775 */
776 static callbacks_process_capture_result_t sProcessCaptureResult;
777
778 static callbacks_notify_t sNotify;
779
780}; // class Camera3Device
781
782}; // namespace android
783
784#endif