blob: 0ea9b8bd418dbd1a64c4beeefb52e2f9698ec5a1 [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:
65 Camera3Device(int id);
66
67 virtual ~Camera3Device();
68
69 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080070 * CameraDeviceBase interface
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080071 */
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080072
Igor Murashkin71381052013-03-04 14:53:08 -080073 virtual int getId() const;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080074
75 // Transitions to idle state on success.
Yin-Chia Yehe074a932015-01-30 10:29:02 -080076 virtual status_t initialize(CameraModule *module);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080077 virtual status_t disconnect();
78 virtual status_t dump(int fd, const Vector<String16> &args);
79 virtual const CameraMetadata& info() const;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080080
81 // Capture and setStreamingRequest will configure streams if currently in
82 // idle state
Jianing Weicb0652e2014-03-12 18:29:36 -070083 virtual status_t capture(CameraMetadata &request, int64_t *lastFrameNumber = NULL);
84 virtual status_t captureList(const List<const CameraMetadata> &requests,
85 int64_t *lastFrameNumber = NULL);
86 virtual status_t setStreamingRequest(const CameraMetadata &request,
87 int64_t *lastFrameNumber = NULL);
88 virtual status_t setStreamingRequestList(const List<const CameraMetadata> &requests,
89 int64_t *lastFrameNumber = NULL);
90 virtual status_t clearStreamingRequest(int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080091
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080092 virtual status_t waitUntilRequestReceived(int32_t requestId, nsecs_t timeout);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080093
94 // Actual stream creation/deletion is delayed until first request is submitted
95 // If adding streams while actively capturing, will pause device before adding
Zhijun He28c9b6f2014-08-08 12:00:47 -070096 // stream, reconfiguring device, and unpausing.
Eino-Ville Talvala727d1722015-06-09 13:44:19 -070097 virtual status_t createStream(sp<Surface> consumer,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -080098 uint32_t width, uint32_t height, int format,
Yin-Chia Yehb97babb2015-03-12 13:42:44 -070099 android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id);
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700100 virtual status_t createInputStream(
101 uint32_t width, uint32_t height, int format,
102 int *id);
Igor Murashkin2fba5842013-04-22 14:03:54 -0700103 virtual status_t createZslStream(
104 uint32_t width, uint32_t height,
105 int depth,
106 /*out*/
107 int *id,
108 sp<camera3::Camera3ZslStream>* zslStream);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800109 virtual status_t createReprocessStreamFromStream(int outputId, int *id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800110
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800111 virtual status_t getStreamInfo(int id,
Eino-Ville Talvalad46a6b92015-05-14 17:26:24 -0700112 uint32_t *width, uint32_t *height,
113 uint32_t *format, android_dataspace *dataSpace);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800114 virtual status_t setStreamTransform(int id, int transform);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800115
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800116 virtual status_t deleteStream(int id);
117 virtual status_t deleteReprocessStream(int id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800118
Zhijun He1fa89992015-06-01 15:44:31 -0700119 virtual status_t configureStreams(bool isConstraiedHighSpeed = false);
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700120 virtual status_t getInputBufferProducer(
121 sp<IGraphicBufferProducer> *producer);
Igor Murashkine2d167e2014-08-19 16:19:59 -0700122
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800123 virtual status_t createDefaultRequest(int templateId, CameraMetadata *request);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800124
125 // Transitions to the idle state on success
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800126 virtual status_t waitUntilDrained();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800127
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800128 virtual status_t setNotifyCallback(NotificationListener *listener);
Eino-Ville Talvala46910bd2013-07-18 19:15:17 -0700129 virtual bool willNotify3A();
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800130 virtual status_t waitForNextFrame(nsecs_t timeout);
Jianing Weicb0652e2014-03-12 18:29:36 -0700131 virtual status_t getNextResult(CaptureResult *frame);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800132
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800133 virtual status_t triggerAutofocus(uint32_t id);
134 virtual status_t triggerCancelAutofocus(uint32_t id);
135 virtual status_t triggerPrecaptureMetering(uint32_t id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800136
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800137 virtual status_t pushReprocessBuffer(int reprocessStreamId,
138 buffer_handle_t *buffer, wp<BufferReleasedListener> listener);
139
Jianing Weicb0652e2014-03-12 18:29:36 -0700140 virtual status_t flush(int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700141
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700142 virtual status_t prepare(int streamId);
143
Eino-Ville Talvalab25e3c82015-07-15 16:04:27 -0700144 virtual status_t tearDown(int streamId);
145
Zhijun He204e3292014-07-14 17:09:23 -0700146 virtual uint32_t getDeviceVersion();
147
Zhijun He28c9b6f2014-08-08 12:00:47 -0700148 virtual ssize_t getJpegBufferSize(uint32_t width, uint32_t height) const;
Eino-Ville Talvala95a1d0f2015-08-11 15:08:53 -0700149 ssize_t getPointCloudBufferSize() const;
Zhijun He28c9b6f2014-08-08 12:00:47 -0700150
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700151 // Methods called by subclasses
152 void notifyStatus(bool idle); // updates from StatusTracker
153
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800154 private:
Igor Murashkin1e479c02013-09-06 16:55:14 -0700155 static const size_t kDumpLockAttempts = 10;
156 static const size_t kDumpSleepDuration = 100000; // 0.10 sec
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700157 static const size_t kInFlightWarnLimit = 20;
158 static const nsecs_t kShutdownTimeout = 5000000000; // 5 sec
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700159 static const nsecs_t kActiveTimeout = 500000000; // 500 ms
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700160 struct RequestTrigger;
Zhijun Hef7da0962014-04-24 13:27:56 -0700161 // minimal jpeg buffer size: 256KB + blob header
162 static const ssize_t kMinJpegBufferSize = 256 * 1024 + sizeof(camera3_jpeg_blob);
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700163 // Constant to use for stream ID when one doesn't exist
164 static const int NO_STREAM = -1;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800165
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700166 // A lock to enforce serialization on the input/configure side
167 // of the public interface.
168 // Only locked by public methods inherited from CameraDeviceBase.
169 // Not locked by methods guarded by mOutputLock, since they may act
170 // concurrently to the input/configure side of the interface.
171 // Must be locked before mLock if both will be locked by a method
172 Mutex mInterfaceLock;
173
174 // The main lock on internal state
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800175 Mutex mLock;
176
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700177 // Camera device ID
178 const int mId;
179
Zhijun He1fa89992015-06-01 15:44:31 -0700180 // Flag indicating is the current active stream configuration is constrained high speed.
181 bool mIsConstrainedHighSpeedConfiguration;
182
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800183 /**** Scope for mLock ****/
184
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800185 camera3_device_t *mHal3Device;
186
187 CameraMetadata mDeviceInfo;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800188
Zhijun Hea1530f12014-09-14 12:44:20 -0700189 CameraMetadata mRequestTemplateCache[CAMERA3_TEMPLATE_COUNT];
190
Zhijun He204e3292014-07-14 17:09:23 -0700191 uint32_t mDeviceVersion;
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700192
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700193 struct Size {
194 uint32_t width;
195 uint32_t height;
196 Size(uint32_t w = 0, uint32_t h = 0) : width(w), height(h){}
197 };
198 // Map from format to size.
199 Vector<Size> mSupportedOpaqueInputSizes;
200
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700201 enum Status {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800202 STATUS_ERROR,
203 STATUS_UNINITIALIZED,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700204 STATUS_UNCONFIGURED,
205 STATUS_CONFIGURED,
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800206 STATUS_ACTIVE
207 } mStatus;
Ruben Brunk183f0562015-08-12 12:55:02 -0700208
209 // Only clear mRecentStatusUpdates, mStatusWaiters from waitUntilStateThenRelock
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700210 Vector<Status> mRecentStatusUpdates;
Ruben Brunk183f0562015-08-12 12:55:02 -0700211 int mStatusWaiters;
212
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700213 Condition mStatusChanged;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800214
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700215 // Tracking cause of fatal errors when in STATUS_ERROR
216 String8 mErrorCause;
217
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800218 // Mapping of stream IDs to stream instances
Igor Murashkin2fba5842013-04-22 14:03:54 -0700219 typedef KeyedVector<int, sp<camera3::Camera3OutputStreamInterface> >
220 StreamSet;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800221
222 StreamSet mOutputStreams;
223 sp<camera3::Camera3Stream> mInputStream;
224 int mNextStreamId;
Eino-Ville Talvalaea26c772013-06-11 16:04:06 -0700225 bool mNeedConfig;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800226
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700227 int mDummyStreamId;
228
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700229 // Whether to send state updates upstream
230 // Pause when doing transparent reconfiguration
231 bool mPauseStateNotify;
232
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800233 // Need to hold on to stream references until configure completes.
Igor Murashkin2fba5842013-04-22 14:03:54 -0700234 Vector<sp<camera3::Camera3StreamInterface> > mDeletedStreams;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800235
Zhijun He204e3292014-07-14 17:09:23 -0700236 // Whether the HAL will send partial result
237 bool mUsePartialResult;
238
239 // Number of partial results that will be delivered by the HAL.
240 uint32_t mNumPartialResults;
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700241
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800242 /**** End scope for mLock ****/
243
Chien-Yu Chend196d612015-06-22 19:49:01 -0700244 typedef struct AeTriggerCancelOverride {
245 bool applyAeLock;
246 uint8_t aeLock;
247 bool applyAePrecaptureTrigger;
248 uint8_t aePrecaptureTrigger;
249 } AeTriggerCancelOverride_t;
250
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800251 class CaptureRequest : public LightRefBase<CaptureRequest> {
252 public:
253 CameraMetadata mSettings;
254 sp<camera3::Camera3Stream> mInputStream;
Chien-Yu Chenc2adf482015-05-27 14:27:49 -0700255 camera3_stream_buffer_t mInputBuffer;
Igor Murashkin2fba5842013-04-22 14:03:54 -0700256 Vector<sp<camera3::Camera3OutputStreamInterface> >
257 mOutputStreams;
Jianing Weicb0652e2014-03-12 18:29:36 -0700258 CaptureResultExtras mResultExtras;
Chien-Yu Chend196d612015-06-22 19:49:01 -0700259 // Used to cancel AE precapture trigger for devices doesn't support
260 // CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL
261 AeTriggerCancelOverride_t mAeTriggerCancelOverride;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800262 };
263 typedef List<sp<CaptureRequest> > RequestList;
264
Jianing Wei90e59c92014-03-12 18:29:36 -0700265 status_t checkStatusOkToCaptureLocked();
266
267 status_t convertMetadataListToRequestListLocked(
268 const List<const CameraMetadata> &metadataList,
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700269 /*out*/
270 RequestList *requestList);
Jianing Wei90e59c92014-03-12 18:29:36 -0700271
Jianing Weicb0652e2014-03-12 18:29:36 -0700272 status_t submitRequestsHelper(const List<const CameraMetadata> &requests, bool repeating,
273 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700274
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800275 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700276 * Get the last request submitted to the hal by the request thread.
277 *
278 * Takes mLock.
279 */
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700280 virtual CameraMetadata getLatestRequestLocked();
Igor Murashkin1e479c02013-09-06 16:55:14 -0700281
282 /**
Ruben Brunk183f0562015-08-12 12:55:02 -0700283 * Update the current device status and wake all waiting threads.
284 *
285 * Must be called with mLock held.
286 */
287 void internalUpdateStatusLocked(Status status);
288
289 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700290 * Pause processing and flush everything, but don't tell the clients.
291 * This is for reconfiguring outputs transparently when according to the
292 * CameraDeviceBase interface we shouldn't need to.
293 * Must be called with mLock and mInterfaceLock both held.
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800294 */
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700295 status_t internalPauseAndWaitLocked();
296
297 /**
298 * Resume work after internalPauseAndWaitLocked()
299 * Must be called with mLock and mInterfaceLock both held.
300 */
301 status_t internalResumeLocked();
302
303 /**
304 * Wait until status tracker tells us we've transitioned to the target state
305 * set, which is either ACTIVE when active==true or IDLE (which is any
306 * non-ACTIVE state) when active==false.
307 *
308 * Needs to be called with mLock and mInterfaceLock held. This means there
309 * can ever only be one waiter at most.
310 *
311 * During the wait mLock is released.
312 *
313 */
314 status_t waitUntilStateThenRelock(bool active, nsecs_t timeout);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800315
316 /**
Zhijun He69a37482014-03-23 18:44:49 -0700317 * Implementation of waitUntilDrained. On success, will transition to IDLE state.
318 *
319 * Need to be called with mLock and mInterfaceLock held.
320 */
321 status_t waitUntilDrainedLocked();
322
323 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800324 * Do common work for setting up a streaming or single capture request.
325 * On success, will transition to ACTIVE if in IDLE.
326 */
327 sp<CaptureRequest> setUpRequestLocked(const CameraMetadata &request);
328
329 /**
330 * Build a CaptureRequest request from the CameraDeviceBase request
331 * settings.
332 */
333 sp<CaptureRequest> createCaptureRequest(const CameraMetadata &request);
334
335 /**
336 * Take the currently-defined set of streams and configure the HAL to use
337 * them. This is a long-running operation (may be several hundered ms).
338 */
339 status_t configureStreamsLocked();
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800340
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700341 /**
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700342 * Add a dummy stream to the current stream set as a workaround for
343 * not allowing 0 streams in the camera HAL spec.
344 */
345 status_t addDummyStreamLocked();
346
347 /**
348 * Remove a dummy stream if the current config includes real streams.
349 */
350 status_t tryRemoveDummyStreamLocked();
351
352 /**
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700353 * Set device into an error state due to some fatal failure, and set an
354 * error message to indicate why. Only the first call's message will be
355 * used. The message is also sent to the log.
356 */
357 void setErrorState(const char *fmt, ...);
358 void setErrorStateV(const char *fmt, va_list args);
359 void setErrorStateLocked(const char *fmt, ...);
360 void setErrorStateLockedV(const char *fmt, va_list args);
361
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700362 /**
363 * Debugging trylock/spin method
364 * Try to acquire a lock a few times with sleeps between before giving up.
365 */
366 bool tryLockSpinRightRound(Mutex& lock);
367
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700368 /**
369 * Helper function to determine if an input size for implementation defined
370 * format is supported.
371 */
372 bool isOpaqueInputSizeSupported(uint32_t width, uint32_t height);
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700373
374 /**
375 * Helper function to get the largest Jpeg resolution (in area)
376 * Return Size(0, 0) if static metatdata is invalid
377 */
378 Size getMaxJpegResolution() const;
379
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700380 struct RequestTrigger {
381 // Metadata tag number, e.g. android.control.aePrecaptureTrigger
382 uint32_t metadataTag;
383 // Metadata value, e.g. 'START' or the trigger ID
384 int32_t entryValue;
385
386 // The last part of the fully qualified path, e.g. afTrigger
387 const char *getTagName() const {
388 return get_camera_metadata_tag_name(metadataTag) ?: "NULL";
389 }
390
391 // e.g. TYPE_BYTE, TYPE_INT32, etc.
392 int getTagType() const {
393 return get_camera_metadata_tag_type(metadataTag);
394 }
395 };
396
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800397 /**
398 * Thread for managing capture request submission to HAL device.
399 */
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800400 class RequestThread : public Thread {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800401
402 public:
403
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800404 RequestThread(wp<Camera3Device> parent,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700405 sp<camera3::StatusTracker> statusTracker,
Chien-Yu Chenab5135b2015-06-30 11:20:58 -0700406 camera3_device_t *hal3Device,
407 bool aeLockAvailable);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800408
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700409 void setNotificationListener(NotificationListener *listener);
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700410
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800411 /**
412 * Call after stream (re)-configuration is completed.
413 */
414 void configurationComplete();
415
416 /**
417 * Set or clear the list of repeating requests. Does not block
418 * on either. Use waitUntilPaused to wait until request queue
419 * has emptied out.
420 */
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700421 status_t setRepeatingRequests(const RequestList& requests,
422 /*out*/
423 int64_t *lastFrameNumber = NULL);
424 status_t clearRepeatingRequests(/*out*/
425 int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800426
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700427 status_t queueRequestList(List<sp<CaptureRequest> > &requests,
428 /*out*/
429 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700430
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800431 /**
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700432 * Remove all queued and repeating requests, and pending triggers
433 */
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700434 status_t clear(NotificationListener *listener,
435 /*out*/
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700436 int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700437
438 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700439 * Queue a trigger to be dispatched with the next outgoing
440 * process_capture_request. The settings for that request only
441 * will be temporarily rewritten to add the trigger tag/value.
442 * Subsequent requests will not be rewritten (for this tag).
443 */
444 status_t queueTrigger(RequestTrigger trigger[], size_t count);
445
446 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800447 * Pause/unpause the capture thread. Doesn't block, so use
448 * waitUntilPaused to wait until the thread is paused.
449 */
450 void setPaused(bool paused);
451
452 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700453 * Wait until thread processes the capture request with settings'
454 * android.request.id == requestId.
455 *
456 * Returns TIMED_OUT in case the thread does not process the request
457 * within the timeout.
458 */
459 status_t waitUntilRequestProcessed(int32_t requestId, nsecs_t timeout);
460
Igor Murashkin1e479c02013-09-06 16:55:14 -0700461 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700462 * Shut down the thread. Shutdown is asynchronous, so thread may
463 * still be running once this method returns.
464 */
465 virtual void requestExit();
466
467 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700468 * Get the latest request that was sent to the HAL
469 * with process_capture_request.
470 */
471 CameraMetadata getLatestRequest() const;
472
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700473 /**
474 * Returns true if the stream is a target of any queued or repeating
475 * capture request
476 */
477 bool isStreamPending(sp<camera3::Camera3StreamInterface>& stream);
478
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800479 protected:
480
481 virtual bool threadLoop();
482
483 private:
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700484 static int getId(const wp<Camera3Device> &device);
485
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700486 status_t queueTriggerLocked(RequestTrigger trigger);
487 // Mix-in queued triggers into this request
488 int32_t insertTriggers(const sp<CaptureRequest> &request);
489 // Purge the queued triggers from this request,
490 // restoring the old field values for those tags.
491 status_t removeTriggers(const sp<CaptureRequest> &request);
492
Eino-Ville Talvala2f876f92013-09-13 11:39:24 -0700493 // HAL workaround: Make sure a trigger ID always exists if
494 // a trigger does
495 status_t addDummyTriggerIds(const sp<CaptureRequest> &request);
496
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800497 static const nsecs_t kRequestTimeout = 50e6; // 50 ms
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800498
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800499 // Waits for a request, or returns NULL if times out.
500 sp<CaptureRequest> waitForNextRequest();
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800501
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800502 // Return buffers, etc, for a request that couldn't be fully
503 // constructed. The buffers will be returned in the ERROR state
504 // to mark them as not having valid data.
505 // All arguments will be modified.
506 void cleanUpFailedRequest(camera3_capture_request_t &request,
507 sp<CaptureRequest> &nextRequest,
508 Vector<camera3_stream_buffer_t> &outputBuffers);
509
510 // Pause handling
511 bool waitIfPaused();
Eino-Ville Talvala26fe6c72013-08-29 12:46:18 -0700512 void unpauseForNewRequests();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800513
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700514 // Relay error to parent device object setErrorState
515 void setErrorState(const char *fmt, ...);
516
Yin-Chia Yeh8684b7f2014-06-13 14:53:05 -0700517 // If the input request is in mRepeatingRequests. Must be called with mRequestLock hold
518 bool isRepeatingRequestLocked(const sp<CaptureRequest>);
519
Chien-Yu Chend196d612015-06-22 19:49:01 -0700520 // Handle AE precapture trigger cancel for devices <= CAMERA_DEVICE_API_VERSION_3_2.
521 void handleAePrecaptureCancelRequest(sp<CaptureRequest> request);
522
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800523 wp<Camera3Device> mParent;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700524 wp<camera3::StatusTracker> mStatusTracker;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800525 camera3_device_t *mHal3Device;
526
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700527 NotificationListener *mListener;
528
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700529 const int mId; // The camera ID
530 int mStatusId; // The RequestThread's component ID for
531 // status tracking
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700532
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800533 Mutex mRequestLock;
534 Condition mRequestSignal;
535 RequestList mRequestQueue;
536 RequestList mRepeatingRequests;
Eino-Ville Talvalae74c2282015-05-27 14:46:23 -0700537 // The next request being prepped for submission to the HAL, no longer
538 // on the request queue. Read-only even with mRequestLock held, outside
539 // of threadLoop
540 sp<const CaptureRequest> mNextRequest;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800541
542 bool mReconfigured;
543
544 // Used by waitIfPaused, waitForNextRequest, and waitUntilPaused
545 Mutex mPauseLock;
546 bool mDoPause;
547 Condition mDoPauseSignal;
548 bool mPaused;
549 Condition mPausedSignal;
550
551 sp<CaptureRequest> mPrevRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700552 int32_t mPrevTriggers;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800553
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700554 uint32_t mFrameNumber;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700555
Igor Murashkin1e479c02013-09-06 16:55:14 -0700556 mutable Mutex mLatestRequestMutex;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700557 Condition mLatestRequestSignal;
558 // android.request.id for latest process_capture_request
559 int32_t mLatestRequestId;
Igor Murashkin1e479c02013-09-06 16:55:14 -0700560 CameraMetadata mLatestRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700561
562 typedef KeyedVector<uint32_t/*tag*/, RequestTrigger> TriggerMap;
563 Mutex mTriggerMutex;
564 TriggerMap mTriggerMap;
565 TriggerMap mTriggerRemovedMap;
566 TriggerMap mTriggerReplacedMap;
Yin-Chia Yehc00a25c2014-08-21 14:27:44 -0700567 uint32_t mCurrentAfTriggerId;
568 uint32_t mCurrentPreCaptureTriggerId;
Jianing Weicb0652e2014-03-12 18:29:36 -0700569
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700570 int64_t mRepeatingLastFrameNumber;
Chien-Yu Chend196d612015-06-22 19:49:01 -0700571
572 // Whether the device supports AE lock
573 bool mAeLockAvailable;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800574 };
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800575 sp<RequestThread> mRequestThread;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800576
577 /**
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700578 * In-flight queue for tracking completion of capture requests.
579 */
580
581 struct InFlightRequest {
582 // Set by notify() SHUTTER call.
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800583 nsecs_t shutterTimestamp;
584 // Set by process_capture_result().
585 nsecs_t sensorTimestamp;
Zhijun He1d1f8462013-10-02 16:29:51 -0700586 int requestStatus;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700587 // Set by process_capture_result call with valid metadata
588 bool haveResultMetadata;
589 // Decremented by calls to process_capture_result with valid output
Zhijun Hef0d962a2014-06-30 10:24:11 -0700590 // and input buffers
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700591 int numBuffersLeft;
Jianing Weicb0652e2014-03-12 18:29:36 -0700592 CaptureResultExtras resultExtras;
Zhijun Hec98bd8d2014-07-07 12:44:10 -0700593 // If this request has any input buffer
594 bool hasInputBuffer;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700595
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800596 // The last metadata that framework receives from HAL and
597 // not yet send out because the shutter event hasn't arrived.
598 // It's added by process_capture_result and sent when framework
599 // receives the shutter event.
600 CameraMetadata pendingMetadata;
601
602 // Buffers are added by process_capture_result when output buffers
603 // return from HAL but framework has not yet received the shutter
604 // event. They will be returned to the streams when framework receives
605 // the shutter event.
606 Vector<camera3_stream_buffer_t> pendingOutputBuffers;
607
Chien-Yu Chend196d612015-06-22 19:49:01 -0700608 // Used to cancel AE precapture trigger for devices doesn't support
609 // CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL
610 AeTriggerCancelOverride_t aeTriggerCancelOverride;
611
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800612
Zhijun He204e3292014-07-14 17:09:23 -0700613 // Fields used by the partial result only
614 struct PartialResultInFlight {
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700615 // Set by process_capture_result once 3A has been sent to clients
616 bool haveSent3A;
617 // Result metadata collected so far, when partial results are in use
618 CameraMetadata collectedResult;
619
Zhijun He204e3292014-07-14 17:09:23 -0700620 PartialResultInFlight():
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700621 haveSent3A(false) {
622 }
Zhijun He204e3292014-07-14 17:09:23 -0700623 } partialResult;
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700624
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700625 // Default constructor needed by KeyedVector
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700626 InFlightRequest() :
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800627 shutterTimestamp(0),
628 sensorTimestamp(0),
Zhijun He1d1f8462013-10-02 16:29:51 -0700629 requestStatus(OK),
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700630 haveResultMetadata(false),
Zhijun Hec98bd8d2014-07-07 12:44:10 -0700631 numBuffersLeft(0),
Chien-Yu Chend196d612015-06-22 19:49:01 -0700632 hasInputBuffer(false),
633 aeTriggerCancelOverride({false, 0, false, 0}){
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700634 }
635
Chien-Yu Chend196d612015-06-22 19:49:01 -0700636 InFlightRequest(int numBuffers, CaptureResultExtras extras, bool hasInput,
637 AeTriggerCancelOverride aeTriggerCancelOverride) :
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800638 shutterTimestamp(0),
639 sensorTimestamp(0),
Jianing Weicb0652e2014-03-12 18:29:36 -0700640 requestStatus(OK),
641 haveResultMetadata(false),
642 numBuffersLeft(numBuffers),
Zhijun Hec98bd8d2014-07-07 12:44:10 -0700643 resultExtras(extras),
Chien-Yu Chend196d612015-06-22 19:49:01 -0700644 hasInputBuffer(hasInput),
645 aeTriggerCancelOverride(aeTriggerCancelOverride){
Zhijun Hec98bd8d2014-07-07 12:44:10 -0700646 }
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700647 };
648
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700649 // Map from frame number to the in-flight request state
650 typedef KeyedVector<uint32_t, InFlightRequest> InFlightMap;
651
652 Mutex mInFlightLock; // Protects mInFlightMap
653 InFlightMap mInFlightMap;
654
Jianing Weicb0652e2014-03-12 18:29:36 -0700655 status_t registerInFlight(uint32_t frameNumber,
Chien-Yu Chend196d612015-06-22 19:49:01 -0700656 int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput,
657 const AeTriggerCancelOverride_t &aeTriggerCancelOverride);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700658
659 /**
Zhijun He204e3292014-07-14 17:09:23 -0700660 * For the partial result, check if all 3A state fields are available
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700661 * and if so, queue up 3A-only result to the client. Returns true if 3A
662 * is sent.
663 */
Zhijun He204e3292014-07-14 17:09:23 -0700664 bool processPartial3AResult(uint32_t frameNumber,
Jianing Weicb0652e2014-03-12 18:29:36 -0700665 const CameraMetadata& partial, const CaptureResultExtras& resultExtras);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700666
667 // Helpers for reading and writing 3A metadata into to/from partial results
668 template<typename T>
669 bool get3AResult(const CameraMetadata& result, int32_t tag,
Jianing Weicb0652e2014-03-12 18:29:36 -0700670 T* value, uint32_t frameNumber);
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700671
672 template<typename T>
673 bool insert3AResult(CameraMetadata &result, int32_t tag, const T* value,
Jianing Weicb0652e2014-03-12 18:29:36 -0700674 uint32_t frameNumber);
Chien-Yu Chend196d612015-06-22 19:49:01 -0700675
676 /**
677 * Override result metadata for cancelling AE precapture trigger applied in
678 * handleAePrecaptureCancelRequest().
679 */
680 void overrideResultForPrecaptureCancel(CameraMetadata* result,
681 const AeTriggerCancelOverride_t &aeTriggerCancelOverride);
682
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700683 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700684 * Tracking for idle detection
685 */
686 sp<camera3::StatusTracker> mStatusTracker;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700687
688 /**
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700689 * Thread for preparing streams
690 */
691 class PreparerThread : private Thread, public virtual RefBase {
692 public:
693 PreparerThread();
694 ~PreparerThread();
695
696 void setNotificationListener(NotificationListener *listener);
697
698 /**
699 * Queue up a stream to be prepared. Streams are processed by
700 * a background thread in FIFO order
701 */
702 status_t prepare(sp<camera3::Camera3StreamInterface>& stream);
703
704 /**
705 * Cancel all current and pending stream preparation
706 */
707 status_t clear();
708
709 private:
710 Mutex mLock;
711
712 virtual bool threadLoop();
713
714 // Guarded by mLock
715
716 NotificationListener *mListener;
717 List<sp<camera3::Camera3StreamInterface> > mPendingStreams;
718 bool mActive;
719 bool mCancelNow;
720
721 // Only accessed by threadLoop and the destructor
722
723 sp<camera3::Camera3StreamInterface> mCurrentStream;
724 };
725 sp<PreparerThread> mPreparerThread;
726
727 /**
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -0700728 * Output result queue and current HAL device 3A state
729 */
730
731 // Lock for output side of device
732 Mutex mOutputLock;
733
734 /**** Scope for mOutputLock ****/
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700735 // the minimal frame number of the next non-reprocess result
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700736 uint32_t mNextResultFrameNumber;
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700737 // the minimal frame number of the next reprocess result
738 uint32_t mNextReprocessResultFrameNumber;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700739 uint32_t mNextShutterFrameNumber;
Jianing Weicb0652e2014-03-12 18:29:36 -0700740 List<CaptureResult> mResultQueue;
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -0700741 Condition mResultSignal;
742 NotificationListener *mListener;
743
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -0700744 /**** End scope for mOutputLock ****/
745
746 /**
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800747 * Callback functions from HAL device
748 */
749 void processCaptureResult(const camera3_capture_result *result);
750
751 void notify(const camera3_notify_msg *msg);
752
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700753 // Specific notify handlers
754 void notifyError(const camera3_error_msg_t &msg,
755 NotificationListener *listener);
756 void notifyShutter(const camera3_shutter_msg_t &msg,
757 NotificationListener *listener);
758
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800759 // helper function to return the output buffers to the streams.
760 void returnOutputBuffers(const camera3_stream_buffer_t *outputBuffers,
761 size_t numBuffers, nsecs_t timestamp);
762
763 // Insert the capture result given the pending metadata, result extras,
764 // partial results, and the frame number to the result queue.
765 void sendCaptureResult(CameraMetadata &pendingMetadata,
766 CaptureResultExtras &resultExtras,
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700767 CameraMetadata &collectedPartialResult, uint32_t frameNumber,
Chien-Yu Chend196d612015-06-22 19:49:01 -0700768 bool reprocess, const AeTriggerCancelOverride_t &aeTriggerCancelOverride);
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800769
770 /**** Scope for mInFlightLock ****/
771
772 // Remove the in-flight request of the given index from mInFlightMap
773 // if it's no longer needed. It must only be called with mInFlightLock held.
774 void removeInFlightRequestIfReadyLocked(int idx);
775
776 /**** End scope for mInFlightLock ****/
777
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800778 /**
779 * Static callback forwarding methods from HAL to instance
780 */
781 static callbacks_process_capture_result_t sProcessCaptureResult;
782
783 static callbacks_notify_t sNotify;
784
785}; // class Camera3Device
786
787}; // namespace android
788
789#endif