blob: 1635a9099d0eb7519895f124d0f87b667925a24e [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
Jianing Weicb0652e2014-03-12 18:29:36 -070032#include <camera/CaptureResult.h>
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080033
Ravneetdbd5b242022-03-02 07:22:46 +000034#include "CameraServiceWatchdog.h"
Jayant Chowdharyc67af1b2022-04-07 18:05:04 +000035#include <aidl/android/hardware/camera/device/CameraBlob.h>
36
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070037#include "common/CameraDeviceBase.h"
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -080038#include "device3/BufferUtils.h"
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -070039#include "device3/StatusTracker.h"
Zhijun He125684a2015-12-26 15:07:30 -080040#include "device3/Camera3BufferManager.h"
Eino-Ville Talvala7b8a1fd2018-05-22 15:30:35 -070041#include "device3/DistortionMapper.h"
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -080042#include "device3/ZoomRatioMapper.h"
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -080043#include "device3/RotateAndCropMapper.h"
Jayant Chowdhary9255ce02021-07-15 11:18:17 -070044#include "device3/UHRCropAndMeteringRegionMapper.h"
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -080045#include "device3/InFlightRequest.h"
46#include "device3/Camera3OutputInterface.h"
47#include "device3/Camera3OfflineSession.h"
Shuzhen Wang83bff122020-11-20 15:51:39 -080048#include "device3/Camera3StreamInterface.h"
Eino-Ville Talvala4d453832016-07-15 11:56:53 -070049#include "utils/TagMonitor.h"
Jayant Chowdhary22441f32021-12-26 18:35:41 -080050#include "utils/IPCTransport.h"
Shuzhen Wang686f6442017-06-20 16:16:04 -070051#include "utils/LatencyHistogram.h"
Austin Borger74fca042022-05-23 12:41:21 -070052#include "utils/CameraServiceProxyWrapper.h"
Emilian Peev71c73a22017-03-21 16:35:51 +000053#include <camera_metadata_hidden.h>
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080054
Emilian Peevf4816702020-04-03 15:44:51 -070055using android::camera3::camera_capture_request_t;
Emilian Peevf4816702020-04-03 15:44:51 -070056using android::camera3::camera_request_template;
57using android::camera3::camera_stream_buffer_t;
58using android::camera3::camera_stream_configuration_t;
59using android::camera3::camera_stream_configuration_mode_t;
60using android::camera3::CAMERA_TEMPLATE_COUNT;
Emilian Peev40ead602017-09-26 15:46:36 +010061using android::camera3::OutputStreamInfo;
62
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080063namespace android {
64
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070065namespace camera3 {
66
67class Camera3Stream;
68class Camera3ZslStream;
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070069class Camera3StreamInterface;
70
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080071} // namespace camera3
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070072
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080073/**
Zhijun He95dd5ba2014-03-26 18:18:00 -070074 * CameraDevice for HAL devices with version CAMERA_DEVICE_API_VERSION_3_0 or higher.
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080075 */
76class Camera3Device :
77 public CameraDeviceBase,
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -080078 public camera3::SetErrorInterface,
79 public camera3::InflightRequestUpdateInterface,
80 public camera3::RequestBufferInterface,
81 public camera3::FlushBufferInterface {
Jayant Chowdhary22441f32021-12-26 18:35:41 -080082 friend class HidlCamera3Device;
Jayant Chowdhary35642f22022-01-08 00:39:39 +000083 friend class AidlCamera3Device;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080084 public:
Ruben Brunkc78ac262015-08-13 17:58:46 -070085
Austin Borger74fca042022-05-23 12:41:21 -070086 explicit Camera3Device(std::shared_ptr<CameraServiceProxyWrapper>& cameraServiceProxyWrapper,
Austin Borger18b30a72022-10-27 12:20:29 -070087 const String8& id, bool overrideForPerfClass, bool overrideToPortrait,
88 bool legacyClient = false);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080089
90 virtual ~Camera3Device();
Jayant Chowdhary35642f22022-01-08 00:39:39 +000091 // Delete and optionally close native handles and clear the input vector afterward
92 static void cleanupNativeHandles(
93 std::vector<native_handle_t*> *handles, bool closeFd = false);
94
Jayant Chowdharyc67af1b2022-04-07 18:05:04 +000095 virtual IPCTransport getTransportType() const override {
96 return mInterface->getTransportType();
97 }
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080098
99 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800100 * CameraDeviceBase interface
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800101 */
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800102
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800103 const String8& getId() const override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800104
Emilian Peev00420d22018-02-05 21:33:13 +0000105 metadata_vendor_id_t getVendorTagId() const override { return mVendorTagId; }
106
Ravneetdbd5b242022-03-02 07:22:46 +0000107 // Watchdog thread
108 sp<CameraServiceWatchdog> mCameraServiceWatchdog;
109
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800110 // Transitions to idle state on success.
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800111 virtual status_t initialize(sp<CameraProviderManager> /*manager*/,
112 const String8& /*monitorTags*/) = 0;
113
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800114 status_t disconnect() override;
115 status_t dump(int fd, const Vector<String16> &args) override;
Avichal Rakesh7e53cad2021-10-05 13:46:30 -0700116 status_t startWatchingTags(const String8 &tags) override;
117 status_t stopWatchingTags() override;
118 status_t dumpWatchedEventsToVector(std::vector<std::string> &out) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800119 const CameraMetadata& info() const override;
Emilian Peevfaa4bde2020-01-23 12:19:37 -0800120 const CameraMetadata& infoPhysical(const String8& physicalId) const override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800121
122 // Capture and setStreamingRequest will configure streams if currently in
123 // idle state
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800124 status_t capture(CameraMetadata &request, int64_t *lastFrameNumber = NULL) override;
Emilian Peevaebbe412018-01-15 13:53:24 +0000125 status_t captureList(const List<const PhysicalCameraSettingsList> &requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700126 const std::list<const SurfaceMap> &surfaceMaps,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800127 int64_t *lastFrameNumber = NULL) override;
128 status_t setStreamingRequest(const CameraMetadata &request,
129 int64_t *lastFrameNumber = NULL) override;
Emilian Peevaebbe412018-01-15 13:53:24 +0000130 status_t setStreamingRequestList(const List<const PhysicalCameraSettingsList> &requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700131 const std::list<const SurfaceMap> &surfaceMaps,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800132 int64_t *lastFrameNumber = NULL) override;
133 status_t clearStreamingRequest(int64_t *lastFrameNumber = NULL) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800134
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800135 status_t waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800136
137 // Actual stream creation/deletion is delayed until first request is submitted
138 // If adding streams while actively capturing, will pause device before adding
Zhijun He5d677d12016-05-29 16:52:39 -0700139 // stream, reconfiguring device, and unpausing. If the client create a stream
Shuzhen Wang758c2152017-01-10 18:26:18 -0800140 // with nullptr consumer surface, the client must then call setConsumers()
Zhijun He5d677d12016-05-29 16:52:39 -0700141 // and finish the stream configuration before starting output streaming.
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800142 status_t createStream(sp<Surface> consumer,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800143 uint32_t width, uint32_t height, int format,
Emilian Peevf4816702020-04-03 15:44:51 -0700144 android_dataspace dataSpace, camera_stream_rotation_t rotation, int *id,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800145 const String8& physicalCameraId,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800146 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peev40ead602017-09-26 15:46:36 +0100147 std::vector<int> *surfaceIds = nullptr,
Zhijun He5d677d12016-05-29 16:52:39 -0700148 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,
Shuzhen Wang83bff122020-11-20 15:51:39 -0800149 bool isShared = false, bool isMultiResolution = false,
Emilian Peev2295df72021-11-12 18:14:10 -0800150 uint64_t consumerUsage = 0,
Emilian Peevc81a7592022-02-14 17:38:18 -0800151 int64_t dynamicRangeProfile =
Shuzhen Wangc8ab4522021-12-14 20:12:42 -0800152 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
Shuzhen Wang8ed1e872022-03-08 16:34:33 -0800153 int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800154 int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT,
Austin Borger9e2b27c2022-07-15 11:27:24 -0700155 int mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO,
Shuzhen Wangbce53db2022-12-03 00:38:20 +0000156 int32_t colorSpace = ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED,
157 bool useReadoutTimestamp = false)
Austin Borger9e2b27c2022-07-15 11:27:24 -0700158 override;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800159
Shuzhen Wang0129d522016-10-30 22:43:41 -0700160 status_t createStream(const std::vector<sp<Surface>>& consumers,
161 bool hasDeferredConsumer, uint32_t width, uint32_t height, int format,
Emilian Peevf4816702020-04-03 15:44:51 -0700162 android_dataspace dataSpace, camera_stream_rotation_t rotation, int *id,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800163 const String8& physicalCameraId,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800164 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peev40ead602017-09-26 15:46:36 +0100165 std::vector<int> *surfaceIds = nullptr,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700166 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,
Shuzhen Wang83bff122020-11-20 15:51:39 -0800167 bool isShared = false, bool isMultiResolution = false,
Emilian Peev2295df72021-11-12 18:14:10 -0800168 uint64_t consumerUsage = 0,
Emilian Peevc81a7592022-02-14 17:38:18 -0800169 int64_t dynamicRangeProfile =
Shuzhen Wangc8ab4522021-12-14 20:12:42 -0800170 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
Shuzhen Wang8ed1e872022-03-08 16:34:33 -0800171 int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800172 int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT,
Austin Borger9e2b27c2022-07-15 11:27:24 -0700173 int mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO,
Shuzhen Wangbce53db2022-12-03 00:38:20 +0000174 int32_t colorSpace = ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED,
175 bool useReadoutTimestamp = false)
Austin Borger9e2b27c2022-07-15 11:27:24 -0700176 override;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700177
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800178 status_t createInputStream(
Shuzhen Wang83bff122020-11-20 15:51:39 -0800179 uint32_t width, uint32_t height, int format, bool isMultiResolution,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800180 int *id) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800181
Emilian Peev710c1422017-08-30 11:19:38 +0100182 status_t getStreamInfo(int id, StreamInfo *streamInfo) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800183 status_t setStreamTransform(int id, int transform) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800184
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800185 status_t deleteStream(int id) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800186
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100187 status_t configureStreams(const CameraMetadata& sessionParams,
188 int operatingMode =
Emilian Peevf4816702020-04-03 15:44:51 -0700189 camera_stream_configuration_mode_t::CAMERA_STREAM_CONFIGURATION_NORMAL_MODE) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800190 status_t getInputBufferProducer(
191 sp<IGraphicBufferProducer> *producer) override;
Igor Murashkine2d167e2014-08-19 16:19:59 -0700192
Emilian Peevcc0b7952020-01-07 13:54:47 -0800193 void getOfflineStreamIds(std::vector<int> *offlineStreamIds) override;
194
Emilian Peevf4816702020-04-03 15:44:51 -0700195 status_t createDefaultRequest(camera_request_template_t templateId,
196 CameraMetadata *request) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800197
198 // Transitions to the idle state on success
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800199 status_t waitUntilDrained() override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800200
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800201 status_t setNotifyCallback(wp<NotificationListener> listener) override;
202 bool willNotify3A() override;
203 status_t waitForNextFrame(nsecs_t timeout) override;
204 status_t getNextResult(CaptureResult *frame) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800205
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800206 status_t triggerAutofocus(uint32_t id) override;
207 status_t triggerCancelAutofocus(uint32_t id) override;
208 status_t triggerPrecaptureMetering(uint32_t id) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800209
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800210 status_t flush(int64_t *lastFrameNumber = NULL) override;
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700211
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800212 status_t prepare(int streamId) override;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700213
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800214 status_t tearDown(int streamId) override;
Eino-Ville Talvalab25e3c82015-07-15 16:04:27 -0700215
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800216 status_t addBufferListenerForStream(int streamId,
217 wp<camera3::Camera3StreamBufferListener> listener) override;
Shuzhen Wangb0fdc1e2016-03-20 23:21:39 -0700218
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800219 status_t prepare(int maxCount, int streamId) override;
Ruben Brunkc78ac262015-08-13 17:58:46 -0700220
Jayant Chowdhary6a6d3a82021-11-17 16:54:34 -0800221 ssize_t getJpegBufferSize(const CameraMetadata &info, uint32_t width,
222 uint32_t height) const override;
223 ssize_t getPointCloudBufferSize(const CameraMetadata &info) const;
224 ssize_t getRawOpaqueBufferSize(const CameraMetadata &info, int32_t width, int32_t height,
225 bool maxResolution) const;
Zhijun He28c9b6f2014-08-08 12:00:47 -0700226
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700227 // Methods called by subclasses
228 void notifyStatus(bool idle); // updates from StatusTracker
229
Zhijun He5d677d12016-05-29 16:52:39 -0700230 /**
Shuzhen Wang758c2152017-01-10 18:26:18 -0800231 * Set the deferred consumer surfaces to the output stream and finish the deferred
Zhijun He5d677d12016-05-29 16:52:39 -0700232 * consumer configuration.
233 */
Emilian Peev40ead602017-09-26 15:46:36 +0100234 status_t setConsumerSurfaces(
235 int streamId, const std::vector<sp<Surface>>& consumers,
236 std::vector<int> *surfaceIds /*out*/) override;
237
238 /**
239 * Update a given stream.
240 */
241 status_t updateStream(int streamId, const std::vector<sp<Surface>> &newSurfaces,
242 const std::vector<OutputStreamInfo> &outputInfo,
243 const std::vector<size_t> &removedSurfaceIds,
244 KeyedVector<sp<Surface>, size_t> *outputMap/*out*/);
Zhijun He5d677d12016-05-29 16:52:39 -0700245
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700246 /**
247 * Drop buffers for stream of streamId if dropping is true. If dropping is false, do not
248 * drop buffers for stream of streamId.
249 */
250 status_t dropStreamBuffers(bool dropping, int streamId) override;
251
Emilian Peev2a8e2832019-08-23 13:00:31 -0700252 nsecs_t getExpectedInFlightDuration() override;
253
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800254 virtual status_t switchToOffline(const std::vector<int32_t>& ,
255 /*out*/ sp<CameraOfflineSessionBase>* ) override {
256 return INVALID_OPERATION;
257 };
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700258
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800259 // RequestBufferInterface
260 bool startRequestBuffer() override;
261 void endRequestBuffer() override;
262 nsecs_t getWaitDuration() override;
263
264 // FlushBufferInterface
265 void getInflightBufferKeys(std::vector<std::pair<int32_t, int32_t>>* out) override;
266 void getInflightRequestBufferKeys(std::vector<uint64_t>* out) override;
267 std::vector<sp<camera3::Camera3StreamInterface>> getAllStreams() override;
268
Emilian Peev35ae8262018-11-08 13:11:32 +0000269 /**
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800270 * Set the current behavior for the ROTATE_AND_CROP control when in AUTO.
271 *
272 * The value must be one of the ROTATE_AND_CROP_* values besides AUTO,
273 * and defaults to NONE.
274 */
275 status_t setRotateAndCropAutoBehavior(
276 camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropValue);
277
Eino-Ville Talvala305cec62020-11-12 14:18:17 -0800278 /**
Bharatt Kukreja7146ced2022-10-25 15:45:29 +0000279 * Set the current behavior for the AUTOFRAMING control when in AUTO.
280 *
281 * The value must be one of the AUTOFRAMING_* values besides AUTO.
282 */
283 status_t setAutoframingAutoBehavior(
284 camera_metadata_enum_android_control_autoframing_t autoframingValue);
285
286 /**
Eino-Ville Talvala305cec62020-11-12 14:18:17 -0800287 * Whether camera muting (producing black-only output) is supported.
288 *
289 * Calling setCameraMute(true) when this returns false will return an
290 * INVALID_OPERATION error.
291 */
292 bool supportsCameraMute();
293
294 /**
295 * Mute the camera.
296 *
297 * When muted, black image data is output on all output streams.
298 */
299 status_t setCameraMute(bool enabled);
300
Ravneetaeb20dc2022-03-30 05:33:03 +0000301 /**
302 * Enables/disables camera service watchdog
303 */
304 status_t setCameraServiceWatchdog(bool enabled);
305
Shuzhen Wang16610a62022-12-15 22:38:07 -0800306 // Set stream use case overrides
307 void setStreamUseCaseOverrides(
308 const std::vector<int64_t>& useCaseOverrides);
309
310 // Clear stream use case overrides
311 void clearStreamUseCaseOverrides();
312
Shuzhen Wange8675782019-12-05 09:12:14 -0800313 // Get the status trackeer for the camera device
314 wp<camera3::StatusTracker> getStatusTracker() { return mStatusTracker; }
315
Shuzhen Wang03fe6232023-02-05 12:41:15 -0800316 // Whether the device is in error state
317 bool hasDeviceError();
318
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800319 /**
Cliff Wuc2ad9c82021-04-21 00:58:58 +0800320 * The injection camera session to replace the internal camera
321 * session.
322 */
323 status_t injectCamera(const String8& injectedCamId,
324 sp<CameraProviderManager> manager);
325
326 /**
327 * Stop the injection camera and restore to internal camera session.
328 */
329 status_t stopInjection();
330
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800331 protected:
Yin-Chia Yehc5248132018-08-15 12:19:20 -0700332 status_t disconnectImpl();
Jayant Chowdhary65c9bf02021-09-03 16:44:16 +0000333 static status_t removeFwkOnlyRegionKeys(CameraMetadata *request);
Yin-Chia Yehc5248132018-08-15 12:19:20 -0700334
Austin Borger4a870a32022-02-25 01:48:41 +0000335 float getMaxPreviewFps(sp<camera3::Camera3OutputStreamInterface> stream);
336
Igor Murashkin1e479c02013-09-06 16:55:14 -0700337 static const size_t kDumpLockAttempts = 10;
338 static const size_t kDumpSleepDuration = 100000; // 0.10 sec
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700339 static const nsecs_t kActiveTimeout = 500000000; // 500 ms
Yin-Chia Yeh99fd0972019-06-27 14:22:44 -0700340 static const nsecs_t kMinWarnInflightDuration = 5000000000; // 5 s
Yin-Chia Yeh90c0fdf2017-06-29 13:22:12 -0700341 static const size_t kInFlightWarnLimit = 30;
Chien-Yu Chenc96ac8d2015-08-12 16:46:24 -0700342 static const size_t kInFlightWarnLimitHighSpeed = 256; // batch size 32 * pipe depth 8
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -0700343 static const nsecs_t kMinInflightDuration = 5000000000; // 5 s
Yin-Chia Yehb3a80b12018-09-04 12:13:05 -0700344 static const nsecs_t kBaseGetBufferWait = 3000000000; // 3 sec.
Eino-Ville Talvalaf99498e2015-09-25 16:52:55 -0700345 // SCHED_FIFO priority for request submission thread in HFR mode
Zhijun He7ee4c072016-07-25 13:52:28 -0700346 static const int kRequestThreadPriority = 1;
Chien-Yu Chenc96ac8d2015-08-12 16:46:24 -0700347
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700348 struct RequestTrigger;
Zhijun Hef7da0962014-04-24 13:27:56 -0700349 // minimal jpeg buffer size: 256KB + blob header
Jayant Chowdharyc67af1b2022-04-07 18:05:04 +0000350 static const ssize_t kMinJpegBufferSize =
351 256 * 1024 + sizeof(aidl::android::hardware::camera::device::CameraBlob);
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700352 // Constant to use for stream ID when one doesn't exist
353 static const int NO_STREAM = -1;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800354
Austin Borger74fca042022-05-23 12:41:21 -0700355 std::shared_ptr<CameraServiceProxyWrapper> mCameraServiceProxyWrapper;
356
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700357 // A lock to enforce serialization on the input/configure side
358 // of the public interface.
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700359 // Not locked by methods guarded by mOutputLock, since they may act
360 // concurrently to the input/configure side of the interface.
361 // Must be locked before mLock if both will be locked by a method
362 Mutex mInterfaceLock;
363
364 // The main lock on internal state
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800365 Mutex mLock;
366
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700367 // Camera device ID
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800368 const String8 mId;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700369
Emilian Peev5104fe92021-10-21 14:27:09 -0700370 // Legacy camera client flag
371 bool mLegacyClient;
372
Eino-Ville Talvalabbbbe842017-02-28 17:50:56 -0800373 // Current stream configuration mode;
374 int mOperatingMode;
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100375 // Current session wide parameters
376 hardware::camera2::impl::CameraMetadataNative mSessionParams;
377
Eino-Ville Talvalabbbbe842017-02-28 17:50:56 -0800378 // Constant to use for no set operating mode
379 static const int NO_MODE = -1;
380
Zhijun He1fa89992015-06-01 15:44:31 -0700381 // Flag indicating is the current active stream configuration is constrained high speed.
382 bool mIsConstrainedHighSpeedConfiguration;
383
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800384 /**** Scope for mLock ****/
385
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800386 class HalInterface : public camera3::Camera3StreamBufferFreedListener,
387 public camera3::BufferRecordsInterface {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800388 public:
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800389 HalInterface(bool useHalBufManager, bool supportOfflineProcessing) :
390 mUseHalBufManager(useHalBufManager),
391 mIsReconfigurationQuerySupported(true),
392 mSupportOfflineProcessing(supportOfflineProcessing)
393 {};
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800394 HalInterface(const HalInterface &other);
395 HalInterface();
396
Jayant Chowdharyc67af1b2022-04-07 18:05:04 +0000397 virtual IPCTransport getTransportType() const = 0;
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800398
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800399 // Returns true if constructed with a valid device or session, and not yet cleared
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800400 virtual bool valid() = 0;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800401
402 // Reset this HalInterface object (does not call close())
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800403 virtual void clear() = 0;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800404
405 // Calls into the HAL interface
406
407 // Caller takes ownership of requestTemplate
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800408 virtual status_t constructDefaultRequestSettings(camera_request_template templateId,
409 /*out*/ camera_metadata_t **requestTemplate) = 0;
410
411 virtual status_t configureStreams(const camera_metadata_t * sessionParams,
412 /*inout*/ camera_stream_configuration_t * config,
413 const std::vector<uint32_t>& bufferSizes) = 0;
Yin-Chia Yeh11648852019-05-16 10:42:54 -0700414
Cliff Wuc2ad9c82021-04-21 00:58:58 +0800415 // The injection camera configures the streams to hal.
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800416 virtual status_t configureInjectedStreams(
Cliff Wuc2ad9c82021-04-21 00:58:58 +0800417 const camera_metadata_t* sessionParams,
418 /*inout*/ camera_stream_configuration_t* config,
419 const std::vector<uint32_t>& bufferSizes,
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800420 const CameraMetadata& cameraCharacteristics) = 0;
Cliff Wuc2ad9c82021-04-21 00:58:58 +0800421
Yin-Chia Yeh11648852019-05-16 10:42:54 -0700422 // When the call succeeds, the ownership of acquire fences in requests is transferred to
423 // HalInterface. More specifically, the current implementation will send the fence to
424 // HAL process and close the FD in cameraserver process. When the call fails, the ownership
425 // of the acquire fence still belongs to the caller.
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800426 virtual status_t processBatchCaptureRequests(
Emilian Peevf4816702020-04-03 15:44:51 -0700427 std::vector<camera_capture_request_t*>& requests,
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800428 /*out*/uint32_t* numRequestProcessed) = 0;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800429
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800430 virtual status_t flush() = 0;
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700431
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800432 virtual status_t dump(int fd) = 0;
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700433
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800434 virtual status_t close() = 0;
435
436 virtual void signalPipelineDrain(const std::vector<int>& streamIds) = 0;
437
438 virtual bool isReconfigurationRequired(CameraMetadata& oldSessionParams,
439 CameraMetadata& newSessionParams) = 0;
440
441 virtual status_t repeatingRequestEnd(uint32_t frameNumber,
442 const std::vector<int32_t> &streamIds) = 0;
Emilian Peev2295df72021-11-12 18:14:10 -0800443
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800444 /////////////////////////////////////////////////////////////////////
445 // Implements BufferRecordsInterface
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700446
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800447 std::pair<bool, uint64_t> getBufferId(
448 const buffer_handle_t& buf, int streamId) override;
449
Shuzhen Wangcd5b1822021-09-07 11:52:48 -0700450 uint64_t removeOneBufferCache(int streamId, const native_handle_t* handle) override;
451
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800452 status_t popInflightBuffer(int32_t frameNumber, int32_t streamId,
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800453 /*out*/ buffer_handle_t **buffer) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800454
Yin-Chia Yeh84be5782019-03-01 11:47:02 -0800455 status_t pushInflightRequestBuffer(
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800456 uint64_t bufferId, buffer_handle_t* buf, int32_t streamId) override;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700457
Yin-Chia Yeh84be5782019-03-01 11:47:02 -0800458 status_t popInflightRequestBuffer(uint64_t bufferId,
459 /*out*/ buffer_handle_t** buffer,
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800460 /*optional out*/ int32_t* streamId = nullptr) override;
461
462 /////////////////////////////////////////////////////////////////////
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700463
Yin-Chia Yehf3fe36f2017-07-07 18:23:18 -0700464 // Get a vector of (frameNumber, streamId) pair of currently inflight
465 // buffers
466 void getInflightBufferKeys(std::vector<std::pair<int32_t, int32_t>>* out);
467
Yin-Chia Yeh84be5782019-03-01 11:47:02 -0800468 // Get a vector of bufferId of currently inflight buffers
469 void getInflightRequestBufferKeys(std::vector<uint64_t>* out);
470
Yin-Chia Yeh573a2702019-04-17 10:08:55 -0700471 void onStreamReConfigured(int streamId);
472
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800473 protected:
Yin-Chia Yehf8e28fb2019-05-16 11:46:54 -0700474
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800475 // Return true if the input caches match what we have; otherwise false
476 bool verifyBufferIds(int32_t streamId, std::vector<uint64_t>& inBufIds);
Yin-Chia Yehf8e28fb2019-05-16 11:46:54 -0700477
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800478 template <typename OfflineSessionInfoT>
479 status_t verifyBufferCaches(
480 const OfflineSessionInfoT *offlineSessionInfo, camera3::BufferRecords *bufferRecords) {
481 // Validate buffer caches
482 std::vector<int32_t> streams;
483 streams.reserve(offlineSessionInfo->offlineStreams.size());
484 for (auto offlineStream : offlineSessionInfo->offlineStreams) {
485 int32_t id = offlineStream.id;
486 streams.push_back(id);
487 // Verify buffer caches
488 std::vector<uint64_t> bufIds(offlineStream.circulatingBufferIds.begin(),
489 offlineStream.circulatingBufferIds.end());
Emilian Peevb267f202022-05-24 11:08:32 -0700490 {
491 // Due to timing it is possible that we may not have any remaining pending
492 // capture requests that can update the caches on Hal side. This can result in
493 // buffer cache mismatch between the service and the Hal and must be accounted
494 // for.
495 std::lock_guard<std::mutex> l(mFreedBuffersLock);
496 for (const auto& it : mFreedBuffers) {
497 if (it.first == id) {
498 ALOGV("%s: stream ID %d buffer id %" PRIu64 " cache removal still "
499 "pending", __FUNCTION__, id, it.second);
500 const auto& cachedEntry = std::find(bufIds.begin(), bufIds.end(),
501 it.second);
502 if (cachedEntry != bufIds.end()) {
503 bufIds.erase(cachedEntry);
504 } else {
505 ALOGE("%s: stream ID %d buffer id %" PRIu64 " cache removal still "
506 "pending however buffer is no longer in the offline stream "
507 "info!", __FUNCTION__, id, it.second);
508 }
509 }
510 }
511 }
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800512 if (!verifyBufferIds(id, bufIds)) {
513 ALOGE("%s: stream ID %d buffer cache records mismatch!", __FUNCTION__, id);
514 return UNKNOWN_ERROR;
515 }
516 }
517
518 // Move buffer records
519 bufferRecords->takeBufferCaches(mBufferRecords, streams);
520 bufferRecords->takeInflightBufferMap(mBufferRecords);
521 bufferRecords->takeRequestedBufferMap(mBufferRecords);
522 return OK;
523 }
524
Yin-Chia Yehbe83fa72017-03-30 13:35:36 -0700525 virtual void onBufferFreed(int streamId, const native_handle_t* handle) override;
526
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800527 std::mutex mFreedBuffersLock;
Yin-Chia Yehbe83fa72017-03-30 13:35:36 -0700528 std::vector<std::pair<int, uint64_t>> mFreedBuffers;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700529
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800530 // Keep track of buffer cache and inflight buffer records
531 camera3::BufferRecords mBufferRecords;
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700532
533 uint32_t mNextStreamConfigCounter = 1;
Yin-Chia Yeh651fe2e2018-11-13 11:49:31 -0800534
535 const bool mUseHalBufManager;
Emilian Peev4ec17882019-01-24 17:16:58 -0800536 bool mIsReconfigurationQuerySupported;
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700537
538 const bool mSupportOfflineProcessing;
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800539 }; // class HalInterface
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800540
Yin-Chia Yehdb1e8642017-07-14 15:19:30 -0700541 sp<HalInterface> mInterface;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800542
543 CameraMetadata mDeviceInfo;
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -0800544 bool mSupportNativeZoomRatio;
Shuzhen Wang2e7f58f2018-07-11 14:00:29 -0700545 std::unordered_map<std::string, CameraMetadata> mPhysicalDeviceInfoMap;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800546
Emilian Peevf4816702020-04-03 15:44:51 -0700547 CameraMetadata mRequestTemplateCache[CAMERA_TEMPLATE_COUNT];
Zhijun Hea1530f12014-09-14 12:44:20 -0700548
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700549 struct Size {
550 uint32_t width;
551 uint32_t height;
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -0700552 explicit Size(uint32_t w = 0, uint32_t h = 0) : width(w), height(h){}
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700553 };
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700554
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700555 enum Status {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800556 STATUS_ERROR,
557 STATUS_UNINITIALIZED,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700558 STATUS_UNCONFIGURED,
559 STATUS_CONFIGURED,
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800560 STATUS_ACTIVE
561 } mStatus;
Ruben Brunk183f0562015-08-12 12:55:02 -0700562
563 // Only clear mRecentStatusUpdates, mStatusWaiters from waitUntilStateThenRelock
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700564 Vector<Status> mRecentStatusUpdates;
Ruben Brunk183f0562015-08-12 12:55:02 -0700565 int mStatusWaiters;
566
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700567 Condition mStatusChanged;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800568
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700569 // Tracking cause of fatal errors when in STATUS_ERROR
570 String8 mErrorCause;
571
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800572 camera3::StreamSet mOutputStreams;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800573 sp<camera3::Camera3Stream> mInputStream;
Shuzhen Wang83bff122020-11-20 15:51:39 -0800574 bool mIsInputStreamMultiResolution;
Shuzhen Wang316781a2020-08-18 18:11:01 -0700575 SessionStatsBuilder mSessionStatsBuilder;
Shuzhen Wang99080502021-03-07 21:08:20 -0800576 // Map from stream group ID to physical cameras backing the stream group
577 std::map<int32_t, std::set<String8>> mGroupIdPhysicalCameraMap;
Shuzhen Wang316781a2020-08-18 18:11:01 -0700578
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800579 int mNextStreamId;
Eino-Ville Talvalaea26c772013-06-11 16:04:06 -0700580 bool mNeedConfig;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800581
Ivan Lozanoc0ad82f2020-07-30 09:32:57 -0400582 int mFakeStreamId;
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700583
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700584 // Whether to send state updates upstream
585 // Pause when doing transparent reconfiguration
586 bool mPauseStateNotify;
587
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800588 // Need to hold on to stream references until configure completes.
Igor Murashkin2fba5842013-04-22 14:03:54 -0700589 Vector<sp<camera3::Camera3StreamInterface> > mDeletedStreams;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800590
Zhijun He204e3292014-07-14 17:09:23 -0700591 // Whether the HAL will send partial result
592 bool mUsePartialResult;
593
594 // Number of partial results that will be delivered by the HAL.
595 uint32_t mNumPartialResults;
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700596
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800597 /**** End scope for mLock ****/
598
Shuzhen Wange4208922022-02-01 16:52:48 -0800599 bool mDeviceTimeBaseIsRealtime;
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800600 // The offset converting from clock domain of other subsystem
601 // (video/hardware composer) to that of camera. Assumption is that this
602 // offset won't change during the life cycle of the camera device. In other
603 // words, camera device shouldn't be open during CPU suspend.
604 nsecs_t mTimestampOffset;
605
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800606 class CaptureRequest : public LightRefBase<CaptureRequest> {
607 public:
Emilian Peevaebbe412018-01-15 13:53:24 +0000608 PhysicalCameraSettingsList mSettingsList;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800609 sp<camera3::Camera3Stream> mInputStream;
Emilian Peevf4816702020-04-03 15:44:51 -0700610 camera_stream_buffer_t mInputBuffer;
Shuzhen Wang83bff122020-11-20 15:51:39 -0800611 camera3::Size mInputBufferSize;
Igor Murashkin2fba5842013-04-22 14:03:54 -0700612 Vector<sp<camera3::Camera3OutputStreamInterface> >
613 mOutputStreams;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700614 SurfaceMap mOutputSurfaces;
Jianing Weicb0652e2014-03-12 18:29:36 -0700615 CaptureResultExtras mResultExtras;
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700616 // The number of requests that should be submitted to HAL at a time.
617 // For example, if batch size is 8, this request and the following 7
618 // requests will be submitted to HAL at a time. The batch size for
619 // the following 7 requests will be ignored by the request thread.
620 int mBatchSize;
Shuzhen Wang9d066012016-09-30 11:30:20 -0700621 // Whether this request is from a repeating or repeating burst.
622 bool mRepeating;
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800623 // Whether this request has ROTATE_AND_CROP_AUTO set, so needs both
624 // overriding of ROTATE_AND_CROP value and adjustment of coordinates
625 // in several other controls in both the request and the result
626 bool mRotateAndCropAuto;
Bharatt Kukreja7146ced2022-10-25 15:45:29 +0000627 // Whether this request has AUTOFRAMING_AUTO set, so need to override the AUTOFRAMING value
628 // in the capture request.
629 bool mAutoframingAuto;
Eino-Ville Talvala305cec62020-11-12 14:18:17 -0800630
Shuzhen Wangd1d051a2020-08-20 15:42:23 -0700631 // Whether this capture request has its zoom ratio set to 1.0x before
632 // the framework overrides it for camera HAL consumption.
633 bool mZoomRatioIs1x;
Shuzhen Wang316781a2020-08-18 18:11:01 -0700634 // The systemTime timestamp when the request is created.
635 nsecs_t mRequestTimeNs;
Shuzhen Wangd1d051a2020-08-20 15:42:23 -0700636
Shuzhen Wangd1d051a2020-08-20 15:42:23 -0700637 // Whether this capture request's distortion correction update has
638 // been done.
639 bool mDistortionCorrectionUpdated = false;
640 // Whether this capture request's rotation and crop update has been
641 // done.
642 bool mRotationAndCropUpdated = false;
Bharatt Kukreja7146ced2022-10-25 15:45:29 +0000643 // Whether this capture request's autoframing has been done.
644 bool mAutoframingUpdated = false;
Shuzhen Wangd1d051a2020-08-20 15:42:23 -0700645 // Whether this capture request's zoom ratio update has been done.
646 bool mZoomRatioUpdated = false;
Jayant Chowdhary9255ce02021-07-15 11:18:17 -0700647 // Whether this max resolution capture request's crop / metering region update has been
648 // done.
649 bool mUHRCropAndMeteringRegionsUpdated = false;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800650 };
651 typedef List<sp<CaptureRequest> > RequestList;
652
Jianing Wei90e59c92014-03-12 18:29:36 -0700653 status_t checkStatusOkToCaptureLocked();
654
655 status_t convertMetadataListToRequestListLocked(
Emilian Peevaebbe412018-01-15 13:53:24 +0000656 const List<const PhysicalCameraSettingsList> &metadataList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700657 const std::list<const SurfaceMap> &surfaceMaps,
Shuzhen Wang316781a2020-08-18 18:11:01 -0700658 bool repeating, nsecs_t requestTimeNs,
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700659 /*out*/
660 RequestList *requestList);
Jianing Wei90e59c92014-03-12 18:29:36 -0700661
Emilian Peevaebbe412018-01-15 13:53:24 +0000662 void convertToRequestList(List<const PhysicalCameraSettingsList>& requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700663 std::list<const SurfaceMap>& surfaceMaps,
664 const CameraMetadata& request);
665
Emilian Peevaebbe412018-01-15 13:53:24 +0000666 status_t submitRequestsHelper(const List<const PhysicalCameraSettingsList> &requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700667 const std::list<const SurfaceMap> &surfaceMaps,
668 bool repeating,
Jianing Weicb0652e2014-03-12 18:29:36 -0700669 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700670
Yifan Honga640c5a2017-04-12 16:30:31 -0700671 // lock to ensure only one processCaptureResult is called at a time.
672 Mutex mProcessCaptureResultLock;
673
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800674 /**
675 * Common initialization code shared by both HAL paths
676 *
677 * Must be called with mLock and mInterfaceLock held.
678 */
679 status_t initializeCommonLocked();
680
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800681 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700682 * Get the last request submitted to the hal by the request thread.
683 *
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800684 * Must be called with mLock held.
Igor Murashkin1e479c02013-09-06 16:55:14 -0700685 */
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700686 virtual CameraMetadata getLatestRequestLocked();
Igor Murashkin1e479c02013-09-06 16:55:14 -0700687
Jayant Chowdhary22441f32021-12-26 18:35:41 -0800688 virtual status_t injectionCameraInitialize(const String8 &injectCamId,
689 sp<CameraProviderManager> manager) = 0;
690
Igor Murashkin1e479c02013-09-06 16:55:14 -0700691 /**
Ruben Brunk183f0562015-08-12 12:55:02 -0700692 * Update the current device status and wake all waiting threads.
693 *
694 * Must be called with mLock held.
695 */
696 void internalUpdateStatusLocked(Status status);
697
698 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700699 * Pause processing and flush everything, but don't tell the clients.
700 * This is for reconfiguring outputs transparently when according to the
701 * CameraDeviceBase interface we shouldn't need to.
702 * Must be called with mLock and mInterfaceLock both held.
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800703 */
Yin-Chia Yeh598fc602017-07-24 11:37:23 -0700704 status_t internalPauseAndWaitLocked(nsecs_t maxExpectedDuration);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700705
706 /**
707 * Resume work after internalPauseAndWaitLocked()
708 * Must be called with mLock and mInterfaceLock both held.
709 */
710 status_t internalResumeLocked();
711
712 /**
713 * Wait until status tracker tells us we've transitioned to the target state
714 * set, which is either ACTIVE when active==true or IDLE (which is any
715 * non-ACTIVE state) when active==false.
716 *
717 * Needs to be called with mLock and mInterfaceLock held. This means there
718 * can ever only be one waiter at most.
719 *
720 * During the wait mLock is released.
721 *
722 */
723 status_t waitUntilStateThenRelock(bool active, nsecs_t timeout);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800724
725 /**
Zhijun He69a37482014-03-23 18:44:49 -0700726 * Implementation of waitUntilDrained. On success, will transition to IDLE state.
727 *
728 * Need to be called with mLock and mInterfaceLock held.
729 */
Yin-Chia Yeh598fc602017-07-24 11:37:23 -0700730 status_t waitUntilDrainedLocked(nsecs_t maxExpectedDuration);
Zhijun He69a37482014-03-23 18:44:49 -0700731
732 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800733 * Do common work for setting up a streaming or single capture request.
734 * On success, will transition to ACTIVE if in IDLE.
735 */
Emilian Peevaebbe412018-01-15 13:53:24 +0000736 sp<CaptureRequest> setUpRequestLocked(const PhysicalCameraSettingsList &request,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700737 const SurfaceMap &surfaceMap);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800738
739 /**
740 * Build a CaptureRequest request from the CameraDeviceBase request
741 * settings.
742 */
Emilian Peevaebbe412018-01-15 13:53:24 +0000743 sp<CaptureRequest> createCaptureRequest(const PhysicalCameraSettingsList &request,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700744 const SurfaceMap &surfaceMap);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800745
746 /**
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000747 * Internally re-configure camera device using new session parameters.
Emilian Peev3bead5f2020-05-28 17:29:08 -0700748 * This will get triggered by the request thread.
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000749 */
Emilian Peev3bead5f2020-05-28 17:29:08 -0700750 bool reconfigureCamera(const CameraMetadata& sessionParams, int clientStatusId);
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000751
752 /**
Emilian Peev0d0191e2020-04-21 17:01:18 -0700753 * Return true in case of any output or input abandoned streams,
754 * otherwise return false.
755 */
756 bool checkAbandonedStreamsLocked();
757
758 /**
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000759 * Filter stream session parameters and configure camera HAL.
760 */
761 status_t filterParamsAndConfigureLocked(const CameraMetadata& sessionParams,
762 int operatingMode);
763
764 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800765 * Take the currently-defined set of streams and configure the HAL to use
766 * them. This is a long-running operation (may be several hundered ms).
767 */
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100768 status_t configureStreamsLocked(int operatingMode,
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000769 const CameraMetadata& sessionParams, bool notifyRequestThread = true);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800770
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700771 /**
Chien-Yu Chen9b5860b2016-06-10 13:39:09 -0700772 * Cancel stream configuration that did not finish successfully.
773 */
774 void cancelStreamsConfigurationLocked();
775
776 /**
Ivan Lozanoc0ad82f2020-07-30 09:32:57 -0400777 * Add a fake stream to the current stream set as a workaround for
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700778 * not allowing 0 streams in the camera HAL spec.
779 */
Ivan Lozanoc0ad82f2020-07-30 09:32:57 -0400780 status_t addFakeStreamLocked();
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700781
782 /**
Ivan Lozanoc0ad82f2020-07-30 09:32:57 -0400783 * Remove a fake stream if the current config includes real streams.
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700784 */
Ivan Lozanoc0ad82f2020-07-30 09:32:57 -0400785 status_t tryRemoveFakeStreamLocked();
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700786
787 /**
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700788 * Set device into an error state due to some fatal failure, and set an
789 * error message to indicate why. Only the first call's message will be
790 * used. The message is also sent to the log.
791 */
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800792 void setErrorState(const char *fmt, ...) override;
793 void setErrorStateLocked(const char *fmt, ...) override;
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700794 void setErrorStateV(const char *fmt, va_list args);
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700795 void setErrorStateLockedV(const char *fmt, va_list args);
796
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800797 /////////////////////////////////////////////////////////////////////
798 // Implements InflightRequestUpdateInterface
799
800 void onInflightEntryRemovedLocked(nsecs_t duration) override;
801 void checkInflightMapLengthLocked() override;
802 void onInflightMapFlushedLocked() override;
803
804 /////////////////////////////////////////////////////////////////////
805
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700806 /**
807 * Debugging trylock/spin method
808 * Try to acquire a lock a few times with sleeps between before giving up.
809 */
810 bool tryLockSpinRightRound(Mutex& lock);
811
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700812 /**
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800813 * Helper function to get the offset between MONOTONIC and BOOTTIME
814 * timestamp.
815 */
816 static nsecs_t getMonoToBoottimeOffset();
817
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700818 struct RequestTrigger {
819 // Metadata tag number, e.g. android.control.aePrecaptureTrigger
820 uint32_t metadataTag;
821 // Metadata value, e.g. 'START' or the trigger ID
822 int32_t entryValue;
823
824 // The last part of the fully qualified path, e.g. afTrigger
825 const char *getTagName() const {
826 return get_camera_metadata_tag_name(metadataTag) ?: "NULL";
827 }
828
829 // e.g. TYPE_BYTE, TYPE_INT32, etc.
830 int getTagType() const {
831 return get_camera_metadata_tag_type(metadataTag);
832 }
833 };
834
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800835 /**
836 * Thread for managing capture request submission to HAL device.
837 */
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800838 class RequestThread : public Thread {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800839
840 public:
841
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800842 RequestThread(wp<Camera3Device> parent,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700843 sp<camera3::StatusTracker> statusTracker,
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700844 sp<HalInterface> interface,
845 const Vector<int32_t>& sessionParamKeys,
Eino-Ville Talvala1646c3c2021-07-29 13:48:40 -0700846 bool useHalBufManager,
Austin Borger18b30a72022-10-27 12:20:29 -0700847 bool supportCameraMute,
848 bool overrideToPortrait);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800849 ~RequestThread();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800850
Yin-Chia Yehe1c80632016-08-08 14:48:05 -0700851 void setNotificationListener(wp<NotificationListener> listener);
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700852
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800853 /**
854 * Call after stream (re)-configuration is completed.
855 */
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000856 void configurationComplete(bool isConstrainedHighSpeed,
Shuzhen Wang99080502021-03-07 21:08:20 -0800857 const CameraMetadata& sessionParams,
858 const std::map<int32_t, std::set<String8>>& groupIdPhysicalCameraMap);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800859
860 /**
861 * Set or clear the list of repeating requests. Does not block
862 * on either. Use waitUntilPaused to wait until request queue
863 * has emptied out.
864 */
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700865 status_t setRepeatingRequests(const RequestList& requests,
866 /*out*/
867 int64_t *lastFrameNumber = NULL);
868 status_t clearRepeatingRequests(/*out*/
869 int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800870
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700871 status_t queueRequestList(List<sp<CaptureRequest> > &requests,
872 /*out*/
873 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700874
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800875 /**
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700876 * Remove all queued and repeating requests, and pending triggers
877 */
Yin-Chia Yehe1c80632016-08-08 14:48:05 -0700878 status_t clear(/*out*/int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700879
880 /**
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700881 * Flush all pending requests in HAL.
882 */
883 status_t flush();
884
885 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700886 * Queue a trigger to be dispatched with the next outgoing
887 * process_capture_request. The settings for that request only
888 * will be temporarily rewritten to add the trigger tag/value.
889 * Subsequent requests will not be rewritten (for this tag).
890 */
891 status_t queueTrigger(RequestTrigger trigger[], size_t count);
892
893 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800894 * Pause/unpause the capture thread. Doesn't block, so use
895 * waitUntilPaused to wait until the thread is paused.
896 */
897 void setPaused(bool paused);
898
Jayant Chowdharya93f3462022-11-01 23:32:45 +0000899 // set mRequestClearing - no new requests are expected to be queued to RequestThread
900 void setRequestClearing();
901
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800902 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700903 * Wait until thread processes the capture request with settings'
904 * android.request.id == requestId.
905 *
906 * Returns TIMED_OUT in case the thread does not process the request
907 * within the timeout.
908 */
909 status_t waitUntilRequestProcessed(int32_t requestId, nsecs_t timeout);
910
Igor Murashkin1e479c02013-09-06 16:55:14 -0700911 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700912 * Shut down the thread. Shutdown is asynchronous, so thread may
913 * still be running once this method returns.
914 */
915 virtual void requestExit();
916
917 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700918 * Get the latest request that was sent to the HAL
919 * with process_capture_request.
920 */
921 CameraMetadata getLatestRequest() const;
922
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700923 /**
924 * Returns true if the stream is a target of any queued or repeating
925 * capture request
926 */
927 bool isStreamPending(sp<camera3::Camera3StreamInterface>& stream);
928
Emilian Peev40ead602017-09-26 15:46:36 +0100929 /**
930 * Returns true if the surface is a target of any queued or repeating
931 * capture request
932 */
933 bool isOutputSurfacePending(int streamId, size_t surfaceId);
934
Shuzhen Wang686f6442017-06-20 16:16:04 -0700935 // dump processCaptureRequest latency
936 void dumpCaptureRequestLatency(int fd, const char* name) {
937 mRequestLatency.dump(fd, name);
938 }
939
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700940 void signalPipelineDrain(const std::vector<int>& streamIds);
Yin-Chia Yehe52b8fa2020-07-28 00:17:58 -0700941 void resetPipelineDrain();
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700942
Emilian Peevc0fe54c2020-03-11 14:05:07 -0700943 void clearPreviousRequest();
944
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800945 status_t setRotateAndCropAutoBehavior(
946 camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropValue);
Bharatt Kukreja7146ced2022-10-25 15:45:29 +0000947
948 status_t setAutoframingAutoBehaviour(
949 camera_metadata_enum_android_control_autoframing_t autoframingValue);
950
Emilian Peeve23f1d92021-09-20 14:56:01 -0700951 status_t setComposerSurface(bool composerSurfacePresent);
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800952
Eino-Ville Talvala11afe4f2021-05-27 14:45:31 -0700953 status_t setCameraMute(int32_t muteMode);
Cliff Wuc2ad9c82021-04-21 00:58:58 +0800954
955 status_t setHalInterface(sp<HalInterface> newHalInterface);
956
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800957 protected:
958
959 virtual bool threadLoop();
960
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800961 static const String8& getId(const wp<Camera3Device> &device);
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700962
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700963 status_t queueTriggerLocked(RequestTrigger trigger);
964 // Mix-in queued triggers into this request
965 int32_t insertTriggers(const sp<CaptureRequest> &request);
966 // Purge the queued triggers from this request,
967 // restoring the old field values for those tags.
968 status_t removeTriggers(const sp<CaptureRequest> &request);
969
Eino-Ville Talvala2f876f92013-09-13 11:39:24 -0700970 // HAL workaround: Make sure a trigger ID always exists if
971 // a trigger does
Ivan Lozanoc0ad82f2020-07-30 09:32:57 -0400972 status_t addFakeTriggerIds(const sp<CaptureRequest> &request);
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800973
974 // Override rotate_and_crop control if needed; returns true if the current value was changed
975 bool overrideAutoRotateAndCrop(const sp<CaptureRequest> &request);
Eino-Ville Talvala2f876f92013-09-13 11:39:24 -0700976
Bharatt Kukreja7146ced2022-10-25 15:45:29 +0000977 // Override autoframing control if needed; returns true if the current value was changed
978 bool overrideAutoframing(const sp<CaptureRequest> &request);
979
Eino-Ville Talvala305cec62020-11-12 14:18:17 -0800980 // Override test_pattern control if needed for camera mute; returns true
981 // if the current value was changed
982 bool overrideTestPattern(const sp<CaptureRequest> &request);
983
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800984 static const nsecs_t kRequestTimeout = 50e6; // 50 ms
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800985
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700986 // TODO: does this need to be adjusted for long exposure requests?
987 static const nsecs_t kRequestSubmitTimeout = 200e6; // 200 ms
988
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700989 // Used to prepare a batch of requests.
990 struct NextRequest {
991 sp<CaptureRequest> captureRequest;
Emilian Peevf4816702020-04-03 15:44:51 -0700992 camera_capture_request_t halRequest;
993 Vector<camera_stream_buffer_t> outputBuffers;
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700994 bool submitted;
995 };
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800996
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700997 // Wait for the next batch of requests and put them in mNextRequests. mNextRequests will
998 // be empty if it times out.
999 void waitForNextRequestBatch();
Chien-Yu Chen85a64552015-08-28 15:46:12 -07001000
1001 // Waits for a request, or returns NULL if times out. Must be called with mRequestLock hold.
1002 sp<CaptureRequest> waitForNextRequestLocked();
1003
Chien-Yu Chen57ea2922015-09-04 12:58:56 -07001004 // Prepare HAL requests and output buffers in mNextRequests. Return TIMED_OUT if getting any
1005 // output buffer timed out. If an error is returned, the caller should clean up the pending
1006 // request batch.
1007 status_t prepareHalRequests();
Chien-Yu Chen85a64552015-08-28 15:46:12 -07001008
Chien-Yu Chen57ea2922015-09-04 12:58:56 -07001009 // Return buffers, etc, for requests in mNextRequests that couldn't be fully constructed and
1010 // send request errors if sendRequestError is true. The buffers will be returned in the
1011 // ERROR state to mark them as not having valid data. mNextRequests will be cleared.
1012 void cleanUpFailedRequests(bool sendRequestError);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001013
Chien-Yu Chene8c535e2016-04-14 12:18:26 -07001014 // Stop the repeating request if any of its output streams is abandoned.
1015 void checkAndStopRepeatingRequest();
1016
Emilian Peevaebbe412018-01-15 13:53:24 +00001017 // Release physical camera settings and camera id resources.
1018 void cleanupPhysicalSettings(sp<CaptureRequest> request,
Emilian Peevf4816702020-04-03 15:44:51 -07001019 /*out*/camera_capture_request_t *halRequest);
Emilian Peevaebbe412018-01-15 13:53:24 +00001020
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001021 // Pause handling
1022 bool waitIfPaused();
Eino-Ville Talvala26fe6c72013-08-29 12:46:18 -07001023 void unpauseForNewRequests();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001024
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -07001025 // Relay error to parent device object setErrorState
1026 void setErrorState(const char *fmt, ...);
1027
Yin-Chia Yeh8684b7f2014-06-13 14:53:05 -07001028 // If the input request is in mRepeatingRequests. Must be called with mRequestLock hold
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -07001029 bool isRepeatingRequestLocked(const sp<CaptureRequest>&);
Yin-Chia Yeh8684b7f2014-06-13 14:53:05 -07001030
Chien-Yu Chene8c535e2016-04-14 12:18:26 -07001031 // Clear repeating requests. Must be called with mRequestLock held.
1032 status_t clearRepeatingRequestsLocked(/*out*/ int64_t *lastFrameNumber = NULL);
1033
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -08001034 // send request in mNextRequests to HAL in a batch. Return true = sucssess
1035 bool sendRequestsBatch();
1036
Shuzhen Wang696e4da2022-09-08 14:31:13 -07001037 // Calculate the expected (minimum, maximum, isFixedFps) duration info for a request
1038 struct ExpectedDurationInfo {
1039 nsecs_t minDuration;
1040 nsecs_t maxDuration;
1041 bool isFixedFps;
1042 };
1043 ExpectedDurationInfo calculateExpectedDurationRange(
Shuzhen Wang00abbeb2022-02-25 17:14:42 -08001044 const camera_metadata_t *request);
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -07001045
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001046 // Check and update latest session parameters based on the current request settings.
1047 bool updateSessionParameters(const CameraMetadata& settings);
1048
Emilian Peeva14b4dd2018-05-15 11:00:31 +01001049 // Check whether FPS range session parameter re-configuration is needed in constrained
1050 // high speed recording camera sessions.
1051 bool skipHFRTargetFPSUpdate(int32_t tag, const camera_metadata_ro_entry_t& newEntry,
1052 const camera_metadata_entry_t& currentEntry);
1053
Shuzhen Wangc2cba122018-05-17 18:10:24 -07001054 // Update next request sent to HAL
1055 void updateNextRequest(NextRequest& nextRequest);
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001056
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001057 wp<Camera3Device> mParent;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001058 wp<camera3::StatusTracker> mStatusTracker;
Yin-Chia Yehdb1e8642017-07-14 15:19:30 -07001059 sp<HalInterface> mInterface;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001060
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001061 wp<NotificationListener> mListener;
Eino-Ville Talvala17543512014-08-06 14:32:02 -07001062
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -08001063 const String8& mId; // The camera ID
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001064 int mStatusId; // The RequestThread's component ID for
1065 // status tracking
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001066
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001067 Mutex mRequestLock;
1068 Condition mRequestSignal;
Shuzhen Wangbb9b93d2022-04-07 13:22:48 -07001069 bool mRequestClearing;
1070
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001071 Condition mRequestSubmittedSignal;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001072 RequestList mRequestQueue;
1073 RequestList mRepeatingRequests;
Shuzhen Wang316781a2020-08-18 18:11:01 -07001074 bool mFirstRepeating;
Chien-Yu Chen57ea2922015-09-04 12:58:56 -07001075 // The next batch of requests being prepped for submission to the HAL, no longer
Eino-Ville Talvalae74c2282015-05-27 14:46:23 -07001076 // on the request queue. Read-only even with mRequestLock held, outside
1077 // of threadLoop
Chien-Yu Chen57ea2922015-09-04 12:58:56 -07001078 Vector<NextRequest> mNextRequests;
Chien-Yu Chen85a64552015-08-28 15:46:12 -07001079
1080 // To protect flush() and sending a request batch to HAL.
1081 Mutex mFlushLock;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001082
1083 bool mReconfigured;
1084
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -07001085 // Used by waitIfPaused, waitForNextRequest, waitUntilPaused, and signalPipelineDrain
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001086 Mutex mPauseLock;
1087 bool mDoPause;
1088 Condition mDoPauseSignal;
1089 bool mPaused;
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -07001090 bool mNotifyPipelineDrain;
1091 std::vector<int> mStreamIdsToBeDrained;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001092
1093 sp<CaptureRequest> mPrevRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001094 int32_t mPrevTriggers;
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -08001095 std::set<std::string> mPrevCameraIdsWithZoom;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001096
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001097 uint32_t mFrameNumber;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001098
Igor Murashkin1e479c02013-09-06 16:55:14 -07001099 mutable Mutex mLatestRequestMutex;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001100 Condition mLatestRequestSignal;
1101 // android.request.id for latest process_capture_request
1102 int32_t mLatestRequestId;
Igor Murashkin1e479c02013-09-06 16:55:14 -07001103 CameraMetadata mLatestRequest;
Shuzhen Wangc2cba122018-05-17 18:10:24 -07001104 std::unordered_map<std::string, CameraMetadata> mLatestPhysicalRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001105
1106 typedef KeyedVector<uint32_t/*tag*/, RequestTrigger> TriggerMap;
1107 Mutex mTriggerMutex;
1108 TriggerMap mTriggerMap;
1109 TriggerMap mTriggerRemovedMap;
1110 TriggerMap mTriggerReplacedMap;
Yin-Chia Yehc00a25c2014-08-21 14:27:44 -07001111 uint32_t mCurrentAfTriggerId;
1112 uint32_t mCurrentPreCaptureTriggerId;
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001113 camera_metadata_enum_android_scaler_rotate_and_crop_t mRotateAndCropOverride;
Bharatt Kukreja7146ced2022-10-25 15:45:29 +00001114 camera_metadata_enum_android_control_autoframing_t mAutoframingOverride;
Emilian Peeve23f1d92021-09-20 14:56:01 -07001115 bool mComposerOutput;
Eino-Ville Talvala11afe4f2021-05-27 14:45:31 -07001116 int32_t mCameraMute; // 0 = no mute, otherwise the TEST_PATTERN_MODE to use
Eino-Ville Talvala305cec62020-11-12 14:18:17 -08001117 bool mCameraMuteChanged;
Jianing Weicb0652e2014-03-12 18:29:36 -07001118
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07001119 int64_t mRepeatingLastFrameNumber;
Chien-Yu Chend196d612015-06-22 19:49:01 -07001120
Chien-Yu Chenc66969b2016-05-19 16:37:51 -07001121 // Flag indicating if we should prepare video stream for video requests.
1122 bool mPrepareVideoStream;
Shuzhen Wang686f6442017-06-20 16:16:04 -07001123
Emilian Peeva14b4dd2018-05-15 11:00:31 +01001124 bool mConstrainedMode;
1125
Shuzhen Wang686f6442017-06-20 16:16:04 -07001126 static const int32_t kRequestLatencyBinSize = 40; // in ms
1127 CameraLatencyHistogram mRequestLatency;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001128
1129 Vector<int32_t> mSessionParamKeys;
1130 CameraMetadata mLatestSessionParams;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001131
Shuzhen Wang99080502021-03-07 21:08:20 -08001132 std::map<int32_t, std::set<String8>> mGroupIdPhysicalCameraMap;
1133
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001134 const bool mUseHalBufManager;
Eino-Ville Talvala1646c3c2021-07-29 13:48:40 -07001135 const bool mSupportCameraMute;
Austin Borger18b30a72022-10-27 12:20:29 -07001136 const bool mOverrideToPortrait;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001137 };
Jayant Chowdhary22441f32021-12-26 18:35:41 -08001138
1139 virtual sp<RequestThread> createNewRequestThread(wp<Camera3Device> /*parent*/,
1140 sp<camera3::StatusTracker> /*statusTracker*/,
1141 sp<HalInterface> /*interface*/,
1142 const Vector<int32_t>& /*sessionParamKeys*/,
1143 bool /*useHalBufManager*/,
Austin Borger18b30a72022-10-27 12:20:29 -07001144 bool /*supportCameraMute*/,
1145 bool /*overrideToPortrait*/) = 0;
Jayant Chowdhary22441f32021-12-26 18:35:41 -08001146
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001147 sp<RequestThread> mRequestThread;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001148
1149 /**
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001150 * In-flight queue for tracking completion of capture requests.
1151 */
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001152 std::mutex mInFlightLock;
1153 camera3::InFlightRequestMap mInFlightMap;
1154 nsecs_t mExpectedInflightDuration = 0;
Shuzhen Wangb7b42652020-05-07 11:59:02 -07001155 int64_t mLastCompletedRegularFrameNumber = -1;
1156 int64_t mLastCompletedReprocessFrameNumber = -1;
1157 int64_t mLastCompletedZslFrameNumber = -1;
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001158 // End of mInFlightLock protection scope
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001159
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001160 int mInFlightStatusId; // const after initialize
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001161
Jianing Weicb0652e2014-03-12 18:29:36 -07001162 status_t registerInFlight(uint32_t frameNumber,
Chien-Yu Chend196d612015-06-22 19:49:01 -07001163 int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput,
Shuzhen Wang00abbeb2022-02-25 17:14:42 -08001164 bool callback, nsecs_t minExpectedDuration, nsecs_t maxExpectedDuration,
Shuzhen Wang696e4da2022-09-08 14:31:13 -07001165 bool isFixedFps, const std::set<std::set<String8>>& physicalCameraIds,
Bharatt Kukreja7146ced2022-10-25 15:45:29 +00001166 bool isStillCapture, bool isZslCapture, bool rotateAndCropAuto, bool autoframingAuto,
Shuzhen Wang316781a2020-08-18 18:11:01 -07001167 const std::set<std::string>& cameraIdsWithZoom, const SurfaceMap& outputSurfaces,
1168 nsecs_t requestTimeNs);
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -07001169
1170 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001171 * Tracking for idle detection
1172 */
1173 sp<camera3::StatusTracker> mStatusTracker;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001174
1175 /**
Zhijun He125684a2015-12-26 15:07:30 -08001176 * Graphic buffer manager for output streams. Each device has a buffer manager, which is used
1177 * by the output streams to get and return buffers if these streams are registered to this
1178 * buffer manager.
1179 */
1180 sp<camera3::Camera3BufferManager> mBufferManager;
1181
1182 /**
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001183 * Thread for preparing streams
1184 */
1185 class PreparerThread : private Thread, public virtual RefBase {
1186 public:
1187 PreparerThread();
1188 ~PreparerThread();
1189
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001190 void setNotificationListener(wp<NotificationListener> listener);
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001191
1192 /**
Ruben Brunkc78ac262015-08-13 17:58:46 -07001193 * Queue up a stream to be prepared. Streams are processed by a background thread in FIFO
1194 * order. Pre-allocate up to maxCount buffers for the stream, or the maximum number needed
1195 * for the pipeline if maxCount is ALLOCATE_PIPELINE_MAX.
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001196 */
Ruben Brunkc78ac262015-08-13 17:58:46 -07001197 status_t prepare(int maxCount, sp<camera3::Camera3StreamInterface>& stream);
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001198
1199 /**
1200 * Cancel all current and pending stream preparation
1201 */
1202 status_t clear();
1203
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001204 /**
1205 * Pause all preparation activities
1206 */
1207 void pause();
1208
1209 /**
1210 * Resume preparation activities
1211 */
1212 status_t resume();
1213
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001214 private:
1215 Mutex mLock;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001216 Condition mThreadActiveSignal;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001217
1218 virtual bool threadLoop();
1219
1220 // Guarded by mLock
1221
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001222 wp<NotificationListener> mListener;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001223 std::unordered_map<int, sp<camera3::Camera3StreamInterface> > mPendingStreams;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001224 bool mActive;
1225 bool mCancelNow;
1226
1227 // Only accessed by threadLoop and the destructor
1228
1229 sp<camera3::Camera3StreamInterface> mCurrentStream;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001230 int mCurrentMaxCount;
1231 bool mCurrentPrepareComplete;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001232 };
1233 sp<PreparerThread> mPreparerThread;
1234
1235 /**
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001236 * Output result queue and current HAL device 3A state
1237 */
1238
1239 // Lock for output side of device
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001240 std::mutex mOutputLock;
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001241
1242 /**** Scope for mOutputLock ****/
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001243 // the minimal frame number of the next non-reprocess result
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001244 uint32_t mNextResultFrameNumber;
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001245 // the minimal frame number of the next reprocess result
1246 uint32_t mNextReprocessResultFrameNumber;
Shuzhen Wang5ee99842019-04-12 11:55:48 -07001247 // the minimal frame number of the next ZSL still capture result
1248 uint32_t mNextZslStillResultFrameNumber;
Chien-Yu Chen3df11ce2015-09-30 14:13:30 -07001249 // the minimal frame number of the next non-reprocess shutter
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001250 uint32_t mNextShutterFrameNumber;
Chien-Yu Chen3df11ce2015-09-30 14:13:30 -07001251 // the minimal frame number of the next reprocess shutter
1252 uint32_t mNextReprocessShutterFrameNumber;
Shuzhen Wang5ee99842019-04-12 11:55:48 -07001253 // the minimal frame number of the next ZSL still capture shutter
1254 uint32_t mNextZslStillShutterFrameNumber;
Jayant Chowdhary8a0be292020-01-08 13:10:38 -08001255 std::list<CaptureResult> mResultQueue;
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001256 std::condition_variable mResultSignal;
1257 wp<NotificationListener> mListener;
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001258
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001259 /**** End scope for mOutputLock ****/
1260
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001261 /**** Scope for mInFlightLock ****/
1262
Shuzhen Wangcadb3302016-11-04 14:17:56 -07001263 // Remove the in-flight map entry of the given index from mInFlightMap.
1264 // It must only be called with mInFlightLock held.
1265 void removeInFlightMapEntryLocked(int idx);
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001266
Yin-Chia Yehf3fe36f2017-07-07 18:23:18 -07001267 // Remove all in-flight requests and return all buffers.
1268 // This is used after HAL interface is closed to cleanup any request/buffers
1269 // not returned by HAL.
1270 void flushInflightRequests();
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001271
1272 /**** End scope for mInFlightLock ****/
1273
Eino-Ville Talvala7b8a1fd2018-05-22 15:30:35 -07001274 /**
1275 * Distortion correction support
1276 */
Shuzhen Wang4f6fa9d2019-03-29 10:40:35 -07001277 // Map from camera IDs to its corresponding distortion mapper. Only contains
1278 // 1 ID if the device isn't a logical multi-camera. Otherwise contains both
1279 // logical camera and its physical subcameras.
1280 std::unordered_map<std::string, camera3::DistortionMapper> mDistortionMappers;
Eino-Ville Talvala7b8a1fd2018-05-22 15:30:35 -07001281
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -08001282 /**
1283 * Zoom ratio mapper support
1284 */
1285 std::unordered_map<std::string, camera3::ZoomRatioMapper> mZoomRatioMappers;
1286
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001287 /**
Jayant Chowdhary9255ce02021-07-15 11:18:17 -07001288 * UHR request crop / metering region mapper support
1289 */
1290 std::unordered_map<std::string, camera3::UHRCropAndMeteringRegionMapper>
1291 mUHRCropAndMeteringRegionMappers;
1292
1293 /**
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001294 * RotateAndCrop mapper support
1295 */
1296 std::unordered_map<std::string, camera3::RotateAndCropMapper> mRotateAndCropMappers;
1297
Eino-Ville Talvala4d453832016-07-15 11:56:53 -07001298 // Debug tracker for metadata tag value changes
1299 // - Enabled with the -m <taglist> option to dumpsys, such as
1300 // dumpsys -m android.control.aeState,android.control.aeMode
1301 // - Disabled with -m off
1302 // - dumpsys -m 3a is a shortcut for ae/af/awbMode, State, and Triggers
1303 TagMonitor mTagMonitor;
1304
1305 void monitorMetadata(TagMonitor::eventSource source, int64_t frameNumber,
Shuzhen Wangc2cba122018-05-17 18:10:24 -07001306 nsecs_t timestamp, const CameraMetadata& metadata,
Jayant Chowdharycd277cd2021-08-11 15:48:40 -07001307 const std::unordered_map<std::string, CameraMetadata>& physicalMetadata,
Jayant Chowdharyc30b4c32021-08-18 11:43:16 -07001308 const camera_stream_buffer_t *outputBuffers, uint32_t numOutputBuffers,
1309 int32_t inputStreamId);
Eino-Ville Talvala4d453832016-07-15 11:56:53 -07001310
Emilian Peev71c73a22017-03-21 16:35:51 +00001311 metadata_vendor_id_t mVendorTagId;
1312
Emilian Peev811d2952018-05-25 11:08:40 +01001313 // Cached last requested template id
1314 int mLastTemplateId;
1315
Emilian Peev26d975d2018-07-05 14:52:57 +01001316 // Synchronizes access to status tracker between inflight updates and disconnect.
1317 // b/79972865
1318 Mutex mTrackerLock;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001319
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001320 // Whether HAL request buffers through requestStreamBuffers API
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001321 bool mUseHalBufManager = false;
1322
1323 // Lock to ensure requestStreamBuffers() callbacks are serialized
1324 std::mutex mRequestBufferInterfaceLock;
1325
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001326 // The state machine to control when requestStreamBuffers should allow
1327 // HAL to request buffers.
1328 enum RequestBufferState {
1329 /**
1330 * This is the initial state.
1331 * requestStreamBuffers call will return FAILED_CONFIGURING in this state.
1332 * Will switch to RB_STATUS_READY after a successful configureStreams or
1333 * processCaptureRequest call.
1334 */
1335 RB_STATUS_STOPPED,
1336
1337 /**
1338 * requestStreamBuffers call will proceed in this state.
1339 * When device is asked to stay idle via waitUntilStateThenRelock() call:
1340 * - Switch to RB_STATUS_STOPPED if there is no inflight requests and
1341 * request thread is paused.
1342 * - Switch to RB_STATUS_PENDING_STOP otherwise
1343 */
1344 RB_STATUS_READY,
1345
1346 /**
1347 * requestStreamBuffers call will proceed in this state.
1348 * Switch to RB_STATUS_STOPPED when all inflight requests are fulfilled
1349 * and request thread is paused
1350 */
1351 RB_STATUS_PENDING_STOP,
1352 };
1353
1354 class RequestBufferStateMachine {
1355 public:
1356 status_t initialize(sp<camera3::StatusTracker> statusTracker);
1357
1358 // Return if the state machine currently allows for requestBuffers
1359 // If the state allows for it, mRequestBufferOngoing will be set to true
1360 // and caller must call endRequestBuffer() later to unset the flag
1361 bool startRequestBuffer();
1362 void endRequestBuffer();
1363
1364 // Events triggered by application API call
1365 void onStreamsConfigured();
1366 void onWaitUntilIdle();
1367
1368 // Events usually triggered by hwBinder processCaptureResult callback thread
1369 // But can also be triggered on request thread for failed request, or on
1370 // hwbinder notify callback thread for shutter/error callbacks
1371 void onInflightMapEmpty();
1372
1373 // Events triggered by RequestThread
Yin-Chia Yehcd333fe2019-02-08 13:45:41 -08001374 void onSubmittingRequest();
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001375 void onRequestThreadPaused();
1376
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001377 // Events triggered by successful switchToOffline call
1378 // Return true is there is no ongoing requestBuffer call.
1379 bool onSwitchToOfflineSuccess();
1380
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001381 private:
1382 void notifyTrackerLocked(bool active);
1383
1384 // Switch to STOPPED state and return true if all conditions allows for it.
1385 // Otherwise do nothing and return false.
1386 bool checkSwitchToStopLocked();
1387
1388 std::mutex mLock;
1389 RequestBufferState mStatus = RB_STATUS_STOPPED;
1390
1391 bool mRequestThreadPaused = true;
1392 bool mInflightMapEmpty = true;
1393 bool mRequestBufferOngoing = false;
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001394 bool mSwitchedToOffline = false;
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001395
1396 wp<camera3::StatusTracker> mStatusTracker;
1397 int mRequestBufferStatusId;
1398 } mRequestBufferSM;
1399
Shuzhen Wang268a1362018-10-16 16:32:59 -07001400 // Fix up result metadata for monochrome camera.
1401 bool mNeedFixupMonochromeTags;
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001402
1403 // Whether HAL supports offline processing capability.
1404 bool mSupportOfflineProcessing = false;
Eino-Ville Talvala305cec62020-11-12 14:18:17 -08001405
1406 // Whether the HAL supports camera muting via test pattern
1407 bool mSupportCameraMute = false;
Eino-Ville Talvala11afe4f2021-05-27 14:45:31 -07001408 // Whether the HAL supports SOLID_COLOR or BLACK if mSupportCameraMute is true
1409 bool mSupportTestPatternSolidColor = false;
Eino-Ville Talvala305cec62020-11-12 14:18:17 -08001410
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001411 // Whether the camera framework overrides the device characteristics for
1412 // performance class.
1413 bool mOverrideForPerfClass;
1414
Austin Borger18b30a72022-10-27 12:20:29 -07001415 // Whether the camera framework overrides the device characteristics for
1416 // app compatibility reasons.
1417 bool mOverrideToPortrait;
1418
Austin Borgerc8099762023-01-12 17:08:46 -08001419 // Current active physical id of the logical multi-camera, if any
1420 std::string mActivePhysicalId;
1421
Shuzhen Wang00abbeb2022-02-25 17:14:42 -08001422 // The current minimum expected frame duration based on AE_TARGET_FPS_RANGE
1423 nsecs_t mMinExpectedDuration = 0;
Shuzhen Wang696e4da2022-09-08 14:31:13 -07001424 // Whether the camera device runs at fixed frame rate based on AE_MODE and
1425 // AE_TARGET_FPS_RANGE
1426 bool mIsFixedFps = false;
Shuzhen Wang00abbeb2022-02-25 17:14:42 -08001427
Cliff Wuc2ad9c82021-04-21 00:58:58 +08001428 // Injection camera related methods.
1429 class Camera3DeviceInjectionMethods : public virtual RefBase {
1430 public:
1431 Camera3DeviceInjectionMethods(wp<Camera3Device> parent);
1432
1433 ~Camera3DeviceInjectionMethods();
1434
Cliff Wuc2ad9c82021-04-21 00:58:58 +08001435 // Injection camera will replace the internal camera and configure streams
1436 // when device is IDLE and request thread is paused.
1437 status_t injectCamera(
1438 camera3::camera_stream_configuration& injectionConfig,
Cliff Wu3b268182021-07-06 15:44:43 +08001439 const std::vector<uint32_t>& injectionBufferSizes);
Cliff Wuc2ad9c82021-04-21 00:58:58 +08001440
1441 // Stop the injection camera and switch back to backup hal interface.
1442 status_t stopInjection();
1443
1444 bool isInjecting();
1445
Cliff Wu3b268182021-07-06 15:44:43 +08001446 bool isStreamConfigCompleteButNotInjected();
1447
Cliff Wuc2ad9c82021-04-21 00:58:58 +08001448 const String8& getInjectedCamId() const;
1449
1450 void getInjectionConfig(/*out*/ camera3::camera_stream_configuration* injectionConfig,
1451 /*out*/ std::vector<uint32_t>* injectionBufferSizes);
1452
Cliff Wu3b268182021-07-06 15:44:43 +08001453 // When the streaming configuration is completed and the camera device is active, but the
1454 // injection camera has not yet been injected, the streaming configuration of the internal
1455 // camera will be stored first.
1456 void storeInjectionConfig(
1457 const camera3::camera_stream_configuration& injectionConfig,
1458 const std::vector<uint32_t>& injectionBufferSizes);
1459
Jayant Chowdhary22441f32021-12-26 18:35:41 -08001460 protected:
Cliff Wuc2ad9c82021-04-21 00:58:58 +08001461 // Configure the streams of injection camera, it need wait until the
1462 // output streams are created and configured to the original camera before
1463 // proceeding.
1464 status_t injectionConfigureStreams(
1465 camera3::camera_stream_configuration& injectionConfig,
Cliff Wu3b268182021-07-06 15:44:43 +08001466 const std::vector<uint32_t>& injectionBufferSizes);
Cliff Wuc2ad9c82021-04-21 00:58:58 +08001467
1468 // Disconnect the injection camera and delete the hal interface.
1469 void injectionDisconnectImpl();
1470
1471 // Use injection camera hal interface to replace and backup original
1472 // camera hal interface.
Jayant Chowdhary22441f32021-12-26 18:35:41 -08001473 virtual status_t replaceHalInterface(sp<HalInterface> /*newHalInterface*/,
1474 bool /*keepBackup*/) = 0;
Cliff Wuc2ad9c82021-04-21 00:58:58 +08001475
1476 wp<Camera3Device> mParent;
1477
1478 // Backup of the original camera hal interface.
1479 sp<HalInterface> mBackupHalInterface;
1480
1481 // Generated injection camera hal interface.
1482 sp<HalInterface> mInjectedCamHalInterface;
1483
Cliff Wu3b268182021-07-06 15:44:43 +08001484 // The flag indicates that the stream configuration is complete, the camera device is
1485 // active, but the injection camera has not yet been injected.
1486 bool mIsStreamConfigCompleteButNotInjected = false;
1487
Cliff Wuc2ad9c82021-04-21 00:58:58 +08001488 // Copy the configuration of the internal camera.
1489 camera3::camera_stream_configuration mInjectionConfig;
1490
Cliff Wud0476312021-07-27 20:15:55 +08001491 // Copy the streams of the internal camera.
1492 Vector<camera3::camera_stream_t*> mInjectionStreams;
1493
Cliff Wuc2ad9c82021-04-21 00:58:58 +08001494 // Copy the bufferSizes of the output streams of the internal camera.
1495 std::vector<uint32_t> mInjectionBufferSizes;
1496
1497 // Synchronizes access to injection camera between initialize and
1498 // disconnect.
1499 Mutex mInjectionLock;
1500
1501 // The injection camera ID.
1502 String8 mInjectedCamId;
1503 };
Jayant Chowdhary22441f32021-12-26 18:35:41 -08001504
1505 virtual sp<Camera3DeviceInjectionMethods>
1506 createCamera3DeviceInjectionMethods(wp<Camera3Device>) = 0;
1507
Cliff Wuc2ad9c82021-04-21 00:58:58 +08001508 sp<Camera3DeviceInjectionMethods> mInjectionMethods;
1509
Shuzhen Wang16610a62022-12-15 22:38:07 -08001510 void overrideStreamUseCaseLocked();
1511
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001512}; // class Camera3Device
1513
1514}; // namespace android
1515
1516#endif