blob: 679a156213d5d6601870ef85785fd4dfbfe0804b [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>
Shuzhen Wangc28dccc2016-02-11 23:48:46 -080026#include <utils/Timers.h>
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070027#include <hardware/camera3.h>
Jianing Weicb0652e2014-03-12 18:29:36 -070028#include <camera/CaptureResult.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"
Zhijun He125684a2015-12-26 15:07:30 -080032#include "device3/Camera3BufferManager.h"
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080033
34/**
35 * Function pointer types with C calling convention to
36 * use for HAL callback functions.
37 */
38extern "C" {
39 typedef void (callbacks_process_capture_result_t)(
40 const struct camera3_callback_ops *,
41 const camera3_capture_result_t *);
42
43 typedef void (callbacks_notify_t)(
44 const struct camera3_callback_ops *,
45 const camera3_notify_msg_t *);
46}
47
48namespace android {
49
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070050namespace camera3 {
51
52class Camera3Stream;
53class Camera3ZslStream;
54class Camera3OutputStreamInterface;
55class Camera3StreamInterface;
56
57}
58
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080059/**
Zhijun He95dd5ba2014-03-26 18:18:00 -070060 * CameraDevice for HAL devices with version CAMERA_DEVICE_API_VERSION_3_0 or higher.
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080061 */
62class Camera3Device :
63 public CameraDeviceBase,
64 private camera3_callback_ops {
65 public:
Ruben Brunkc78ac262015-08-13 17:58:46 -070066
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080067 Camera3Device(int id);
68
69 virtual ~Camera3Device();
70
71 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080072 * CameraDeviceBase interface
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080073 */
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080074
Igor Murashkin71381052013-03-04 14:53:08 -080075 virtual int getId() const;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080076
77 // Transitions to idle state on success.
Yin-Chia Yehe074a932015-01-30 10:29:02 -080078 virtual status_t initialize(CameraModule *module);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080079 virtual status_t disconnect();
80 virtual status_t dump(int fd, const Vector<String16> &args);
81 virtual const CameraMetadata& info() const;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080082
83 // Capture and setStreamingRequest will configure streams if currently in
84 // idle state
Jianing Weicb0652e2014-03-12 18:29:36 -070085 virtual status_t capture(CameraMetadata &request, int64_t *lastFrameNumber = NULL);
86 virtual status_t captureList(const List<const CameraMetadata> &requests,
87 int64_t *lastFrameNumber = NULL);
88 virtual status_t setStreamingRequest(const CameraMetadata &request,
89 int64_t *lastFrameNumber = NULL);
90 virtual status_t setStreamingRequestList(const List<const CameraMetadata> &requests,
91 int64_t *lastFrameNumber = NULL);
92 virtual status_t clearStreamingRequest(int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080093
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080094 virtual status_t waitUntilRequestReceived(int32_t requestId, nsecs_t timeout);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080095
96 // Actual stream creation/deletion is delayed until first request is submitted
97 // If adding streams while actively capturing, will pause device before adding
Zhijun He5d677d12016-05-29 16:52:39 -070098 // stream, reconfiguring device, and unpausing. If the client create a stream
99 // with nullptr consumer surface, the client must then call setConsumer()
100 // and finish the stream configuration before starting output streaming.
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700101 virtual status_t createStream(sp<Surface> consumer,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800102 uint32_t width, uint32_t height, int format,
Zhijun He125684a2015-12-26 15:07:30 -0800103 android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id,
Zhijun He5d677d12016-05-29 16:52:39 -0700104 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,
105 uint32_t consumerUsage = 0);
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700106 virtual status_t createInputStream(
107 uint32_t width, uint32_t height, int format,
108 int *id);
Igor Murashkin2fba5842013-04-22 14:03:54 -0700109 virtual status_t createZslStream(
110 uint32_t width, uint32_t height,
111 int depth,
112 /*out*/
113 int *id,
114 sp<camera3::Camera3ZslStream>* zslStream);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800115 virtual status_t createReprocessStreamFromStream(int outputId, int *id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800116
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800117 virtual status_t getStreamInfo(int id,
Eino-Ville Talvalad46a6b92015-05-14 17:26:24 -0700118 uint32_t *width, uint32_t *height,
119 uint32_t *format, android_dataspace *dataSpace);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800120 virtual status_t setStreamTransform(int id, int transform);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800121
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800122 virtual status_t deleteStream(int id);
123 virtual status_t deleteReprocessStream(int id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800124
Zhijun He1fa89992015-06-01 15:44:31 -0700125 virtual status_t configureStreams(bool isConstraiedHighSpeed = false);
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700126 virtual status_t getInputBufferProducer(
127 sp<IGraphicBufferProducer> *producer);
Igor Murashkine2d167e2014-08-19 16:19:59 -0700128
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800129 virtual status_t createDefaultRequest(int templateId, CameraMetadata *request);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800130
131 // Transitions to the idle state on success
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800132 virtual status_t waitUntilDrained();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800133
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800134 virtual status_t setNotifyCallback(NotificationListener *listener);
Eino-Ville Talvala46910bd2013-07-18 19:15:17 -0700135 virtual bool willNotify3A();
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800136 virtual status_t waitForNextFrame(nsecs_t timeout);
Jianing Weicb0652e2014-03-12 18:29:36 -0700137 virtual status_t getNextResult(CaptureResult *frame);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800138
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800139 virtual status_t triggerAutofocus(uint32_t id);
140 virtual status_t triggerCancelAutofocus(uint32_t id);
141 virtual status_t triggerPrecaptureMetering(uint32_t id);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800142
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800143 virtual status_t pushReprocessBuffer(int reprocessStreamId,
144 buffer_handle_t *buffer, wp<BufferReleasedListener> listener);
145
Jianing Weicb0652e2014-03-12 18:29:36 -0700146 virtual status_t flush(int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700147
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700148 virtual status_t prepare(int streamId);
149
Eino-Ville Talvalab25e3c82015-07-15 16:04:27 -0700150 virtual status_t tearDown(int streamId);
151
Shuzhen Wangb0fdc1e2016-03-20 23:21:39 -0700152 virtual status_t addBufferListenerForStream(int streamId,
153 wp<camera3::Camera3StreamBufferListener> listener);
154
Ruben Brunkc78ac262015-08-13 17:58:46 -0700155 virtual status_t prepare(int maxCount, int streamId);
156
Zhijun He204e3292014-07-14 17:09:23 -0700157 virtual uint32_t getDeviceVersion();
158
Zhijun He28c9b6f2014-08-08 12:00:47 -0700159 virtual ssize_t getJpegBufferSize(uint32_t width, uint32_t height) const;
Eino-Ville Talvala95a1d0f2015-08-11 15:08:53 -0700160 ssize_t getPointCloudBufferSize() const;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800161 ssize_t getRawOpaqueBufferSize(int32_t width, int32_t height) const;
Zhijun He28c9b6f2014-08-08 12:00:47 -0700162
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700163 // Methods called by subclasses
164 void notifyStatus(bool idle); // updates from StatusTracker
165
Zhijun He5d677d12016-05-29 16:52:39 -0700166 /**
167 * Set the deferred consumer surface to the output stream and finish the deferred
168 * consumer configuration.
169 */
170 virtual status_t setConsumerSurface(int streamId, sp<Surface> consumer);
171
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800172 private:
Igor Murashkin1e479c02013-09-06 16:55:14 -0700173 static const size_t kDumpLockAttempts = 10;
174 static const size_t kDumpSleepDuration = 100000; // 0.10 sec
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700175 static const nsecs_t kShutdownTimeout = 5000000000; // 5 sec
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700176 static const nsecs_t kActiveTimeout = 500000000; // 500 ms
Chien-Yu Chenc96ac8d2015-08-12 16:46:24 -0700177 static const size_t kInFlightWarnLimit = 20;
178 static const size_t kInFlightWarnLimitHighSpeed = 256; // batch size 32 * pipe depth 8
Eino-Ville Talvalaf99498e2015-09-25 16:52:55 -0700179 // SCHED_FIFO priority for request submission thread in HFR mode
Chien-Yu Chen4a8f4a32015-10-01 15:23:22 -0700180 static const int kConstrainedHighSpeedThreadPriority = 1;
Chien-Yu Chenc96ac8d2015-08-12 16:46:24 -0700181
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700182 struct RequestTrigger;
Zhijun Hef7da0962014-04-24 13:27:56 -0700183 // minimal jpeg buffer size: 256KB + blob header
184 static const ssize_t kMinJpegBufferSize = 256 * 1024 + sizeof(camera3_jpeg_blob);
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700185 // Constant to use for stream ID when one doesn't exist
186 static const int NO_STREAM = -1;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800187
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700188 // A lock to enforce serialization on the input/configure side
189 // of the public interface.
190 // Only locked by public methods inherited from CameraDeviceBase.
191 // Not locked by methods guarded by mOutputLock, since they may act
192 // concurrently to the input/configure side of the interface.
193 // Must be locked before mLock if both will be locked by a method
194 Mutex mInterfaceLock;
195
196 // The main lock on internal state
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800197 Mutex mLock;
198
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700199 // Camera device ID
200 const int mId;
201
Zhijun He1fa89992015-06-01 15:44:31 -0700202 // Flag indicating is the current active stream configuration is constrained high speed.
203 bool mIsConstrainedHighSpeedConfiguration;
204
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800205 /**** Scope for mLock ****/
206
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800207 camera3_device_t *mHal3Device;
208
209 CameraMetadata mDeviceInfo;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800210
Zhijun Hea1530f12014-09-14 12:44:20 -0700211 CameraMetadata mRequestTemplateCache[CAMERA3_TEMPLATE_COUNT];
212
Zhijun He204e3292014-07-14 17:09:23 -0700213 uint32_t mDeviceVersion;
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700214
Yin-Chia Yeh4c060992016-04-11 17:40:12 -0700215 // whether Camera3Device should derive ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST for
216 // backward compatibility. Should not be changed after initialization.
217 bool mDerivePostRawSensKey = false;
218
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700219 struct Size {
220 uint32_t width;
221 uint32_t height;
222 Size(uint32_t w = 0, uint32_t h = 0) : width(w), height(h){}
223 };
224 // Map from format to size.
225 Vector<Size> mSupportedOpaqueInputSizes;
226
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700227 enum Status {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800228 STATUS_ERROR,
229 STATUS_UNINITIALIZED,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700230 STATUS_UNCONFIGURED,
231 STATUS_CONFIGURED,
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800232 STATUS_ACTIVE
233 } mStatus;
Ruben Brunk183f0562015-08-12 12:55:02 -0700234
235 // Only clear mRecentStatusUpdates, mStatusWaiters from waitUntilStateThenRelock
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700236 Vector<Status> mRecentStatusUpdates;
Ruben Brunk183f0562015-08-12 12:55:02 -0700237 int mStatusWaiters;
238
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700239 Condition mStatusChanged;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800240
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700241 // Tracking cause of fatal errors when in STATUS_ERROR
242 String8 mErrorCause;
243
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800244 // Mapping of stream IDs to stream instances
Igor Murashkin2fba5842013-04-22 14:03:54 -0700245 typedef KeyedVector<int, sp<camera3::Camera3OutputStreamInterface> >
246 StreamSet;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800247
248 StreamSet mOutputStreams;
249 sp<camera3::Camera3Stream> mInputStream;
250 int mNextStreamId;
Eino-Ville Talvalaea26c772013-06-11 16:04:06 -0700251 bool mNeedConfig;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800252
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700253 int mDummyStreamId;
254
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700255 // Whether to send state updates upstream
256 // Pause when doing transparent reconfiguration
257 bool mPauseStateNotify;
258
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800259 // Need to hold on to stream references until configure completes.
Igor Murashkin2fba5842013-04-22 14:03:54 -0700260 Vector<sp<camera3::Camera3StreamInterface> > mDeletedStreams;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800261
Zhijun He204e3292014-07-14 17:09:23 -0700262 // Whether the HAL will send partial result
263 bool mUsePartialResult;
264
265 // Number of partial results that will be delivered by the HAL.
266 uint32_t mNumPartialResults;
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700267
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800268 /**** End scope for mLock ****/
269
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800270 // The offset converting from clock domain of other subsystem
271 // (video/hardware composer) to that of camera. Assumption is that this
272 // offset won't change during the life cycle of the camera device. In other
273 // words, camera device shouldn't be open during CPU suspend.
274 nsecs_t mTimestampOffset;
275
Chien-Yu Chend196d612015-06-22 19:49:01 -0700276 typedef struct AeTriggerCancelOverride {
277 bool applyAeLock;
278 uint8_t aeLock;
279 bool applyAePrecaptureTrigger;
280 uint8_t aePrecaptureTrigger;
281 } AeTriggerCancelOverride_t;
282
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800283 class CaptureRequest : public LightRefBase<CaptureRequest> {
284 public:
285 CameraMetadata mSettings;
286 sp<camera3::Camera3Stream> mInputStream;
Chien-Yu Chenc2adf482015-05-27 14:27:49 -0700287 camera3_stream_buffer_t mInputBuffer;
Igor Murashkin2fba5842013-04-22 14:03:54 -0700288 Vector<sp<camera3::Camera3OutputStreamInterface> >
289 mOutputStreams;
Jianing Weicb0652e2014-03-12 18:29:36 -0700290 CaptureResultExtras mResultExtras;
Chien-Yu Chend196d612015-06-22 19:49:01 -0700291 // Used to cancel AE precapture trigger for devices doesn't support
292 // CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL
293 AeTriggerCancelOverride_t mAeTriggerCancelOverride;
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700294 // The number of requests that should be submitted to HAL at a time.
295 // For example, if batch size is 8, this request and the following 7
296 // requests will be submitted to HAL at a time. The batch size for
297 // the following 7 requests will be ignored by the request thread.
298 int mBatchSize;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800299 };
300 typedef List<sp<CaptureRequest> > RequestList;
301
Jianing Wei90e59c92014-03-12 18:29:36 -0700302 status_t checkStatusOkToCaptureLocked();
303
304 status_t convertMetadataListToRequestListLocked(
305 const List<const CameraMetadata> &metadataList,
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700306 /*out*/
307 RequestList *requestList);
Jianing Wei90e59c92014-03-12 18:29:36 -0700308
Jianing Weicb0652e2014-03-12 18:29:36 -0700309 status_t submitRequestsHelper(const List<const CameraMetadata> &requests, bool repeating,
310 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700311
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800312 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700313 * Get the last request submitted to the hal by the request thread.
314 *
315 * Takes mLock.
316 */
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700317 virtual CameraMetadata getLatestRequestLocked();
Igor Murashkin1e479c02013-09-06 16:55:14 -0700318
319 /**
Ruben Brunk183f0562015-08-12 12:55:02 -0700320 * Update the current device status and wake all waiting threads.
321 *
322 * Must be called with mLock held.
323 */
324 void internalUpdateStatusLocked(Status status);
325
326 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700327 * Pause processing and flush everything, but don't tell the clients.
328 * This is for reconfiguring outputs transparently when according to the
329 * CameraDeviceBase interface we shouldn't need to.
330 * Must be called with mLock and mInterfaceLock both held.
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800331 */
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700332 status_t internalPauseAndWaitLocked();
333
334 /**
335 * Resume work after internalPauseAndWaitLocked()
336 * Must be called with mLock and mInterfaceLock both held.
337 */
338 status_t internalResumeLocked();
339
340 /**
341 * Wait until status tracker tells us we've transitioned to the target state
342 * set, which is either ACTIVE when active==true or IDLE (which is any
343 * non-ACTIVE state) when active==false.
344 *
345 * Needs to be called with mLock and mInterfaceLock held. This means there
346 * can ever only be one waiter at most.
347 *
348 * During the wait mLock is released.
349 *
350 */
351 status_t waitUntilStateThenRelock(bool active, nsecs_t timeout);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800352
353 /**
Zhijun He69a37482014-03-23 18:44:49 -0700354 * Implementation of waitUntilDrained. On success, will transition to IDLE state.
355 *
356 * Need to be called with mLock and mInterfaceLock held.
357 */
358 status_t waitUntilDrainedLocked();
359
360 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800361 * Do common work for setting up a streaming or single capture request.
362 * On success, will transition to ACTIVE if in IDLE.
363 */
364 sp<CaptureRequest> setUpRequestLocked(const CameraMetadata &request);
365
366 /**
367 * Build a CaptureRequest request from the CameraDeviceBase request
368 * settings.
369 */
370 sp<CaptureRequest> createCaptureRequest(const CameraMetadata &request);
371
372 /**
373 * Take the currently-defined set of streams and configure the HAL to use
374 * them. This is a long-running operation (may be several hundered ms).
375 */
376 status_t configureStreamsLocked();
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800377
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700378 /**
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700379 * Add a dummy stream to the current stream set as a workaround for
380 * not allowing 0 streams in the camera HAL spec.
381 */
382 status_t addDummyStreamLocked();
383
384 /**
385 * Remove a dummy stream if the current config includes real streams.
386 */
387 status_t tryRemoveDummyStreamLocked();
388
389 /**
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700390 * Set device into an error state due to some fatal failure, and set an
391 * error message to indicate why. Only the first call's message will be
392 * used. The message is also sent to the log.
393 */
394 void setErrorState(const char *fmt, ...);
395 void setErrorStateV(const char *fmt, va_list args);
396 void setErrorStateLocked(const char *fmt, ...);
397 void setErrorStateLockedV(const char *fmt, va_list args);
398
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700399 /**
400 * Debugging trylock/spin method
401 * Try to acquire a lock a few times with sleeps between before giving up.
402 */
403 bool tryLockSpinRightRound(Mutex& lock);
404
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700405 /**
406 * Helper function to determine if an input size for implementation defined
407 * format is supported.
408 */
409 bool isOpaqueInputSizeSupported(uint32_t width, uint32_t height);
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700410
411 /**
412 * Helper function to get the largest Jpeg resolution (in area)
413 * Return Size(0, 0) if static metatdata is invalid
414 */
415 Size getMaxJpegResolution() const;
416
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800417 /**
418 * Helper function to get the offset between MONOTONIC and BOOTTIME
419 * timestamp.
420 */
421 static nsecs_t getMonoToBoottimeOffset();
422
Eino-Ville Talvala2cbf6ce2016-03-14 13:03:25 -0700423 /**
424 * Helper function to map between legacy and new dataspace enums
425 */
426 static android_dataspace mapToLegacyDataspace(android_dataspace dataSpace);
427
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700428 struct RequestTrigger {
429 // Metadata tag number, e.g. android.control.aePrecaptureTrigger
430 uint32_t metadataTag;
431 // Metadata value, e.g. 'START' or the trigger ID
432 int32_t entryValue;
433
434 // The last part of the fully qualified path, e.g. afTrigger
435 const char *getTagName() const {
436 return get_camera_metadata_tag_name(metadataTag) ?: "NULL";
437 }
438
439 // e.g. TYPE_BYTE, TYPE_INT32, etc.
440 int getTagType() const {
441 return get_camera_metadata_tag_type(metadataTag);
442 }
443 };
444
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800445 /**
446 * Thread for managing capture request submission to HAL device.
447 */
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800448 class RequestThread : public Thread {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800449
450 public:
451
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800452 RequestThread(wp<Camera3Device> parent,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700453 sp<camera3::StatusTracker> statusTracker,
Chien-Yu Chenab5135b2015-06-30 11:20:58 -0700454 camera3_device_t *hal3Device,
455 bool aeLockAvailable);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800456
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700457 void setNotificationListener(NotificationListener *listener);
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700458
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800459 /**
460 * Call after stream (re)-configuration is completed.
461 */
462 void configurationComplete();
463
464 /**
465 * Set or clear the list of repeating requests. Does not block
466 * on either. Use waitUntilPaused to wait until request queue
467 * has emptied out.
468 */
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700469 status_t setRepeatingRequests(const RequestList& requests,
470 /*out*/
471 int64_t *lastFrameNumber = NULL);
472 status_t clearRepeatingRequests(/*out*/
473 int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800474
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700475 status_t queueRequestList(List<sp<CaptureRequest> > &requests,
476 /*out*/
477 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700478
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800479 /**
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700480 * Remove all queued and repeating requests, and pending triggers
481 */
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700482 status_t clear(NotificationListener *listener,
483 /*out*/
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700484 int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700485
486 /**
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700487 * Flush all pending requests in HAL.
488 */
489 status_t flush();
490
491 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700492 * Queue a trigger to be dispatched with the next outgoing
493 * process_capture_request. The settings for that request only
494 * will be temporarily rewritten to add the trigger tag/value.
495 * Subsequent requests will not be rewritten (for this tag).
496 */
497 status_t queueTrigger(RequestTrigger trigger[], size_t count);
498
499 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800500 * Pause/unpause the capture thread. Doesn't block, so use
501 * waitUntilPaused to wait until the thread is paused.
502 */
503 void setPaused(bool paused);
504
505 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700506 * Wait until thread processes the capture request with settings'
507 * android.request.id == requestId.
508 *
509 * Returns TIMED_OUT in case the thread does not process the request
510 * within the timeout.
511 */
512 status_t waitUntilRequestProcessed(int32_t requestId, nsecs_t timeout);
513
Igor Murashkin1e479c02013-09-06 16:55:14 -0700514 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700515 * Shut down the thread. Shutdown is asynchronous, so thread may
516 * still be running once this method returns.
517 */
518 virtual void requestExit();
519
520 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700521 * Get the latest request that was sent to the HAL
522 * with process_capture_request.
523 */
524 CameraMetadata getLatestRequest() const;
525
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700526 /**
527 * Returns true if the stream is a target of any queued or repeating
528 * capture request
529 */
530 bool isStreamPending(sp<camera3::Camera3StreamInterface>& stream);
531
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800532 protected:
533
534 virtual bool threadLoop();
535
536 private:
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700537 static int getId(const wp<Camera3Device> &device);
538
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700539 status_t queueTriggerLocked(RequestTrigger trigger);
540 // Mix-in queued triggers into this request
541 int32_t insertTriggers(const sp<CaptureRequest> &request);
542 // Purge the queued triggers from this request,
543 // restoring the old field values for those tags.
544 status_t removeTriggers(const sp<CaptureRequest> &request);
545
Eino-Ville Talvala2f876f92013-09-13 11:39:24 -0700546 // HAL workaround: Make sure a trigger ID always exists if
547 // a trigger does
548 status_t addDummyTriggerIds(const sp<CaptureRequest> &request);
549
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800550 static const nsecs_t kRequestTimeout = 50e6; // 50 ms
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800551
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700552 // Used to prepare a batch of requests.
553 struct NextRequest {
554 sp<CaptureRequest> captureRequest;
555 camera3_capture_request_t halRequest;
556 Vector<camera3_stream_buffer_t> outputBuffers;
557 bool submitted;
558 };
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800559
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700560 // Wait for the next batch of requests and put them in mNextRequests. mNextRequests will
561 // be empty if it times out.
562 void waitForNextRequestBatch();
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700563
564 // Waits for a request, or returns NULL if times out. Must be called with mRequestLock hold.
565 sp<CaptureRequest> waitForNextRequestLocked();
566
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700567 // Prepare HAL requests and output buffers in mNextRequests. Return TIMED_OUT if getting any
568 // output buffer timed out. If an error is returned, the caller should clean up the pending
569 // request batch.
570 status_t prepareHalRequests();
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700571
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700572 // Return buffers, etc, for requests in mNextRequests that couldn't be fully constructed and
573 // send request errors if sendRequestError is true. The buffers will be returned in the
574 // ERROR state to mark them as not having valid data. mNextRequests will be cleared.
575 void cleanUpFailedRequests(bool sendRequestError);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800576
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700577 // Stop the repeating request if any of its output streams is abandoned.
578 void checkAndStopRepeatingRequest();
579
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800580 // Pause handling
581 bool waitIfPaused();
Eino-Ville Talvala26fe6c72013-08-29 12:46:18 -0700582 void unpauseForNewRequests();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800583
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700584 // Relay error to parent device object setErrorState
585 void setErrorState(const char *fmt, ...);
586
Yin-Chia Yeh8684b7f2014-06-13 14:53:05 -0700587 // If the input request is in mRepeatingRequests. Must be called with mRequestLock hold
588 bool isRepeatingRequestLocked(const sp<CaptureRequest>);
589
Chien-Yu Chend196d612015-06-22 19:49:01 -0700590 // Handle AE precapture trigger cancel for devices <= CAMERA_DEVICE_API_VERSION_3_2.
591 void handleAePrecaptureCancelRequest(sp<CaptureRequest> request);
592
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700593 // Clear repeating requests. Must be called with mRequestLock held.
594 status_t clearRepeatingRequestsLocked(/*out*/ int64_t *lastFrameNumber = NULL);
595
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800596 wp<Camera3Device> mParent;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700597 wp<camera3::StatusTracker> mStatusTracker;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800598 camera3_device_t *mHal3Device;
599
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700600 NotificationListener *mListener;
601
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700602 const int mId; // The camera ID
603 int mStatusId; // The RequestThread's component ID for
604 // status tracking
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700605
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800606 Mutex mRequestLock;
607 Condition mRequestSignal;
608 RequestList mRequestQueue;
609 RequestList mRepeatingRequests;
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700610 // The next batch of requests being prepped for submission to the HAL, no longer
Eino-Ville Talvalae74c2282015-05-27 14:46:23 -0700611 // on the request queue. Read-only even with mRequestLock held, outside
612 // of threadLoop
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700613 Vector<NextRequest> mNextRequests;
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700614
615 // To protect flush() and sending a request batch to HAL.
616 Mutex mFlushLock;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800617
618 bool mReconfigured;
619
620 // Used by waitIfPaused, waitForNextRequest, and waitUntilPaused
621 Mutex mPauseLock;
622 bool mDoPause;
623 Condition mDoPauseSignal;
624 bool mPaused;
625 Condition mPausedSignal;
626
627 sp<CaptureRequest> mPrevRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700628 int32_t mPrevTriggers;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800629
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700630 uint32_t mFrameNumber;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700631
Igor Murashkin1e479c02013-09-06 16:55:14 -0700632 mutable Mutex mLatestRequestMutex;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700633 Condition mLatestRequestSignal;
634 // android.request.id for latest process_capture_request
635 int32_t mLatestRequestId;
Igor Murashkin1e479c02013-09-06 16:55:14 -0700636 CameraMetadata mLatestRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700637
638 typedef KeyedVector<uint32_t/*tag*/, RequestTrigger> TriggerMap;
639 Mutex mTriggerMutex;
640 TriggerMap mTriggerMap;
641 TriggerMap mTriggerRemovedMap;
642 TriggerMap mTriggerReplacedMap;
Yin-Chia Yehc00a25c2014-08-21 14:27:44 -0700643 uint32_t mCurrentAfTriggerId;
644 uint32_t mCurrentPreCaptureTriggerId;
Jianing Weicb0652e2014-03-12 18:29:36 -0700645
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700646 int64_t mRepeatingLastFrameNumber;
Chien-Yu Chend196d612015-06-22 19:49:01 -0700647
648 // Whether the device supports AE lock
649 bool mAeLockAvailable;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800650 };
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800651 sp<RequestThread> mRequestThread;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800652
653 /**
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700654 * In-flight queue for tracking completion of capture requests.
655 */
656
657 struct InFlightRequest {
658 // Set by notify() SHUTTER call.
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800659 nsecs_t shutterTimestamp;
660 // Set by process_capture_result().
661 nsecs_t sensorTimestamp;
Zhijun He1d1f8462013-10-02 16:29:51 -0700662 int requestStatus;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700663 // Set by process_capture_result call with valid metadata
664 bool haveResultMetadata;
665 // Decremented by calls to process_capture_result with valid output
Zhijun Hef0d962a2014-06-30 10:24:11 -0700666 // and input buffers
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700667 int numBuffersLeft;
Jianing Weicb0652e2014-03-12 18:29:36 -0700668 CaptureResultExtras resultExtras;
Zhijun Hec98bd8d2014-07-07 12:44:10 -0700669 // If this request has any input buffer
670 bool hasInputBuffer;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700671
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800672 // The last metadata that framework receives from HAL and
673 // not yet send out because the shutter event hasn't arrived.
674 // It's added by process_capture_result and sent when framework
675 // receives the shutter event.
676 CameraMetadata pendingMetadata;
677
Chien-Yu Chen5cd8d642016-03-08 14:46:58 -0800678 // The metadata of the partial results that framework receives from HAL so far
679 // and has sent out.
680 CameraMetadata collectedPartialResult;
681
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800682 // Buffers are added by process_capture_result when output buffers
683 // return from HAL but framework has not yet received the shutter
684 // event. They will be returned to the streams when framework receives
685 // the shutter event.
686 Vector<camera3_stream_buffer_t> pendingOutputBuffers;
687
Chien-Yu Chend196d612015-06-22 19:49:01 -0700688 // Used to cancel AE precapture trigger for devices doesn't support
689 // CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL
690 AeTriggerCancelOverride_t aeTriggerCancelOverride;
691
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700692 // Default constructor needed by KeyedVector
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700693 InFlightRequest() :
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800694 shutterTimestamp(0),
695 sensorTimestamp(0),
Zhijun He1d1f8462013-10-02 16:29:51 -0700696 requestStatus(OK),
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700697 haveResultMetadata(false),
Zhijun Hec98bd8d2014-07-07 12:44:10 -0700698 numBuffersLeft(0),
Chien-Yu Chend196d612015-06-22 19:49:01 -0700699 hasInputBuffer(false),
700 aeTriggerCancelOverride({false, 0, false, 0}){
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700701 }
702
Chien-Yu Chend196d612015-06-22 19:49:01 -0700703 InFlightRequest(int numBuffers, CaptureResultExtras extras, bool hasInput,
704 AeTriggerCancelOverride aeTriggerCancelOverride) :
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800705 shutterTimestamp(0),
706 sensorTimestamp(0),
Jianing Weicb0652e2014-03-12 18:29:36 -0700707 requestStatus(OK),
708 haveResultMetadata(false),
709 numBuffersLeft(numBuffers),
Zhijun Hec98bd8d2014-07-07 12:44:10 -0700710 resultExtras(extras),
Chien-Yu Chend196d612015-06-22 19:49:01 -0700711 hasInputBuffer(hasInput),
712 aeTriggerCancelOverride(aeTriggerCancelOverride){
Zhijun Hec98bd8d2014-07-07 12:44:10 -0700713 }
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700714 };
715
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700716 // Map from frame number to the in-flight request state
717 typedef KeyedVector<uint32_t, InFlightRequest> InFlightMap;
718
719 Mutex mInFlightLock; // Protects mInFlightMap
720 InFlightMap mInFlightMap;
721
Jianing Weicb0652e2014-03-12 18:29:36 -0700722 status_t registerInFlight(uint32_t frameNumber,
Chien-Yu Chend196d612015-06-22 19:49:01 -0700723 int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput,
724 const AeTriggerCancelOverride_t &aeTriggerCancelOverride);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700725
726 /**
Chien-Yu Chend196d612015-06-22 19:49:01 -0700727 * Override result metadata for cancelling AE precapture trigger applied in
728 * handleAePrecaptureCancelRequest().
729 */
730 void overrideResultForPrecaptureCancel(CameraMetadata* result,
731 const AeTriggerCancelOverride_t &aeTriggerCancelOverride);
732
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700733 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700734 * Tracking for idle detection
735 */
736 sp<camera3::StatusTracker> mStatusTracker;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700737
738 /**
Zhijun He125684a2015-12-26 15:07:30 -0800739 * Graphic buffer manager for output streams. Each device has a buffer manager, which is used
740 * by the output streams to get and return buffers if these streams are registered to this
741 * buffer manager.
742 */
743 sp<camera3::Camera3BufferManager> mBufferManager;
744
745 /**
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700746 * Thread for preparing streams
747 */
748 class PreparerThread : private Thread, public virtual RefBase {
749 public:
750 PreparerThread();
751 ~PreparerThread();
752
753 void setNotificationListener(NotificationListener *listener);
754
755 /**
Ruben Brunkc78ac262015-08-13 17:58:46 -0700756 * Queue up a stream to be prepared. Streams are processed by a background thread in FIFO
757 * order. Pre-allocate up to maxCount buffers for the stream, or the maximum number needed
758 * for the pipeline if maxCount is ALLOCATE_PIPELINE_MAX.
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700759 */
Ruben Brunkc78ac262015-08-13 17:58:46 -0700760 status_t prepare(int maxCount, sp<camera3::Camera3StreamInterface>& stream);
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700761
762 /**
763 * Cancel all current and pending stream preparation
764 */
765 status_t clear();
766
767 private:
768 Mutex mLock;
769
770 virtual bool threadLoop();
771
772 // Guarded by mLock
773
774 NotificationListener *mListener;
775 List<sp<camera3::Camera3StreamInterface> > mPendingStreams;
776 bool mActive;
777 bool mCancelNow;
778
779 // Only accessed by threadLoop and the destructor
780
781 sp<camera3::Camera3StreamInterface> mCurrentStream;
782 };
783 sp<PreparerThread> mPreparerThread;
784
785 /**
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -0700786 * Output result queue and current HAL device 3A state
787 */
788
789 // Lock for output side of device
790 Mutex mOutputLock;
791
792 /**** Scope for mOutputLock ****/
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700793 // the minimal frame number of the next non-reprocess result
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700794 uint32_t mNextResultFrameNumber;
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700795 // the minimal frame number of the next reprocess result
796 uint32_t mNextReprocessResultFrameNumber;
Chien-Yu Chen3df11ce2015-09-30 14:13:30 -0700797 // the minimal frame number of the next non-reprocess shutter
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700798 uint32_t mNextShutterFrameNumber;
Chien-Yu Chen3df11ce2015-09-30 14:13:30 -0700799 // the minimal frame number of the next reprocess shutter
800 uint32_t mNextReprocessShutterFrameNumber;
Jianing Weicb0652e2014-03-12 18:29:36 -0700801 List<CaptureResult> mResultQueue;
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -0700802 Condition mResultSignal;
803 NotificationListener *mListener;
804
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -0700805 /**** End scope for mOutputLock ****/
806
807 /**
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800808 * Callback functions from HAL device
809 */
810 void processCaptureResult(const camera3_capture_result *result);
811
812 void notify(const camera3_notify_msg *msg);
813
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700814 // Specific notify handlers
815 void notifyError(const camera3_error_msg_t &msg,
816 NotificationListener *listener);
817 void notifyShutter(const camera3_shutter_msg_t &msg,
818 NotificationListener *listener);
819
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800820 // helper function to return the output buffers to the streams.
821 void returnOutputBuffers(const camera3_stream_buffer_t *outputBuffers,
822 size_t numBuffers, nsecs_t timestamp);
823
Chien-Yu Chen5cd8d642016-03-08 14:46:58 -0800824 // Send a partial capture result.
825 void sendPartialCaptureResult(const camera_metadata_t * partialResult,
826 const CaptureResultExtras &resultExtras, uint32_t frameNumber,
827 const AeTriggerCancelOverride_t &aeTriggerCancelOverride);
828
829 // Send a total capture result given the pending metadata and result extras,
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800830 // partial results, and the frame number to the result queue.
831 void sendCaptureResult(CameraMetadata &pendingMetadata,
832 CaptureResultExtras &resultExtras,
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700833 CameraMetadata &collectedPartialResult, uint32_t frameNumber,
Chien-Yu Chend196d612015-06-22 19:49:01 -0700834 bool reprocess, const AeTriggerCancelOverride_t &aeTriggerCancelOverride);
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800835
Chien-Yu Chen5cd8d642016-03-08 14:46:58 -0800836 // Insert the result to the result queue after updating frame number and overriding AE
837 // trigger cancel.
838 // mOutputLock must be held when calling this function.
839 void insertResultLocked(CaptureResult *result, uint32_t frameNumber,
840 const AeTriggerCancelOverride_t &aeTriggerCancelOverride);
841
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800842 /**** Scope for mInFlightLock ****/
843
844 // Remove the in-flight request of the given index from mInFlightMap
845 // if it's no longer needed. It must only be called with mInFlightLock held.
846 void removeInFlightRequestIfReadyLocked(int idx);
847
848 /**** End scope for mInFlightLock ****/
849
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800850 /**
851 * Static callback forwarding methods from HAL to instance
852 */
853 static callbacks_process_capture_result_t sProcessCaptureResult;
854
855 static callbacks_notify_t sNotify;
856
857}; // class Camera3Device
858
859}; // namespace android
860
861#endif