blob: 08d36dbeacae3b25a1513fae250c42d55da210ba [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>
Yin-Chia Yehb978c382019-10-30 00:22:37 -070037#include <android/hardware/camera/device/3.6/ICameraDeviceSession.h>
Shuzhen Wang83bff122020-11-20 15:51:39 -080038#include <android/hardware/camera/device/3.7/ICameraDeviceSession.h>
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080039#include <android/hardware/camera/device/3.2/ICameraDeviceCallback.h>
Shuzhen Wang5c22c152017-12-31 17:12:25 -080040#include <android/hardware/camera/device/3.4/ICameraDeviceCallback.h>
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -070041#include <android/hardware/camera/device/3.5/ICameraDeviceCallback.h>
Yifan Hongf79b5542017-04-11 14:44:25 -070042#include <fmq/MessageQueue.h>
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080043
Jianing Weicb0652e2014-03-12 18:29:36 -070044#include <camera/CaptureResult.h>
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080045
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070046#include "common/CameraDeviceBase.h"
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -080047#include "device3/BufferUtils.h"
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -070048#include "device3/StatusTracker.h"
Zhijun He125684a2015-12-26 15:07:30 -080049#include "device3/Camera3BufferManager.h"
Eino-Ville Talvala7b8a1fd2018-05-22 15:30:35 -070050#include "device3/DistortionMapper.h"
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -080051#include "device3/ZoomRatioMapper.h"
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -080052#include "device3/RotateAndCropMapper.h"
Jayant Chowdhary9255ce02021-07-15 11:18:17 -070053#include "device3/UHRCropAndMeteringRegionMapper.h"
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -080054#include "device3/InFlightRequest.h"
55#include "device3/Camera3OutputInterface.h"
56#include "device3/Camera3OfflineSession.h"
Shuzhen Wang83bff122020-11-20 15:51:39 -080057#include "device3/Camera3StreamInterface.h"
Eino-Ville Talvala4d453832016-07-15 11:56:53 -070058#include "utils/TagMonitor.h"
Shuzhen Wang686f6442017-06-20 16:16:04 -070059#include "utils/LatencyHistogram.h"
Emilian Peev71c73a22017-03-21 16:35:51 +000060#include <camera_metadata_hidden.h>
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080061
Emilian Peevf4816702020-04-03 15:44:51 -070062using android::camera3::camera_capture_request_t;
63using android::camera3::camera_jpeg_blob_t;
64using android::camera3::camera_request_template;
65using android::camera3::camera_stream_buffer_t;
66using android::camera3::camera_stream_configuration_t;
67using android::camera3::camera_stream_configuration_mode_t;
68using android::camera3::CAMERA_TEMPLATE_COUNT;
Emilian Peev40ead602017-09-26 15:46:36 +010069using android::camera3::OutputStreamInfo;
70
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080071namespace android {
72
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070073namespace camera3 {
74
75class Camera3Stream;
76class Camera3ZslStream;
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070077class Camera3StreamInterface;
78
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -080079} // namespace camera3
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070080
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080081/**
Zhijun He95dd5ba2014-03-26 18:18:00 -070082 * CameraDevice for HAL devices with version CAMERA_DEVICE_API_VERSION_3_0 or higher.
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080083 */
84class Camera3Device :
85 public CameraDeviceBase,
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -080086 virtual public hardware::camera::device::V3_5::ICameraDeviceCallback,
87 public camera3::SetErrorInterface,
88 public camera3::InflightRequestUpdateInterface,
89 public camera3::RequestBufferInterface,
90 public camera3::FlushBufferInterface {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080091 public:
Ruben Brunkc78ac262015-08-13 17:58:46 -070092
Emilian Peev5104fe92021-10-21 14:27:09 -070093 explicit Camera3Device(const String8& id, bool overrideForPerfClass, bool legacyClient = false);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080094
95 virtual ~Camera3Device();
96
97 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -080098 * CameraDeviceBase interface
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080099 */
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800100
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800101 const String8& getId() const override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800102
Emilian Peev00420d22018-02-05 21:33:13 +0000103 metadata_vendor_id_t getVendorTagId() const override { return mVendorTagId; }
104
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800105 // Transitions to idle state on success.
Emilian Peevbd8c5032018-02-14 23:05:40 +0000106 status_t initialize(sp<CameraProviderManager> manager, const String8& monitorTags) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800107 status_t disconnect() override;
108 status_t dump(int fd, const Vector<String16> &args) override;
109 const CameraMetadata& info() const override;
Emilian Peevfaa4bde2020-01-23 12:19:37 -0800110 const CameraMetadata& infoPhysical(const String8& physicalId) const override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800111
112 // Capture and setStreamingRequest will configure streams if currently in
113 // idle state
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800114 status_t capture(CameraMetadata &request, int64_t *lastFrameNumber = NULL) override;
Emilian Peevaebbe412018-01-15 13:53:24 +0000115 status_t captureList(const List<const PhysicalCameraSettingsList> &requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700116 const std::list<const SurfaceMap> &surfaceMaps,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800117 int64_t *lastFrameNumber = NULL) override;
118 status_t setStreamingRequest(const CameraMetadata &request,
119 int64_t *lastFrameNumber = NULL) override;
Emilian Peevaebbe412018-01-15 13:53:24 +0000120 status_t setStreamingRequestList(const List<const PhysicalCameraSettingsList> &requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700121 const std::list<const SurfaceMap> &surfaceMaps,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800122 int64_t *lastFrameNumber = NULL) override;
123 status_t clearStreamingRequest(int64_t *lastFrameNumber = NULL) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800124
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800125 status_t waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800126
127 // Actual stream creation/deletion is delayed until first request is submitted
128 // If adding streams while actively capturing, will pause device before adding
Zhijun He5d677d12016-05-29 16:52:39 -0700129 // stream, reconfiguring device, and unpausing. If the client create a stream
Shuzhen Wang758c2152017-01-10 18:26:18 -0800130 // with nullptr consumer surface, the client must then call setConsumers()
Zhijun He5d677d12016-05-29 16:52:39 -0700131 // and finish the stream configuration before starting output streaming.
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800132 status_t createStream(sp<Surface> consumer,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800133 uint32_t width, uint32_t height, int format,
Emilian Peevf4816702020-04-03 15:44:51 -0700134 android_dataspace dataSpace, camera_stream_rotation_t rotation, int *id,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800135 const String8& physicalCameraId,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800136 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peev40ead602017-09-26 15:46:36 +0100137 std::vector<int> *surfaceIds = nullptr,
Zhijun He5d677d12016-05-29 16:52:39 -0700138 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,
Shuzhen Wang83bff122020-11-20 15:51:39 -0800139 bool isShared = false, bool isMultiResolution = false,
140 uint64_t consumerUsage = 0) override;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800141
Shuzhen Wang0129d522016-10-30 22:43:41 -0700142 status_t createStream(const std::vector<sp<Surface>>& consumers,
143 bool hasDeferredConsumer, 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,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700148 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,
Shuzhen Wang83bff122020-11-20 15:51:39 -0800149 bool isShared = false, bool isMultiResolution = false,
150 uint64_t consumerUsage = 0) override;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700151
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800152 status_t createInputStream(
Shuzhen Wang83bff122020-11-20 15:51:39 -0800153 uint32_t width, uint32_t height, int format, bool isMultiResolution,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800154 int *id) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800155
Emilian Peev710c1422017-08-30 11:19:38 +0100156 status_t getStreamInfo(int id, StreamInfo *streamInfo) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800157 status_t setStreamTransform(int id, int transform) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800158
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800159 status_t deleteStream(int id) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800160
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100161 status_t configureStreams(const CameraMetadata& sessionParams,
162 int operatingMode =
Emilian Peevf4816702020-04-03 15:44:51 -0700163 camera_stream_configuration_mode_t::CAMERA_STREAM_CONFIGURATION_NORMAL_MODE) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800164 status_t getInputBufferProducer(
165 sp<IGraphicBufferProducer> *producer) override;
Igor Murashkine2d167e2014-08-19 16:19:59 -0700166
Emilian Peevcc0b7952020-01-07 13:54:47 -0800167 void getOfflineStreamIds(std::vector<int> *offlineStreamIds) override;
168
Emilian Peevf4816702020-04-03 15:44:51 -0700169 status_t createDefaultRequest(camera_request_template_t templateId,
170 CameraMetadata *request) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800171
172 // Transitions to the idle state on success
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800173 status_t waitUntilDrained() override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800174
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800175 status_t setNotifyCallback(wp<NotificationListener> listener) override;
176 bool willNotify3A() override;
177 status_t waitForNextFrame(nsecs_t timeout) override;
178 status_t getNextResult(CaptureResult *frame) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800179
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800180 status_t triggerAutofocus(uint32_t id) override;
181 status_t triggerCancelAutofocus(uint32_t id) override;
182 status_t triggerPrecaptureMetering(uint32_t id) override;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800183
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800184 status_t flush(int64_t *lastFrameNumber = NULL) override;
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700185
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800186 status_t prepare(int streamId) override;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700187
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800188 status_t tearDown(int streamId) override;
Eino-Ville Talvalab25e3c82015-07-15 16:04:27 -0700189
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800190 status_t addBufferListenerForStream(int streamId,
191 wp<camera3::Camera3StreamBufferListener> listener) override;
Shuzhen Wangb0fdc1e2016-03-20 23:21:39 -0700192
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800193 status_t prepare(int maxCount, int streamId) override;
Ruben Brunkc78ac262015-08-13 17:58:46 -0700194
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800195 ssize_t getJpegBufferSize(uint32_t width, uint32_t height) const override;
Eino-Ville Talvala95a1d0f2015-08-11 15:08:53 -0700196 ssize_t getPointCloudBufferSize() const;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800197 ssize_t getRawOpaqueBufferSize(int32_t width, int32_t height, bool maxResolution) const;
Zhijun He28c9b6f2014-08-08 12:00:47 -0700198
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700199 // Methods called by subclasses
200 void notifyStatus(bool idle); // updates from StatusTracker
201
Zhijun He5d677d12016-05-29 16:52:39 -0700202 /**
Shuzhen Wang758c2152017-01-10 18:26:18 -0800203 * Set the deferred consumer surfaces to the output stream and finish the deferred
Zhijun He5d677d12016-05-29 16:52:39 -0700204 * consumer configuration.
205 */
Emilian Peev40ead602017-09-26 15:46:36 +0100206 status_t setConsumerSurfaces(
207 int streamId, const std::vector<sp<Surface>>& consumers,
208 std::vector<int> *surfaceIds /*out*/) override;
209
210 /**
211 * Update a given stream.
212 */
213 status_t updateStream(int streamId, const std::vector<sp<Surface>> &newSurfaces,
214 const std::vector<OutputStreamInfo> &outputInfo,
215 const std::vector<size_t> &removedSurfaceIds,
216 KeyedVector<sp<Surface>, size_t> *outputMap/*out*/);
Zhijun He5d677d12016-05-29 16:52:39 -0700217
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700218 /**
219 * Drop buffers for stream of streamId if dropping is true. If dropping is false, do not
220 * drop buffers for stream of streamId.
221 */
222 status_t dropStreamBuffers(bool dropping, int streamId) override;
223
Emilian Peev2a8e2832019-08-23 13:00:31 -0700224 nsecs_t getExpectedInFlightDuration() override;
225
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700226 status_t switchToOffline(const std::vector<int32_t>& streamsToKeep,
227 /*out*/ sp<CameraOfflineSessionBase>* session) override;
228
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800229 // RequestBufferInterface
230 bool startRequestBuffer() override;
231 void endRequestBuffer() override;
232 nsecs_t getWaitDuration() override;
233
234 // FlushBufferInterface
235 void getInflightBufferKeys(std::vector<std::pair<int32_t, int32_t>>* out) override;
236 void getInflightRequestBufferKeys(std::vector<uint64_t>* out) override;
237 std::vector<sp<camera3::Camera3StreamInterface>> getAllStreams() override;
238
Emilian Peev35ae8262018-11-08 13:11:32 +0000239 /**
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800240 * Set the current behavior for the ROTATE_AND_CROP control when in AUTO.
241 *
242 * The value must be one of the ROTATE_AND_CROP_* values besides AUTO,
243 * and defaults to NONE.
244 */
245 status_t setRotateAndCropAutoBehavior(
246 camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropValue);
247
Eino-Ville Talvala305cec62020-11-12 14:18:17 -0800248 /**
249 * Whether camera muting (producing black-only output) is supported.
250 *
251 * Calling setCameraMute(true) when this returns false will return an
252 * INVALID_OPERATION error.
253 */
254 bool supportsCameraMute();
255
256 /**
257 * Mute the camera.
258 *
259 * When muted, black image data is output on all output streams.
260 */
261 status_t setCameraMute(bool enabled);
262
Shuzhen Wange8675782019-12-05 09:12:14 -0800263 // Get the status trackeer for the camera device
264 wp<camera3::StatusTracker> getStatusTracker() { return mStatusTracker; }
265
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800266 /**
Cliff Wuc2ad9c82021-04-21 00:58:58 +0800267 * The injection camera session to replace the internal camera
268 * session.
269 */
270 status_t injectCamera(const String8& injectedCamId,
271 sp<CameraProviderManager> manager);
272
273 /**
274 * Stop the injection camera and restore to internal camera session.
275 */
276 status_t stopInjection();
277
278 /**
Emilian Peev35ae8262018-11-08 13:11:32 +0000279 * Helper functions to map between framework and HIDL values
280 */
281 static hardware::graphics::common::V1_0::PixelFormat mapToPixelFormat(int frameworkFormat);
282 static hardware::camera::device::V3_2::DataspaceFlags mapToHidlDataspace(
283 android_dataspace dataSpace);
284 static hardware::camera::device::V3_2::BufferUsageFlags mapToConsumerUsage(uint64_t usage);
285 static hardware::camera::device::V3_2::StreamRotation mapToStreamRotation(
Emilian Peevf4816702020-04-03 15:44:51 -0700286 camera_stream_rotation_t rotation);
Emilian Peev35ae8262018-11-08 13:11:32 +0000287 // Returns a negative error code if the passed-in operation mode is not valid.
Emilian Peevf4816702020-04-03 15:44:51 -0700288 static status_t mapToStreamConfigurationMode(camera_stream_configuration_mode_t operationMode,
Emilian Peev35ae8262018-11-08 13:11:32 +0000289 /*out*/ hardware::camera::device::V3_2::StreamConfigurationMode *mode);
Emilian Peev35ae8262018-11-08 13:11:32 +0000290 static int mapToFrameworkFormat(hardware::graphics::common::V1_0::PixelFormat pixelFormat);
291 static android_dataspace mapToFrameworkDataspace(
292 hardware::camera::device::V3_2::DataspaceFlags);
293 static uint64_t mapConsumerToFrameworkUsage(
294 hardware::camera::device::V3_2::BufferUsageFlags usage);
295 static uint64_t mapProducerToFrameworkUsage(
296 hardware::camera::device::V3_2::BufferUsageFlags usage);
297
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800298 private:
Yin-Chia Yehc5248132018-08-15 12:19:20 -0700299 status_t disconnectImpl();
Jayant Chowdhary65c9bf02021-09-03 16:44:16 +0000300 static status_t removeFwkOnlyRegionKeys(CameraMetadata *request);
Yin-Chia Yehc5248132018-08-15 12:19:20 -0700301
Yifan Hongf79b5542017-04-11 14:44:25 -0700302 // internal typedefs
303 using RequestMetadataQueue = hardware::MessageQueue<uint8_t, hardware::kSynchronizedReadWrite>;
304
Igor Murashkin1e479c02013-09-06 16:55:14 -0700305 static const size_t kDumpLockAttempts = 10;
306 static const size_t kDumpSleepDuration = 100000; // 0.10 sec
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700307 static const nsecs_t kActiveTimeout = 500000000; // 500 ms
Yin-Chia Yeh99fd0972019-06-27 14:22:44 -0700308 static const nsecs_t kMinWarnInflightDuration = 5000000000; // 5 s
Yin-Chia Yeh90c0fdf2017-06-29 13:22:12 -0700309 static const size_t kInFlightWarnLimit = 30;
Chien-Yu Chenc96ac8d2015-08-12 16:46:24 -0700310 static const size_t kInFlightWarnLimitHighSpeed = 256; // batch size 32 * pipe depth 8
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -0700311 static const nsecs_t kDefaultExpectedDuration = 100000000; // 100 ms
312 static const nsecs_t kMinInflightDuration = 5000000000; // 5 s
Yin-Chia Yehb3a80b12018-09-04 12:13:05 -0700313 static const nsecs_t kBaseGetBufferWait = 3000000000; // 3 sec.
Eino-Ville Talvalaf99498e2015-09-25 16:52:55 -0700314 // SCHED_FIFO priority for request submission thread in HFR mode
Zhijun He7ee4c072016-07-25 13:52:28 -0700315 static const int kRequestThreadPriority = 1;
Chien-Yu Chenc96ac8d2015-08-12 16:46:24 -0700316
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700317 struct RequestTrigger;
Zhijun Hef7da0962014-04-24 13:27:56 -0700318 // minimal jpeg buffer size: 256KB + blob header
Emilian Peevf4816702020-04-03 15:44:51 -0700319 static const ssize_t kMinJpegBufferSize = 256 * 1024 + sizeof(camera_jpeg_blob_t);
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700320 // Constant to use for stream ID when one doesn't exist
321 static const int NO_STREAM = -1;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800322
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700323 // A lock to enforce serialization on the input/configure side
324 // of the public interface.
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700325 // Not locked by methods guarded by mOutputLock, since they may act
326 // concurrently to the input/configure side of the interface.
327 // Must be locked before mLock if both will be locked by a method
328 Mutex mInterfaceLock;
329
330 // The main lock on internal state
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800331 Mutex mLock;
332
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700333 // Camera device ID
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800334 const String8 mId;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700335
Emilian Peev5104fe92021-10-21 14:27:09 -0700336 // Legacy camera client flag
337 bool mLegacyClient;
338
Eino-Ville Talvalabbbbe842017-02-28 17:50:56 -0800339 // Current stream configuration mode;
340 int mOperatingMode;
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100341 // Current session wide parameters
342 hardware::camera2::impl::CameraMetadataNative mSessionParams;
343
Eino-Ville Talvalabbbbe842017-02-28 17:50:56 -0800344 // Constant to use for no set operating mode
345 static const int NO_MODE = -1;
346
Zhijun He1fa89992015-06-01 15:44:31 -0700347 // Flag indicating is the current active stream configuration is constrained high speed.
348 bool mIsConstrainedHighSpeedConfiguration;
349
Yifan Honga640c5a2017-04-12 16:30:31 -0700350 // FMQ to write result on. Must be guarded by mProcessCaptureResultLock.
351 std::unique_ptr<ResultMetadataQueue> mResultMetadataQueue;
352
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800353 /**** Scope for mLock ****/
354
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800355 /**
356 * Adapter for legacy HAL / HIDL HAL interface calls; calls either into legacy HALv3 or the
357 * HIDL HALv3 interfaces.
358 */
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800359 class HalInterface : public camera3::Camera3StreamBufferFreedListener,
360 public camera3::BufferRecordsInterface {
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800361 public:
Yifan Hongf79b5542017-04-11 14:44:25 -0700362 HalInterface(sp<hardware::camera::device::V3_2::ICameraDeviceSession> &session,
Yin-Chia Yeh651fe2e2018-11-13 11:49:31 -0800363 std::shared_ptr<RequestMetadataQueue> queue,
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700364 bool useHalBufManager, bool supportOfflineProcessing);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800365 HalInterface(const HalInterface &other);
366 HalInterface();
367
368 // Returns true if constructed with a valid device or session, and not yet cleared
369 bool valid();
370
371 // Reset this HalInterface object (does not call close())
372 void clear();
373
374 // Calls into the HAL interface
375
376 // Caller takes ownership of requestTemplate
Emilian Peevf4816702020-04-03 15:44:51 -0700377 status_t constructDefaultRequestSettings(camera_request_template templateId,
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800378 /*out*/ camera_metadata_t **requestTemplate);
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100379 status_t configureStreams(const camera_metadata_t *sessionParams,
Emilian Peevf4816702020-04-03 15:44:51 -0700380 /*inout*/ camera_stream_configuration_t *config,
Emilian Peev192ee832018-01-31 14:46:47 +0000381 const std::vector<uint32_t>& bufferSizes);
Yin-Chia Yeh11648852019-05-16 10:42:54 -0700382
Cliff Wuc2ad9c82021-04-21 00:58:58 +0800383 // The injection camera configures the streams to hal.
384 status_t configureInjectedStreams(
385 const camera_metadata_t* sessionParams,
386 /*inout*/ camera_stream_configuration_t* config,
387 const std::vector<uint32_t>& bufferSizes,
388 const CameraMetadata& cameraCharacteristics);
389
Yin-Chia Yeh11648852019-05-16 10:42:54 -0700390 // When the call succeeds, the ownership of acquire fences in requests is transferred to
391 // HalInterface. More specifically, the current implementation will send the fence to
392 // HAL process and close the FD in cameraserver process. When the call fails, the ownership
393 // of the acquire fence still belongs to the caller.
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800394 status_t processBatchCaptureRequests(
Emilian Peevf4816702020-04-03 15:44:51 -0700395 std::vector<camera_capture_request_t*>& requests,
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800396 /*out*/uint32_t* numRequestProcessed);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800397 status_t flush();
398 status_t dump(int fd);
399 status_t close();
400
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700401 void signalPipelineDrain(const std::vector<int>& streamIds);
Emilian Peev4ec17882019-01-24 17:16:58 -0800402 bool isReconfigurationRequired(CameraMetadata& oldSessionParams,
403 CameraMetadata& newSessionParams);
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700404
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800405 // Upon successful return, HalInterface will return buffer maps needed for offline
406 // processing, and clear all its internal buffer maps.
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700407 status_t switchToOffline(
408 const std::vector<int32_t>& streamsToKeep,
409 /*out*/hardware::camera::device::V3_6::CameraOfflineSessionInfo* offlineSessionInfo,
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800410 /*out*/sp<hardware::camera::device::V3_6::ICameraOfflineSession>* offlineSession,
411 /*out*/camera3::BufferRecords* bufferRecords);
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700412
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800413 /////////////////////////////////////////////////////////////////////
414 // Implements BufferRecordsInterface
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700415
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800416 std::pair<bool, uint64_t> getBufferId(
417 const buffer_handle_t& buf, int streamId) override;
418
Shuzhen Wangcd5b1822021-09-07 11:52:48 -0700419 uint64_t removeOneBufferCache(int streamId, const native_handle_t* handle) override;
420
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800421 status_t popInflightBuffer(int32_t frameNumber, int32_t streamId,
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800422 /*out*/ buffer_handle_t **buffer) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800423
Yin-Chia Yeh84be5782019-03-01 11:47:02 -0800424 status_t pushInflightRequestBuffer(
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800425 uint64_t bufferId, buffer_handle_t* buf, int32_t streamId) override;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700426
Yin-Chia Yeh84be5782019-03-01 11:47:02 -0800427 status_t popInflightRequestBuffer(uint64_t bufferId,
428 /*out*/ buffer_handle_t** buffer,
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800429 /*optional out*/ int32_t* streamId = nullptr) override;
430
431 /////////////////////////////////////////////////////////////////////
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700432
Yin-Chia Yehf3fe36f2017-07-07 18:23:18 -0700433 // Get a vector of (frameNumber, streamId) pair of currently inflight
434 // buffers
435 void getInflightBufferKeys(std::vector<std::pair<int32_t, int32_t>>* out);
436
Yin-Chia Yeh84be5782019-03-01 11:47:02 -0800437 // Get a vector of bufferId of currently inflight buffers
438 void getInflightRequestBufferKeys(std::vector<uint64_t>* out);
439
Yin-Chia Yeh573a2702019-04-17 10:08:55 -0700440 void onStreamReConfigured(int streamId);
441
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800442 private:
Eino-Ville Talvala1a86df52018-01-17 16:00:35 -0800443 // Always valid
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800444 sp<hardware::camera::device::V3_2::ICameraDeviceSession> mHidlSession;
Eino-Ville Talvala1a86df52018-01-17 16:00:35 -0800445 // Valid if ICameraDeviceSession is @3.3 or newer
446 sp<hardware::camera::device::V3_3::ICameraDeviceSession> mHidlSession_3_3;
447 // Valid if ICameraDeviceSession is @3.4 or newer
448 sp<hardware::camera::device::V3_4::ICameraDeviceSession> mHidlSession_3_4;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700449 // Valid if ICameraDeviceSession is @3.5 or newer
450 sp<hardware::camera::device::V3_5::ICameraDeviceSession> mHidlSession_3_5;
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700451 // Valid if ICameraDeviceSession is @3.6 or newer
452 sp<hardware::camera::device::V3_6::ICameraDeviceSession> mHidlSession_3_6;
Shuzhen Wang83bff122020-11-20 15:51:39 -0800453 // Valid if ICameraDeviceSession is @3.7 or newer
454 sp<hardware::camera::device::V3_7::ICameraDeviceSession> mHidlSession_3_7;
Eino-Ville Talvala1a86df52018-01-17 16:00:35 -0800455
Yifan Hongf79b5542017-04-11 14:44:25 -0700456 std::shared_ptr<RequestMetadataQueue> mRequestMetadataQueue;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800457
Emilian Peevf4816702020-04-03 15:44:51 -0700458 // The output HIDL request still depends on input camera_capture_request_t
459 // Do not free input camera_capture_request_t before output HIDL request
460 status_t wrapAsHidlRequest(camera_capture_request_t* in,
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800461 /*out*/hardware::camera::device::V3_2::CaptureRequest* out,
Yin-Chia Yehf8e28fb2019-05-16 11:46:54 -0700462 /*out*/std::vector<native_handle_t*>* handlesCreated,
463 /*out*/std::vector<std::pair<int32_t, int32_t>>* inflightBuffers);
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800464
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800465 status_t pushInflightBufferLocked(int32_t frameNumber, int32_t streamId,
Yin-Chia Yehf8e28fb2019-05-16 11:46:54 -0700466 buffer_handle_t *buffer);
467
468 // Pop inflight buffers based on pairs of (frameNumber,streamId)
469 void popInflightBuffers(const std::vector<std::pair<int32_t, int32_t>>& buffers);
470
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800471 // Return true if the input caches match what we have; otherwise false
472 bool verifyBufferIds(int32_t streamId, std::vector<uint64_t>& inBufIds);
Yin-Chia Yehf8e28fb2019-05-16 11:46:54 -0700473
474 // Delete and optionally close native handles and clear the input vector afterward
475 static void cleanupNativeHandles(
476 std::vector<native_handle_t*> *handles, bool closeFd = false);
Yin-Chia Yeh77327052017-01-09 18:23:07 -0800477
Yin-Chia Yehbe83fa72017-03-30 13:35:36 -0700478 virtual void onBufferFreed(int streamId, const native_handle_t* handle) override;
479
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800480 std::mutex mFreedBuffersLock;
Yin-Chia Yehbe83fa72017-03-30 13:35:36 -0700481 std::vector<std::pair<int, uint64_t>> mFreedBuffers;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700482
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800483 // Keep track of buffer cache and inflight buffer records
484 camera3::BufferRecords mBufferRecords;
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700485
486 uint32_t mNextStreamConfigCounter = 1;
Yin-Chia Yeh651fe2e2018-11-13 11:49:31 -0800487
488 const bool mUseHalBufManager;
Emilian Peev4ec17882019-01-24 17:16:58 -0800489 bool mIsReconfigurationQuerySupported;
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700490
491 const bool mSupportOfflineProcessing;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800492 };
493
Yin-Chia Yehdb1e8642017-07-14 15:19:30 -0700494 sp<HalInterface> mInterface;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800495
496 CameraMetadata mDeviceInfo;
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -0800497 bool mSupportNativeZoomRatio;
Shuzhen Wang2e7f58f2018-07-11 14:00:29 -0700498 std::unordered_map<std::string, CameraMetadata> mPhysicalDeviceInfoMap;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800499
Emilian Peevf4816702020-04-03 15:44:51 -0700500 CameraMetadata mRequestTemplateCache[CAMERA_TEMPLATE_COUNT];
Zhijun Hea1530f12014-09-14 12:44:20 -0700501
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700502 struct Size {
503 uint32_t width;
504 uint32_t height;
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -0700505 explicit Size(uint32_t w = 0, uint32_t h = 0) : width(w), height(h){}
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700506 };
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700507
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700508 enum Status {
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800509 STATUS_ERROR,
510 STATUS_UNINITIALIZED,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700511 STATUS_UNCONFIGURED,
512 STATUS_CONFIGURED,
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800513 STATUS_ACTIVE
514 } mStatus;
Ruben Brunk183f0562015-08-12 12:55:02 -0700515
516 // Only clear mRecentStatusUpdates, mStatusWaiters from waitUntilStateThenRelock
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700517 Vector<Status> mRecentStatusUpdates;
Ruben Brunk183f0562015-08-12 12:55:02 -0700518 int mStatusWaiters;
519
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700520 Condition mStatusChanged;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800521
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700522 // Tracking cause of fatal errors when in STATUS_ERROR
523 String8 mErrorCause;
524
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800525 camera3::StreamSet mOutputStreams;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800526 sp<camera3::Camera3Stream> mInputStream;
Shuzhen Wang83bff122020-11-20 15:51:39 -0800527 bool mIsInputStreamMultiResolution;
Shuzhen Wang316781a2020-08-18 18:11:01 -0700528 SessionStatsBuilder mSessionStatsBuilder;
Shuzhen Wang99080502021-03-07 21:08:20 -0800529 // Map from stream group ID to physical cameras backing the stream group
530 std::map<int32_t, std::set<String8>> mGroupIdPhysicalCameraMap;
Shuzhen Wang316781a2020-08-18 18:11:01 -0700531
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800532 int mNextStreamId;
Eino-Ville Talvalaea26c772013-06-11 16:04:06 -0700533 bool mNeedConfig;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800534
Ivan Lozanoc0ad82f2020-07-30 09:32:57 -0400535 int mFakeStreamId;
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700536
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700537 // Whether to send state updates upstream
538 // Pause when doing transparent reconfiguration
539 bool mPauseStateNotify;
540
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800541 // Need to hold on to stream references until configure completes.
Igor Murashkin2fba5842013-04-22 14:03:54 -0700542 Vector<sp<camera3::Camera3StreamInterface> > mDeletedStreams;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800543
Zhijun He204e3292014-07-14 17:09:23 -0700544 // Whether the HAL will send partial result
545 bool mUsePartialResult;
546
547 // Number of partial results that will be delivered by the HAL.
548 uint32_t mNumPartialResults;
Eino-Ville Talvalafd6ecdd2013-10-11 09:51:09 -0700549
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800550 /**** End scope for mLock ****/
551
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800552 // The offset converting from clock domain of other subsystem
553 // (video/hardware composer) to that of camera. Assumption is that this
554 // offset won't change during the life cycle of the camera device. In other
555 // words, camera device shouldn't be open during CPU suspend.
556 nsecs_t mTimestampOffset;
557
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800558 class CaptureRequest : public LightRefBase<CaptureRequest> {
559 public:
Emilian Peevaebbe412018-01-15 13:53:24 +0000560 PhysicalCameraSettingsList mSettingsList;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800561 sp<camera3::Camera3Stream> mInputStream;
Emilian Peevf4816702020-04-03 15:44:51 -0700562 camera_stream_buffer_t mInputBuffer;
Shuzhen Wang83bff122020-11-20 15:51:39 -0800563 camera3::Size mInputBufferSize;
Igor Murashkin2fba5842013-04-22 14:03:54 -0700564 Vector<sp<camera3::Camera3OutputStreamInterface> >
565 mOutputStreams;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700566 SurfaceMap mOutputSurfaces;
Jianing Weicb0652e2014-03-12 18:29:36 -0700567 CaptureResultExtras mResultExtras;
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700568 // The number of requests that should be submitted to HAL at a time.
569 // For example, if batch size is 8, this request and the following 7
570 // requests will be submitted to HAL at a time. The batch size for
571 // the following 7 requests will be ignored by the request thread.
572 int mBatchSize;
Shuzhen Wang9d066012016-09-30 11:30:20 -0700573 // Whether this request is from a repeating or repeating burst.
574 bool mRepeating;
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800575 // Whether this request has ROTATE_AND_CROP_AUTO set, so needs both
576 // overriding of ROTATE_AND_CROP value and adjustment of coordinates
577 // in several other controls in both the request and the result
578 bool mRotateAndCropAuto;
Eino-Ville Talvala305cec62020-11-12 14:18:17 -0800579
Shuzhen Wangd1d051a2020-08-20 15:42:23 -0700580 // Whether this capture request has its zoom ratio set to 1.0x before
581 // the framework overrides it for camera HAL consumption.
582 bool mZoomRatioIs1x;
Shuzhen Wang316781a2020-08-18 18:11:01 -0700583 // The systemTime timestamp when the request is created.
584 nsecs_t mRequestTimeNs;
Shuzhen Wangd1d051a2020-08-20 15:42:23 -0700585
Shuzhen Wangd1d051a2020-08-20 15:42:23 -0700586 // Whether this capture request's distortion correction update has
587 // been done.
588 bool mDistortionCorrectionUpdated = false;
589 // Whether this capture request's rotation and crop update has been
590 // done.
591 bool mRotationAndCropUpdated = false;
592 // Whether this capture request's zoom ratio update has been done.
593 bool mZoomRatioUpdated = false;
Jayant Chowdhary9255ce02021-07-15 11:18:17 -0700594 // Whether this max resolution capture request's crop / metering region update has been
595 // done.
596 bool mUHRCropAndMeteringRegionsUpdated = false;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800597 };
598 typedef List<sp<CaptureRequest> > RequestList;
599
Jianing Wei90e59c92014-03-12 18:29:36 -0700600 status_t checkStatusOkToCaptureLocked();
601
602 status_t convertMetadataListToRequestListLocked(
Emilian Peevaebbe412018-01-15 13:53:24 +0000603 const List<const PhysicalCameraSettingsList> &metadataList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700604 const std::list<const SurfaceMap> &surfaceMaps,
Shuzhen Wang316781a2020-08-18 18:11:01 -0700605 bool repeating, nsecs_t requestTimeNs,
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700606 /*out*/
607 RequestList *requestList);
Jianing Wei90e59c92014-03-12 18:29:36 -0700608
Emilian Peevaebbe412018-01-15 13:53:24 +0000609 void convertToRequestList(List<const PhysicalCameraSettingsList>& requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700610 std::list<const SurfaceMap>& surfaceMaps,
611 const CameraMetadata& request);
612
Emilian Peevaebbe412018-01-15 13:53:24 +0000613 status_t submitRequestsHelper(const List<const PhysicalCameraSettingsList> &requestsList,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700614 const std::list<const SurfaceMap> &surfaceMaps,
615 bool repeating,
Jianing Weicb0652e2014-03-12 18:29:36 -0700616 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700617
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800618
619 /**
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700620 * Implementation of android::hardware::camera::device::V3_5::ICameraDeviceCallback
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800621 */
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700622
Shuzhen Wang5c22c152017-12-31 17:12:25 -0800623 hardware::Return<void> processCaptureResult_3_4(
624 const hardware::hidl_vec<
625 hardware::camera::device::V3_4::CaptureResult>& results) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800626 hardware::Return<void> processCaptureResult(
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800627 const hardware::hidl_vec<
628 hardware::camera::device::V3_2::CaptureResult>& results) override;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800629 hardware::Return<void> notify(
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800630 const hardware::hidl_vec<
631 hardware::camera::device::V3_2::NotifyMsg>& msgs) override;
632
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700633 hardware::Return<void> requestStreamBuffers(
634 const hardware::hidl_vec<
635 hardware::camera::device::V3_5::BufferRequest>& bufReqs,
636 requestStreamBuffers_cb _hidl_cb) override;
637
638 hardware::Return<void> returnStreamBuffers(
639 const hardware::hidl_vec<
640 hardware::camera::device::V3_2::StreamBuffer>& buffers) override;
641
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -0800642 // Handle one notify message
643 void notify(const hardware::camera::device::V3_2::NotifyMsg& msg);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800644
Yifan Honga640c5a2017-04-12 16:30:31 -0700645 // lock to ensure only one processCaptureResult is called at a time.
646 Mutex mProcessCaptureResultLock;
647
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800648 /**
649 * Common initialization code shared by both HAL paths
650 *
651 * Must be called with mLock and mInterfaceLock held.
652 */
653 status_t initializeCommonLocked();
654
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800655 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700656 * Get the last request submitted to the hal by the request thread.
657 *
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800658 * Must be called with mLock held.
Igor Murashkin1e479c02013-09-06 16:55:14 -0700659 */
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700660 virtual CameraMetadata getLatestRequestLocked();
Igor Murashkin1e479c02013-09-06 16:55:14 -0700661
662 /**
Ruben Brunk183f0562015-08-12 12:55:02 -0700663 * Update the current device status and wake all waiting threads.
664 *
665 * Must be called with mLock held.
666 */
667 void internalUpdateStatusLocked(Status status);
668
669 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700670 * Pause processing and flush everything, but don't tell the clients.
671 * This is for reconfiguring outputs transparently when according to the
672 * CameraDeviceBase interface we shouldn't need to.
673 * Must be called with mLock and mInterfaceLock both held.
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800674 */
Yin-Chia Yeh598fc602017-07-24 11:37:23 -0700675 status_t internalPauseAndWaitLocked(nsecs_t maxExpectedDuration);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700676
677 /**
678 * Resume work after internalPauseAndWaitLocked()
679 * Must be called with mLock and mInterfaceLock both held.
680 */
681 status_t internalResumeLocked();
682
683 /**
684 * Wait until status tracker tells us we've transitioned to the target state
685 * set, which is either ACTIVE when active==true or IDLE (which is any
686 * non-ACTIVE state) when active==false.
687 *
688 * Needs to be called with mLock and mInterfaceLock held. This means there
689 * can ever only be one waiter at most.
690 *
691 * During the wait mLock is released.
692 *
693 */
694 status_t waitUntilStateThenRelock(bool active, nsecs_t timeout);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800695
696 /**
Zhijun He69a37482014-03-23 18:44:49 -0700697 * Implementation of waitUntilDrained. On success, will transition to IDLE state.
698 *
699 * Need to be called with mLock and mInterfaceLock held.
700 */
Yin-Chia Yeh598fc602017-07-24 11:37:23 -0700701 status_t waitUntilDrainedLocked(nsecs_t maxExpectedDuration);
Zhijun He69a37482014-03-23 18:44:49 -0700702
703 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800704 * Do common work for setting up a streaming or single capture request.
705 * On success, will transition to ACTIVE if in IDLE.
706 */
Emilian Peevaebbe412018-01-15 13:53:24 +0000707 sp<CaptureRequest> setUpRequestLocked(const PhysicalCameraSettingsList &request,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700708 const SurfaceMap &surfaceMap);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800709
710 /**
711 * Build a CaptureRequest request from the CameraDeviceBase request
712 * settings.
713 */
Emilian Peevaebbe412018-01-15 13:53:24 +0000714 sp<CaptureRequest> createCaptureRequest(const PhysicalCameraSettingsList &request,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700715 const SurfaceMap &surfaceMap);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800716
717 /**
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000718 * Internally re-configure camera device using new session parameters.
Emilian Peev3bead5f2020-05-28 17:29:08 -0700719 * This will get triggered by the request thread.
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000720 */
Emilian Peev3bead5f2020-05-28 17:29:08 -0700721 bool reconfigureCamera(const CameraMetadata& sessionParams, int clientStatusId);
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000722
723 /**
Emilian Peev0d0191e2020-04-21 17:01:18 -0700724 * Return true in case of any output or input abandoned streams,
725 * otherwise return false.
726 */
727 bool checkAbandonedStreamsLocked();
728
729 /**
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000730 * Filter stream session parameters and configure camera HAL.
731 */
732 status_t filterParamsAndConfigureLocked(const CameraMetadata& sessionParams,
733 int operatingMode);
734
735 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800736 * Take the currently-defined set of streams and configure the HAL to use
737 * them. This is a long-running operation (may be several hundered ms).
738 */
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100739 status_t configureStreamsLocked(int operatingMode,
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000740 const CameraMetadata& sessionParams, bool notifyRequestThread = true);
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800741
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700742 /**
Chien-Yu Chen9b5860b2016-06-10 13:39:09 -0700743 * Cancel stream configuration that did not finish successfully.
744 */
745 void cancelStreamsConfigurationLocked();
746
747 /**
Ivan Lozanoc0ad82f2020-07-30 09:32:57 -0400748 * Add a fake stream to the current stream set as a workaround for
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700749 * not allowing 0 streams in the camera HAL spec.
750 */
Ivan Lozanoc0ad82f2020-07-30 09:32:57 -0400751 status_t addFakeStreamLocked();
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700752
753 /**
Ivan Lozanoc0ad82f2020-07-30 09:32:57 -0400754 * Remove a fake stream if the current config includes real streams.
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700755 */
Ivan Lozanoc0ad82f2020-07-30 09:32:57 -0400756 status_t tryRemoveFakeStreamLocked();
Eino-Ville Talvala16a2ada2014-08-27 14:41:33 -0700757
758 /**
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700759 * Set device into an error state due to some fatal failure, and set an
760 * error message to indicate why. Only the first call's message will be
761 * used. The message is also sent to the log.
762 */
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800763 void setErrorState(const char *fmt, ...) override;
764 void setErrorStateLocked(const char *fmt, ...) override;
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700765 void setErrorStateV(const char *fmt, va_list args);
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700766 void setErrorStateLockedV(const char *fmt, va_list args);
767
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800768 /////////////////////////////////////////////////////////////////////
769 // Implements InflightRequestUpdateInterface
770
771 void onInflightEntryRemovedLocked(nsecs_t duration) override;
772 void checkInflightMapLengthLocked() override;
773 void onInflightMapFlushedLocked() override;
774
775 /////////////////////////////////////////////////////////////////////
776
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700777 /**
778 * Debugging trylock/spin method
779 * Try to acquire a lock a few times with sleeps between before giving up.
780 */
781 bool tryLockSpinRightRound(Mutex& lock);
782
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700783 /**
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800784 * Helper function to get the offset between MONOTONIC and BOOTTIME
785 * timestamp.
786 */
787 static nsecs_t getMonoToBoottimeOffset();
788
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700789 struct RequestTrigger {
790 // Metadata tag number, e.g. android.control.aePrecaptureTrigger
791 uint32_t metadataTag;
792 // Metadata value, e.g. 'START' or the trigger ID
793 int32_t entryValue;
794
795 // The last part of the fully qualified path, e.g. afTrigger
796 const char *getTagName() const {
797 return get_camera_metadata_tag_name(metadataTag) ?: "NULL";
798 }
799
800 // e.g. TYPE_BYTE, TYPE_INT32, etc.
801 int getTagType() const {
802 return get_camera_metadata_tag_type(metadataTag);
803 }
804 };
805
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800806 /**
807 * Thread for managing capture request submission to HAL device.
808 */
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800809 class RequestThread : public Thread {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800810
811 public:
812
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800813 RequestThread(wp<Camera3Device> parent,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700814 sp<camera3::StatusTracker> statusTracker,
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700815 sp<HalInterface> interface,
816 const Vector<int32_t>& sessionParamKeys,
Eino-Ville Talvala1646c3c2021-07-29 13:48:40 -0700817 bool useHalBufManager,
818 bool supportCameraMute);
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800819 ~RequestThread();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800820
Yin-Chia Yehe1c80632016-08-08 14:48:05 -0700821 void setNotificationListener(wp<NotificationListener> listener);
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700822
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800823 /**
824 * Call after stream (re)-configuration is completed.
825 */
Emilian Peevac3ce6c2017-12-12 15:27:02 +0000826 void configurationComplete(bool isConstrainedHighSpeed,
Shuzhen Wang99080502021-03-07 21:08:20 -0800827 const CameraMetadata& sessionParams,
828 const std::map<int32_t, std::set<String8>>& groupIdPhysicalCameraMap);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800829
830 /**
831 * Set or clear the list of repeating requests. Does not block
832 * on either. Use waitUntilPaused to wait until request queue
833 * has emptied out.
834 */
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700835 status_t setRepeatingRequests(const RequestList& requests,
836 /*out*/
837 int64_t *lastFrameNumber = NULL);
838 status_t clearRepeatingRequests(/*out*/
839 int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800840
Jianing Wei2d6bb3f2014-04-11 10:00:31 -0700841 status_t queueRequestList(List<sp<CaptureRequest> > &requests,
842 /*out*/
843 int64_t *lastFrameNumber = NULL);
Jianing Wei90e59c92014-03-12 18:29:36 -0700844
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800845 /**
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700846 * Remove all queued and repeating requests, and pending triggers
847 */
Yin-Chia Yehe1c80632016-08-08 14:48:05 -0700848 status_t clear(/*out*/int64_t *lastFrameNumber = NULL);
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700849
850 /**
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700851 * Flush all pending requests in HAL.
852 */
853 status_t flush();
854
855 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700856 * Queue a trigger to be dispatched with the next outgoing
857 * process_capture_request. The settings for that request only
858 * will be temporarily rewritten to add the trigger tag/value.
859 * Subsequent requests will not be rewritten (for this tag).
860 */
861 status_t queueTrigger(RequestTrigger trigger[], size_t count);
862
863 /**
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800864 * Pause/unpause the capture thread. Doesn't block, so use
865 * waitUntilPaused to wait until the thread is paused.
866 */
867 void setPaused(bool paused);
868
869 /**
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700870 * Wait until thread processes the capture request with settings'
871 * android.request.id == requestId.
872 *
873 * Returns TIMED_OUT in case the thread does not process the request
874 * within the timeout.
875 */
876 status_t waitUntilRequestProcessed(int32_t requestId, nsecs_t timeout);
877
Igor Murashkin1e479c02013-09-06 16:55:14 -0700878 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700879 * Shut down the thread. Shutdown is asynchronous, so thread may
880 * still be running once this method returns.
881 */
882 virtual void requestExit();
883
884 /**
Igor Murashkin1e479c02013-09-06 16:55:14 -0700885 * Get the latest request that was sent to the HAL
886 * with process_capture_request.
887 */
888 CameraMetadata getLatestRequest() const;
889
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700890 /**
891 * Returns true if the stream is a target of any queued or repeating
892 * capture request
893 */
894 bool isStreamPending(sp<camera3::Camera3StreamInterface>& stream);
895
Emilian Peev40ead602017-09-26 15:46:36 +0100896 /**
897 * Returns true if the surface is a target of any queued or repeating
898 * capture request
899 */
900 bool isOutputSurfacePending(int streamId, size_t surfaceId);
901
Shuzhen Wang686f6442017-06-20 16:16:04 -0700902 // dump processCaptureRequest latency
903 void dumpCaptureRequestLatency(int fd, const char* name) {
904 mRequestLatency.dump(fd, name);
905 }
906
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700907 void signalPipelineDrain(const std::vector<int>& streamIds);
Yin-Chia Yehe52b8fa2020-07-28 00:17:58 -0700908 void resetPipelineDrain();
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -0700909
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700910 status_t switchToOffline(
911 const std::vector<int32_t>& streamsToKeep,
912 /*out*/hardware::camera::device::V3_6::CameraOfflineSessionInfo* offlineSessionInfo,
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800913 /*out*/sp<hardware::camera::device::V3_6::ICameraOfflineSession>* offlineSession,
914 /*out*/camera3::BufferRecords* bufferRecords);
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700915
Emilian Peevc0fe54c2020-03-11 14:05:07 -0700916 void clearPreviousRequest();
917
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800918 status_t setRotateAndCropAutoBehavior(
919 camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropValue);
Emilian Peeve23f1d92021-09-20 14:56:01 -0700920 status_t setComposerSurface(bool composerSurfacePresent);
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800921
Eino-Ville Talvala11afe4f2021-05-27 14:45:31 -0700922 status_t setCameraMute(int32_t muteMode);
Cliff Wuc2ad9c82021-04-21 00:58:58 +0800923
924 status_t setHalInterface(sp<HalInterface> newHalInterface);
925
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800926 protected:
927
928 virtual bool threadLoop();
929
930 private:
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800931 static const String8& getId(const wp<Camera3Device> &device);
Eino-Ville Talvala42368d92013-04-09 14:13:50 -0700932
Igor Murashkin4d2f2e82013-04-01 17:29:07 -0700933 status_t queueTriggerLocked(RequestTrigger trigger);
934 // Mix-in queued triggers into this request
935 int32_t insertTriggers(const sp<CaptureRequest> &request);
936 // Purge the queued triggers from this request,
937 // restoring the old field values for those tags.
938 status_t removeTriggers(const sp<CaptureRequest> &request);
939
Eino-Ville Talvala2f876f92013-09-13 11:39:24 -0700940 // HAL workaround: Make sure a trigger ID always exists if
941 // a trigger does
Ivan Lozanoc0ad82f2020-07-30 09:32:57 -0400942 status_t addFakeTriggerIds(const sp<CaptureRequest> &request);
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800943
944 // Override rotate_and_crop control if needed; returns true if the current value was changed
945 bool overrideAutoRotateAndCrop(const sp<CaptureRequest> &request);
Eino-Ville Talvala2f876f92013-09-13 11:39:24 -0700946
Eino-Ville Talvala305cec62020-11-12 14:18:17 -0800947 // Override test_pattern control if needed for camera mute; returns true
948 // if the current value was changed
949 bool overrideTestPattern(const sp<CaptureRequest> &request);
950
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800951 static const nsecs_t kRequestTimeout = 50e6; // 50 ms
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800952
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700953 // TODO: does this need to be adjusted for long exposure requests?
954 static const nsecs_t kRequestSubmitTimeout = 200e6; // 200 ms
955
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700956 // Used to prepare a batch of requests.
957 struct NextRequest {
958 sp<CaptureRequest> captureRequest;
Emilian Peevf4816702020-04-03 15:44:51 -0700959 camera_capture_request_t halRequest;
960 Vector<camera_stream_buffer_t> outputBuffers;
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700961 bool submitted;
962 };
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800963
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700964 // Wait for the next batch of requests and put them in mNextRequests. mNextRequests will
965 // be empty if it times out.
966 void waitForNextRequestBatch();
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700967
968 // Waits for a request, or returns NULL if times out. Must be called with mRequestLock hold.
969 sp<CaptureRequest> waitForNextRequestLocked();
970
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700971 // Prepare HAL requests and output buffers in mNextRequests. Return TIMED_OUT if getting any
972 // output buffer timed out. If an error is returned, the caller should clean up the pending
973 // request batch.
974 status_t prepareHalRequests();
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700975
Chien-Yu Chen57ea2922015-09-04 12:58:56 -0700976 // Return buffers, etc, for requests in mNextRequests that couldn't be fully constructed and
977 // send request errors if sendRequestError is true. The buffers will be returned in the
978 // ERROR state to mark them as not having valid data. mNextRequests will be cleared.
979 void cleanUpFailedRequests(bool sendRequestError);
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800980
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700981 // Stop the repeating request if any of its output streams is abandoned.
982 void checkAndStopRepeatingRequest();
983
Emilian Peevaebbe412018-01-15 13:53:24 +0000984 // Release physical camera settings and camera id resources.
985 void cleanupPhysicalSettings(sp<CaptureRequest> request,
Emilian Peevf4816702020-04-03 15:44:51 -0700986 /*out*/camera_capture_request_t *halRequest);
Emilian Peevaebbe412018-01-15 13:53:24 +0000987
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800988 // Pause handling
989 bool waitIfPaused();
Eino-Ville Talvala26fe6c72013-08-29 12:46:18 -0700990 void unpauseForNewRequests();
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -0800991
Eino-Ville Talvalab2058d12013-04-09 13:49:56 -0700992 // Relay error to parent device object setErrorState
993 void setErrorState(const char *fmt, ...);
994
Yin-Chia Yeh8684b7f2014-06-13 14:53:05 -0700995 // If the input request is in mRepeatingRequests. Must be called with mRequestLock hold
Chih-Hung Hsieh8b0b9712016-08-09 14:25:53 -0700996 bool isRepeatingRequestLocked(const sp<CaptureRequest>&);
Yin-Chia Yeh8684b7f2014-06-13 14:53:05 -0700997
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700998 // Clear repeating requests. Must be called with mRequestLock held.
999 status_t clearRepeatingRequestsLocked(/*out*/ int64_t *lastFrameNumber = NULL);
1000
Yin-Chia Yeh94c68e02017-03-06 14:09:44 -08001001 // send request in mNextRequests to HAL in a batch. Return true = sucssess
1002 bool sendRequestsBatch();
1003
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -07001004 // Calculate the expected maximum duration for a request
1005 nsecs_t calculateMaxExpectedDuration(const camera_metadata_t *request);
1006
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001007 // Check and update latest session parameters based on the current request settings.
1008 bool updateSessionParameters(const CameraMetadata& settings);
1009
Emilian Peeva14b4dd2018-05-15 11:00:31 +01001010 // Check whether FPS range session parameter re-configuration is needed in constrained
1011 // high speed recording camera sessions.
1012 bool skipHFRTargetFPSUpdate(int32_t tag, const camera_metadata_ro_entry_t& newEntry,
1013 const camera_metadata_entry_t& currentEntry);
1014
Shuzhen Wangc2cba122018-05-17 18:10:24 -07001015 // Update next request sent to HAL
1016 void updateNextRequest(NextRequest& nextRequest);
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001017
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001018 wp<Camera3Device> mParent;
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001019 wp<camera3::StatusTracker> mStatusTracker;
Yin-Chia Yehdb1e8642017-07-14 15:19:30 -07001020 sp<HalInterface> mInterface;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001021
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001022 wp<NotificationListener> mListener;
Eino-Ville Talvala17543512014-08-06 14:32:02 -07001023
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -08001024 const String8& mId; // The camera ID
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001025 int mStatusId; // The RequestThread's component ID for
1026 // status tracking
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001027
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001028 Mutex mRequestLock;
1029 Condition mRequestSignal;
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001030 Condition mRequestSubmittedSignal;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001031 RequestList mRequestQueue;
1032 RequestList mRepeatingRequests;
Shuzhen Wang316781a2020-08-18 18:11:01 -07001033 bool mFirstRepeating;
Chien-Yu Chen57ea2922015-09-04 12:58:56 -07001034 // The next batch of requests being prepped for submission to the HAL, no longer
Eino-Ville Talvalae74c2282015-05-27 14:46:23 -07001035 // on the request queue. Read-only even with mRequestLock held, outside
1036 // of threadLoop
Chien-Yu Chen57ea2922015-09-04 12:58:56 -07001037 Vector<NextRequest> mNextRequests;
Chien-Yu Chen85a64552015-08-28 15:46:12 -07001038
1039 // To protect flush() and sending a request batch to HAL.
1040 Mutex mFlushLock;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001041
1042 bool mReconfigured;
1043
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -07001044 // Used by waitIfPaused, waitForNextRequest, waitUntilPaused, and signalPipelineDrain
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001045 Mutex mPauseLock;
1046 bool mDoPause;
1047 Condition mDoPauseSignal;
1048 bool mPaused;
Yin-Chia Yeh7447f0f2018-10-11 15:28:12 -07001049 bool mNotifyPipelineDrain;
1050 std::vector<int> mStreamIdsToBeDrained;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001051
1052 sp<CaptureRequest> mPrevRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001053 int32_t mPrevTriggers;
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -08001054 std::set<std::string> mPrevCameraIdsWithZoom;
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001055
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001056 uint32_t mFrameNumber;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001057
Igor Murashkin1e479c02013-09-06 16:55:14 -07001058 mutable Mutex mLatestRequestMutex;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001059 Condition mLatestRequestSignal;
1060 // android.request.id for latest process_capture_request
1061 int32_t mLatestRequestId;
Igor Murashkin1e479c02013-09-06 16:55:14 -07001062 CameraMetadata mLatestRequest;
Shuzhen Wangc2cba122018-05-17 18:10:24 -07001063 std::unordered_map<std::string, CameraMetadata> mLatestPhysicalRequest;
Igor Murashkin4d2f2e82013-04-01 17:29:07 -07001064
1065 typedef KeyedVector<uint32_t/*tag*/, RequestTrigger> TriggerMap;
1066 Mutex mTriggerMutex;
1067 TriggerMap mTriggerMap;
1068 TriggerMap mTriggerRemovedMap;
1069 TriggerMap mTriggerReplacedMap;
Yin-Chia Yehc00a25c2014-08-21 14:27:44 -07001070 uint32_t mCurrentAfTriggerId;
1071 uint32_t mCurrentPreCaptureTriggerId;
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001072 camera_metadata_enum_android_scaler_rotate_and_crop_t mRotateAndCropOverride;
Emilian Peeve23f1d92021-09-20 14:56:01 -07001073 bool mComposerOutput;
Eino-Ville Talvala11afe4f2021-05-27 14:45:31 -07001074 int32_t mCameraMute; // 0 = no mute, otherwise the TEST_PATTERN_MODE to use
Eino-Ville Talvala305cec62020-11-12 14:18:17 -08001075 bool mCameraMuteChanged;
Jianing Weicb0652e2014-03-12 18:29:36 -07001076
Jianing Wei2d6bb3f2014-04-11 10:00:31 -07001077 int64_t mRepeatingLastFrameNumber;
Chien-Yu Chend196d612015-06-22 19:49:01 -07001078
Chien-Yu Chenc66969b2016-05-19 16:37:51 -07001079 // Flag indicating if we should prepare video stream for video requests.
1080 bool mPrepareVideoStream;
Shuzhen Wang686f6442017-06-20 16:16:04 -07001081
Emilian Peeva14b4dd2018-05-15 11:00:31 +01001082 bool mConstrainedMode;
1083
Shuzhen Wang686f6442017-06-20 16:16:04 -07001084 static const int32_t kRequestLatencyBinSize = 40; // in ms
1085 CameraLatencyHistogram mRequestLatency;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001086
1087 Vector<int32_t> mSessionParamKeys;
1088 CameraMetadata mLatestSessionParams;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001089
Shuzhen Wang99080502021-03-07 21:08:20 -08001090 std::map<int32_t, std::set<String8>> mGroupIdPhysicalCameraMap;
1091
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001092 const bool mUseHalBufManager;
Eino-Ville Talvala1646c3c2021-07-29 13:48:40 -07001093 const bool mSupportCameraMute;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001094 };
Eino-Ville Talvalaf76e0272013-02-27 18:02:26 -08001095 sp<RequestThread> mRequestThread;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001096
1097 /**
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001098 * In-flight queue for tracking completion of capture requests.
1099 */
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001100 std::mutex mInFlightLock;
1101 camera3::InFlightRequestMap mInFlightMap;
1102 nsecs_t mExpectedInflightDuration = 0;
Shuzhen Wangb7b42652020-05-07 11:59:02 -07001103 int64_t mLastCompletedRegularFrameNumber = -1;
1104 int64_t mLastCompletedReprocessFrameNumber = -1;
1105 int64_t mLastCompletedZslFrameNumber = -1;
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001106 // End of mInFlightLock protection scope
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001107
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001108 int mInFlightStatusId; // const after initialize
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001109
Jianing Weicb0652e2014-03-12 18:29:36 -07001110 status_t registerInFlight(uint32_t frameNumber,
Chien-Yu Chend196d612015-06-22 19:49:01 -07001111 int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput,
Shuzhen Wang99080502021-03-07 21:08:20 -08001112 bool callback, nsecs_t maxExpectedDuration,
1113 const std::set<std::set<String8>>& physicalCameraIds,
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001114 bool isStillCapture, bool isZslCapture, bool rotateAndCropAuto,
Shuzhen Wang316781a2020-08-18 18:11:01 -07001115 const std::set<std::string>& cameraIdsWithZoom, const SurfaceMap& outputSurfaces,
1116 nsecs_t requestTimeNs);
Eino-Ville Talvala10bd57e2017-06-23 16:22:44 -07001117
1118 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001119 * Tracking for idle detection
1120 */
1121 sp<camera3::StatusTracker> mStatusTracker;
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001122
1123 /**
Zhijun He125684a2015-12-26 15:07:30 -08001124 * Graphic buffer manager for output streams. Each device has a buffer manager, which is used
1125 * by the output streams to get and return buffers if these streams are registered to this
1126 * buffer manager.
1127 */
1128 sp<camera3::Camera3BufferManager> mBufferManager;
1129
1130 /**
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001131 * Thread for preparing streams
1132 */
1133 class PreparerThread : private Thread, public virtual RefBase {
1134 public:
1135 PreparerThread();
1136 ~PreparerThread();
1137
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001138 void setNotificationListener(wp<NotificationListener> listener);
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001139
1140 /**
Ruben Brunkc78ac262015-08-13 17:58:46 -07001141 * Queue up a stream to be prepared. Streams are processed by a background thread in FIFO
1142 * order. Pre-allocate up to maxCount buffers for the stream, or the maximum number needed
1143 * for the pipeline if maxCount is ALLOCATE_PIPELINE_MAX.
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001144 */
Ruben Brunkc78ac262015-08-13 17:58:46 -07001145 status_t prepare(int maxCount, sp<camera3::Camera3StreamInterface>& stream);
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001146
1147 /**
1148 * Cancel all current and pending stream preparation
1149 */
1150 status_t clear();
1151
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001152 /**
1153 * Pause all preparation activities
1154 */
1155 void pause();
1156
1157 /**
1158 * Resume preparation activities
1159 */
1160 status_t resume();
1161
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001162 private:
1163 Mutex mLock;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001164 Condition mThreadActiveSignal;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001165
1166 virtual bool threadLoop();
1167
1168 // Guarded by mLock
1169
Yin-Chia Yehe1c80632016-08-08 14:48:05 -07001170 wp<NotificationListener> mListener;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001171 std::unordered_map<int, sp<camera3::Camera3StreamInterface> > mPendingStreams;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001172 bool mActive;
1173 bool mCancelNow;
1174
1175 // Only accessed by threadLoop and the destructor
1176
1177 sp<camera3::Camera3StreamInterface> mCurrentStream;
Emilian Peevac3ce6c2017-12-12 15:27:02 +00001178 int mCurrentMaxCount;
1179 bool mCurrentPrepareComplete;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001180 };
1181 sp<PreparerThread> mPreparerThread;
1182
1183 /**
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001184 * Output result queue and current HAL device 3A state
1185 */
1186
1187 // Lock for output side of device
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001188 std::mutex mOutputLock;
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001189
1190 /**** Scope for mOutputLock ****/
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001191 // the minimal frame number of the next non-reprocess result
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001192 uint32_t mNextResultFrameNumber;
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001193 // the minimal frame number of the next reprocess result
1194 uint32_t mNextReprocessResultFrameNumber;
Shuzhen Wang5ee99842019-04-12 11:55:48 -07001195 // the minimal frame number of the next ZSL still capture result
1196 uint32_t mNextZslStillResultFrameNumber;
Chien-Yu Chen3df11ce2015-09-30 14:13:30 -07001197 // the minimal frame number of the next non-reprocess shutter
Eino-Ville Talvala42368d92013-04-09 14:13:50 -07001198 uint32_t mNextShutterFrameNumber;
Chien-Yu Chen3df11ce2015-09-30 14:13:30 -07001199 // the minimal frame number of the next reprocess shutter
1200 uint32_t mNextReprocessShutterFrameNumber;
Shuzhen Wang5ee99842019-04-12 11:55:48 -07001201 // the minimal frame number of the next ZSL still capture shutter
1202 uint32_t mNextZslStillShutterFrameNumber;
Jayant Chowdhary8a0be292020-01-08 13:10:38 -08001203 std::list<CaptureResult> mResultQueue;
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001204 std::condition_variable mResultSignal;
1205 wp<NotificationListener> mListener;
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001206
Eino-Ville Talvala7d346fa2013-03-11 14:13:50 -07001207 /**** End scope for mOutputLock ****/
1208
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001209 /**** Scope for mInFlightLock ****/
1210
Shuzhen Wangcadb3302016-11-04 14:17:56 -07001211 // Remove the in-flight map entry of the given index from mInFlightMap.
1212 // It must only be called with mInFlightLock held.
1213 void removeInFlightMapEntryLocked(int idx);
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001214
Yin-Chia Yehf3fe36f2017-07-07 18:23:18 -07001215 // Remove all in-flight requests and return all buffers.
1216 // This is used after HAL interface is closed to cleanup any request/buffers
1217 // not returned by HAL.
1218 void flushInflightRequests();
Chien-Yu Chen43e69a62014-11-25 16:38:33 -08001219
1220 /**** End scope for mInFlightLock ****/
1221
Eino-Ville Talvala7b8a1fd2018-05-22 15:30:35 -07001222 /**
1223 * Distortion correction support
1224 */
Shuzhen Wang4f6fa9d2019-03-29 10:40:35 -07001225 // Map from camera IDs to its corresponding distortion mapper. Only contains
1226 // 1 ID if the device isn't a logical multi-camera. Otherwise contains both
1227 // logical camera and its physical subcameras.
1228 std::unordered_map<std::string, camera3::DistortionMapper> mDistortionMappers;
Eino-Ville Talvala7b8a1fd2018-05-22 15:30:35 -07001229
Shuzhen Wangdbdf72b2019-11-13 11:22:12 -08001230 /**
1231 * Zoom ratio mapper support
1232 */
1233 std::unordered_map<std::string, camera3::ZoomRatioMapper> mZoomRatioMappers;
1234
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001235 /**
Jayant Chowdhary9255ce02021-07-15 11:18:17 -07001236 * UHR request crop / metering region mapper support
1237 */
1238 std::unordered_map<std::string, camera3::UHRCropAndMeteringRegionMapper>
1239 mUHRCropAndMeteringRegionMappers;
1240
1241 /**
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001242 * RotateAndCrop mapper support
1243 */
1244 std::unordered_map<std::string, camera3::RotateAndCropMapper> mRotateAndCropMappers;
1245
Eino-Ville Talvala4d453832016-07-15 11:56:53 -07001246 // Debug tracker for metadata tag value changes
1247 // - Enabled with the -m <taglist> option to dumpsys, such as
1248 // dumpsys -m android.control.aeState,android.control.aeMode
1249 // - Disabled with -m off
1250 // - dumpsys -m 3a is a shortcut for ae/af/awbMode, State, and Triggers
1251 TagMonitor mTagMonitor;
1252
1253 void monitorMetadata(TagMonitor::eventSource source, int64_t frameNumber,
Shuzhen Wangc2cba122018-05-17 18:10:24 -07001254 nsecs_t timestamp, const CameraMetadata& metadata,
1255 const std::unordered_map<std::string, CameraMetadata>& physicalMetadata);
Eino-Ville Talvala4d453832016-07-15 11:56:53 -07001256
Emilian Peev71c73a22017-03-21 16:35:51 +00001257 metadata_vendor_id_t mVendorTagId;
1258
Emilian Peev811d2952018-05-25 11:08:40 +01001259 // Cached last requested template id
1260 int mLastTemplateId;
1261
Emilian Peev26d975d2018-07-05 14:52:57 +01001262 // Synchronizes access to status tracker between inflight updates and disconnect.
1263 // b/79972865
1264 Mutex mTrackerLock;
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001265
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001266 // Whether HAL request buffers through requestStreamBuffers API
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -07001267 bool mUseHalBufManager = false;
1268
1269 // Lock to ensure requestStreamBuffers() callbacks are serialized
1270 std::mutex mRequestBufferInterfaceLock;
1271
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001272 // The state machine to control when requestStreamBuffers should allow
1273 // HAL to request buffers.
1274 enum RequestBufferState {
1275 /**
1276 * This is the initial state.
1277 * requestStreamBuffers call will return FAILED_CONFIGURING in this state.
1278 * Will switch to RB_STATUS_READY after a successful configureStreams or
1279 * processCaptureRequest call.
1280 */
1281 RB_STATUS_STOPPED,
1282
1283 /**
1284 * requestStreamBuffers call will proceed in this state.
1285 * When device is asked to stay idle via waitUntilStateThenRelock() call:
1286 * - Switch to RB_STATUS_STOPPED if there is no inflight requests and
1287 * request thread is paused.
1288 * - Switch to RB_STATUS_PENDING_STOP otherwise
1289 */
1290 RB_STATUS_READY,
1291
1292 /**
1293 * requestStreamBuffers call will proceed in this state.
1294 * Switch to RB_STATUS_STOPPED when all inflight requests are fulfilled
1295 * and request thread is paused
1296 */
1297 RB_STATUS_PENDING_STOP,
1298 };
1299
1300 class RequestBufferStateMachine {
1301 public:
1302 status_t initialize(sp<camera3::StatusTracker> statusTracker);
1303
1304 // Return if the state machine currently allows for requestBuffers
1305 // If the state allows for it, mRequestBufferOngoing will be set to true
1306 // and caller must call endRequestBuffer() later to unset the flag
1307 bool startRequestBuffer();
1308 void endRequestBuffer();
1309
1310 // Events triggered by application API call
1311 void onStreamsConfigured();
1312 void onWaitUntilIdle();
1313
1314 // Events usually triggered by hwBinder processCaptureResult callback thread
1315 // But can also be triggered on request thread for failed request, or on
1316 // hwbinder notify callback thread for shutter/error callbacks
1317 void onInflightMapEmpty();
1318
1319 // Events triggered by RequestThread
Yin-Chia Yehcd333fe2019-02-08 13:45:41 -08001320 void onSubmittingRequest();
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001321 void onRequestThreadPaused();
1322
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001323 // Events triggered by successful switchToOffline call
1324 // Return true is there is no ongoing requestBuffer call.
1325 bool onSwitchToOfflineSuccess();
1326
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001327 private:
1328 void notifyTrackerLocked(bool active);
1329
1330 // Switch to STOPPED state and return true if all conditions allows for it.
1331 // Otherwise do nothing and return false.
1332 bool checkSwitchToStopLocked();
1333
1334 std::mutex mLock;
1335 RequestBufferState mStatus = RB_STATUS_STOPPED;
1336
1337 bool mRequestThreadPaused = true;
1338 bool mInflightMapEmpty = true;
1339 bool mRequestBufferOngoing = false;
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -08001340 bool mSwitchedToOffline = false;
Yin-Chia Yeh30ab5ed2018-10-12 15:57:04 -07001341
1342 wp<camera3::StatusTracker> mStatusTracker;
1343 int mRequestBufferStatusId;
1344 } mRequestBufferSM;
1345
Shuzhen Wang268a1362018-10-16 16:32:59 -07001346 // Fix up result metadata for monochrome camera.
1347 bool mNeedFixupMonochromeTags;
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001348
1349 // Whether HAL supports offline processing capability.
1350 bool mSupportOfflineProcessing = false;
Eino-Ville Talvala305cec62020-11-12 14:18:17 -08001351
1352 // Whether the HAL supports camera muting via test pattern
1353 bool mSupportCameraMute = false;
Eino-Ville Talvala11afe4f2021-05-27 14:45:31 -07001354 // Whether the HAL supports SOLID_COLOR or BLACK if mSupportCameraMute is true
1355 bool mSupportTestPatternSolidColor = false;
Eino-Ville Talvala305cec62020-11-12 14:18:17 -08001356
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001357 // Whether the camera framework overrides the device characteristics for
1358 // performance class.
1359 bool mOverrideForPerfClass;
1360
Cliff Wuc2ad9c82021-04-21 00:58:58 +08001361 // Injection camera related methods.
1362 class Camera3DeviceInjectionMethods : public virtual RefBase {
1363 public:
1364 Camera3DeviceInjectionMethods(wp<Camera3Device> parent);
1365
1366 ~Camera3DeviceInjectionMethods();
1367
1368 // Initialize the injection camera and generate an hal interface.
1369 status_t injectionInitialize(
1370 const String8& injectedCamId, sp<CameraProviderManager> manager,
1371 const sp<
1372 android::hardware::camera::device::V3_2 ::ICameraDeviceCallback>&
1373 callback);
1374
1375 // Injection camera will replace the internal camera and configure streams
1376 // when device is IDLE and request thread is paused.
1377 status_t injectCamera(
1378 camera3::camera_stream_configuration& injectionConfig,
1379 std::vector<uint32_t>& injectionBufferSizes);
1380
1381 // Stop the injection camera and switch back to backup hal interface.
1382 status_t stopInjection();
1383
1384 bool isInjecting();
1385
1386 const String8& getInjectedCamId() const;
1387
1388 void getInjectionConfig(/*out*/ camera3::camera_stream_configuration* injectionConfig,
1389 /*out*/ std::vector<uint32_t>* injectionBufferSizes);
1390
1391 private:
1392 // Configure the streams of injection camera, it need wait until the
1393 // output streams are created and configured to the original camera before
1394 // proceeding.
1395 status_t injectionConfigureStreams(
1396 camera3::camera_stream_configuration& injectionConfig,
1397 std::vector<uint32_t>& injectionBufferSizes);
1398
1399 // Disconnect the injection camera and delete the hal interface.
1400 void injectionDisconnectImpl();
1401
1402 // Use injection camera hal interface to replace and backup original
1403 // camera hal interface.
1404 status_t replaceHalInterface(sp<HalInterface> newHalInterface,
1405 bool keepBackup);
1406
1407 wp<Camera3Device> mParent;
1408
1409 // Backup of the original camera hal interface.
1410 sp<HalInterface> mBackupHalInterface;
1411
1412 // Generated injection camera hal interface.
1413 sp<HalInterface> mInjectedCamHalInterface;
1414
1415 // Copy the configuration of the internal camera.
1416 camera3::camera_stream_configuration mInjectionConfig;
1417
1418 // Copy the bufferSizes of the output streams of the internal camera.
1419 std::vector<uint32_t> mInjectionBufferSizes;
1420
1421 // Synchronizes access to injection camera between initialize and
1422 // disconnect.
1423 Mutex mInjectionLock;
1424
1425 // The injection camera ID.
1426 String8 mInjectedCamId;
1427 };
1428 sp<Camera3DeviceInjectionMethods> mInjectionMethods;
1429
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001430}; // class Camera3Device
1431
1432}; // namespace android
1433
1434#endif