blob: f8245df82169d58043e1621b4cf46eb0d634dbfc [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
Emilian Peev35ae8262018-11-08 13:11:32 +0000197 /**
198 * Helper functions to map between framework and HIDL values
199 */
200 static hardware::graphics::common::V1_0::PixelFormat mapToPixelFormat(int frameworkFormat);
201 static hardware::camera::device::V3_2::DataspaceFlags mapToHidlDataspace(
202 android_dataspace dataSpace);
203 static hardware::camera::device::V3_2::BufferUsageFlags mapToConsumerUsage(uint64_t usage);
204 static hardware::camera::device::V3_2::StreamRotation mapToStreamRotation(
205 camera3_stream_rotation_t rotation);
206 // Returns a negative error code if the passed-in operation mode is not valid.
207 static status_t mapToStreamConfigurationMode(camera3_stream_configuration_mode_t operationMode,
208 /*out*/ hardware::camera::device::V3_2::StreamConfigurationMode *mode);
209 static camera3_buffer_status_t mapHidlBufferStatus(
210 hardware::camera::device::V3_2::BufferStatus status);
211 static int mapToFrameworkFormat(hardware::graphics::common::V1_0::PixelFormat pixelFormat);
212 static android_dataspace mapToFrameworkDataspace(
213 hardware::camera::device::V3_2::DataspaceFlags);
214 static uint64_t mapConsumerToFrameworkUsage(
215 hardware::camera::device::V3_2::BufferUsageFlags usage);
216 static uint64_t mapProducerToFrameworkUsage(
217 hardware::camera::device::V3_2::BufferUsageFlags usage);
218
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800219 private:
Yifan Hongf79b5542017-04-11 14:44:25 -0700220
Yin-Chia Yehc5248132018-08-15 12:19:20 -0700221 status_t disconnectImpl();
222
Yifan Hongf79b5542017-04-11 14:44:25 -0700223 // internal typedefs
224 using RequestMetadataQueue = hardware::MessageQueue<uint8_t, hardware::kSynchronizedReadWrite>;
Yifan Honga640c5a2017-04-12 16:30:31 -0700225 using ResultMetadataQueue = hardware::MessageQueue<uint8_t, hardware::kSynchronizedReadWrite>;
Yifan Hongf79b5542017-04-11 14:44:25 -0700226
Igor Murashkin1e479c02013-09-06 16:55:14 -0700227 static const size_t kDumpLockAttempts = 10;
228 static const size_t kDumpSleepDuration = 100000; // 0.10 sec
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700229 static const nsecs_t kActiveTimeout = 500000000; // 500 ms
Yin-Chia Yeh90c0fdf2017-06-29 13:22:12 -0700230 static const size_t kInFlightWarnLimit = 30;
Chien-Yu Chenc96ac8d2015-08-12 16:46:24 -0700231 static const size_t kInFlightWarnLimitHighSpeed = 256; // batch size 32 * pipe depth 8
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -0700232 static const nsecs_t kDefaultExpectedDuration = 100000000; // 100 ms
233 static const nsecs_t kMinInflightDuration = 5000000000; // 5 s
Yin-Chia Yehb3a80b12018-09-04 12:13:05 -0700234 static const nsecs_t kBaseGetBufferWait = 3000000000; // 3 sec.
Eino-Ville Talvalaf99498e2015-09-25 16:52:55 -0700235 // SCHED_FIFO priority for request submission thread in HFR mode
Zhijun He7ee4c072016-07-25 13:52:28 -0700236 static const int kRequestThreadPriority = 1;
Chien-Yu Chenc96ac8d2015-08-12 16:46:24 -0700237
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700238 struct RequestTrigger;
Zhijun Hef7da0962014-04-24 13:27:56 -0700239 // minimal jpeg buffer size: 256KB + blob header
240 static const ssize_t kMinJpegBufferSize = 256 * 1024 + sizeof(camera3_jpeg_blob);
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700241 // Constant to use for stream ID when one doesn't exist
242 static const int NO_STREAM = -1;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800243
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700244 // A lock to enforce serialization on the input/configure side
245 // of the public interface.
246 // Only locked by public methods inherited from CameraDeviceBase.
247 // Not locked by methods guarded by mOutputLock, since they may act
248 // concurrently to the input/configure side of the interface.
249 // Must be locked before mLock if both will be locked by a method
250 Mutex mInterfaceLock;
251
252 // The main lock on internal state
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800253 Mutex mLock;
254
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700255 // Camera device ID
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800256 const String8 mId;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700257
Eino-Ville Talvalabbbbe842017-02-28 17:50:56 -0800258 // Current stream configuration mode;
259 int mOperatingMode;
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100260 // Current session wide parameters
261 hardware::camera2::impl::CameraMetadataNative mSessionParams;
262
Eino-Ville Talvalabbbbe842017-02-28 17:50:56 -0800263 // Constant to use for no set operating mode
264 static const int NO_MODE = -1;
265
Zhijun He1fa89992015-06-01 15:44:31 -0700266 // Flag indicating is the current active stream configuration is constrained high speed.
267 bool mIsConstrainedHighSpeedConfiguration;
268
Yifan Honga640c5a2017-04-12 16:30:31 -0700269 // FMQ to write result on. Must be guarded by mProcessCaptureResultLock.
270 std::unique_ptr<ResultMetadataQueue> mResultMetadataQueue;
271
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800272 /**** Scope for mLock ****/
273
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800274 /**
275 * Adapter for legacy HAL / HIDL HAL interface calls; calls either into legacy HALv3 or the
276 * HIDL HALv3 interfaces.
277 */
Yin-Chia Yehbe83fa72017-03-30 13:35:36 -0700278 class HalInterface : public camera3::Camera3StreamBufferFreedListener {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800279 public:
Yifan Hongf79b5542017-04-11 14:44:25 -0700280 HalInterface(sp<hardware::camera::device::V3_2::ICameraDeviceSession> &session,
Yin-Chia Yeh651fe2e2018-11-13 11:49:31 -0800281 std::shared_ptr<RequestMetadataQueue> queue,
282 bool useHalBufManager);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800283 HalInterface(const HalInterface &other);
284 HalInterface();
285
286 // Returns true if constructed with a valid device or session, and not yet cleared
287 bool valid();
288
289 // Reset this HalInterface object (does not call close())
290 void clear();
291
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800292 // Check if HalInterface support sending requests in batch
293 bool supportBatchRequest();
294
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800295 // Calls into the HAL interface
296
297 // Caller takes ownership of requestTemplate
298 status_t constructDefaultRequestSettings(camera3_request_template_t templateId,
299 /*out*/ camera_metadata_t **requestTemplate);
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100300 status_t configureStreams(const camera_metadata_t *sessionParams,
Yin-Chia Yehfb6e55b2018-01-25 10:50:26 -0800301 /*inout*/ camera3_stream_configuration *config,
Emilian Peev192ee832018-01-31 14:46:47 +0000302 const std::vector<uint32_t>& bufferSizes);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800303 status_t processCaptureRequest(camera3_capture_request_t *request);
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800304 status_t processBatchCaptureRequests(
305 std::vector<camera3_capture_request_t*>& requests,
306 /*out*/uint32_t* numRequestProcessed);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800307 status_t flush();
308 status_t dump(int fd);
309 status_t close();
310
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700311 void signalPipelineDrain(const std::vector<int>& streamIds);
Emilian Peev4ec17882019-01-24 17:16:58 -0800312 bool isReconfigurationRequired(CameraMetadata& oldSessionParams,
313 CameraMetadata& newSessionParams);
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700314
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700315 // method to extract buffer's unique ID
316 // return pair of (newlySeenBuffer?, bufferId)
317 std::pair<bool, uint64_t> getBufferId(const buffer_handle_t& buf, int streamId);
318
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800319 // Find a buffer_handle_t based on frame number and stream ID
320 status_t popInflightBuffer(int32_t frameNumber, int32_t streamId,
321 /*out*/ buffer_handle_t **buffer);
322
Yin-Chia Yeh84be5782019-03-01 11:47:02 -0800323 // Register a bufId (streamId, buffer_handle_t) to inflight request buffer
324 status_t pushInflightRequestBuffer(
325 uint64_t bufferId, buffer_handle_t* buf, int32_t streamId);
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700326
327 // Find a buffer_handle_t based on bufferId
Yin-Chia Yeh84be5782019-03-01 11:47:02 -0800328 status_t popInflightRequestBuffer(uint64_t bufferId,
329 /*out*/ buffer_handle_t** buffer,
330 /*optional out*/ int32_t* streamId = nullptr);
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700331
Yin-Chia Yehf3fe36f2017-07-07 18:23:18 -0700332 // Get a vector of (frameNumber, streamId) pair of currently inflight
333 // buffers
334 void getInflightBufferKeys(std::vector<std::pair<int32_t, int32_t>>* out);
335
Yin-Chia Yeh84be5782019-03-01 11:47:02 -0800336 // Get a vector of bufferId of currently inflight buffers
337 void getInflightRequestBufferKeys(std::vector<uint64_t>* out);
338
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700339 static const uint64_t BUFFER_ID_NO_BUFFER = 0;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800340 private:
Eino-Ville Talvala1a86df52018-01-17 16:00:35 -0800341 // Always valid
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800342 sp<hardware::camera::device::V3_2::ICameraDeviceSession> mHidlSession;
Eino-Ville Talvala1a86df52018-01-17 16:00:35 -0800343 // Valid if ICameraDeviceSession is @3.3 or newer
344 sp<hardware::camera::device::V3_3::ICameraDeviceSession> mHidlSession_3_3;
345 // Valid if ICameraDeviceSession is @3.4 or newer
346 sp<hardware::camera::device::V3_4::ICameraDeviceSession> mHidlSession_3_4;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700347 // Valid if ICameraDeviceSession is @3.5 or newer
348 sp<hardware::camera::device::V3_5::ICameraDeviceSession> mHidlSession_3_5;
Eino-Ville Talvala1a86df52018-01-17 16:00:35 -0800349
Yifan Hongf79b5542017-04-11 14:44:25 -0700350 std::shared_ptr<RequestMetadataQueue> mRequestMetadataQueue;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800351
352 std::mutex mInflightLock;
353
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800354 // The output HIDL request still depends on input camera3_capture_request_t
355 // Do not free input camera3_capture_request_t before output HIDL request
Yin-Chia Yeh651fe2e2018-11-13 11:49:31 -0800356 status_t wrapAsHidlRequest(camera3_capture_request_t* in,
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800357 /*out*/hardware::camera::device::V3_2::CaptureRequest* out,
358 /*out*/std::vector<native_handle_t*>* handlesCreated);
359
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800360 status_t pushInflightBufferLocked(int32_t frameNumber, int32_t streamId,
Yin-Chia Yehf4650602017-01-10 13:13:39 -0800361 buffer_handle_t *buffer, int acquireFence);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800362 // Cache of buffer handles keyed off (frameNumber << 32 | streamId)
Yin-Chia Yehf4650602017-01-10 13:13:39 -0800363 // value is a pair of (buffer_handle_t*, acquire_fence FD)
364 std::unordered_map<uint64_t, std::pair<buffer_handle_t*, int>> mInflightBufferMap;
Yin-Chia Yeh77327052017-01-09 18:23:07 -0800365
366 struct BufferHasher {
367 size_t operator()(const buffer_handle_t& buf) const {
368 if (buf == nullptr)
369 return 0;
370
371 size_t result = 1;
372 result = 31 * result + buf->numFds;
Emilian Peev2a6a4682017-04-20 10:58:51 +0100373 for (int i = 0; i < buf->numFds; i++) {
Yin-Chia Yeh77327052017-01-09 18:23:07 -0800374 result = 31 * result + buf->data[i];
375 }
376 return result;
377 }
378 };
379
380 struct BufferComparator {
381 bool operator()(const buffer_handle_t& buf1, const buffer_handle_t& buf2) const {
Emilian Peev2a6a4682017-04-20 10:58:51 +0100382 if (buf1->numFds == buf2->numFds) {
383 for (int i = 0; i < buf1->numFds; i++) {
Yin-Chia Yeh77327052017-01-09 18:23:07 -0800384 if (buf1->data[i] != buf2->data[i]) {
385 return false;
386 }
387 }
388 return true;
389 }
390 return false;
391 }
392 };
393
394 std::mutex mBufferIdMapLock; // protecting mBufferIdMaps and mNextBufferId
395 typedef std::unordered_map<const buffer_handle_t, uint64_t,
396 BufferHasher, BufferComparator> BufferIdMap;
397 // stream ID -> per stream buffer ID map
398 std::unordered_map<int, BufferIdMap> mBufferIdMaps;
399 uint64_t mNextBufferId = 1; // 0 means no buffer
Yin-Chia Yehbe83fa72017-03-30 13:35:36 -0700400
401 virtual void onBufferFreed(int streamId, const native_handle_t* handle) override;
402
403 std::vector<std::pair<int, uint64_t>> mFreedBuffers;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700404
405 // Buffers given to HAL through requestStreamBuffer API
406 std::mutex mRequestedBuffersLock;
Yin-Chia Yeh84be5782019-03-01 11:47:02 -0800407 std::unordered_map<uint64_t, std::pair<int32_t, buffer_handle_t*>> mRequestedBuffers;
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700408
409 uint32_t mNextStreamConfigCounter = 1;
Yin-Chia Yeh651fe2e2018-11-13 11:49:31 -0800410
411 const bool mUseHalBufManager;
Emilian Peev4ec17882019-01-24 17:16:58 -0800412 bool mIsReconfigurationQuerySupported;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800413 };
414
Yin-Chia Yehdb1e8642017-07-14 15:19:30 -0700415 sp<HalInterface> mInterface;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800416
417 CameraMetadata mDeviceInfo;
Shuzhen Wang2e7f58f2018-07-11 14:00:29 -0700418 std::unordered_map<std::string, CameraMetadata> mPhysicalDeviceInfoMap;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800419
Zhijun Hea1530f12014-09-14 12:44:20 -0700420 CameraMetadata mRequestTemplateCache[CAMERA3_TEMPLATE_COUNT];
421
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700422 struct Size {
423 uint32_t width;
424 uint32_t height;
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -0700425 explicit Size(uint32_t w = 0, uint32_t h = 0) : width(w), height(h){}
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700426 };
427 // Map from format to size.
428 Vector<Size> mSupportedOpaqueInputSizes;
429
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700430 enum Status {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800431 STATUS_ERROR,
432 STATUS_UNINITIALIZED,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700433 STATUS_UNCONFIGURED,
434 STATUS_CONFIGURED,
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800435 STATUS_ACTIVE
436 } mStatus;
Ruben Brunk183f0562015-08-12 12:55:02 -0700437
438 // Only clear mRecentStatusUpdates, mStatusWaiters from waitUntilStateThenRelock
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700439 Vector<Status> mRecentStatusUpdates;
Ruben Brunk183f0562015-08-12 12:55:02 -0700440 int mStatusWaiters;
441
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700442 Condition mStatusChanged;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800443
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700444 // Tracking cause of fatal errors when in STATUS_ERROR
445 String8 mErrorCause;
446
Yin-Chia Yeh4ee35432018-10-10 13:52:31 -0700447 // Synchronized mapping of stream IDs to stream instances
448 class StreamSet {
449 public:
450 status_t add(int streamId, sp<camera3::Camera3OutputStreamInterface>);
451 ssize_t remove(int streamId);
452 sp<camera3::Camera3OutputStreamInterface> get(int streamId);
453 // get by (underlying) vector index
454 sp<camera3::Camera3OutputStreamInterface> operator[] (size_t index);
455 size_t size() const;
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700456 std::vector<int> getStreamIds();
Yin-Chia Yeh4ee35432018-10-10 13:52:31 -0700457 void clear();
458
459 private:
460 mutable std::mutex mLock;
461 KeyedVector<int, sp<camera3::Camera3OutputStreamInterface>> mData;
462 };
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800463
464 StreamSet mOutputStreams;
465 sp<camera3::Camera3Stream> mInputStream;
466 int mNextStreamId;
Eino-Ville Talvalaea26c772013-06-11 16:04:06 -0700467 bool mNeedConfig;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800468
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700469 int mDummyStreamId;
470
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700471 // Whether to send state updates upstream
472 // Pause when doing transparent reconfiguration
473 bool mPauseStateNotify;
474
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800475 // Need to hold on to stream references until configure completes.
Igor Murashkin2fba5842013-04-22 14:03:54 -0700476 Vector<sp<camera3::Camera3StreamInterface> > mDeletedStreams;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800477
Zhijun He204e3292014-07-14 17:09:23 -0700478 // Whether the HAL will send partial result
479 bool mUsePartialResult;
480
481 // Number of partial results that will be delivered by the HAL.
482 uint32_t mNumPartialResults;
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700483
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800484 /**** End scope for mLock ****/
485
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800486 // The offset converting from clock domain of other subsystem
487 // (video/hardware composer) to that of camera. Assumption is that this
488 // offset won't change during the life cycle of the camera device. In other
489 // words, camera device shouldn't be open during CPU suspend.
490 nsecs_t mTimestampOffset;
491
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800492 class CaptureRequest : public LightRefBase<CaptureRequest> {
493 public:
Emilian Peevaebbe412018-01-15 13:53:24 +0000494 PhysicalCameraSettingsList mSettingsList;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800495 sp<camera3::Camera3Stream> mInputStream;
Chien-Yu Chenc2adf482015-05-27 14:27:49 -0700496 camera3_stream_buffer_t mInputBuffer;
Igor Murashkin2fba5842013-04-22 14:03:54 -0700497 Vector<sp<camera3::Camera3OutputStreamInterface> >
498 mOutputStreams;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700499 SurfaceMap mOutputSurfaces;
Jianing Weicb0652e2014-03-12 18:29:36 -0700500 CaptureResultExtras mResultExtras;
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700501 // The number of requests that should be submitted to HAL at a time.
502 // For example, if batch size is 8, this request and the following 7
503 // requests will be submitted to HAL at a time. The batch size for
504 // the following 7 requests will be ignored by the request thread.
505 int mBatchSize;
Shuzhen Wang9d066012016-09-30 11:30:20 -0700506 // Whether this request is from a repeating or repeating burst.
507 bool mRepeating;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800508 };
509 typedef List<sp<CaptureRequest> > RequestList;
510
Jianing Wei90e59c92014-03-12 18:29:36 -0700511 status_t checkStatusOkToCaptureLocked();
512
513 status_t convertMetadataListToRequestListLocked(
Emilian Peevaebbe412018-01-15 13:53:24 +0000514 const List<const PhysicalCameraSettingsList> &metadataList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700515 const std::list<const SurfaceMap> &surfaceMaps,
Shuzhen Wang9d066012016-09-30 11:30:20 -0700516 bool repeating,
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700517 /*out*/
518 RequestList *requestList);
Jianing Wei90e59c92014-03-12 18:29:36 -0700519
Emilian Peevaebbe412018-01-15 13:53:24 +0000520 void convertToRequestList(List<const PhysicalCameraSettingsList>& requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700521 std::list<const SurfaceMap>& surfaceMaps,
522 const CameraMetadata& request);
523
Emilian Peevaebbe412018-01-15 13:53:24 +0000524 status_t submitRequestsHelper(const List<const PhysicalCameraSettingsList> &requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700525 const std::list<const SurfaceMap> &surfaceMaps,
526 bool repeating,
Jianing Weicb0652e2014-03-12 18:29:36 -0700527 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700528
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800529
530 /**
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700531 * Implementation of android::hardware::camera::device::V3_5::ICameraDeviceCallback
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800532 */
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700533
Shuzhen Wang5c22c152017-12-31 17:12:25 -0800534 hardware::Return<void> processCaptureResult_3_4(
535 const hardware::hidl_vec<
536 hardware::camera::device::V3_4::CaptureResult>& results) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800537 hardware::Return<void> processCaptureResult(
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800538 const hardware::hidl_vec<
539 hardware::camera::device::V3_2::CaptureResult>& results) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800540 hardware::Return<void> notify(
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800541 const hardware::hidl_vec<
542 hardware::camera::device::V3_2::NotifyMsg>& msgs) override;
543
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700544 hardware::Return<void> requestStreamBuffers(
545 const hardware::hidl_vec<
546 hardware::camera::device::V3_5::BufferRequest>& bufReqs,
547 requestStreamBuffers_cb _hidl_cb) override;
548
549 hardware::Return<void> returnStreamBuffers(
550 const hardware::hidl_vec<
551 hardware::camera::device::V3_2::StreamBuffer>& buffers) override;
552
Yifan Honga640c5a2017-04-12 16:30:31 -0700553 // Handle one capture result. Assume that mProcessCaptureResultLock is held.
554 void processOneCaptureResultLocked(
Shuzhen Wang5c22c152017-12-31 17:12:25 -0800555 const hardware::camera::device::V3_2::CaptureResult& result,
556 const hardware::hidl_vec<
557 hardware::camera::device::V3_4::PhysicalCameraMetadata> physicalCameraMetadatas);
558 status_t readOneCameraMetadataLocked(uint64_t fmqResultSize,
559 hardware::camera::device::V3_2::CameraMetadata& resultMetadata,
560 const hardware::camera::device::V3_2::CameraMetadata& result);
561
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800562 // Handle one notify message
563 void notify(const hardware::camera::device::V3_2::NotifyMsg& msg);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800564
Yifan Honga640c5a2017-04-12 16:30:31 -0700565 // lock to ensure only one processCaptureResult is called at a time.
566 Mutex mProcessCaptureResultLock;
567
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800568 /**
569 * Common initialization code shared by both HAL paths
570 *
571 * Must be called with mLock and mInterfaceLock held.
572 */
573 status_t initializeCommonLocked();
574
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800575 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700576 * Get the last request submitted to the hal by the request thread.
577 *
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800578 * Must be called with mLock held.
Igor Murashkin1e479c02013-09-06 16:55:14 -0700579 */
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700580 virtual CameraMetadata getLatestRequestLocked();
Igor Murashkin1e479c02013-09-06 16:55:14 -0700581
582 /**
Ruben Brunk183f0562015-08-12 12:55:02 -0700583 * Update the current device status and wake all waiting threads.
584 *
585 * Must be called with mLock held.
586 */
587 void internalUpdateStatusLocked(Status status);
588
589 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700590 * Pause processing and flush everything, but don't tell the clients.
591 * This is for reconfiguring outputs transparently when according to the
592 * CameraDeviceBase interface we shouldn't need to.
593 * Must be called with mLock and mInterfaceLock both held.
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800594 */
Yin-Chia Yeh598fc602017-07-24 11:37:23 -0700595 status_t internalPauseAndWaitLocked(nsecs_t maxExpectedDuration);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700596
597 /**
598 * Resume work after internalPauseAndWaitLocked()
599 * Must be called with mLock and mInterfaceLock both held.
600 */
601 status_t internalResumeLocked();
602
603 /**
604 * Wait until status tracker tells us we've transitioned to the target state
605 * set, which is either ACTIVE when active==true or IDLE (which is any
606 * non-ACTIVE state) when active==false.
607 *
608 * Needs to be called with mLock and mInterfaceLock held. This means there
609 * can ever only be one waiter at most.
610 *
611 * During the wait mLock is released.
612 *
613 */
614 status_t waitUntilStateThenRelock(bool active, nsecs_t timeout);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800615
616 /**
Zhijun He69a37482014-03-23 18:44:49 -0700617 * Implementation of waitUntilDrained. On success, will transition to IDLE state.
618 *
619 * Need to be called with mLock and mInterfaceLock held.
620 */
Yin-Chia Yeh598fc602017-07-24 11:37:23 -0700621 status_t waitUntilDrainedLocked(nsecs_t maxExpectedDuration);
Zhijun He69a37482014-03-23 18:44:49 -0700622
623 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800624 * Do common work for setting up a streaming or single capture request.
625 * On success, will transition to ACTIVE if in IDLE.
626 */
Emilian Peevaebbe412018-01-15 13:53:24 +0000627 sp<CaptureRequest> setUpRequestLocked(const PhysicalCameraSettingsList &request,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700628 const SurfaceMap &surfaceMap);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800629
630 /**
631 * Build a CaptureRequest request from the CameraDeviceBase request
632 * settings.
633 */
Emilian Peevaebbe412018-01-15 13:53:24 +0000634 sp<CaptureRequest> createCaptureRequest(const PhysicalCameraSettingsList &request,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700635 const SurfaceMap &surfaceMap);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800636
637 /**
Eino-Ville Talvala002001b2018-01-23 16:53:50 -0800638 * Pause state updates to the client application. Needed to mask out idle/active
639 * transitions during internal reconfigure
640 */
641 void pauseStateNotify(bool enable);
642
643 /**
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000644 * Internally re-configure camera device using new session parameters.
Eino-Ville Talvala002001b2018-01-23 16:53:50 -0800645 * This will get triggered by the request thread. Be sure to call
646 * pauseStateNotify(true) before going idle in the requesting location.
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000647 */
648 bool reconfigureCamera(const CameraMetadata& sessionParams);
649
650 /**
651 * Filter stream session parameters and configure camera HAL.
652 */
653 status_t filterParamsAndConfigureLocked(const CameraMetadata& sessionParams,
654 int operatingMode);
655
656 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800657 * Take the currently-defined set of streams and configure the HAL to use
658 * them. This is a long-running operation (may be several hundered ms).
659 */
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100660 status_t configureStreamsLocked(int operatingMode,
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000661 const CameraMetadata& sessionParams, bool notifyRequestThread = true);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800662
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700663 /**
Chien-Yu Chen9b5860b2016-06-10 13:39:09 -0700664 * Cancel stream configuration that did not finish successfully.
665 */
666 void cancelStreamsConfigurationLocked();
667
668 /**
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700669 * Add a dummy stream to the current stream set as a workaround for
670 * not allowing 0 streams in the camera HAL spec.
671 */
672 status_t addDummyStreamLocked();
673
674 /**
675 * Remove a dummy stream if the current config includes real streams.
676 */
677 status_t tryRemoveDummyStreamLocked();
678
679 /**
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700680 * Set device into an error state due to some fatal failure, and set an
681 * error message to indicate why. Only the first call's message will be
682 * used. The message is also sent to the log.
683 */
684 void setErrorState(const char *fmt, ...);
685 void setErrorStateV(const char *fmt, va_list args);
686 void setErrorStateLocked(const char *fmt, ...);
687 void setErrorStateLockedV(const char *fmt, va_list args);
688
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700689 /**
690 * Debugging trylock/spin method
691 * Try to acquire a lock a few times with sleeps between before giving up.
692 */
693 bool tryLockSpinRightRound(Mutex& lock);
694
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700695 /**
696 * Helper function to determine if an input size for implementation defined
697 * format is supported.
698 */
699 bool isOpaqueInputSizeSupported(uint32_t width, uint32_t height);
Yin-Chia Yehcd8fce82014-06-18 10:51:34 -0700700
701 /**
702 * Helper function to get the largest Jpeg resolution (in area)
703 * Return Size(0, 0) if static metatdata is invalid
704 */
705 Size getMaxJpegResolution() const;
706
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800707 /**
708 * Helper function to get the offset between MONOTONIC and BOOTTIME
709 * timestamp.
710 */
711 static nsecs_t getMonoToBoottimeOffset();
712
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700713 struct RequestTrigger {
714 // Metadata tag number, e.g. android.control.aePrecaptureTrigger
715 uint32_t metadataTag;
716 // Metadata value, e.g. 'START' or the trigger ID
717 int32_t entryValue;
718
719 // The last part of the fully qualified path, e.g. afTrigger
720 const char *getTagName() const {
721 return get_camera_metadata_tag_name(metadataTag) ?: "NULL";
722 }
723
724 // e.g. TYPE_BYTE, TYPE_INT32, etc.
725 int getTagType() const {
726 return get_camera_metadata_tag_type(metadataTag);
727 }
728 };
729
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800730 /**
731 * Thread for managing capture request submission to HAL device.
732 */
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800733 class RequestThread : public Thread {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800734
735 public:
736
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800737 RequestThread(wp<Camera3Device> parent,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700738 sp<camera3::StatusTracker> statusTracker,
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700739 sp<HalInterface> interface,
740 const Vector<int32_t>& sessionParamKeys,
741 bool useHalBufManager);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800742 ~RequestThread();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800743
Yin-Chia Yehe1c80632016-08-08 14:48:05 -0700744 void setNotificationListener(wp<NotificationListener> listener);
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700745
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800746 /**
747 * Call after stream (re)-configuration is completed.
748 */
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000749 void configurationComplete(bool isConstrainedHighSpeed,
750 const CameraMetadata& sessionParams);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800751
752 /**
753 * Set or clear the list of repeating requests. Does not block
754 * on either. Use waitUntilPaused to wait until request queue
755 * has emptied out.
756 */
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700757 status_t setRepeatingRequests(const RequestList& requests,
758 /*out*/
759 int64_t *lastFrameNumber = NULL);
760 status_t clearRepeatingRequests(/*out*/
761 int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800762
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700763 status_t queueRequestList(List<sp<CaptureRequest> > &requests,
764 /*out*/
765 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700766
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800767 /**
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700768 * Remove all queued and repeating requests, and pending triggers
769 */
Yin-Chia Yehe1c80632016-08-08 14:48:05 -0700770 status_t clear(/*out*/int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700771
772 /**
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700773 * Flush all pending requests in HAL.
774 */
775 status_t flush();
776
777 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700778 * Queue a trigger to be dispatched with the next outgoing
779 * process_capture_request. The settings for that request only
780 * will be temporarily rewritten to add the trigger tag/value.
781 * Subsequent requests will not be rewritten (for this tag).
782 */
783 status_t queueTrigger(RequestTrigger trigger[], size_t count);
784
785 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800786 * Pause/unpause the capture thread. Doesn't block, so use
787 * waitUntilPaused to wait until the thread is paused.
788 */
789 void setPaused(bool paused);
790
791 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700792 * Wait until thread processes the capture request with settings'
793 * android.request.id == requestId.
794 *
795 * Returns TIMED_OUT in case the thread does not process the request
796 * within the timeout.
797 */
798 status_t waitUntilRequestProcessed(int32_t requestId, nsecs_t timeout);
799
Igor Murashkin1e479c02013-09-06 16:55:14 -0700800 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700801 * Shut down the thread. Shutdown is asynchronous, so thread may
802 * still be running once this method returns.
803 */
804 virtual void requestExit();
805
806 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700807 * Get the latest request that was sent to the HAL
808 * with process_capture_request.
809 */
810 CameraMetadata getLatestRequest() const;
811
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700812 /**
813 * Returns true if the stream is a target of any queued or repeating
814 * capture request
815 */
816 bool isStreamPending(sp<camera3::Camera3StreamInterface>& stream);
817
Emilian Peev40ead602017-09-26 15:46:36 +0100818 /**
819 * Returns true if the surface is a target of any queued or repeating
820 * capture request
821 */
822 bool isOutputSurfacePending(int streamId, size_t surfaceId);
823
Shuzhen Wang686f6442017-06-20 16:16:04 -0700824 // dump processCaptureRequest latency
825 void dumpCaptureRequestLatency(int fd, const char* name) {
826 mRequestLatency.dump(fd, name);
827 }
828
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700829 void signalPipelineDrain(const std::vector<int>& streamIds);
830
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800831 protected:
832
833 virtual bool threadLoop();
834
835 private:
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800836 static const String8& getId(const wp<Camera3Device> &device);
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700837
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700838 status_t queueTriggerLocked(RequestTrigger trigger);
839 // Mix-in queued triggers into this request
840 int32_t insertTriggers(const sp<CaptureRequest> &request);
841 // Purge the queued triggers from this request,
842 // restoring the old field values for those tags.
843 status_t removeTriggers(const sp<CaptureRequest> &request);
844
Eino-Ville Talvala2f876f92013-09-13 11:39:24 -0700845 // HAL workaround: Make sure a trigger ID always exists if
846 // a trigger does
847 status_t addDummyTriggerIds(const sp<CaptureRequest> &request);
848
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800849 static const nsecs_t kRequestTimeout = 50e6; // 50 ms
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800850
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700851 // Used to prepare a batch of requests.
852 struct NextRequest {
853 sp<CaptureRequest> captureRequest;
854 camera3_capture_request_t halRequest;
855 Vector<camera3_stream_buffer_t> outputBuffers;
856 bool submitted;
857 };
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800858
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700859 // Wait for the next batch of requests and put them in mNextRequests. mNextRequests will
860 // be empty if it times out.
861 void waitForNextRequestBatch();
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700862
863 // Waits for a request, or returns NULL if times out. Must be called with mRequestLock hold.
864 sp<CaptureRequest> waitForNextRequestLocked();
865
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700866 // Prepare HAL requests and output buffers in mNextRequests. Return TIMED_OUT if getting any
867 // output buffer timed out. If an error is returned, the caller should clean up the pending
868 // request batch.
869 status_t prepareHalRequests();
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700870
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700871 // Return buffers, etc, for requests in mNextRequests that couldn't be fully constructed and
872 // send request errors if sendRequestError is true. The buffers will be returned in the
873 // ERROR state to mark them as not having valid data. mNextRequests will be cleared.
874 void cleanUpFailedRequests(bool sendRequestError);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800875
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700876 // Stop the repeating request if any of its output streams is abandoned.
877 void checkAndStopRepeatingRequest();
878
Emilian Peevaebbe412018-01-15 13:53:24 +0000879 // Release physical camera settings and camera id resources.
880 void cleanupPhysicalSettings(sp<CaptureRequest> request,
881 /*out*/camera3_capture_request_t *halRequest);
882
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800883 // Pause handling
884 bool waitIfPaused();
Eino-Ville Talvala26fe6c72013-08-29 12:46:18 -0700885 void unpauseForNewRequests();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800886
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700887 // Relay error to parent device object setErrorState
888 void setErrorState(const char *fmt, ...);
889
Yin-Chia Yeh8684b7f2014-06-13 14:53:05 -0700890 // If the input request is in mRepeatingRequests. Must be called with mRequestLock hold
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -0700891 bool isRepeatingRequestLocked(const sp<CaptureRequest>&);
Yin-Chia Yeh8684b7f2014-06-13 14:53:05 -0700892
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700893 // Clear repeating requests. Must be called with mRequestLock held.
894 status_t clearRepeatingRequestsLocked(/*out*/ int64_t *lastFrameNumber = NULL);
895
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800896 // send request in mNextRequests to HAL one by one. Return true = sucssess
897 bool sendRequestsOneByOne();
898
899 // send request in mNextRequests to HAL in a batch. Return true = sucssess
900 bool sendRequestsBatch();
901
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -0700902 // Calculate the expected maximum duration for a request
903 nsecs_t calculateMaxExpectedDuration(const camera_metadata_t *request);
904
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000905 // Check and update latest session parameters based on the current request settings.
906 bool updateSessionParameters(const CameraMetadata& settings);
907
Emilian Peeva14b4dd2018-05-15 11:00:31 +0100908 // Check whether FPS range session parameter re-configuration is needed in constrained
909 // high speed recording camera sessions.
910 bool skipHFRTargetFPSUpdate(int32_t tag, const camera_metadata_ro_entry_t& newEntry,
911 const camera_metadata_entry_t& currentEntry);
912
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000913 // Re-configure camera using the latest session parameters.
914 bool reconfigureCamera();
915
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800916 wp<Camera3Device> mParent;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700917 wp<camera3::StatusTracker> mStatusTracker;
Yin-Chia Yehdb1e8642017-07-14 15:19:30 -0700918 sp<HalInterface> mInterface;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800919
Yin-Chia Yehe1c80632016-08-08 14:48:05 -0700920 wp<NotificationListener> mListener;
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700921
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800922 const String8& mId; // The camera ID
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700923 int mStatusId; // The RequestThread's component ID for
924 // status tracking
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700925
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800926 Mutex mRequestLock;
927 Condition mRequestSignal;
928 RequestList mRequestQueue;
929 RequestList mRepeatingRequests;
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700930 // The next batch of requests being prepped for submission to the HAL, no longer
Eino-Ville Talvalae74c2282015-05-27 14:46:23 -0700931 // on the request queue. Read-only even with mRequestLock held, outside
932 // of threadLoop
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700933 Vector<NextRequest> mNextRequests;
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700934
935 // To protect flush() and sending a request batch to HAL.
936 Mutex mFlushLock;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800937
938 bool mReconfigured;
939
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700940 // Used by waitIfPaused, waitForNextRequest, waitUntilPaused, and signalPipelineDrain
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800941 Mutex mPauseLock;
942 bool mDoPause;
943 Condition mDoPauseSignal;
944 bool mPaused;
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700945 bool mNotifyPipelineDrain;
946 std::vector<int> mStreamIdsToBeDrained;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800947
948 sp<CaptureRequest> mPrevRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700949 int32_t mPrevTriggers;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800950
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700951 uint32_t mFrameNumber;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700952
Igor Murashkin1e479c02013-09-06 16:55:14 -0700953 mutable Mutex mLatestRequestMutex;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700954 Condition mLatestRequestSignal;
955 // android.request.id for latest process_capture_request
956 int32_t mLatestRequestId;
Igor Murashkin1e479c02013-09-06 16:55:14 -0700957 CameraMetadata mLatestRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700958
959 typedef KeyedVector<uint32_t/*tag*/, RequestTrigger> TriggerMap;
960 Mutex mTriggerMutex;
961 TriggerMap mTriggerMap;
962 TriggerMap mTriggerRemovedMap;
963 TriggerMap mTriggerReplacedMap;
Yin-Chia Yehc00a25c2014-08-21 14:27:44 -0700964 uint32_t mCurrentAfTriggerId;
965 uint32_t mCurrentPreCaptureTriggerId;
Jianing Weicb0652e2014-03-12 18:29:36 -0700966
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700967 int64_t mRepeatingLastFrameNumber;
Chien-Yu Chend196d612015-06-22 19:49:01 -0700968
Chien-Yu Chenc66969b2016-05-19 16:37:51 -0700969 // Flag indicating if we should prepare video stream for video requests.
970 bool mPrepareVideoStream;
Shuzhen Wang686f6442017-06-20 16:16:04 -0700971
Emilian Peeva14b4dd2018-05-15 11:00:31 +0100972 bool mConstrainedMode;
973
Shuzhen Wang686f6442017-06-20 16:16:04 -0700974 static const int32_t kRequestLatencyBinSize = 40; // in ms
975 CameraLatencyHistogram mRequestLatency;
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000976
977 Vector<int32_t> mSessionParamKeys;
978 CameraMetadata mLatestSessionParams;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700979
980 const bool mUseHalBufManager;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800981 };
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800982 sp<RequestThread> mRequestThread;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800983
984 /**
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700985 * In-flight queue for tracking completion of capture requests.
986 */
987
988 struct InFlightRequest {
989 // Set by notify() SHUTTER call.
Chien-Yu Chen43e69a62014-11-25 16:38:33 -0800990 nsecs_t shutterTimestamp;
991 // Set by process_capture_result().
992 nsecs_t sensorTimestamp;
Zhijun He1d1f8462013-10-02 16:29:51 -0700993 int requestStatus;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700994 // Set by process_capture_result call with valid metadata
995 bool haveResultMetadata;
996 // Decremented by calls to process_capture_result with valid output
Zhijun Hef0d962a2014-06-30 10:24:11 -0700997 // and input buffers
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700998 int numBuffersLeft;
Jianing Weicb0652e2014-03-12 18:29:36 -0700999 CaptureResultExtras resultExtras;
Zhijun Hec98bd8d2014-07-07 12:44:10 -07001000 // If this request has any input buffer
1001 bool hasInputBuffer;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001002
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001003 // The last metadata that framework receives from HAL and
1004 // not yet send out because the shutter event hasn't arrived.
1005 // It's added by process_capture_result and sent when framework
1006 // receives the shutter event.
1007 CameraMetadata pendingMetadata;
1008
Chien-Yu Chen5cd8d642016-03-08 14:46:58 -08001009 // The metadata of the partial results that framework receives from HAL so far
1010 // and has sent out.
1011 CameraMetadata collectedPartialResult;
1012
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001013 // Buffers are added by process_capture_result when output buffers
1014 // return from HAL but framework has not yet received the shutter
1015 // event. They will be returned to the streams when framework receives
1016 // the shutter event.
1017 Vector<camera3_stream_buffer_t> pendingOutputBuffers;
1018
Shuzhen Wang4a472662017-02-26 23:29:04 -08001019 // Whether this inflight request's shutter and result callback are to be
1020 // called. The policy is that if the request is the last one in the constrained
1021 // high speed recording request list, this flag will be true. If the request list
1022 // is not for constrained high speed recording, this flag will also be true.
1023 bool hasCallback;
1024
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -07001025 // Maximum expected frame duration for this request.
1026 // For manual captures, equal to the max of requested exposure time and frame duration
1027 // For auto-exposure modes, equal to 1/(lower end of target FPS range)
1028 nsecs_t maxExpectedDuration;
1029
Shuzhen Wang20f57342017-08-24 15:39:05 -07001030 // Whether the result metadata for this request is to be skipped. The
1031 // result metadata should be skipped in the case of
1032 // REQUEST/RESULT error.
1033 bool skipResultMetadata;
1034
Shuzhen Wang5c22c152017-12-31 17:12:25 -08001035 // The physical camera ids being requested.
1036 std::set<String8> physicalCameraIds;
1037
1038 // Map of physicalCameraId <-> Metadata
1039 std::vector<PhysicalCaptureResultInfo> physicalMetadatas;
1040
Emilian Peev9dd21f42018-08-03 13:39:29 +01001041 // Indicates a still capture request.
1042 bool stillCapture;
1043
Shuzhen Wang26abaf42018-08-28 15:41:20 -07001044 // Indicates a ZSL capture request
1045 bool zslCapture;
1046
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -07001047 // What shared surfaces an output should go to
1048 SurfaceMap outputSurfaces;
1049
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001050 // Default constructor needed by KeyedVector
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001051 InFlightRequest() :
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001052 shutterTimestamp(0),
1053 sensorTimestamp(0),
Zhijun He1d1f8462013-10-02 16:29:51 -07001054 requestStatus(OK),
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001055 haveResultMetadata(false),
Zhijun Hec98bd8d2014-07-07 12:44:10 -07001056 numBuffersLeft(0),
Chien-Yu Chend196d612015-06-22 19:49:01 -07001057 hasInputBuffer(false),
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -07001058 hasCallback(true),
Shuzhen Wang20f57342017-08-24 15:39:05 -07001059 maxExpectedDuration(kDefaultExpectedDuration),
Emilian Peev9dd21f42018-08-03 13:39:29 +01001060 skipResultMetadata(false),
Shuzhen Wang26abaf42018-08-28 15:41:20 -07001061 stillCapture(false),
1062 zslCapture(false) {
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001063 }
1064
Chien-Yu Chend196d612015-06-22 19:49:01 -07001065 InFlightRequest(int numBuffers, CaptureResultExtras extras, bool hasInput,
Shuzhen Wang5c22c152017-12-31 17:12:25 -08001066 bool hasAppCallback, nsecs_t maxDuration,
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001067 const std::set<String8>& physicalCameraIdSet, bool isStillCapture,
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -07001068 bool isZslCapture,
1069 const SurfaceMap& outSurfaces = SurfaceMap{}) :
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001070 shutterTimestamp(0),
1071 sensorTimestamp(0),
Jianing Weicb0652e2014-03-12 18:29:36 -07001072 requestStatus(OK),
1073 haveResultMetadata(false),
1074 numBuffersLeft(numBuffers),
Zhijun Hec98bd8d2014-07-07 12:44:10 -07001075 resultExtras(extras),
Chien-Yu Chend196d612015-06-22 19:49:01 -07001076 hasInputBuffer(hasInput),
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -07001077 hasCallback(hasAppCallback),
Shuzhen Wang20f57342017-08-24 15:39:05 -07001078 maxExpectedDuration(maxDuration),
Shuzhen Wang5c22c152017-12-31 17:12:25 -08001079 skipResultMetadata(false),
Emilian Peev9dd21f42018-08-03 13:39:29 +01001080 physicalCameraIds(physicalCameraIdSet),
Shuzhen Wang26abaf42018-08-28 15:41:20 -07001081 stillCapture(isStillCapture),
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -07001082 zslCapture(isZslCapture),
1083 outputSurfaces(outSurfaces) {
Zhijun Hec98bd8d2014-07-07 12:44:10 -07001084 }
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001085 };
1086
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001087 // Map from frame number to the in-flight request state
1088 typedef KeyedVector<uint32_t, InFlightRequest> InFlightMap;
1089
Yin-Chia Yeh598fc602017-07-24 11:37:23 -07001090
1091 Mutex mInFlightLock; // Protects mInFlightMap and
1092 // mExpectedInflightDuration
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001093 InFlightMap mInFlightMap;
Yin-Chia Yeh598fc602017-07-24 11:37:23 -07001094 nsecs_t mExpectedInflightDuration = 0;
Eino-Ville Talvala24b366e2016-07-21 12:53:07 -07001095 int mInFlightStatusId;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001096
Jianing Weicb0652e2014-03-12 18:29:36 -07001097 status_t registerInFlight(uint32_t frameNumber,
Chien-Yu Chend196d612015-06-22 19:49:01 -07001098 int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput,
Emilian Peev9dd21f42018-08-03 13:39:29 +01001099 bool callback, nsecs_t maxExpectedDuration, std::set<String8>& physicalCameraIds,
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -07001100 bool isStillCapture, bool isZslCapture,
1101 const SurfaceMap& outputSurfaces);
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -07001102
1103 /**
1104 * Returns the maximum expected time it'll take for all currently in-flight
1105 * requests to complete, based on their settings
1106 */
Yin-Chia Yeh598fc602017-07-24 11:37:23 -07001107 nsecs_t getExpectedInFlightDuration();
Chien-Yu Chend196d612015-06-22 19:49:01 -07001108
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -07001109 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001110 * Tracking for idle detection
1111 */
1112 sp<camera3::StatusTracker> mStatusTracker;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001113
1114 /**
Zhijun He125684a2015-12-26 15:07:30 -08001115 * Graphic buffer manager for output streams. Each device has a buffer manager, which is used
1116 * by the output streams to get and return buffers if these streams are registered to this
1117 * buffer manager.
1118 */
1119 sp<camera3::Camera3BufferManager> mBufferManager;
1120
1121 /**
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001122 * Thread for preparing streams
1123 */
1124 class PreparerThread : private Thread, public virtual RefBase {
1125 public:
1126 PreparerThread();
1127 ~PreparerThread();
1128
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001129 void setNotificationListener(wp<NotificationListener> listener);
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001130
1131 /**
Ruben Brunkc78ac262015-08-13 17:58:46 -07001132 * Queue up a stream to be prepared. Streams are processed by a background thread in FIFO
1133 * order. Pre-allocate up to maxCount buffers for the stream, or the maximum number needed
1134 * for the pipeline if maxCount is ALLOCATE_PIPELINE_MAX.
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001135 */
Ruben Brunkc78ac262015-08-13 17:58:46 -07001136 status_t prepare(int maxCount, sp<camera3::Camera3StreamInterface>& stream);
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001137
1138 /**
1139 * Cancel all current and pending stream preparation
1140 */
1141 status_t clear();
1142
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001143 /**
1144 * Pause all preparation activities
1145 */
1146 void pause();
1147
1148 /**
1149 * Resume preparation activities
1150 */
1151 status_t resume();
1152
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001153 private:
1154 Mutex mLock;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001155 Condition mThreadActiveSignal;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001156
1157 virtual bool threadLoop();
1158
1159 // Guarded by mLock
1160
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001161 wp<NotificationListener> mListener;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001162 std::unordered_map<int, sp<camera3::Camera3StreamInterface> > mPendingStreams;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001163 bool mActive;
1164 bool mCancelNow;
1165
1166 // Only accessed by threadLoop and the destructor
1167
1168 sp<camera3::Camera3StreamInterface> mCurrentStream;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001169 int mCurrentMaxCount;
1170 bool mCurrentPrepareComplete;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001171 };
1172 sp<PreparerThread> mPreparerThread;
1173
1174 /**
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001175 * Output result queue and current HAL device 3A state
1176 */
1177
1178 // Lock for output side of device
1179 Mutex mOutputLock;
1180
1181 /**** Scope for mOutputLock ****/
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001182 // the minimal frame number of the next non-reprocess result
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001183 uint32_t mNextResultFrameNumber;
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001184 // the minimal frame number of the next reprocess result
1185 uint32_t mNextReprocessResultFrameNumber;
Chien-Yu Chen3df11ce2015-09-30 14:13:30 -07001186 // the minimal frame number of the next non-reprocess shutter
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001187 uint32_t mNextShutterFrameNumber;
Chien-Yu Chen3df11ce2015-09-30 14:13:30 -07001188 // the minimal frame number of the next reprocess shutter
1189 uint32_t mNextReprocessShutterFrameNumber;
Jianing Weicb0652e2014-03-12 18:29:36 -07001190 List<CaptureResult> mResultQueue;
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001191 Condition mResultSignal;
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001192 wp<NotificationListener> mListener;
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001193
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001194 /**** End scope for mOutputLock ****/
1195
1196 /**
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001197 * Callback functions from HAL device
1198 */
1199 void processCaptureResult(const camera3_capture_result *result);
1200
1201 void notify(const camera3_notify_msg *msg);
1202
Eino-Ville Talvala17543512014-08-06 14:32:02 -07001203 // Specific notify handlers
1204 void notifyError(const camera3_error_msg_t &msg,
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001205 sp<NotificationListener> listener);
Eino-Ville Talvala17543512014-08-06 14:32:02 -07001206 void notifyShutter(const camera3_shutter_msg_t &msg,
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001207 sp<NotificationListener> listener);
Eino-Ville Talvala17543512014-08-06 14:32:02 -07001208
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001209 // helper function to return the output buffers to the streams.
1210 void returnOutputBuffers(const camera3_stream_buffer_t *outputBuffers,
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -07001211 size_t numBuffers, nsecs_t timestamp, bool timestampIncreasing = true,
1212 // The following arguments are only meant for surface sharing use case
1213 const SurfaceMap& outputSurfaces = SurfaceMap{},
1214 // Used to send buffer error callback when failing to return buffer
1215 const CaptureResultExtras &resultExtras = CaptureResultExtras{});
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001216
Chien-Yu Chen5cd8d642016-03-08 14:46:58 -08001217 // Send a partial capture result.
1218 void sendPartialCaptureResult(const camera_metadata_t * partialResult,
Emilian Peev7e25e5e2017-04-07 15:48:49 +01001219 const CaptureResultExtras &resultExtras, uint32_t frameNumber);
Chien-Yu Chen5cd8d642016-03-08 14:46:58 -08001220
1221 // Send a total capture result given the pending metadata and result extras,
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001222 // partial results, and the frame number to the result queue.
1223 void sendCaptureResult(CameraMetadata &pendingMetadata,
1224 CaptureResultExtras &resultExtras,
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001225 CameraMetadata &collectedPartialResult, uint32_t frameNumber,
Shuzhen Wang5c22c152017-12-31 17:12:25 -08001226 bool reprocess, const std::vector<PhysicalCaptureResultInfo>& physicalMetadatas);
1227
1228 bool isLastFullResult(const InFlightRequest& inFlightRequest);
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001229
Chien-Yu Chen5cd8d642016-03-08 14:46:58 -08001230 // Insert the result to the result queue after updating frame number and overriding AE
1231 // trigger cancel.
1232 // mOutputLock must be held when calling this function.
Emilian Peev7e25e5e2017-04-07 15:48:49 +01001233 void insertResultLocked(CaptureResult *result, uint32_t frameNumber);
Chien-Yu Chen5cd8d642016-03-08 14:46:58 -08001234
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001235 /**** Scope for mInFlightLock ****/
1236
Shuzhen Wangcadb3302016-11-04 14:17:56 -07001237 // Remove the in-flight map entry of the given index from mInFlightMap.
1238 // It must only be called with mInFlightLock held.
1239 void removeInFlightMapEntryLocked(int idx);
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001240 // Remove the in-flight request of the given index from mInFlightMap
1241 // if it's no longer needed. It must only be called with mInFlightLock held.
1242 void removeInFlightRequestIfReadyLocked(int idx);
Yin-Chia Yehf3fe36f2017-07-07 18:23:18 -07001243 // Remove all in-flight requests and return all buffers.
1244 // This is used after HAL interface is closed to cleanup any request/buffers
1245 // not returned by HAL.
1246 void flushInflightRequests();
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001247
1248 /**** End scope for mInFlightLock ****/
1249
Eino-Ville Talvala7b8a1fd2018-05-22 15:30:35 -07001250 /**
1251 * Distortion correction support
1252 */
Shuzhen Wang4f6fa9d2019-03-29 10:40:35 -07001253 // Map from camera IDs to its corresponding distortion mapper. Only contains
1254 // 1 ID if the device isn't a logical multi-camera. Otherwise contains both
1255 // logical camera and its physical subcameras.
1256 std::unordered_map<std::string, camera3::DistortionMapper> mDistortionMappers;
Eino-Ville Talvala7b8a1fd2018-05-22 15:30:35 -07001257
Eino-Ville Talvala4d453832016-07-15 11:56:53 -07001258 // Debug tracker for metadata tag value changes
1259 // - Enabled with the -m <taglist> option to dumpsys, such as
1260 // dumpsys -m android.control.aeState,android.control.aeMode
1261 // - Disabled with -m off
1262 // - dumpsys -m 3a is a shortcut for ae/af/awbMode, State, and Triggers
1263 TagMonitor mTagMonitor;
1264
1265 void monitorMetadata(TagMonitor::eventSource source, int64_t frameNumber,
1266 nsecs_t timestamp, const CameraMetadata& metadata);
1267
Emilian Peev71c73a22017-03-21 16:35:51 +00001268 metadata_vendor_id_t mVendorTagId;
1269
Emilian Peev811d2952018-05-25 11:08:40 +01001270 // Cached last requested template id
1271 int mLastTemplateId;
1272
Emilian Peev26d975d2018-07-05 14:52:57 +01001273 // Synchronizes access to status tracker between inflight updates and disconnect.
1274 // b/79972865
1275 Mutex mTrackerLock;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001276
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001277 // Whether HAL request buffers through requestStreamBuffers API
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001278 bool mUseHalBufManager = false;
1279
1280 // Lock to ensure requestStreamBuffers() callbacks are serialized
1281 std::mutex mRequestBufferInterfaceLock;
1282
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001283 // The state machine to control when requestStreamBuffers should allow
1284 // HAL to request buffers.
1285 enum RequestBufferState {
1286 /**
1287 * This is the initial state.
1288 * requestStreamBuffers call will return FAILED_CONFIGURING in this state.
1289 * Will switch to RB_STATUS_READY after a successful configureStreams or
1290 * processCaptureRequest call.
1291 */
1292 RB_STATUS_STOPPED,
1293
1294 /**
1295 * requestStreamBuffers call will proceed in this state.
1296 * When device is asked to stay idle via waitUntilStateThenRelock() call:
1297 * - Switch to RB_STATUS_STOPPED if there is no inflight requests and
1298 * request thread is paused.
1299 * - Switch to RB_STATUS_PENDING_STOP otherwise
1300 */
1301 RB_STATUS_READY,
1302
1303 /**
1304 * requestStreamBuffers call will proceed in this state.
1305 * Switch to RB_STATUS_STOPPED when all inflight requests are fulfilled
1306 * and request thread is paused
1307 */
1308 RB_STATUS_PENDING_STOP,
1309 };
1310
1311 class RequestBufferStateMachine {
1312 public:
1313 status_t initialize(sp<camera3::StatusTracker> statusTracker);
1314
1315 // Return if the state machine currently allows for requestBuffers
1316 // If the state allows for it, mRequestBufferOngoing will be set to true
1317 // and caller must call endRequestBuffer() later to unset the flag
1318 bool startRequestBuffer();
1319 void endRequestBuffer();
1320
1321 // Events triggered by application API call
1322 void onStreamsConfigured();
1323 void onWaitUntilIdle();
1324
1325 // Events usually triggered by hwBinder processCaptureResult callback thread
1326 // But can also be triggered on request thread for failed request, or on
1327 // hwbinder notify callback thread for shutter/error callbacks
1328 void onInflightMapEmpty();
1329
1330 // Events triggered by RequestThread
Yin-Chia Yehcd333fe2019-02-08 13:45:41 -08001331 void onSubmittingRequest();
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001332 void onRequestThreadPaused();
1333
1334 private:
1335 void notifyTrackerLocked(bool active);
1336
1337 // Switch to STOPPED state and return true if all conditions allows for it.
1338 // Otherwise do nothing and return false.
1339 bool checkSwitchToStopLocked();
1340
1341 std::mutex mLock;
1342 RequestBufferState mStatus = RB_STATUS_STOPPED;
1343
1344 bool mRequestThreadPaused = true;
1345 bool mInflightMapEmpty = true;
1346 bool mRequestBufferOngoing = false;
1347
1348 wp<camera3::StatusTracker> mStatusTracker;
1349 int mRequestBufferStatusId;
1350 } mRequestBufferSM;
1351
Shuzhen Wang268a1362018-10-16 16:32:59 -07001352 // Fix up result metadata for monochrome camera.
1353 bool mNeedFixupMonochromeTags;
1354 status_t fixupMonochromeTags(const CameraMetadata& deviceInfo, CameraMetadata& resultMetadata);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001355}; // class Camera3Device
1356
1357}; // namespace android
1358
1359#endif