blob: 3f291ba8f00c68eeb158a6e3bbade2b7f769d940 [file] [log] [blame]
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001/*
Shuzhen Wangc28189a2017-11-27 23:05:10 -08002 * Copyright (C) 2013-2018 The Android Open Source Project
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08003 *
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
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080020#include <utility>
21#include <unordered_map>
Shuzhen Wang5c22c152017-12-31 17:12:25 -080022#include <set>
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080023
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080024#include <utils/Condition.h>
25#include <utils/Errors.h>
26#include <utils/List.h>
27#include <utils/Mutex.h>
28#include <utils/Thread.h>
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070029#include <utils/KeyedVector.h>
Shuzhen Wangc28dccc2016-02-11 23:48:46 -080030#include <utils/Timers.h>
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080031
32#include <android/hardware/camera/device/3.2/ICameraDevice.h>
33#include <android/hardware/camera/device/3.2/ICameraDeviceSession.h>
Eino-Ville Talvala91cd3f82017-08-21 16:12:50 -070034#include <android/hardware/camera/device/3.3/ICameraDeviceSession.h>
Eino-Ville Talvala1a86df52018-01-17 16:00:35 -080035#include <android/hardware/camera/device/3.4/ICameraDeviceSession.h>
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -070036#include <android/hardware/camera/device/3.5/ICameraDeviceSession.h>
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080037#include <android/hardware/camera/device/3.2/ICameraDeviceCallback.h>
Shuzhen Wang5c22c152017-12-31 17:12:25 -080038#include <android/hardware/camera/device/3.4/ICameraDeviceCallback.h>
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -070039#include <android/hardware/camera/device/3.5/ICameraDeviceCallback.h>
Yifan Hongf79b5542017-04-11 14:44:25 -070040#include <fmq/MessageQueue.h>
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080041
Jianing Weicb0652e2014-03-12 18:29:36 -070042#include <camera/CaptureResult.h>
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080043
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070044#include "common/CameraDeviceBase.h"
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -070045#include "device3/StatusTracker.h"
Zhijun He125684a2015-12-26 15:07:30 -080046#include "device3/Camera3BufferManager.h"
Eino-Ville Talvala7b8a1fd2018-05-22 15:30:35 -070047#include "device3/DistortionMapper.h"
Eino-Ville Talvala4d453832016-07-15 11:56:53 -070048#include "utils/TagMonitor.h"
Shuzhen Wang686f6442017-06-20 16:16:04 -070049#include "utils/LatencyHistogram.h"
Emilian Peev71c73a22017-03-21 16:35:51 +000050#include <camera_metadata_hidden.h>
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080051
Emilian Peev40ead602017-09-26 15:46:36 +010052using android::camera3::OutputStreamInfo;
53
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080054namespace android {
55
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070056namespace camera3 {
57
58class Camera3Stream;
59class Camera3ZslStream;
60class Camera3OutputStreamInterface;
61class Camera3StreamInterface;
62
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080063} // namespace camera3
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070064
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080065/**
Zhijun He95dd5ba2014-03-26 18:18:00 -070066 * CameraDevice for HAL devices with version CAMERA_DEVICE_API_VERSION_3_0 or higher.
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080067 */
68class Camera3Device :
69 public CameraDeviceBase,
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -070070 virtual public hardware::camera::device::V3_5::ICameraDeviceCallback {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080071 public:
Ruben Brunkc78ac262015-08-13 17:58:46 -070072
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080073 explicit Camera3Device(const String8& id);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080074
75 virtual ~Camera3Device();
76
77 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080078 * CameraDeviceBase interface
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080079 */
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080080
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080081 const String8& getId() const override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080082
Emilian Peev00420d22018-02-05 21:33:13 +000083 metadata_vendor_id_t getVendorTagId() const override { return mVendorTagId; }
84
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080085 // Transitions to idle state on success.
Emilian Peevbd8c5032018-02-14 23:05:40 +000086 status_t initialize(sp<CameraProviderManager> manager, const String8& monitorTags) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080087 status_t disconnect() override;
88 status_t dump(int fd, const Vector<String16> &args) override;
89 const CameraMetadata& info() const override;
Shuzhen Wang2e7f58f2018-07-11 14:00:29 -070090 const CameraMetadata& info(const String8& physicalId) const override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080091
92 // Capture and setStreamingRequest will configure streams if currently in
93 // idle state
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080094 status_t capture(CameraMetadata &request, int64_t *lastFrameNumber = NULL) override;
Emilian Peevaebbe412018-01-15 13:53:24 +000095 status_t captureList(const List<const PhysicalCameraSettingsList> &requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -070096 const std::list<const SurfaceMap> &surfaceMaps,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080097 int64_t *lastFrameNumber = NULL) override;
98 status_t setStreamingRequest(const CameraMetadata &request,
99 int64_t *lastFrameNumber = NULL) override;
Emilian Peevaebbe412018-01-15 13:53:24 +0000100 status_t setStreamingRequestList(const List<const PhysicalCameraSettingsList> &requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700101 const std::list<const SurfaceMap> &surfaceMaps,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800102 int64_t *lastFrameNumber = NULL) override;
103 status_t clearStreamingRequest(int64_t *lastFrameNumber = NULL) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800104
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800105 status_t waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800106
107 // Actual stream creation/deletion is delayed until first request is submitted
108 // If adding streams while actively capturing, will pause device before adding
Zhijun He5d677d12016-05-29 16:52:39 -0700109 // stream, reconfiguring device, and unpausing. If the client create a stream
Shuzhen Wang758c2152017-01-10 18:26:18 -0800110 // with nullptr consumer surface, the client must then call setConsumers()
Zhijun He5d677d12016-05-29 16:52:39 -0700111 // and finish the stream configuration before starting output streaming.
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800112 status_t createStream(sp<Surface> consumer,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800113 uint32_t width, uint32_t height, int format,
Zhijun He125684a2015-12-26 15:07:30 -0800114 android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800115 const String8& physicalCameraId,
Emilian Peev40ead602017-09-26 15:46:36 +0100116 std::vector<int> *surfaceIds = nullptr,
Zhijun He5d677d12016-05-29 16:52:39 -0700117 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,
Emilian Peev050f5dc2017-05-18 14:43:56 +0100118 bool isShared = false, uint64_t consumerUsage = 0) override;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700119 status_t createStream(const std::vector<sp<Surface>>& consumers,
120 bool hasDeferredConsumer, uint32_t width, uint32_t height, int format,
121 android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800122 const String8& physicalCameraId,
Emilian Peev40ead602017-09-26 15:46:36 +0100123 std::vector<int> *surfaceIds = nullptr,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700124 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,
Emilian Peev050f5dc2017-05-18 14:43:56 +0100125 bool isShared = false, uint64_t consumerUsage = 0) override;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700126
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800127 status_t createInputStream(
Igor Murashkin5a269fa2013-04-15 14:59:22 -0700128 uint32_t width, uint32_t height, int format,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800129 int *id) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800130
Emilian Peev710c1422017-08-30 11:19:38 +0100131 status_t getStreamInfo(int id, StreamInfo *streamInfo) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800132 status_t setStreamTransform(int id, int transform) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800133
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800134 status_t deleteStream(int id) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800135
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100136 status_t configureStreams(const CameraMetadata& sessionParams,
137 int operatingMode =
Eino-Ville Talvalabbbbe842017-02-28 17:50:56 -0800138 static_cast<int>(hardware::camera::device::V3_2::StreamConfigurationMode::NORMAL_MODE))
139 override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800140 status_t getInputBufferProducer(
141 sp<IGraphicBufferProducer> *producer) override;
Igor Murashkine2d167e2014-08-19 16:19:59 -0700142
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800143 status_t createDefaultRequest(int templateId, CameraMetadata *request) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800144
145 // Transitions to the idle state on success
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800146 status_t waitUntilDrained() override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800147
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800148 status_t setNotifyCallback(wp<NotificationListener> listener) override;
149 bool willNotify3A() override;
150 status_t waitForNextFrame(nsecs_t timeout) override;
151 status_t getNextResult(CaptureResult *frame) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800152
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800153 status_t triggerAutofocus(uint32_t id) override;
154 status_t triggerCancelAutofocus(uint32_t id) override;
155 status_t triggerPrecaptureMetering(uint32_t id) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800156
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800157 status_t flush(int64_t *lastFrameNumber = NULL) override;
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700158
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800159 status_t prepare(int streamId) override;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700160
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800161 status_t tearDown(int streamId) override;
Eino-Ville Talvalab25e3c82015-07-15 16:04:27 -0700162
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800163 status_t addBufferListenerForStream(int streamId,
164 wp<camera3::Camera3StreamBufferListener> listener) override;
Shuzhen Wangb0fdc1e2016-03-20 23:21:39 -0700165
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800166 status_t prepare(int maxCount, int streamId) override;
Ruben Brunkc78ac262015-08-13 17:58:46 -0700167
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800168 ssize_t getJpegBufferSize(uint32_t width, uint32_t height) const override;
Eino-Ville Talvala95a1d0f2015-08-11 15:08:53 -0700169 ssize_t getPointCloudBufferSize() const;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800170 ssize_t getRawOpaqueBufferSize(int32_t width, int32_t height) const;
Zhijun He28c9b6f2014-08-08 12:00:47 -0700171
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700172 // Methods called by subclasses
173 void notifyStatus(bool idle); // updates from StatusTracker
174
Zhijun He5d677d12016-05-29 16:52:39 -0700175 /**
Shuzhen Wang758c2152017-01-10 18:26:18 -0800176 * Set the deferred consumer surfaces to the output stream and finish the deferred
Zhijun He5d677d12016-05-29 16:52:39 -0700177 * consumer configuration.
178 */
Emilian Peev40ead602017-09-26 15:46:36 +0100179 status_t setConsumerSurfaces(
180 int streamId, const std::vector<sp<Surface>>& consumers,
181 std::vector<int> *surfaceIds /*out*/) override;
182
183 /**
184 * Update a given stream.
185 */
186 status_t updateStream(int streamId, const std::vector<sp<Surface>> &newSurfaces,
187 const std::vector<OutputStreamInfo> &outputInfo,
188 const std::vector<size_t> &removedSurfaceIds,
189 KeyedVector<sp<Surface>, size_t> *outputMap/*out*/);
Zhijun He5d677d12016-05-29 16:52:39 -0700190
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700191 /**
192 * Drop buffers for stream of streamId if dropping is true. If dropping is false, do not
193 * drop buffers for stream of streamId.
194 */
195 status_t dropStreamBuffers(bool dropping, int streamId) override;
196
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800197 private:
Yifan Hongf79b5542017-04-11 14:44:25 -0700198
Yin-Chia Yehc5248132018-08-15 12:19:20 -0700199 status_t disconnectImpl();
200
Yifan Hongf79b5542017-04-11 14:44:25 -0700201 // internal typedefs
202 using RequestMetadataQueue = hardware::MessageQueue<uint8_t, hardware::kSynchronizedReadWrite>;
Yifan Honga640c5a2017-04-12 16:30:31 -0700203 using ResultMetadataQueue = hardware::MessageQueue<uint8_t, hardware::kSynchronizedReadWrite>;
Yifan Hongf79b5542017-04-11 14:44:25 -0700204
Igor Murashkin1e479c02013-09-06 16:55:14 -0700205 static const size_t kDumpLockAttempts = 10;
206 static const size_t kDumpSleepDuration = 100000; // 0.10 sec
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700207 static const nsecs_t kActiveTimeout = 500000000; // 500 ms
Yin-Chia Yeh90c0fdf2017-06-29 13:22:12 -0700208 static const size_t kInFlightWarnLimit = 30;
Chien-Yu Chenc96ac8d2015-08-12 16:46:24 -0700209 static const size_t kInFlightWarnLimitHighSpeed = 256; // batch size 32 * pipe depth 8
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -0700210 static const nsecs_t kDefaultExpectedDuration = 100000000; // 100 ms
211 static const nsecs_t kMinInflightDuration = 5000000000; // 5 s
Yin-Chia Yehb3a80b12018-09-04 12:13:05 -0700212 static const nsecs_t kBaseGetBufferWait = 3000000000; // 3 sec.
Eino-Ville Talvalaf99498e2015-09-25 16:52:55 -0700213 // SCHED_FIFO priority for request submission thread in HFR mode
Zhijun He7ee4c072016-07-25 13:52:28 -0700214 static const int kRequestThreadPriority = 1;
Chien-Yu Chenc96ac8d2015-08-12 16:46:24 -0700215
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700216 struct RequestTrigger;
Zhijun Hef7da0962014-04-24 13:27:56 -0700217 // minimal jpeg buffer size: 256KB + blob header
218 static const ssize_t kMinJpegBufferSize = 256 * 1024 + sizeof(camera3_jpeg_blob);
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700219 // Constant to use for stream ID when one doesn't exist
220 static const int NO_STREAM = -1;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800221
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700222 // A lock to enforce serialization on the input/configure side
223 // of the public interface.
224 // Only locked by public methods inherited from CameraDeviceBase.
225 // Not locked by methods guarded by mOutputLock, since they may act
226 // concurrently to the input/configure side of the interface.
227 // Must be locked before mLock if both will be locked by a method
228 Mutex mInterfaceLock;
229
230 // The main lock on internal state
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800231 Mutex mLock;
232
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700233 // Camera device ID
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800234 const String8 mId;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700235
Eino-Ville Talvalabbbbe842017-02-28 17:50:56 -0800236 // Current stream configuration mode;
237 int mOperatingMode;
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100238 // Current session wide parameters
239 hardware::camera2::impl::CameraMetadataNative mSessionParams;
240
Eino-Ville Talvalabbbbe842017-02-28 17:50:56 -0800241 // Constant to use for no set operating mode
242 static const int NO_MODE = -1;
243
Zhijun He1fa89992015-06-01 15:44:31 -0700244 // Flag indicating is the current active stream configuration is constrained high speed.
245 bool mIsConstrainedHighSpeedConfiguration;
246
Yifan Honga640c5a2017-04-12 16:30:31 -0700247 // FMQ to write result on. Must be guarded by mProcessCaptureResultLock.
248 std::unique_ptr<ResultMetadataQueue> mResultMetadataQueue;
249
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800250 /**** Scope for mLock ****/
251
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800252 /**
253 * Adapter for legacy HAL / HIDL HAL interface calls; calls either into legacy HALv3 or the
254 * HIDL HALv3 interfaces.
255 */
Yin-Chia Yehbe83fa72017-03-30 13:35:36 -0700256 class HalInterface : public camera3::Camera3StreamBufferFreedListener {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800257 public:
Yifan Hongf79b5542017-04-11 14:44:25 -0700258 HalInterface(sp<hardware::camera::device::V3_2::ICameraDeviceSession> &session,
259 std::shared_ptr<RequestMetadataQueue> queue);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800260 HalInterface(const HalInterface &other);
261 HalInterface();
262
263 // Returns true if constructed with a valid device or session, and not yet cleared
264 bool valid();
265
266 // Reset this HalInterface object (does not call close())
267 void clear();
268
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800269 // Check if HalInterface support sending requests in batch
270 bool supportBatchRequest();
271
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800272 // Calls into the HAL interface
273
274 // Caller takes ownership of requestTemplate
275 status_t constructDefaultRequestSettings(camera3_request_template_t templateId,
276 /*out*/ camera_metadata_t **requestTemplate);
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100277 status_t configureStreams(const camera_metadata_t *sessionParams,
Yin-Chia Yehfb6e55b2018-01-25 10:50:26 -0800278 /*inout*/ camera3_stream_configuration *config,
Emilian Peev192ee832018-01-31 14:46:47 +0000279 const std::vector<uint32_t>& bufferSizes);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800280 status_t processCaptureRequest(camera3_capture_request_t *request);
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800281 status_t processBatchCaptureRequests(
282 std::vector<camera3_capture_request_t*>& requests,
283 /*out*/uint32_t* numRequestProcessed);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800284 status_t flush();
285 status_t dump(int fd);
286 status_t close();
287
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700288 void signalPipelineDrain(const std::vector<int>& streamIds);
289
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700290 // method to extract buffer's unique ID
291 // return pair of (newlySeenBuffer?, bufferId)
292 std::pair<bool, uint64_t> getBufferId(const buffer_handle_t& buf, int streamId);
293
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800294 // Find a buffer_handle_t based on frame number and stream ID
295 status_t popInflightBuffer(int32_t frameNumber, int32_t streamId,
296 /*out*/ buffer_handle_t **buffer);
297
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700298 // Register a bufId/buffer_handle_t to inflight request buffer
299 status_t pushInflightRequestBuffer(uint64_t bufferId, buffer_handle_t* buf);
300
301 // Find a buffer_handle_t based on bufferId
302 status_t popInflightRequestBuffer(uint64_t bufferId, /*out*/ buffer_handle_t **buffer);
303
Yin-Chia Yehf3fe36f2017-07-07 18:23:18 -0700304 // Get a vector of (frameNumber, streamId) pair of currently inflight
305 // buffers
306 void getInflightBufferKeys(std::vector<std::pair<int32_t, int32_t>>* out);
307
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700308 static const uint64_t BUFFER_ID_NO_BUFFER = 0;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800309 private:
Eino-Ville Talvala1a86df52018-01-17 16:00:35 -0800310 // Always valid
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800311 sp<hardware::camera::device::V3_2::ICameraDeviceSession> mHidlSession;
Eino-Ville Talvala1a86df52018-01-17 16:00:35 -0800312 // Valid if ICameraDeviceSession is @3.3 or newer
313 sp<hardware::camera::device::V3_3::ICameraDeviceSession> mHidlSession_3_3;
314 // Valid if ICameraDeviceSession is @3.4 or newer
315 sp<hardware::camera::device::V3_4::ICameraDeviceSession> mHidlSession_3_4;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700316 // Valid if ICameraDeviceSession is @3.5 or newer
317 sp<hardware::camera::device::V3_5::ICameraDeviceSession> mHidlSession_3_5;
Eino-Ville Talvala1a86df52018-01-17 16:00:35 -0800318
Yifan Hongf79b5542017-04-11 14:44:25 -0700319 std::shared_ptr<RequestMetadataQueue> mRequestMetadataQueue;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800320
321 std::mutex mInflightLock;
322
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800323 // The output HIDL request still depends on input camera3_capture_request_t
324 // Do not free input camera3_capture_request_t before output HIDL request
325 void wrapAsHidlRequest(camera3_capture_request_t* in,
326 /*out*/hardware::camera::device::V3_2::CaptureRequest* out,
327 /*out*/std::vector<native_handle_t*>* handlesCreated);
328
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800329 status_t pushInflightBufferLocked(int32_t frameNumber, int32_t streamId,
Yin-Chia Yehf4650602017-01-10 13:13:39 -0800330 buffer_handle_t *buffer, int acquireFence);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800331 // Cache of buffer handles keyed off (frameNumber << 32 | streamId)
Yin-Chia Yehf4650602017-01-10 13:13:39 -0800332 // value is a pair of (buffer_handle_t*, acquire_fence FD)
333 std::unordered_map<uint64_t, std::pair<buffer_handle_t*, int>> mInflightBufferMap;
Yin-Chia Yeh77327052017-01-09 18:23:07 -0800334
335 struct BufferHasher {
336 size_t operator()(const buffer_handle_t& buf) const {
337 if (buf == nullptr)
338 return 0;
339
340 size_t result = 1;
341 result = 31 * result + buf->numFds;
Emilian Peev2a6a4682017-04-20 10:58:51 +0100342 for (int i = 0; i < buf->numFds; i++) {
Yin-Chia Yeh77327052017-01-09 18:23:07 -0800343 result = 31 * result + buf->data[i];
344 }
345 return result;
346 }
347 };
348
349 struct BufferComparator {
350 bool operator()(const buffer_handle_t& buf1, const buffer_handle_t& buf2) const {
Emilian Peev2a6a4682017-04-20 10:58:51 +0100351 if (buf1->numFds == buf2->numFds) {
352 for (int i = 0; i < buf1->numFds; i++) {
Yin-Chia Yeh77327052017-01-09 18:23:07 -0800353 if (buf1->data[i] != buf2->data[i]) {
354 return false;
355 }
356 }
357 return true;
358 }
359 return false;
360 }
361 };
362
363 std::mutex mBufferIdMapLock; // protecting mBufferIdMaps and mNextBufferId
364 typedef std::unordered_map<const buffer_handle_t, uint64_t,
365 BufferHasher, BufferComparator> BufferIdMap;
366 // stream ID -> per stream buffer ID map
367 std::unordered_map<int, BufferIdMap> mBufferIdMaps;
368 uint64_t mNextBufferId = 1; // 0 means no buffer
Yin-Chia Yehbe83fa72017-03-30 13:35:36 -0700369
370 virtual void onBufferFreed(int streamId, const native_handle_t* handle) override;
371
372 std::vector<std::pair<int, uint64_t>> mFreedBuffers;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700373
374 // Buffers given to HAL through requestStreamBuffer API
375 std::mutex mRequestedBuffersLock;
376 std::unordered_map<uint64_t, buffer_handle_t*> mRequestedBuffers;
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700377
378 uint32_t mNextStreamConfigCounter = 1;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800379 };
380
Yin-Chia Yehdb1e8642017-07-14 15:19:30 -0700381 sp<HalInterface> mInterface;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800382
383 CameraMetadata mDeviceInfo;
Shuzhen Wang2e7f58f2018-07-11 14:00:29 -0700384 std::unordered_map<std::string, CameraMetadata> mPhysicalDeviceInfoMap;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800385
Zhijun Hea1530f12014-09-14 12:44:20 -0700386 CameraMetadata mRequestTemplateCache[CAMERA3_TEMPLATE_COUNT];
387
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700388 struct Size {
389 uint32_t width;
390 uint32_t height;
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -0700391 explicit Size(uint32_t w = 0, uint32_t h = 0) : width(w), height(h){}
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700392 };
393 // Map from format to size.
394 Vector<Size> mSupportedOpaqueInputSizes;
395
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700396 enum Status {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800397 STATUS_ERROR,
398 STATUS_UNINITIALIZED,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700399 STATUS_UNCONFIGURED,
400 STATUS_CONFIGURED,
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800401 STATUS_ACTIVE
402 } mStatus;
Ruben Brunk183f0562015-08-12 12:55:02 -0700403
404 // Only clear mRecentStatusUpdates, mStatusWaiters from waitUntilStateThenRelock
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700405 Vector<Status> mRecentStatusUpdates;
Ruben Brunk183f0562015-08-12 12:55:02 -0700406 int mStatusWaiters;
407
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700408 Condition mStatusChanged;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800409
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700410 // Tracking cause of fatal errors when in STATUS_ERROR
411 String8 mErrorCause;
412
Yin-Chia Yeh4ee35432018-10-10 13:52:31 -0700413 // Synchronized mapping of stream IDs to stream instances
414 class StreamSet {
415 public:
416 status_t add(int streamId, sp<camera3::Camera3OutputStreamInterface>);
417 ssize_t remove(int streamId);
418 sp<camera3::Camera3OutputStreamInterface> get(int streamId);
419 // get by (underlying) vector index
420 sp<camera3::Camera3OutputStreamInterface> operator[] (size_t index);
421 size_t size() const;
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700422 std::vector<int> getStreamIds();
Yin-Chia Yeh4ee35432018-10-10 13:52:31 -0700423 void clear();
424
425 private:
426 mutable std::mutex mLock;
427 KeyedVector<int, sp<camera3::Camera3OutputStreamInterface>> mData;
428 };
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800429
430 StreamSet mOutputStreams;
431 sp<camera3::Camera3Stream> mInputStream;
432 int mNextStreamId;
Eino-Ville Talvalaea26c772013-06-11 16:04:06 -0700433 bool mNeedConfig;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800434
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700435 int mDummyStreamId;
436
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700437 // Whether to send state updates upstream
438 // Pause when doing transparent reconfiguration
439 bool mPauseStateNotify;
440
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800441 // Need to hold on to stream references until configure completes.
Igor Murashkin2fba5842013-04-22 14:03:54 -0700442 Vector<sp<camera3::Camera3StreamInterface> > mDeletedStreams;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800443
Zhijun He204e3292014-07-14 17:09:23 -0700444 // Whether the HAL will send partial result
445 bool mUsePartialResult;
446
447 // Number of partial results that will be delivered by the HAL.
448 uint32_t mNumPartialResults;
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700449
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800450 /**** End scope for mLock ****/
451
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800452 // The offset converting from clock domain of other subsystem
453 // (video/hardware composer) to that of camera. Assumption is that this
454 // offset won't change during the life cycle of the camera device. In other
455 // words, camera device shouldn't be open during CPU suspend.
456 nsecs_t mTimestampOffset;
457
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800458 class CaptureRequest : public LightRefBase<CaptureRequest> {
459 public:
Emilian Peevaebbe412018-01-15 13:53:24 +0000460 PhysicalCameraSettingsList mSettingsList;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800461 sp<camera3::Camera3Stream> mInputStream;
Chien-Yu Chenc2adf482015-05-27 14:27:49 -0700462 camera3_stream_buffer_t mInputBuffer;
Igor Murashkin2fba5842013-04-22 14:03:54 -0700463 Vector<sp<camera3::Camera3OutputStreamInterface> >
464 mOutputStreams;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700465 SurfaceMap mOutputSurfaces;
Jianing Weicb0652e2014-03-12 18:29:36 -0700466 CaptureResultExtras mResultExtras;
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700467 // The number of requests that should be submitted to HAL at a time.
468 // For example, if batch size is 8, this request and the following 7
469 // requests will be submitted to HAL at a time. The batch size for
470 // the following 7 requests will be ignored by the request thread.
471 int mBatchSize;
Shuzhen Wang9d066012016-09-30 11:30:20 -0700472 // Whether this request is from a repeating or repeating burst.
473 bool mRepeating;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800474 };
475 typedef List<sp<CaptureRequest> > RequestList;
476
Jianing Wei90e59c92014-03-12 18:29:36 -0700477 status_t checkStatusOkToCaptureLocked();
478
479 status_t convertMetadataListToRequestListLocked(
Emilian Peevaebbe412018-01-15 13:53:24 +0000480 const List<const PhysicalCameraSettingsList> &metadataList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700481 const std::list<const SurfaceMap> &surfaceMaps,
Shuzhen Wang9d066012016-09-30 11:30:20 -0700482 bool repeating,
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700483 /*out*/
484 RequestList *requestList);
Jianing Wei90e59c92014-03-12 18:29:36 -0700485
Emilian Peevaebbe412018-01-15 13:53:24 +0000486 void convertToRequestList(List<const PhysicalCameraSettingsList>& requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700487 std::list<const SurfaceMap>& surfaceMaps,
488 const CameraMetadata& request);
489
Emilian Peevaebbe412018-01-15 13:53:24 +0000490 status_t submitRequestsHelper(const List<const PhysicalCameraSettingsList> &requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700491 const std::list<const SurfaceMap> &surfaceMaps,
492 bool repeating,
Jianing Weicb0652e2014-03-12 18:29:36 -0700493 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700494
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800495
496 /**
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700497 * Implementation of android::hardware::camera::device::V3_5::ICameraDeviceCallback
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800498 */
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700499
Shuzhen Wang5c22c152017-12-31 17:12:25 -0800500 hardware::Return<void> processCaptureResult_3_4(
501 const hardware::hidl_vec<
502 hardware::camera::device::V3_4::CaptureResult>& results) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800503 hardware::Return<void> processCaptureResult(
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800504 const hardware::hidl_vec<
505 hardware::camera::device::V3_2::CaptureResult>& results) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800506 hardware::Return<void> notify(
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800507 const hardware::hidl_vec<
508 hardware::camera::device::V3_2::NotifyMsg>& msgs) override;
509
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700510 hardware::Return<void> requestStreamBuffers(
511 const hardware::hidl_vec<
512 hardware::camera::device::V3_5::BufferRequest>& bufReqs,
513 requestStreamBuffers_cb _hidl_cb) override;
514
515 hardware::Return<void> returnStreamBuffers(
516 const hardware::hidl_vec<
517 hardware::camera::device::V3_2::StreamBuffer>& buffers) override;
518
Yifan Honga640c5a2017-04-12 16:30:31 -0700519 // Handle one capture result. Assume that mProcessCaptureResultLock is held.
520 void processOneCaptureResultLocked(
Shuzhen Wang5c22c152017-12-31 17:12:25 -0800521 const hardware::camera::device::V3_2::CaptureResult& result,
522 const hardware::hidl_vec<
523 hardware::camera::device::V3_4::PhysicalCameraMetadata> physicalCameraMetadatas);
524 status_t readOneCameraMetadataLocked(uint64_t fmqResultSize,
525 hardware::camera::device::V3_2::CameraMetadata& resultMetadata,
526 const hardware::camera::device::V3_2::CameraMetadata& result);
527
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800528 // Handle one notify message
529 void notify(const hardware::camera::device::V3_2::NotifyMsg& msg);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800530
Yifan Honga640c5a2017-04-12 16:30:31 -0700531 // lock to ensure only one processCaptureResult is called at a time.
532 Mutex mProcessCaptureResultLock;
533
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800534 /**
535 * Common initialization code shared by both HAL paths
536 *
537 * Must be called with mLock and mInterfaceLock held.
538 */
539 status_t initializeCommonLocked();
540
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800541 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700542 * Get the last request submitted to the hal by the request thread.
543 *
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800544 * Must be called with mLock held.
Igor Murashkin1e479c02013-09-06 16:55:14 -0700545 */
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700546 virtual CameraMetadata getLatestRequestLocked();
Igor Murashkin1e479c02013-09-06 16:55:14 -0700547
548 /**
Ruben Brunk183f0562015-08-12 12:55:02 -0700549 * Update the current device status and wake all waiting threads.
550 *
551 * Must be called with mLock held.
552 */
553 void internalUpdateStatusLocked(Status status);
554
555 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700556 * Pause processing and flush everything, but don't tell the clients.
557 * This is for reconfiguring outputs transparently when according to the
558 * CameraDeviceBase interface we shouldn't need to.
559 * Must be called with mLock and mInterfaceLock both held.
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800560 */
Yin-Chia Yeh598fc602017-07-24 11:37:23 -0700561 status_t internalPauseAndWaitLocked(nsecs_t maxExpectedDuration);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700562
563 /**
564 * Resume work after internalPauseAndWaitLocked()
565 * Must be called with mLock and mInterfaceLock both held.
566 */
567 status_t internalResumeLocked();
568
569 /**
570 * Wait until status tracker tells us we've transitioned to the target state
571 * set, which is either ACTIVE when active==true or IDLE (which is any
572 * non-ACTIVE state) when active==false.
573 *
574 * Needs to be called with mLock and mInterfaceLock held. This means there
575 * can ever only be one waiter at most.
576 *
577 * During the wait mLock is released.
578 *
579 */
580 status_t waitUntilStateThenRelock(bool active, nsecs_t timeout);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800581
582 /**
Zhijun He69a37482014-03-23 18:44:49 -0700583 * Implementation of waitUntilDrained. On success, will transition to IDLE state.
584 *
585 * Need to be called with mLock and mInterfaceLock held.
586 */
Yin-Chia Yeh598fc602017-07-24 11:37:23 -0700587 status_t waitUntilDrainedLocked(nsecs_t maxExpectedDuration);
Zhijun He69a37482014-03-23 18:44:49 -0700588
589 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800590 * Do common work for setting up a streaming or single capture request.
591 * On success, will transition to ACTIVE if in IDLE.
592 */
Emilian Peevaebbe412018-01-15 13:53:24 +0000593 sp<CaptureRequest> setUpRequestLocked(const PhysicalCameraSettingsList &request,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700594 const SurfaceMap &surfaceMap);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800595
596 /**
597 * Build a CaptureRequest request from the CameraDeviceBase request
598 * settings.
599 */
Emilian Peevaebbe412018-01-15 13:53:24 +0000600 sp<CaptureRequest> createCaptureRequest(const PhysicalCameraSettingsList &request,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700601 const SurfaceMap &surfaceMap);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800602
603 /**
Eino-Ville Talvala002001b2018-01-23 16:53:50 -0800604 * Pause state updates to the client application. Needed to mask out idle/active
605 * transitions during internal reconfigure
606 */
607 void pauseStateNotify(bool enable);
608
609 /**
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000610 * Internally re-configure camera device using new session parameters.
Eino-Ville Talvala002001b2018-01-23 16:53:50 -0800611 * This will get triggered by the request thread. Be sure to call
612 * pauseStateNotify(true) before going idle in the requesting location.
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000613 */
614 bool reconfigureCamera(const CameraMetadata& sessionParams);
615
616 /**
617 * Filter stream session parameters and configure camera HAL.
618 */
619 status_t filterParamsAndConfigureLocked(const CameraMetadata& sessionParams,
620 int operatingMode);
621
622 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800623 * Take the currently-defined set of streams and configure the HAL to use
624 * them. This is a long-running operation (may be several hundered ms).
625 */
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100626 status_t configureStreamsLocked(int operatingMode,
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000627 const CameraMetadata& sessionParams, bool notifyRequestThread = true);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800628
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700629 /**
Chien-Yu Chen9b5860b2016-06-10 13:39:09 -0700630 * Cancel stream configuration that did not finish successfully.
631 */
632 void cancelStreamsConfigurationLocked();
633
634 /**
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700635 * Add a dummy stream to the current stream set as a workaround for
636 * not allowing 0 streams in the camera HAL spec.
637 */
638 status_t addDummyStreamLocked();
639
640 /**
641 * Remove a dummy stream if the current config includes real streams.
642 */
643 status_t tryRemoveDummyStreamLocked();
644
645 /**
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700646 * Set device into an error state due to some fatal failure, and set an
647 * error message to indicate why. Only the first call's message will be
648 * used. The message is also sent to the log.
649 */
650 void setErrorState(const char *fmt, ...);
651 void setErrorStateV(const char *fmt, va_list args);
652 void setErrorStateLocked(const char *fmt, ...);
653 void setErrorStateLockedV(const char *fmt, va_list args);
654
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700655 /**
656 * Debugging trylock/spin method
657 * Try to acquire a lock a few times with sleeps between before giving up.
658 */
659 bool tryLockSpinRightRound(Mutex& lock);
660
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700661 /**
662 * Helper function to determine if an input size for implementation defined
663 * format is supported.
664 */
665 bool isOpaqueInputSizeSupported(uint32_t width, uint32_t height);
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700666
667 /**
668 * Helper function to get the largest Jpeg resolution (in area)
669 * Return Size(0, 0) if static metatdata is invalid
670 */
671 Size getMaxJpegResolution() const;
672
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800673 /**
674 * Helper function to get the offset between MONOTONIC and BOOTTIME
675 * timestamp.
676 */
677 static nsecs_t getMonoToBoottimeOffset();
678
Eino-Ville Talvala2cbf6ce2016-03-14 13:03:25 -0700679 /**
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800680 * Helper functions to map between framework and HIDL values
681 */
682 static hardware::graphics::common::V1_0::PixelFormat mapToPixelFormat(int frameworkFormat);
683 static hardware::camera::device::V3_2::DataspaceFlags mapToHidlDataspace(
684 android_dataspace dataSpace);
Emilian Peev050f5dc2017-05-18 14:43:56 +0100685 static hardware::camera::device::V3_2::BufferUsageFlags mapToConsumerUsage(uint64_t usage);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800686 static hardware::camera::device::V3_2::StreamRotation mapToStreamRotation(
687 camera3_stream_rotation_t rotation);
Eino-Ville Talvalabbbbe842017-02-28 17:50:56 -0800688 // Returns a negative error code if the passed-in operation mode is not valid.
689 static status_t mapToStreamConfigurationMode(camera3_stream_configuration_mode_t operationMode,
690 /*out*/ hardware::camera::device::V3_2::StreamConfigurationMode *mode);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800691 static camera3_buffer_status_t mapHidlBufferStatus(hardware::camera::device::V3_2::BufferStatus status);
692 static int mapToFrameworkFormat(hardware::graphics::common::V1_0::PixelFormat pixelFormat);
Eino-Ville Talvala91cd3f82017-08-21 16:12:50 -0700693 static android_dataspace mapToFrameworkDataspace(
694 hardware::camera::device::V3_2::DataspaceFlags);
Emilian Peev050f5dc2017-05-18 14:43:56 +0100695 static uint64_t mapConsumerToFrameworkUsage(
Chia-I Wu67a0c0e2017-04-06 13:37:01 -0700696 hardware::camera::device::V3_2::BufferUsageFlags usage);
Emilian Peev050f5dc2017-05-18 14:43:56 +0100697 static uint64_t mapProducerToFrameworkUsage(
Chia-I Wu67a0c0e2017-04-06 13:37:01 -0700698 hardware::camera::device::V3_2::BufferUsageFlags usage);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800699
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700700 struct RequestTrigger {
701 // Metadata tag number, e.g. android.control.aePrecaptureTrigger
702 uint32_t metadataTag;
703 // Metadata value, e.g. 'START' or the trigger ID
704 int32_t entryValue;
705
706 // The last part of the fully qualified path, e.g. afTrigger
707 const char *getTagName() const {
708 return get_camera_metadata_tag_name(metadataTag) ?: "NULL";
709 }
710
711 // e.g. TYPE_BYTE, TYPE_INT32, etc.
712 int getTagType() const {
713 return get_camera_metadata_tag_type(metadataTag);
714 }
715 };
716
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800717 /**
718 * Thread for managing capture request submission to HAL device.
719 */
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800720 class RequestThread : public Thread {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800721
722 public:
723
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800724 RequestThread(wp<Camera3Device> parent,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700725 sp<camera3::StatusTracker> statusTracker,
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700726 sp<HalInterface> interface,
727 const Vector<int32_t>& sessionParamKeys,
728 bool useHalBufManager);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800729 ~RequestThread();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800730
Yin-Chia Yehe1c80632016-08-08 14:48:05 -0700731 void setNotificationListener(wp<NotificationListener> listener);
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700732
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800733 /**
734 * Call after stream (re)-configuration is completed.
735 */
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000736 void configurationComplete(bool isConstrainedHighSpeed,
737 const CameraMetadata& sessionParams);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800738
739 /**
740 * Set or clear the list of repeating requests. Does not block
741 * on either. Use waitUntilPaused to wait until request queue
742 * has emptied out.
743 */
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700744 status_t setRepeatingRequests(const RequestList& requests,
745 /*out*/
746 int64_t *lastFrameNumber = NULL);
747 status_t clearRepeatingRequests(/*out*/
748 int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800749
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700750 status_t queueRequestList(List<sp<CaptureRequest> > &requests,
751 /*out*/
752 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700753
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800754 /**
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700755 * Remove all queued and repeating requests, and pending triggers
756 */
Yin-Chia Yehe1c80632016-08-08 14:48:05 -0700757 status_t clear(/*out*/int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700758
759 /**
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700760 * Flush all pending requests in HAL.
761 */
762 status_t flush();
763
764 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700765 * Queue a trigger to be dispatched with the next outgoing
766 * process_capture_request. The settings for that request only
767 * will be temporarily rewritten to add the trigger tag/value.
768 * Subsequent requests will not be rewritten (for this tag).
769 */
770 status_t queueTrigger(RequestTrigger trigger[], size_t count);
771
772 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800773 * Pause/unpause the capture thread. Doesn't block, so use
774 * waitUntilPaused to wait until the thread is paused.
775 */
776 void setPaused(bool paused);
777
778 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700779 * Wait until thread processes the capture request with settings'
780 * android.request.id == requestId.
781 *
782 * Returns TIMED_OUT in case the thread does not process the request
783 * within the timeout.
784 */
785 status_t waitUntilRequestProcessed(int32_t requestId, nsecs_t timeout);
786
Igor Murashkin1e479c02013-09-06 16:55:14 -0700787 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700788 * Shut down the thread. Shutdown is asynchronous, so thread may
789 * still be running once this method returns.
790 */
791 virtual void requestExit();
792
793 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700794 * Get the latest request that was sent to the HAL
795 * with process_capture_request.
796 */
797 CameraMetadata getLatestRequest() const;
798
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700799 /**
800 * Returns true if the stream is a target of any queued or repeating
801 * capture request
802 */
803 bool isStreamPending(sp<camera3::Camera3StreamInterface>& stream);
804
Emilian Peev40ead602017-09-26 15:46:36 +0100805 /**
806 * Returns true if the surface is a target of any queued or repeating
807 * capture request
808 */
809 bool isOutputSurfacePending(int streamId, size_t surfaceId);
810
Shuzhen Wang686f6442017-06-20 16:16:04 -0700811 // dump processCaptureRequest latency
812 void dumpCaptureRequestLatency(int fd, const char* name) {
813 mRequestLatency.dump(fd, name);
814 }
815
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700816 void signalPipelineDrain(const std::vector<int>& streamIds);
817
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800818 protected:
819
820 virtual bool threadLoop();
821
822 private:
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800823 static const String8& getId(const wp<Camera3Device> &device);
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700824
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700825 status_t queueTriggerLocked(RequestTrigger trigger);
826 // Mix-in queued triggers into this request
827 int32_t insertTriggers(const sp<CaptureRequest> &request);
828 // Purge the queued triggers from this request,
829 // restoring the old field values for those tags.
830 status_t removeTriggers(const sp<CaptureRequest> &request);
831
Eino-Ville Talvala2f876f92013-09-13 11:39:24 -0700832 // HAL workaround: Make sure a trigger ID always exists if
833 // a trigger does
834 status_t addDummyTriggerIds(const sp<CaptureRequest> &request);
835
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800836 static const nsecs_t kRequestTimeout = 50e6; // 50 ms
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800837
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700838 // Used to prepare a batch of requests.
839 struct NextRequest {
840 sp<CaptureRequest> captureRequest;
841 camera3_capture_request_t halRequest;
842 Vector<camera3_stream_buffer_t> outputBuffers;
843 bool submitted;
844 };
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800845
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700846 // Wait for the next batch of requests and put them in mNextRequests. mNextRequests will
847 // be empty if it times out.
848 void waitForNextRequestBatch();
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700849
850 // Waits for a request, or returns NULL if times out. Must be called with mRequestLock hold.
851 sp<CaptureRequest> waitForNextRequestLocked();
852
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700853 // Prepare HAL requests and output buffers in mNextRequests. Return TIMED_OUT if getting any
854 // output buffer timed out. If an error is returned, the caller should clean up the pending
855 // request batch.
856 status_t prepareHalRequests();
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700857
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700858 // Return buffers, etc, for requests in mNextRequests that couldn't be fully constructed and
859 // send request errors if sendRequestError is true. The buffers will be returned in the
860 // ERROR state to mark them as not having valid data. mNextRequests will be cleared.
861 void cleanUpFailedRequests(bool sendRequestError);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800862
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700863 // Stop the repeating request if any of its output streams is abandoned.
864 void checkAndStopRepeatingRequest();
865
Emilian Peevaebbe412018-01-15 13:53:24 +0000866 // Release physical camera settings and camera id resources.
867 void cleanupPhysicalSettings(sp<CaptureRequest> request,
868 /*out*/camera3_capture_request_t *halRequest);
869
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800870 // Pause handling
871 bool waitIfPaused();
Eino-Ville Talvala26fe6c72013-08-29 12:46:18 -0700872 void unpauseForNewRequests();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800873
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700874 // Relay error to parent device object setErrorState
875 void setErrorState(const char *fmt, ...);
876
Yin-Chia Yeh8684b7f2014-06-13 14:53:05 -0700877 // If the input request is in mRepeatingRequests. Must be called with mRequestLock hold
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -0700878 bool isRepeatingRequestLocked(const sp<CaptureRequest>&);
Yin-Chia Yeh8684b7f2014-06-13 14:53:05 -0700879
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700880 // Clear repeating requests. Must be called with mRequestLock held.
881 status_t clearRepeatingRequestsLocked(/*out*/ int64_t *lastFrameNumber = NULL);
882
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800883 // send request in mNextRequests to HAL one by one. Return true = sucssess
884 bool sendRequestsOneByOne();
885
886 // send request in mNextRequests to HAL in a batch. Return true = sucssess
887 bool sendRequestsBatch();
888
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -0700889 // Calculate the expected maximum duration for a request
890 nsecs_t calculateMaxExpectedDuration(const camera_metadata_t *request);
891
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000892 // Check and update latest session parameters based on the current request settings.
893 bool updateSessionParameters(const CameraMetadata& settings);
894
Emilian Peeva14b4dd2018-05-15 11:00:31 +0100895 // Check whether FPS range session parameter re-configuration is needed in constrained
896 // high speed recording camera sessions.
897 bool skipHFRTargetFPSUpdate(int32_t tag, const camera_metadata_ro_entry_t& newEntry,
898 const camera_metadata_entry_t& currentEntry);
899
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000900 // Re-configure camera using the latest session parameters.
901 bool reconfigureCamera();
902
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800903 wp<Camera3Device> mParent;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700904 wp<camera3::StatusTracker> mStatusTracker;
Yin-Chia Yehdb1e8642017-07-14 15:19:30 -0700905 sp<HalInterface> mInterface;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800906
Yin-Chia Yehe1c80632016-08-08 14:48:05 -0700907 wp<NotificationListener> mListener;
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700908
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800909 const String8& mId; // The camera ID
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700910 int mStatusId; // The RequestThread's component ID for
911 // status tracking
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700912
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800913 Mutex mRequestLock;
914 Condition mRequestSignal;
915 RequestList mRequestQueue;
916 RequestList mRepeatingRequests;
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700917 // The next batch of requests being prepped for submission to the HAL, no longer
Eino-Ville Talvalae74c2282015-05-27 14:46:23 -0700918 // on the request queue. Read-only even with mRequestLock held, outside
919 // of threadLoop
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700920 Vector<NextRequest> mNextRequests;
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700921
922 // To protect flush() and sending a request batch to HAL.
923 Mutex mFlushLock;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800924
925 bool mReconfigured;
926
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700927 // Used by waitIfPaused, waitForNextRequest, waitUntilPaused, and signalPipelineDrain
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800928 Mutex mPauseLock;
929 bool mDoPause;
930 Condition mDoPauseSignal;
931 bool mPaused;
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700932 bool mNotifyPipelineDrain;
933 std::vector<int> mStreamIdsToBeDrained;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800934
935 sp<CaptureRequest> mPrevRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700936 int32_t mPrevTriggers;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800937
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700938 uint32_t mFrameNumber;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700939
Igor Murashkin1e479c02013-09-06 16:55:14 -0700940 mutable Mutex mLatestRequestMutex;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700941 Condition mLatestRequestSignal;
942 // android.request.id for latest process_capture_request
943 int32_t mLatestRequestId;
Igor Murashkin1e479c02013-09-06 16:55:14 -0700944 CameraMetadata mLatestRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700945
946 typedef KeyedVector<uint32_t/*tag*/, RequestTrigger> TriggerMap;
947 Mutex mTriggerMutex;
948 TriggerMap mTriggerMap;
949 TriggerMap mTriggerRemovedMap;
950 TriggerMap mTriggerReplacedMap;
Yin-Chia Yehc00a25c2014-08-21 14:27:44 -0700951 uint32_t mCurrentAfTriggerId;
952 uint32_t mCurrentPreCaptureTriggerId;
Jianing Weicb0652e2014-03-12 18:29:36 -0700953
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700954 int64_t mRepeatingLastFrameNumber;
Chien-Yu Chend196d612015-06-22 19:49:01 -0700955
Chien-Yu Chenc66969b2016-05-19 16:37:51 -0700956 // Flag indicating if we should prepare video stream for video requests.
957 bool mPrepareVideoStream;
Shuzhen Wang686f6442017-06-20 16:16:04 -0700958
Emilian Peeva14b4dd2018-05-15 11:00:31 +0100959 bool mConstrainedMode;
960
Shuzhen Wang686f6442017-06-20 16:16:04 -0700961 static const int32_t kRequestLatencyBinSize = 40; // in ms
962 CameraLatencyHistogram mRequestLatency;
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000963
964 Vector<int32_t> mSessionParamKeys;
965 CameraMetadata mLatestSessionParams;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700966
967 const bool mUseHalBufManager;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800968 };
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800969 sp<RequestThread> mRequestThread;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800970
971 /**
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700972 * In-flight queue for tracking completion of capture requests.
973 */
974
975 struct InFlightRequest {
976 // Set by notify() SHUTTER call.
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800977 nsecs_t shutterTimestamp;
978 // Set by process_capture_result().
979 nsecs_t sensorTimestamp;
Zhijun He1d1f8462013-10-02 16:29:51 -0700980 int requestStatus;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700981 // Set by process_capture_result call with valid metadata
982 bool haveResultMetadata;
983 // Decremented by calls to process_capture_result with valid output
Zhijun Hef0d962a2014-06-30 10:24:11 -0700984 // and input buffers
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700985 int numBuffersLeft;
Jianing Weicb0652e2014-03-12 18:29:36 -0700986 CaptureResultExtras resultExtras;
Zhijun Hec98bd8d2014-07-07 12:44:10 -0700987 // If this request has any input buffer
988 bool hasInputBuffer;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700989
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800990 // The last metadata that framework receives from HAL and
991 // not yet send out because the shutter event hasn't arrived.
992 // It's added by process_capture_result and sent when framework
993 // receives the shutter event.
994 CameraMetadata pendingMetadata;
995
Chien-Yu Chen5cd8d642016-03-08 14:46:58 -0800996 // The metadata of the partial results that framework receives from HAL so far
997 // and has sent out.
998 CameraMetadata collectedPartialResult;
999
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001000 // Buffers are added by process_capture_result when output buffers
1001 // return from HAL but framework has not yet received the shutter
1002 // event. They will be returned to the streams when framework receives
1003 // the shutter event.
1004 Vector<camera3_stream_buffer_t> pendingOutputBuffers;
1005
Shuzhen Wang4a472662017-02-26 23:29:04 -08001006 // Whether this inflight request's shutter and result callback are to be
1007 // called. The policy is that if the request is the last one in the constrained
1008 // high speed recording request list, this flag will be true. If the request list
1009 // is not for constrained high speed recording, this flag will also be true.
1010 bool hasCallback;
1011
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -07001012 // Maximum expected frame duration for this request.
1013 // For manual captures, equal to the max of requested exposure time and frame duration
1014 // For auto-exposure modes, equal to 1/(lower end of target FPS range)
1015 nsecs_t maxExpectedDuration;
1016
Shuzhen Wang20f57342017-08-24 15:39:05 -07001017 // Whether the result metadata for this request is to be skipped. The
1018 // result metadata should be skipped in the case of
1019 // REQUEST/RESULT error.
1020 bool skipResultMetadata;
1021
Shuzhen Wang5c22c152017-12-31 17:12:25 -08001022 // The physical camera ids being requested.
1023 std::set<String8> physicalCameraIds;
1024
1025 // Map of physicalCameraId <-> Metadata
1026 std::vector<PhysicalCaptureResultInfo> physicalMetadatas;
1027
Emilian Peev9dd21f42018-08-03 13:39:29 +01001028 // Indicates a still capture request.
1029 bool stillCapture;
1030
Shuzhen Wang26abaf42018-08-28 15:41:20 -07001031 // Indicates a ZSL capture request
1032 bool zslCapture;
1033
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001034 // Default constructor needed by KeyedVector
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001035 InFlightRequest() :
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001036 shutterTimestamp(0),
1037 sensorTimestamp(0),
Zhijun He1d1f8462013-10-02 16:29:51 -07001038 requestStatus(OK),
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001039 haveResultMetadata(false),
Zhijun Hec98bd8d2014-07-07 12:44:10 -07001040 numBuffersLeft(0),
Chien-Yu Chend196d612015-06-22 19:49:01 -07001041 hasInputBuffer(false),
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -07001042 hasCallback(true),
Shuzhen Wang20f57342017-08-24 15:39:05 -07001043 maxExpectedDuration(kDefaultExpectedDuration),
Emilian Peev9dd21f42018-08-03 13:39:29 +01001044 skipResultMetadata(false),
Shuzhen Wang26abaf42018-08-28 15:41:20 -07001045 stillCapture(false),
1046 zslCapture(false) {
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001047 }
1048
Chien-Yu Chend196d612015-06-22 19:49:01 -07001049 InFlightRequest(int numBuffers, CaptureResultExtras extras, bool hasInput,
Shuzhen Wang5c22c152017-12-31 17:12:25 -08001050 bool hasAppCallback, nsecs_t maxDuration,
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001051 const std::set<String8>& physicalCameraIdSet, bool isStillCapture,
Shuzhen Wang26abaf42018-08-28 15:41:20 -07001052 bool isZslCapture) :
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001053 shutterTimestamp(0),
1054 sensorTimestamp(0),
Jianing Weicb0652e2014-03-12 18:29:36 -07001055 requestStatus(OK),
1056 haveResultMetadata(false),
1057 numBuffersLeft(numBuffers),
Zhijun Hec98bd8d2014-07-07 12:44:10 -07001058 resultExtras(extras),
Chien-Yu Chend196d612015-06-22 19:49:01 -07001059 hasInputBuffer(hasInput),
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -07001060 hasCallback(hasAppCallback),
Shuzhen Wang20f57342017-08-24 15:39:05 -07001061 maxExpectedDuration(maxDuration),
Shuzhen Wang5c22c152017-12-31 17:12:25 -08001062 skipResultMetadata(false),
Emilian Peev9dd21f42018-08-03 13:39:29 +01001063 physicalCameraIds(physicalCameraIdSet),
Shuzhen Wang26abaf42018-08-28 15:41:20 -07001064 stillCapture(isStillCapture),
1065 zslCapture(isZslCapture) {
Zhijun Hec98bd8d2014-07-07 12:44:10 -07001066 }
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001067 };
1068
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001069 // Map from frame number to the in-flight request state
1070 typedef KeyedVector<uint32_t, InFlightRequest> InFlightMap;
1071
Yin-Chia Yeh598fc602017-07-24 11:37:23 -07001072
1073 Mutex mInFlightLock; // Protects mInFlightMap and
1074 // mExpectedInflightDuration
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001075 InFlightMap mInFlightMap;
Yin-Chia Yeh598fc602017-07-24 11:37:23 -07001076 nsecs_t mExpectedInflightDuration = 0;
Eino-Ville Talvala24b366e2016-07-21 12:53:07 -07001077 int mInFlightStatusId;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001078
Jianing Weicb0652e2014-03-12 18:29:36 -07001079 status_t registerInFlight(uint32_t frameNumber,
Chien-Yu Chend196d612015-06-22 19:49:01 -07001080 int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput,
Emilian Peev9dd21f42018-08-03 13:39:29 +01001081 bool callback, nsecs_t maxExpectedDuration, std::set<String8>& physicalCameraIds,
Shuzhen Wang26abaf42018-08-28 15:41:20 -07001082 bool isStillCapture, bool isZslCapture);
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -07001083
1084 /**
1085 * Returns the maximum expected time it'll take for all currently in-flight
1086 * requests to complete, based on their settings
1087 */
Yin-Chia Yeh598fc602017-07-24 11:37:23 -07001088 nsecs_t getExpectedInFlightDuration();
Chien-Yu Chend196d612015-06-22 19:49:01 -07001089
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001090 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001091 * Tracking for idle detection
1092 */
1093 sp<camera3::StatusTracker> mStatusTracker;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001094
1095 /**
Zhijun He125684a2015-12-26 15:07:30 -08001096 * Graphic buffer manager for output streams. Each device has a buffer manager, which is used
1097 * by the output streams to get and return buffers if these streams are registered to this
1098 * buffer manager.
1099 */
1100 sp<camera3::Camera3BufferManager> mBufferManager;
1101
1102 /**
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001103 * Thread for preparing streams
1104 */
1105 class PreparerThread : private Thread, public virtual RefBase {
1106 public:
1107 PreparerThread();
1108 ~PreparerThread();
1109
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001110 void setNotificationListener(wp<NotificationListener> listener);
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001111
1112 /**
Ruben Brunkc78ac262015-08-13 17:58:46 -07001113 * Queue up a stream to be prepared. Streams are processed by a background thread in FIFO
1114 * order. Pre-allocate up to maxCount buffers for the stream, or the maximum number needed
1115 * for the pipeline if maxCount is ALLOCATE_PIPELINE_MAX.
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001116 */
Ruben Brunkc78ac262015-08-13 17:58:46 -07001117 status_t prepare(int maxCount, sp<camera3::Camera3StreamInterface>& stream);
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001118
1119 /**
1120 * Cancel all current and pending stream preparation
1121 */
1122 status_t clear();
1123
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001124 /**
1125 * Pause all preparation activities
1126 */
1127 void pause();
1128
1129 /**
1130 * Resume preparation activities
1131 */
1132 status_t resume();
1133
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001134 private:
1135 Mutex mLock;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001136 Condition mThreadActiveSignal;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001137
1138 virtual bool threadLoop();
1139
1140 // Guarded by mLock
1141
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001142 wp<NotificationListener> mListener;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001143 std::unordered_map<int, sp<camera3::Camera3StreamInterface> > mPendingStreams;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001144 bool mActive;
1145 bool mCancelNow;
1146
1147 // Only accessed by threadLoop and the destructor
1148
1149 sp<camera3::Camera3StreamInterface> mCurrentStream;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001150 int mCurrentMaxCount;
1151 bool mCurrentPrepareComplete;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001152 };
1153 sp<PreparerThread> mPreparerThread;
1154
1155 /**
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001156 * Output result queue and current HAL device 3A state
1157 */
1158
1159 // Lock for output side of device
1160 Mutex mOutputLock;
1161
1162 /**** Scope for mOutputLock ****/
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001163 // the minimal frame number of the next non-reprocess result
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001164 uint32_t mNextResultFrameNumber;
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001165 // the minimal frame number of the next reprocess result
1166 uint32_t mNextReprocessResultFrameNumber;
Chien-Yu Chen3df11ce2015-09-30 14:13:30 -07001167 // the minimal frame number of the next non-reprocess shutter
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001168 uint32_t mNextShutterFrameNumber;
Chien-Yu Chen3df11ce2015-09-30 14:13:30 -07001169 // the minimal frame number of the next reprocess shutter
1170 uint32_t mNextReprocessShutterFrameNumber;
Jianing Weicb0652e2014-03-12 18:29:36 -07001171 List<CaptureResult> mResultQueue;
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001172 Condition mResultSignal;
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001173 wp<NotificationListener> mListener;
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001174
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001175 /**** End scope for mOutputLock ****/
1176
1177 /**
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001178 * Callback functions from HAL device
1179 */
1180 void processCaptureResult(const camera3_capture_result *result);
1181
1182 void notify(const camera3_notify_msg *msg);
1183
Eino-Ville Talvala17543512014-08-06 14:32:02 -07001184 // Specific notify handlers
1185 void notifyError(const camera3_error_msg_t &msg,
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001186 sp<NotificationListener> listener);
Eino-Ville Talvala17543512014-08-06 14:32:02 -07001187 void notifyShutter(const camera3_shutter_msg_t &msg,
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001188 sp<NotificationListener> listener);
Eino-Ville Talvala17543512014-08-06 14:32:02 -07001189
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001190 // helper function to return the output buffers to the streams.
1191 void returnOutputBuffers(const camera3_stream_buffer_t *outputBuffers,
Shuzhen Wang26abaf42018-08-28 15:41:20 -07001192 size_t numBuffers, nsecs_t timestamp, bool timestampIncreasing = true);
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001193
Chien-Yu Chen5cd8d642016-03-08 14:46:58 -08001194 // Send a partial capture result.
1195 void sendPartialCaptureResult(const camera_metadata_t * partialResult,
Emilian Peev7e25e5e2017-04-07 15:48:49 +01001196 const CaptureResultExtras &resultExtras, uint32_t frameNumber);
Chien-Yu Chen5cd8d642016-03-08 14:46:58 -08001197
1198 // Send a total capture result given the pending metadata and result extras,
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001199 // partial results, and the frame number to the result queue.
1200 void sendCaptureResult(CameraMetadata &pendingMetadata,
1201 CaptureResultExtras &resultExtras,
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001202 CameraMetadata &collectedPartialResult, uint32_t frameNumber,
Shuzhen Wang5c22c152017-12-31 17:12:25 -08001203 bool reprocess, const std::vector<PhysicalCaptureResultInfo>& physicalMetadatas);
1204
1205 bool isLastFullResult(const InFlightRequest& inFlightRequest);
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001206
Chien-Yu Chen5cd8d642016-03-08 14:46:58 -08001207 // Insert the result to the result queue after updating frame number and overriding AE
1208 // trigger cancel.
1209 // mOutputLock must be held when calling this function.
Emilian Peev7e25e5e2017-04-07 15:48:49 +01001210 void insertResultLocked(CaptureResult *result, uint32_t frameNumber);
Chien-Yu Chen5cd8d642016-03-08 14:46:58 -08001211
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001212 /**** Scope for mInFlightLock ****/
1213
Shuzhen Wangcadb3302016-11-04 14:17:56 -07001214 // Remove the in-flight map entry of the given index from mInFlightMap.
1215 // It must only be called with mInFlightLock held.
1216 void removeInFlightMapEntryLocked(int idx);
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001217 // Remove the in-flight request of the given index from mInFlightMap
1218 // if it's no longer needed. It must only be called with mInFlightLock held.
1219 void removeInFlightRequestIfReadyLocked(int idx);
Yin-Chia Yehf3fe36f2017-07-07 18:23:18 -07001220 // Remove all in-flight requests and return all buffers.
1221 // This is used after HAL interface is closed to cleanup any request/buffers
1222 // not returned by HAL.
1223 void flushInflightRequests();
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001224
1225 /**** End scope for mInFlightLock ****/
1226
Eino-Ville Talvala7b8a1fd2018-05-22 15:30:35 -07001227 /**
1228 * Distortion correction support
1229 */
1230
1231 camera3::DistortionMapper mDistortionMapper;
1232
Eino-Ville Talvala4d453832016-07-15 11:56:53 -07001233 // Debug tracker for metadata tag value changes
1234 // - Enabled with the -m <taglist> option to dumpsys, such as
1235 // dumpsys -m android.control.aeState,android.control.aeMode
1236 // - Disabled with -m off
1237 // - dumpsys -m 3a is a shortcut for ae/af/awbMode, State, and Triggers
1238 TagMonitor mTagMonitor;
1239
1240 void monitorMetadata(TagMonitor::eventSource source, int64_t frameNumber,
1241 nsecs_t timestamp, const CameraMetadata& metadata);
1242
Emilian Peev71c73a22017-03-21 16:35:51 +00001243 metadata_vendor_id_t mVendorTagId;
1244
Emilian Peev811d2952018-05-25 11:08:40 +01001245 // Cached last requested template id
1246 int mLastTemplateId;
1247
Emilian Peev26d975d2018-07-05 14:52:57 +01001248 // Synchronizes access to status tracker between inflight updates and disconnect.
1249 // b/79972865
1250 Mutex mTrackerLock;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001251
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001252 // Whether HAL request buffers through requestStreamBuffers API
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001253 bool mUseHalBufManager = false;
1254
1255 // Lock to ensure requestStreamBuffers() callbacks are serialized
1256 std::mutex mRequestBufferInterfaceLock;
1257
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001258 // The state machine to control when requestStreamBuffers should allow
1259 // HAL to request buffers.
1260 enum RequestBufferState {
1261 /**
1262 * This is the initial state.
1263 * requestStreamBuffers call will return FAILED_CONFIGURING in this state.
1264 * Will switch to RB_STATUS_READY after a successful configureStreams or
1265 * processCaptureRequest call.
1266 */
1267 RB_STATUS_STOPPED,
1268
1269 /**
1270 * requestStreamBuffers call will proceed in this state.
1271 * When device is asked to stay idle via waitUntilStateThenRelock() call:
1272 * - Switch to RB_STATUS_STOPPED if there is no inflight requests and
1273 * request thread is paused.
1274 * - Switch to RB_STATUS_PENDING_STOP otherwise
1275 */
1276 RB_STATUS_READY,
1277
1278 /**
1279 * requestStreamBuffers call will proceed in this state.
1280 * Switch to RB_STATUS_STOPPED when all inflight requests are fulfilled
1281 * and request thread is paused
1282 */
1283 RB_STATUS_PENDING_STOP,
1284 };
1285
1286 class RequestBufferStateMachine {
1287 public:
1288 status_t initialize(sp<camera3::StatusTracker> statusTracker);
1289
1290 // Return if the state machine currently allows for requestBuffers
1291 // If the state allows for it, mRequestBufferOngoing will be set to true
1292 // and caller must call endRequestBuffer() later to unset the flag
1293 bool startRequestBuffer();
1294 void endRequestBuffer();
1295
1296 // Events triggered by application API call
1297 void onStreamsConfigured();
1298 void onWaitUntilIdle();
1299
1300 // Events usually triggered by hwBinder processCaptureResult callback thread
1301 // But can also be triggered on request thread for failed request, or on
1302 // hwbinder notify callback thread for shutter/error callbacks
1303 void onInflightMapEmpty();
1304
1305 // Events triggered by RequestThread
1306 void onRequestSubmitted();
1307 void onRequestThreadPaused();
1308
1309 private:
1310 void notifyTrackerLocked(bool active);
1311
1312 // Switch to STOPPED state and return true if all conditions allows for it.
1313 // Otherwise do nothing and return false.
1314 bool checkSwitchToStopLocked();
1315
1316 std::mutex mLock;
1317 RequestBufferState mStatus = RB_STATUS_STOPPED;
1318
1319 bool mRequestThreadPaused = true;
1320 bool mInflightMapEmpty = true;
1321 bool mRequestBufferOngoing = false;
1322
1323 wp<camera3::StatusTracker> mStatusTracker;
1324 int mRequestBufferStatusId;
1325 } mRequestBufferSM;
1326
Shuzhen Wang268a1362018-10-16 16:32:59 -07001327 // Fix up result metadata for monochrome camera.
1328 bool mNeedFixupMonochromeTags;
1329 status_t fixupMonochromeTags(const CameraMetadata& deviceInfo, CameraMetadata& resultMetadata);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001330}; // class Camera3Device
1331
1332}; // namespace android
1333
1334#endif