blob: 11fa99168749f44edd0832142196f4758022c8e3 [file] [log] [blame]
Igor Murashkine7ee7632013-06-11 18:10:18 -07001/*
Shuzhen Wangc28189a2017-11-27 23:05:10 -08002 * Copyright (C) 2013-2018 The Android Open Source Project
Igor Murashkine7ee7632013-06-11 18:10:18 -07003 *
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
17#define LOG_TAG "CameraDeviceClient"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
Jianing Weicb0652e2014-03-12 18:29:36 -070019//#define LOG_NDEBUG 0
Igor Murashkine7ee7632013-06-11 18:10:18 -070020
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070021#include <cutils/properties.h>
Jayant Chowdhary12361932018-08-27 14:46:13 -070022#include <utils/CameraThreadState.h>
Igor Murashkine7ee7632013-06-11 18:10:18 -070023#include <utils/Log.h>
Colin Crossb8a9dbb2020-08-27 04:12:26 +000024#include <utils/SessionConfigurationUtils.h>
Igor Murashkine7ee7632013-06-11 18:10:18 -070025#include <utils/Trace.h>
Igor Murashkine7ee7632013-06-11 18:10:18 -070026#include <gui/Surface.h>
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070027#include <camera/camera2/CaptureRequest.h>
Ruben Brunk5698d442014-06-18 10:39:40 -070028#include <camera/CameraUtils.h>
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070029
30#include "common/CameraDeviceBase.h"
Emilian Peev35ae8262018-11-08 13:11:32 +000031#include "device3/Camera3Device.h"
32#include "device3/Camera3OutputStream.h"
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070033#include "api2/CameraDeviceClient.h"
Shuzhen Wang316781a2020-08-18 18:11:01 -070034#include "utils/CameraServiceProxyWrapper.h"
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070035
Emilian Peev00420d22018-02-05 21:33:13 +000036#include <camera_metadata_hidden.h>
37
Emilian Peev538c90e2018-12-17 18:03:19 +000038#include "DepthCompositeStream.h"
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -080039#include "HeicCompositeStream.h"
Emilian Peev538c90e2018-12-17 18:03:19 +000040
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080041// Convenience methods for constructing binder::Status objects for error returns
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -070042
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080043#define STATUS_ERROR(errorCode, errorString) \
44 binder::Status::fromServiceSpecificError(errorCode, \
Eino-Ville Talvala02bf0322016-02-18 12:41:10 -080045 String8::format("%s:%d: %s", __FUNCTION__, __LINE__, errorString))
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080046
47#define STATUS_ERROR_FMT(errorCode, errorString, ...) \
48 binder::Status::fromServiceSpecificError(errorCode, \
Eino-Ville Talvala02bf0322016-02-18 12:41:10 -080049 String8::format("%s:%d: " errorString, __FUNCTION__, __LINE__, \
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080050 __VA_ARGS__))
Igor Murashkine7ee7632013-06-11 18:10:18 -070051
52namespace android {
53using namespace camera2;
Austin Borgerea931242021-12-13 23:10:41 +000054using namespace camera3;
Emilian Peevf4816702020-04-03 15:44:51 -070055using camera3::camera_stream_rotation_t::CAMERA_STREAM_ROTATION_0;
Igor Murashkine7ee7632013-06-11 18:10:18 -070056
57CameraDeviceClientBase::CameraDeviceClientBase(
58 const sp<CameraService>& cameraService,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080059 const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,
Igor Murashkine7ee7632013-06-11 18:10:18 -070060 const String16& clientPackageName,
Jooyung Han3f9a3b42020-01-23 12:27:18 +090061 const std::optional<String16>& clientFeatureId,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080062 const String8& cameraId,
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080063 int api1CameraId,
Igor Murashkine7ee7632013-06-11 18:10:18 -070064 int cameraFacing,
Emilian Peev8b64f282021-03-25 16:49:57 -070065 int sensorOrientation,
Igor Murashkine7ee7632013-06-11 18:10:18 -070066 int clientPid,
67 uid_t clientUid,
68 int servicePid) :
Eino-Ville Talvalae992e752014-11-07 16:17:48 -080069 BasicClient(cameraService,
Marco Nelissenf8880202014-11-14 07:58:25 -080070 IInterface::asBinder(remoteCallback),
Eino-Ville Talvalae992e752014-11-07 16:17:48 -080071 clientPackageName,
Philip P. Moltmann9e648f62019-11-04 12:52:45 -080072 clientFeatureId,
Eino-Ville Talvalae992e752014-11-07 16:17:48 -080073 cameraId,
74 cameraFacing,
Emilian Peev8b64f282021-03-25 16:49:57 -070075 sensorOrientation,
Eino-Ville Talvalae992e752014-11-07 16:17:48 -080076 clientPid,
77 clientUid,
78 servicePid),
Igor Murashkine7ee7632013-06-11 18:10:18 -070079 mRemoteCallback(remoteCallback) {
Yin-Chia Yehc3e9d6f2018-02-06 10:56:32 -080080 // We don't need it for API2 clients, but Camera2ClientBase requires it.
81 (void) api1CameraId;
Igor Murashkine7ee7632013-06-11 18:10:18 -070082}
Igor Murashkine7ee7632013-06-11 18:10:18 -070083
84// Interface used by CameraService
85
86CameraDeviceClient::CameraDeviceClient(const sp<CameraService>& cameraService,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080087 const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback,
88 const String16& clientPackageName,
Jooyung Han3f9a3b42020-01-23 12:27:18 +090089 const std::optional<String16>& clientFeatureId,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080090 const String8& cameraId,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080091 int cameraFacing,
Emilian Peev8b64f282021-03-25 16:49:57 -070092 int sensorOrientation,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080093 int clientPid,
94 uid_t clientUid,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -070095 int servicePid,
96 bool overrideForPerfClass) :
Philip P. Moltmann9e648f62019-11-04 12:52:45 -080097 Camera2ClientBase(cameraService, remoteCallback, clientPackageName, clientFeatureId,
Shuzhen Wangd4abdf72021-05-28 11:22:50 -070098 cameraId, /*API1 camera ID*/ -1, cameraFacing, sensorOrientation,
99 clientPid, clientUid, servicePid, overrideForPerfClass),
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700100 mInputStream(),
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700101 mStreamingRequestId(REQUEST_ID_NONE),
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700102 mRequestIdCounter(0),
103 mOverrideForPerfClass(overrideForPerfClass) {
Igor Murashkine7ee7632013-06-11 18:10:18 -0700104
105 ATRACE_CALL();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800106 ALOGI("CameraDeviceClient %s: Opened", cameraId.string());
Igor Murashkine7ee7632013-06-11 18:10:18 -0700107}
108
Emilian Peevbd8c5032018-02-14 23:05:40 +0000109status_t CameraDeviceClient::initialize(sp<CameraProviderManager> manager,
110 const String8& monitorTags) {
111 return initializeImpl(manager, monitorTags);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800112}
113
114template<typename TProviderPtr>
Emilian Peevbd8c5032018-02-14 23:05:40 +0000115status_t CameraDeviceClient::initializeImpl(TProviderPtr providerPtr, const String8& monitorTags) {
Igor Murashkine7ee7632013-06-11 18:10:18 -0700116 ATRACE_CALL();
117 status_t res;
118
Emilian Peevbd8c5032018-02-14 23:05:40 +0000119 res = Camera2ClientBase::initialize(providerPtr, monitorTags);
Igor Murashkine7ee7632013-06-11 18:10:18 -0700120 if (res != OK) {
121 return res;
122 }
123
124 String8 threadName;
Eino-Ville Talvala7b82efe2013-07-25 17:12:35 -0700125 mFrameProcessor = new FrameProcessorBase(mDevice);
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800126 threadName = String8::format("CDU-%s-FrameProc", mCameraIdStr.string());
Igor Murashkine7ee7632013-06-11 18:10:18 -0700127 mFrameProcessor->run(threadName.string());
128
Emilian Peevfaa4bde2020-01-23 12:19:37 -0800129 mFrameProcessor->registerListener(camera2::FrameProcessorBase::FRAME_PROCESSOR_LISTENER_MIN_ID,
130 camera2::FrameProcessorBase::FRAME_PROCESSOR_LISTENER_MAX_ID,
Eino-Ville Talvala184dfe42013-11-07 15:13:16 -0800131 /*listener*/this,
Zhijun He25a0aef2014-06-25 11:40:02 -0700132 /*sendPartials*/true);
Igor Murashkine7ee7632013-06-11 18:10:18 -0700133
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800134 const CameraMetadata &deviceInfo = mDevice->info();
135 camera_metadata_ro_entry_t physicalKeysEntry = deviceInfo.find(
Emilian Peev00420d22018-02-05 21:33:13 +0000136 ANDROID_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS);
137 if (physicalKeysEntry.count > 0) {
138 mSupportedPhysicalRequestKeys.insert(mSupportedPhysicalRequestKeys.begin(),
139 physicalKeysEntry.data.i32,
140 physicalKeysEntry.data.i32 + physicalKeysEntry.count);
141 }
142
Emilian Peev2295df72021-11-12 18:14:10 -0800143 auto entry = deviceInfo.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
144 mDynamicProfileMap.emplace(
145 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
146 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD);
147 if (entry.count > 0) {
Shuzhen Wangc8ab4522021-12-14 20:12:42 -0800148 const auto it = std::find(entry.data.u8, entry.data.u8 + entry.count,
Emilian Peev2295df72021-11-12 18:14:10 -0800149 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT);
Shuzhen Wangc8ab4522021-12-14 20:12:42 -0800150 if (it != entry.data.u8 + entry.count) {
Emilian Peev2295df72021-11-12 18:14:10 -0800151 entry = deviceInfo.find(ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP);
152 if (entry.count > 0 || ((entry.count % 2) != 0)) {
153 int standardBitmap = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD;
154 for (size_t i = 0; i < entry.count; i += 2) {
155 if (entry.data.i32[i] !=
156 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD) {
157 mDynamicProfileMap.emplace(entry.data.i32[i], entry.data.i32[i+1]);
158 if ((entry.data.i32[i+1] == 0) || (entry.data.i32[i+1] &
159 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD)) {
160 standardBitmap |= entry.data.i32[i];
161 }
162 } else {
163 ALOGE("%s: Device %s includes unexpected profile entry: 0x%x!",
164 __FUNCTION__, mCameraIdStr.c_str(), entry.data.i32[i]);
165 }
166 }
167 mDynamicProfileMap.emplace(
168 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
169 standardBitmap);
170 } else {
171 ALOGE("%s: Device %s supports 10-bit output but doesn't include a dynamic range"
172 " profile map!", __FUNCTION__, mCameraIdStr.c_str());
173 }
174 }
175 }
176
Shuzhen Wang03d8cc12018-09-12 14:17:09 -0700177 mProviderManager = providerPtr;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800178 // Cache physical camera ids corresponding to this device and also the high
179 // resolution sensors in this device + physical camera ids
180 mProviderManager->isLogicalCamera(mCameraIdStr.string(), &mPhysicalCameraIds);
181 if (isUltraHighResolutionSensor(mCameraIdStr)) {
182 mHighResolutionSensors.insert(mCameraIdStr.string());
183 }
184 for (auto &physicalId : mPhysicalCameraIds) {
185 if (isUltraHighResolutionSensor(String8(physicalId.c_str()))) {
186 mHighResolutionSensors.insert(physicalId.c_str());
187 }
188 }
Igor Murashkine7ee7632013-06-11 18:10:18 -0700189 return OK;
190}
191
192CameraDeviceClient::~CameraDeviceClient() {
193}
194
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800195binder::Status CameraDeviceClient::submitRequest(
196 const hardware::camera2::CaptureRequest& request,
197 bool streaming,
198 /*out*/
199 hardware::camera2::utils::SubmitInfo *submitInfo) {
200 std::vector<hardware::camera2::CaptureRequest> requestList = { request };
201 return submitRequestList(requestList, streaming, submitInfo);
Igor Murashkine7ee7632013-06-11 18:10:18 -0700202}
203
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800204binder::Status CameraDeviceClient::insertGbpLocked(const sp<IGraphicBufferProducer>& gbp,
Emilian Peevf873aa52018-01-26 14:58:28 +0000205 SurfaceMap* outSurfaceMap, Vector<int32_t>* outputStreamIds, int32_t *currentStreamId) {
Emilian Peev538c90e2018-12-17 18:03:19 +0000206 int compositeIdx;
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800207 int idx = mStreamMap.indexOfKey(IInterface::asBinder(gbp));
208
Emilian Peev2f5d6012022-01-19 16:16:50 -0800209 Mutex::Autolock l(mCompositeLock);
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800210 // Trying to submit request with surface that wasn't created
211 if (idx == NAME_NOT_FOUND) {
212 ALOGE("%s: Camera %s: Tried to submit a request with a surface that"
213 " we have not called createStream on",
214 __FUNCTION__, mCameraIdStr.string());
215 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
216 "Request targets Surface that is not part of current capture session");
Emilian Peev538c90e2018-12-17 18:03:19 +0000217 } else if ((compositeIdx = mCompositeStreamMap.indexOfKey(IInterface::asBinder(gbp)))
218 != NAME_NOT_FOUND) {
219 mCompositeStreamMap.valueAt(compositeIdx)->insertGbp(outSurfaceMap, outputStreamIds,
220 currentStreamId);
221 return binder::Status::ok();
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800222 }
223
224 const StreamSurfaceId& streamSurfaceId = mStreamMap.valueAt(idx);
225 if (outSurfaceMap->find(streamSurfaceId.streamId()) == outSurfaceMap->end()) {
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800226 outputStreamIds->push_back(streamSurfaceId.streamId());
227 }
228 (*outSurfaceMap)[streamSurfaceId.streamId()].push_back(streamSurfaceId.surfaceId());
229
230 ALOGV("%s: Camera %s: Appending output stream %d surface %d to request",
231 __FUNCTION__, mCameraIdStr.string(), streamSurfaceId.streamId(),
232 streamSurfaceId.surfaceId());
233
Emilian Peevf873aa52018-01-26 14:58:28 +0000234 if (currentStreamId != nullptr) {
235 *currentStreamId = streamSurfaceId.streamId();
236 }
237
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800238 return binder::Status::ok();
239}
240
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800241static std::list<int> getIntersection(const std::unordered_set<int> &streamIdsForThisCamera,
242 const Vector<int> &streamIdsForThisRequest) {
243 std::list<int> intersection;
244 for (auto &streamId : streamIdsForThisRequest) {
245 if (streamIdsForThisCamera.find(streamId) != streamIdsForThisCamera.end()) {
246 intersection.emplace_back(streamId);
247 }
248 }
249 return intersection;
250}
251
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800252binder::Status CameraDeviceClient::submitRequestList(
253 const std::vector<hardware::camera2::CaptureRequest>& requests,
254 bool streaming,
255 /*out*/
256 hardware::camera2::utils::SubmitInfo *submitInfo) {
Jianing Wei90e59c92014-03-12 18:29:36 -0700257 ATRACE_CALL();
Mark Salyzyn50468412014-06-18 16:33:43 -0700258 ALOGV("%s-start of function. Request list size %zu", __FUNCTION__, requests.size());
Jianing Wei90e59c92014-03-12 18:29:36 -0700259
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800260 binder::Status res = binder::Status::ok();
261 status_t err;
262 if ( !(res = checkPidStatus(__FUNCTION__) ).isOk()) {
263 return res;
264 }
Jianing Wei90e59c92014-03-12 18:29:36 -0700265
266 Mutex::Autolock icl(mBinderSerializationLock);
267
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800268 if (!mDevice.get()) {
269 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
270 }
Jianing Wei90e59c92014-03-12 18:29:36 -0700271
272 if (requests.empty()) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800273 ALOGE("%s: Camera %s: Sent null request. Rejecting request.",
274 __FUNCTION__, mCameraIdStr.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800275 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Empty request list");
Jianing Wei90e59c92014-03-12 18:29:36 -0700276 }
277
Emilian Peevaebbe412018-01-15 13:53:24 +0000278 List<const CameraDeviceBase::PhysicalCameraSettingsList> metadataRequestList;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700279 std::list<const SurfaceMap> surfaceMapList;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800280 submitInfo->mRequestId = mRequestIdCounter;
Jianing Wei90e59c92014-03-12 18:29:36 -0700281 uint32_t loopCounter = 0;
282
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800283 for (auto&& request: requests) {
284 if (request.mIsReprocess) {
Chien-Yu Chened0412e2015-04-27 15:04:22 -0700285 if (!mInputStream.configured) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800286 ALOGE("%s: Camera %s: no input stream is configured.", __FUNCTION__,
287 mCameraIdStr.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800288 return STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800289 "No input configured for camera %s but request is for reprocessing",
290 mCameraIdStr.string());
Chien-Yu Chened0412e2015-04-27 15:04:22 -0700291 } else if (streaming) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800292 ALOGE("%s: Camera %s: streaming reprocess requests not supported.", __FUNCTION__,
293 mCameraIdStr.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800294 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
295 "Repeating reprocess requests not supported");
Emilian Peevaebbe412018-01-15 13:53:24 +0000296 } else if (request.mPhysicalCameraSettings.size() > 1) {
297 ALOGE("%s: Camera %s: reprocess requests not supported for "
298 "multiple physical cameras.", __FUNCTION__,
299 mCameraIdStr.string());
300 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
301 "Reprocess requests not supported for multiple cameras");
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700302 }
Jianing Wei90e59c92014-03-12 18:29:36 -0700303 }
304
Emilian Peevaebbe412018-01-15 13:53:24 +0000305 if (request.mPhysicalCameraSettings.empty()) {
306 ALOGE("%s: Camera %s: request doesn't contain any settings.", __FUNCTION__,
307 mCameraIdStr.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800308 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
Emilian Peevaebbe412018-01-15 13:53:24 +0000309 "Request doesn't contain any settings");
310 }
311
312 //The first capture settings should always match the logical camera id
313 String8 logicalId(request.mPhysicalCameraSettings.begin()->id.c_str());
314 if (mDevice->getId() != logicalId) {
315 ALOGE("%s: Camera %s: Invalid camera request settings.", __FUNCTION__,
316 mCameraIdStr.string());
317 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
318 "Invalid camera request settings");
319 }
320
Emilian Peevaebbe412018-01-15 13:53:24 +0000321 if (request.mSurfaceList.isEmpty() && request.mStreamIdxList.size() == 0) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800322 ALOGE("%s: Camera %s: Requests must have at least one surface target. "
323 "Rejecting request.", __FUNCTION__, mCameraIdStr.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800324 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
325 "Request has no output targets");
Jianing Wei90e59c92014-03-12 18:29:36 -0700326 }
327
Jianing Wei90e59c92014-03-12 18:29:36 -0700328 /**
Shuzhen Wang0129d522016-10-30 22:43:41 -0700329 * Write in the output stream IDs and map from stream ID to surface ID
330 * which we calculate from the capture request's list of surface target
Jianing Wei90e59c92014-03-12 18:29:36 -0700331 */
Shuzhen Wang0129d522016-10-30 22:43:41 -0700332 SurfaceMap surfaceMap;
Jianing Wei90e59c92014-03-12 18:29:36 -0700333 Vector<int32_t> outputStreamIds;
Emilian Peevf873aa52018-01-26 14:58:28 +0000334 std::vector<std::string> requestedPhysicalIds;
Emilian Peev2295df72021-11-12 18:14:10 -0800335 int dynamicProfileBitmap = 0;
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800336 if (request.mSurfaceList.size() > 0) {
Chih-Hung Hsieh3ef324d2018-12-11 11:48:12 -0800337 for (const sp<Surface>& surface : request.mSurfaceList) {
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800338 if (surface == 0) continue;
Jianing Wei90e59c92014-03-12 18:29:36 -0700339
Emilian Peevf873aa52018-01-26 14:58:28 +0000340 int32_t streamId;
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800341 sp<IGraphicBufferProducer> gbp = surface->getIGraphicBufferProducer();
Emilian Peevf873aa52018-01-26 14:58:28 +0000342 res = insertGbpLocked(gbp, &surfaceMap, &outputStreamIds, &streamId);
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800343 if (!res.isOk()) {
344 return res;
345 }
Emilian Peevf873aa52018-01-26 14:58:28 +0000346
347 ssize_t index = mConfiguredOutputs.indexOfKey(streamId);
348 if (index >= 0) {
349 String8 requestedPhysicalId(
350 mConfiguredOutputs.valueAt(index).getPhysicalCameraId());
351 requestedPhysicalIds.push_back(requestedPhysicalId.string());
Emilian Peev2295df72021-11-12 18:14:10 -0800352 dynamicProfileBitmap |=
353 mConfiguredOutputs.valueAt(index).getDynamicRangeProfile();
Emilian Peevf873aa52018-01-26 14:58:28 +0000354 } else {
355 ALOGW("%s: Output stream Id not found among configured outputs!", __FUNCTION__);
356 }
Jianing Wei90e59c92014-03-12 18:29:36 -0700357 }
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800358 } else {
359 for (size_t i = 0; i < request.mStreamIdxList.size(); i++) {
360 int streamId = request.mStreamIdxList.itemAt(i);
361 int surfaceIdx = request.mSurfaceIdxList.itemAt(i);
Jianing Wei90e59c92014-03-12 18:29:36 -0700362
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800363 ssize_t index = mConfiguredOutputs.indexOfKey(streamId);
364 if (index < 0) {
365 ALOGE("%s: Camera %s: Tried to submit a request with a surface that"
366 " we have not called createStream on: stream %d",
367 __FUNCTION__, mCameraIdStr.string(), streamId);
368 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
369 "Request targets Surface that is not part of current capture session");
370 }
371
372 const auto& gbps = mConfiguredOutputs.valueAt(index).getGraphicBufferProducers();
373 if ((size_t)surfaceIdx >= gbps.size()) {
374 ALOGE("%s: Camera %s: Tried to submit a request with a surface that"
375 " we have not called createStream on: stream %d, surfaceIdx %d",
376 __FUNCTION__, mCameraIdStr.string(), streamId, surfaceIdx);
377 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
378 "Request targets Surface has invalid surface index");
379 }
380
Emilian Peevf873aa52018-01-26 14:58:28 +0000381 res = insertGbpLocked(gbps[surfaceIdx], &surfaceMap, &outputStreamIds, nullptr);
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800382 if (!res.isOk()) {
383 return res;
384 }
Emilian Peevf873aa52018-01-26 14:58:28 +0000385
386 String8 requestedPhysicalId(
387 mConfiguredOutputs.valueAt(index).getPhysicalCameraId());
388 requestedPhysicalIds.push_back(requestedPhysicalId.string());
Emilian Peev2295df72021-11-12 18:14:10 -0800389 dynamicProfileBitmap |=
390 mConfiguredOutputs.valueAt(index).getDynamicRangeProfile();
391 }
392 }
393
394 if (dynamicProfileBitmap !=
395 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD) {
396 for (int i = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD;
397 i < ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_MAX; i <<= 1) {
398 if ((dynamicProfileBitmap & i) == 0) {
399 continue;
400 }
401
402 const auto& it = mDynamicProfileMap.find(i);
403 if (it != mDynamicProfileMap.end()) {
404 if ((it->second == 0) ||
405 ((it->second & dynamicProfileBitmap) == dynamicProfileBitmap)) {
406 continue;
407 } else {
408 ALOGE("%s: Camera %s: Tried to submit a request with a surfaces that"
409 " reference an unsupported dynamic range profile combination"
410 " 0x%x!", __FUNCTION__, mCameraIdStr.string(),
411 dynamicProfileBitmap);
412 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
413 "Request targets an unsupported dynamic range profile"
414 " combination");
415 }
416 } else {
417 ALOGE("%s: Camera %s: Tried to submit a request with a surface that"
418 " references unsupported dynamic range profile 0x%x!",
419 __FUNCTION__, mCameraIdStr.string(), i);
420 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
421 "Request targets 10-bit Surface with unsupported dynamic range"
422 " profile");
423 }
Shuzhen Wang0129d522016-10-30 22:43:41 -0700424 }
Jianing Wei90e59c92014-03-12 18:29:36 -0700425 }
426
Emilian Peevf873aa52018-01-26 14:58:28 +0000427 CameraDeviceBase::PhysicalCameraSettingsList physicalSettingsList;
428 for (const auto& it : request.mPhysicalCameraSettings) {
Emilian Peev00420d22018-02-05 21:33:13 +0000429 if (it.settings.isEmpty()) {
430 ALOGE("%s: Camera %s: Sent empty metadata packet. Rejecting request.",
431 __FUNCTION__, mCameraIdStr.string());
432 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
433 "Request settings are empty");
434 }
435
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800436 // Check whether the physical / logical stream has settings
437 // consistent with the sensor pixel mode(s) it was configured with.
438 // mCameraIdToStreamSet will only have ids that are high resolution
439 const auto streamIdSetIt = mHighResolutionCameraIdToStreamIdSet.find(it.id);
440 if (streamIdSetIt != mHighResolutionCameraIdToStreamIdSet.end()) {
441 std::list<int> streamIdsUsedInRequest = getIntersection(streamIdSetIt->second,
442 outputStreamIds);
443 if (!request.mIsReprocess &&
444 !isSensorPixelModeConsistent(streamIdsUsedInRequest, it.settings)) {
445 ALOGE("%s: Camera %s: Request settings CONTROL_SENSOR_PIXEL_MODE not "
446 "consistent with configured streams. Rejecting request.",
447 __FUNCTION__, it.id.c_str());
448 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
449 "Request settings CONTROL_SENSOR_PIXEL_MODE are not consistent with "
450 "streams configured");
451 }
452 }
453
Emilian Peevf873aa52018-01-26 14:58:28 +0000454 String8 physicalId(it.id.c_str());
Shuzhen Wang911c6a32021-10-27 13:36:03 -0700455 bool hasTestPatternModePhysicalKey = std::find(mSupportedPhysicalRequestKeys.begin(),
456 mSupportedPhysicalRequestKeys.end(), ANDROID_SENSOR_TEST_PATTERN_MODE) !=
457 mSupportedPhysicalRequestKeys.end();
458 bool hasTestPatternDataPhysicalKey = std::find(mSupportedPhysicalRequestKeys.begin(),
459 mSupportedPhysicalRequestKeys.end(), ANDROID_SENSOR_TEST_PATTERN_DATA) !=
460 mSupportedPhysicalRequestKeys.end();
Emilian Peevf873aa52018-01-26 14:58:28 +0000461 if (physicalId != mDevice->getId()) {
462 auto found = std::find(requestedPhysicalIds.begin(), requestedPhysicalIds.end(),
463 it.id);
464 if (found == requestedPhysicalIds.end()) {
465 ALOGE("%s: Camera %s: Physical camera id: %s not part of attached outputs.",
466 __FUNCTION__, mCameraIdStr.string(), physicalId.string());
467 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
468 "Invalid physical camera id");
469 }
Emilian Peev00420d22018-02-05 21:33:13 +0000470
471 if (!mSupportedPhysicalRequestKeys.empty()) {
472 // Filter out any unsupported physical request keys.
473 CameraMetadata filteredParams(mSupportedPhysicalRequestKeys.size());
474 camera_metadata_t *meta = const_cast<camera_metadata_t *>(
475 filteredParams.getAndLock());
476 set_camera_metadata_vendor_id(meta, mDevice->getVendorTagId());
477 filteredParams.unlock(meta);
478
479 for (const auto& keyIt : mSupportedPhysicalRequestKeys) {
480 camera_metadata_ro_entry entry = it.settings.find(keyIt);
481 if (entry.count > 0) {
482 filteredParams.update(entry);
483 }
484 }
485
Shuzhen Wang911c6a32021-10-27 13:36:03 -0700486 physicalSettingsList.push_back({it.id, filteredParams,
487 hasTestPatternModePhysicalKey, hasTestPatternDataPhysicalKey});
Emilian Peev00420d22018-02-05 21:33:13 +0000488 }
489 } else {
490 physicalSettingsList.push_back({it.id, it.settings});
Emilian Peevf873aa52018-01-26 14:58:28 +0000491 }
Emilian Peevf873aa52018-01-26 14:58:28 +0000492 }
493
494 if (!enforceRequestPermissions(physicalSettingsList.begin()->metadata)) {
495 // Callee logs
496 return STATUS_ERROR(CameraService::ERROR_PERMISSION_DENIED,
497 "Caller does not have permission to change restricted controls");
498 }
499
Emilian Peevaebbe412018-01-15 13:53:24 +0000500 physicalSettingsList.begin()->metadata.update(ANDROID_REQUEST_OUTPUT_STREAMS,
501 &outputStreamIds[0], outputStreamIds.size());
Jianing Wei90e59c92014-03-12 18:29:36 -0700502
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800503 if (request.mIsReprocess) {
Emilian Peevaebbe412018-01-15 13:53:24 +0000504 physicalSettingsList.begin()->metadata.update(ANDROID_REQUEST_INPUT_STREAMS,
505 &mInputStream.id, 1);
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700506 }
507
Emilian Peevaebbe412018-01-15 13:53:24 +0000508 physicalSettingsList.begin()->metadata.update(ANDROID_REQUEST_ID,
509 &(submitInfo->mRequestId), /*size*/1);
Jianing Wei90e59c92014-03-12 18:29:36 -0700510 loopCounter++; // loopCounter starts from 1
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800511 ALOGV("%s: Camera %s: Creating request with ID %d (%d of %zu)",
512 __FUNCTION__, mCameraIdStr.string(), submitInfo->mRequestId,
513 loopCounter, requests.size());
Jianing Wei90e59c92014-03-12 18:29:36 -0700514
Emilian Peevaebbe412018-01-15 13:53:24 +0000515 metadataRequestList.push_back(physicalSettingsList);
Shuzhen Wang0129d522016-10-30 22:43:41 -0700516 surfaceMapList.push_back(surfaceMap);
Jianing Wei90e59c92014-03-12 18:29:36 -0700517 }
518 mRequestIdCounter++;
519
520 if (streaming) {
Shuzhen Wang0129d522016-10-30 22:43:41 -0700521 err = mDevice->setStreamingRequestList(metadataRequestList, surfaceMapList,
522 &(submitInfo->mLastFrameNumber));
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800523 if (err != OK) {
524 String8 msg = String8::format(
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800525 "Camera %s: Got error %s (%d) after trying to set streaming request",
526 mCameraIdStr.string(), strerror(-err), err);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800527 ALOGE("%s: %s", __FUNCTION__, msg.string());
528 res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION,
529 msg.string());
Jianing Wei90e59c92014-03-12 18:29:36 -0700530 } else {
Shuzhen Wangc9ca6782016-04-26 13:40:31 -0700531 Mutex::Autolock idLock(mStreamingRequestIdLock);
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700532 mStreamingRequestId = submitInfo->mRequestId;
Jianing Wei90e59c92014-03-12 18:29:36 -0700533 }
534 } else {
Shuzhen Wang0129d522016-10-30 22:43:41 -0700535 err = mDevice->captureList(metadataRequestList, surfaceMapList,
536 &(submitInfo->mLastFrameNumber));
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800537 if (err != OK) {
538 String8 msg = String8::format(
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800539 "Camera %s: Got error %s (%d) after trying to submit capture request",
540 mCameraIdStr.string(), strerror(-err), err);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800541 ALOGE("%s: %s", __FUNCTION__, msg.string());
542 res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION,
543 msg.string());
Jianing Wei90e59c92014-03-12 18:29:36 -0700544 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800545 ALOGV("%s: requestId = %d ", __FUNCTION__, submitInfo->mRequestId);
Jianing Wei90e59c92014-03-12 18:29:36 -0700546 }
547
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800548 ALOGV("%s: Camera %s: End of function", __FUNCTION__, mCameraIdStr.string());
Jianing Wei90e59c92014-03-12 18:29:36 -0700549 return res;
550}
551
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800552binder::Status CameraDeviceClient::cancelRequest(
553 int requestId,
554 /*out*/
555 int64_t* lastFrameNumber) {
Igor Murashkine7ee7632013-06-11 18:10:18 -0700556 ATRACE_CALL();
557 ALOGV("%s, requestId = %d", __FUNCTION__, requestId);
558
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800559 status_t err;
560 binder::Status res;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700561
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800562 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700563
564 Mutex::Autolock icl(mBinderSerializationLock);
565
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800566 if (!mDevice.get()) {
567 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
568 }
Igor Murashkine7ee7632013-06-11 18:10:18 -0700569
Shuzhen Wangc9ca6782016-04-26 13:40:31 -0700570 Mutex::Autolock idLock(mStreamingRequestIdLock);
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700571 if (mStreamingRequestId != requestId) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800572 String8 msg = String8::format("Camera %s: Canceling request ID %d doesn't match "
573 "current request ID %d", mCameraIdStr.string(), requestId, mStreamingRequestId);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800574 ALOGE("%s: %s", __FUNCTION__, msg.string());
575 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
Igor Murashkine7ee7632013-06-11 18:10:18 -0700576 }
577
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800578 err = mDevice->clearStreamingRequest(lastFrameNumber);
Igor Murashkine7ee7632013-06-11 18:10:18 -0700579
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800580 if (err == OK) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800581 ALOGV("%s: Camera %s: Successfully cleared streaming request",
582 __FUNCTION__, mCameraIdStr.string());
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700583 mStreamingRequestId = REQUEST_ID_NONE;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800584 } else {
585 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800586 "Camera %s: Error clearing streaming request: %s (%d)",
587 mCameraIdStr.string(), strerror(-err), err);
Igor Murashkine7ee7632013-06-11 18:10:18 -0700588 }
589
590 return res;
591}
592
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800593binder::Status CameraDeviceClient::beginConfigure() {
Ruben Brunkb2119af2014-05-09 19:57:56 -0700594 // TODO: Implement this.
Eino-Ville Talvala6aeb8882017-08-07 17:40:49 -0700595 ATRACE_CALL();
Zhijun He1fa89992015-06-01 15:44:31 -0700596 ALOGV("%s: Not implemented yet.", __FUNCTION__);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800597 return binder::Status::ok();
Ruben Brunkb2119af2014-05-09 19:57:56 -0700598}
599
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100600binder::Status CameraDeviceClient::endConfigure(int operatingMode,
Shuzhen Wang316781a2020-08-18 18:11:01 -0700601 const hardware::camera2::impl::CameraMetadataNative& sessionParams, int64_t startTimeMs,
Emilian Peevcc0b7952020-01-07 13:54:47 -0800602 std::vector<int>* offlineStreamIds /*out*/) {
Eino-Ville Talvala6aeb8882017-08-07 17:40:49 -0700603 ATRACE_CALL();
Shuzhen Wang0129d522016-10-30 22:43:41 -0700604 ALOGV("%s: ending configure (%d input stream, %zu output surfaces)",
605 __FUNCTION__, mInputStream.configured ? 1 : 0,
606 mStreamMap.size());
Igor Murashkine2d167e2014-08-19 16:19:59 -0700607
Zhijun He0effd522016-03-04 10:22:27 -0800608 binder::Status res;
609 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
610
Emilian Peevcc0b7952020-01-07 13:54:47 -0800611 if (offlineStreamIds == nullptr) {
612 String8 msg = String8::format("Invalid offline stream ids");
613 ALOGE("%s: %s", __FUNCTION__, msg.string());
614 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
615 }
616
Zhijun He0effd522016-03-04 10:22:27 -0800617 Mutex::Autolock icl(mBinderSerializationLock);
618
619 if (!mDevice.get()) {
620 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
621 }
622
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700623 res = SessionConfigurationUtils::checkOperatingMode(operatingMode, mDevice->info(),
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000624 mCameraIdStr);
Emilian Peev35ae8262018-11-08 13:11:32 +0000625 if (!res.isOk()) {
626 return res;
627 }
628
629 status_t err = mDevice->configureStreams(sessionParams, operatingMode);
630 if (err == BAD_VALUE) {
631 String8 msg = String8::format("Camera %s: Unsupported set of inputs/outputs provided",
632 mCameraIdStr.string());
633 ALOGE("%s: %s", __FUNCTION__, msg.string());
634 res = STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
635 } else if (err != OK) {
636 String8 msg = String8::format("Camera %s: Error configuring streams: %s (%d)",
637 mCameraIdStr.string(), strerror(-err), err);
638 ALOGE("%s: %s", __FUNCTION__, msg.string());
639 res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
Emilian Peev538c90e2018-12-17 18:03:19 +0000640 } else {
Emilian Peevcc0b7952020-01-07 13:54:47 -0800641 offlineStreamIds->clear();
642 mDevice->getOfflineStreamIds(offlineStreamIds);
643
Emilian Peev2f5d6012022-01-19 16:16:50 -0800644 Mutex::Autolock l(mCompositeLock);
Emilian Peev538c90e2018-12-17 18:03:19 +0000645 for (size_t i = 0; i < mCompositeStreamMap.size(); ++i) {
646 err = mCompositeStreamMap.valueAt(i)->configureStream();
Emilian Peevcc0b7952020-01-07 13:54:47 -0800647 if (err != OK) {
Emilian Peev538c90e2018-12-17 18:03:19 +0000648 String8 msg = String8::format("Camera %s: Error configuring composite "
649 "streams: %s (%d)", mCameraIdStr.string(), strerror(-err), err);
650 ALOGE("%s: %s", __FUNCTION__, msg.string());
651 res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
652 break;
653 }
Emilian Peevcc0b7952020-01-07 13:54:47 -0800654
655 // Composite streams can only support offline mode in case all individual internal
656 // streams are also supported.
657 std::vector<int> internalStreams;
658 mCompositeStreamMap.valueAt(i)->insertCompositeStreamIds(&internalStreams);
Emilian Peevfaa4bde2020-01-23 12:19:37 -0800659 offlineStreamIds->erase(
660 std::remove_if(offlineStreamIds->begin(), offlineStreamIds->end(),
Emilian Peevcc0b7952020-01-07 13:54:47 -0800661 [&internalStreams] (int streamId) {
662 auto it = std::find(internalStreams.begin(), internalStreams.end(),
663 streamId);
664 if (it != internalStreams.end()) {
665 internalStreams.erase(it);
666 return true;
667 }
668
Emilian Peevfaa4bde2020-01-23 12:19:37 -0800669 return false;}), offlineStreamIds->end());
Emilian Peevcc0b7952020-01-07 13:54:47 -0800670 if (internalStreams.empty()) {
671 offlineStreamIds->push_back(mCompositeStreamMap.valueAt(i)->getStreamId());
672 }
673 }
674
675 for (const auto& offlineStreamId : *offlineStreamIds) {
676 mStreamInfoMap[offlineStreamId].supportsOffline = true;
Emilian Peev538c90e2018-12-17 18:03:19 +0000677 }
Shuzhen Wang316781a2020-08-18 18:11:01 -0700678
679 nsecs_t configureEnd = systemTime();
680 int32_t configureDurationMs = ns2ms(configureEnd) - startTimeMs;
681 CameraServiceProxyWrapper::logStreamConfigured(mCameraIdStr, operatingMode,
682 false /*internalReconfig*/, configureDurationMs);
Emilian Peev35ae8262018-11-08 13:11:32 +0000683 }
684
685 return res;
686}
687
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -0800688binder::Status CameraDeviceClient::isSessionConfigurationSupported(
689 const SessionConfiguration& sessionConfiguration, bool *status /*out*/) {
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -0800690
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800691 ATRACE_CALL();
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -0800692 binder::Status res;
693 status_t ret = OK;
694 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
695
696 Mutex::Autolock icl(mBinderSerializationLock);
697
698 if (!mDevice.get()) {
699 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
700 }
701
702 auto operatingMode = sessionConfiguration.getOperatingMode();
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700703 res = SessionConfigurationUtils::checkOperatingMode(operatingMode, mDevice->info(),
Colin Crossb8a9dbb2020-08-27 04:12:26 +0000704 mCameraIdStr);
Jayant Chowdhary2bbdce42020-01-12 14:55:41 -0800705 if (!res.isOk()) {
706 return res;
707 }
708
709 if (status == nullptr) {
710 String8 msg = String8::format( "Camera %s: Invalid status!", mCameraIdStr.string());
711 ALOGE("%s: %s", __FUNCTION__, msg.string());
712 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
713 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700714
Emilian Peev35ae8262018-11-08 13:11:32 +0000715 *status = false;
716 ret = mProviderManager->isSessionConfigurationSupported(mCameraIdStr.string(),
Jayant Chowdhary0bd38522021-11-05 17:49:27 -0700717 sessionConfiguration, mOverrideForPerfClass, status);
Emilian Peev35ae8262018-11-08 13:11:32 +0000718 switch (ret) {
719 case OK:
720 // Expected, do nothing.
721 break;
722 case INVALID_OPERATION: {
723 String8 msg = String8::format(
724 "Camera %s: Session configuration query not supported!",
725 mCameraIdStr.string());
726 ALOGD("%s: %s", __FUNCTION__, msg.string());
727 res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
728 }
729
730 break;
731 default: {
732 String8 msg = String8::format( "Camera %s: Error: %s (%d)", mCameraIdStr.string(),
733 strerror(-ret), ret);
734 ALOGE("%s: %s", __FUNCTION__, msg.string());
735 res = STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
736 msg.string());
737 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800738 }
739
740 return res;
Ruben Brunkb2119af2014-05-09 19:57:56 -0700741}
742
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800743binder::Status CameraDeviceClient::deleteStream(int streamId) {
Igor Murashkine7ee7632013-06-11 18:10:18 -0700744 ATRACE_CALL();
745 ALOGV("%s (streamId = 0x%x)", __FUNCTION__, streamId);
746
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800747 binder::Status res;
748 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700749
750 Mutex::Autolock icl(mBinderSerializationLock);
751
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800752 if (!mDevice.get()) {
753 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
754 }
Igor Murashkine7ee7632013-06-11 18:10:18 -0700755
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700756 bool isInput = false;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700757 std::vector<sp<IBinder>> surfaces;
Zhijun He5d677d12016-05-29 16:52:39 -0700758 ssize_t dIndex = NAME_NOT_FOUND;
Emilian Peev538c90e2018-12-17 18:03:19 +0000759 ssize_t compositeIndex = NAME_NOT_FOUND;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700760
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700761 if (mInputStream.configured && mInputStream.id == streamId) {
762 isInput = true;
763 } else {
764 // Guard against trying to delete non-created streams
765 for (size_t i = 0; i < mStreamMap.size(); ++i) {
Shuzhen Wang0129d522016-10-30 22:43:41 -0700766 if (streamId == mStreamMap.valueAt(i).streamId()) {
767 surfaces.push_back(mStreamMap.keyAt(i));
768 }
769 }
770
771 // See if this stream is one of the deferred streams.
772 for (size_t i = 0; i < mDeferredStreams.size(); ++i) {
773 if (streamId == mDeferredStreams[i]) {
774 dIndex = i;
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700775 break;
776 }
777 }
778
Emilian Peev2f5d6012022-01-19 16:16:50 -0800779 Mutex::Autolock l(mCompositeLock);
Emilian Peev538c90e2018-12-17 18:03:19 +0000780 for (size_t i = 0; i < mCompositeStreamMap.size(); ++i) {
781 if (streamId == mCompositeStreamMap.valueAt(i)->getStreamId()) {
782 compositeIndex = i;
783 break;
784 }
785 }
786
Shuzhen Wang0129d522016-10-30 22:43:41 -0700787 if (surfaces.empty() && dIndex == NAME_NOT_FOUND) {
788 String8 msg = String8::format("Camera %s: Invalid stream ID (%d) specified, no such"
789 " stream created yet", mCameraIdStr.string(), streamId);
790 ALOGW("%s: %s", __FUNCTION__, msg.string());
791 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700792 }
Igor Murashkine7ee7632013-06-11 18:10:18 -0700793 }
794
795 // Also returns BAD_VALUE if stream ID was not valid
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800796 status_t err = mDevice->deleteStream(streamId);
Igor Murashkine7ee7632013-06-11 18:10:18 -0700797
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800798 if (err != OK) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800799 String8 msg = String8::format("Camera %s: Unexpected error %s (%d) when deleting stream %d",
800 mCameraIdStr.string(), strerror(-err), err, streamId);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800801 ALOGE("%s: %s", __FUNCTION__, msg.string());
802 res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
803 } else {
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700804 if (isInput) {
805 mInputStream.configured = false;
Zhijun He5d677d12016-05-29 16:52:39 -0700806 } else {
Shuzhen Wang0129d522016-10-30 22:43:41 -0700807 for (auto& surface : surfaces) {
808 mStreamMap.removeItem(surface);
809 }
810
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800811 mConfiguredOutputs.removeItem(streamId);
812
Shuzhen Wang0129d522016-10-30 22:43:41 -0700813 if (dIndex != NAME_NOT_FOUND) {
814 mDeferredStreams.removeItemsAt(dIndex);
815 }
Emilian Peev538c90e2018-12-17 18:03:19 +0000816
817 if (compositeIndex != NAME_NOT_FOUND) {
Emilian Peev2f5d6012022-01-19 16:16:50 -0800818 Mutex::Autolock l(mCompositeLock);
Emilian Peev538c90e2018-12-17 18:03:19 +0000819 status_t ret;
820 if ((ret = mCompositeStreamMap.valueAt(compositeIndex)->deleteStream())
821 != OK) {
822 String8 msg = String8::format("Camera %s: Unexpected error %s (%d) when "
823 "deleting composite stream %d", mCameraIdStr.string(), strerror(-err), err,
824 streamId);
825 ALOGE("%s: %s", __FUNCTION__, msg.string());
826 res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
827 }
828 mCompositeStreamMap.removeItemsAt(compositeIndex);
829 }
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800830 for (auto &mapIt: mHighResolutionCameraIdToStreamIdSet) {
831 auto &streamSet = mapIt.second;
832 if (streamSet.find(streamId) != streamSet.end()) {
833 streamSet.erase(streamId);
834 break;
835 }
836 }
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700837 }
Igor Murashkine7ee7632013-06-11 18:10:18 -0700838 }
839
840 return res;
841}
842
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800843binder::Status CameraDeviceClient::createStream(
844 const hardware::camera2::params::OutputConfiguration &outputConfiguration,
845 /*out*/
846 int32_t* newStreamId) {
Igor Murashkine7ee7632013-06-11 18:10:18 -0700847 ATRACE_CALL();
Igor Murashkine7ee7632013-06-11 18:10:18 -0700848
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800849 binder::Status res;
850 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700851
852 Mutex::Autolock icl(mBinderSerializationLock);
853
Shuzhen Wang0129d522016-10-30 22:43:41 -0700854 const std::vector<sp<IGraphicBufferProducer>>& bufferProducers =
855 outputConfiguration.getGraphicBufferProducers();
856 size_t numBufferProducers = bufferProducers.size();
Shuzhen Wang758c2152017-01-10 18:26:18 -0800857 bool deferredConsumer = outputConfiguration.isDeferred();
858 bool isShared = outputConfiguration.isShared();
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800859 String8 physicalCameraId = String8(outputConfiguration.getPhysicalCameraId());
Shuzhen Wang758c2152017-01-10 18:26:18 -0800860 bool deferredConsumerOnly = deferredConsumer && numBufferProducers == 0;
Shuzhen Wang83bff122020-11-20 15:51:39 -0800861 bool isMultiResolution = outputConfiguration.isMultiResolution();
Emilian Peev2295df72021-11-12 18:14:10 -0800862 int dynamicRangeProfile = outputConfiguration.getDynamicRangeProfile();
Shuzhen Wangc8ab4522021-12-14 20:12:42 -0800863 int streamUseCase = outputConfiguration.getStreamUseCase();
Shuzhen Wang0129d522016-10-30 22:43:41 -0700864
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700865 res = SessionConfigurationUtils::checkSurfaceType(numBufferProducers, deferredConsumer,
Emilian Peev35ae8262018-11-08 13:11:32 +0000866 outputConfiguration.getSurfaceType());
867 if (!res.isOk()) {
868 return res;
Yin-Chia Yeh89f14da2014-06-10 16:05:44 -0700869 }
Zhijun He5d677d12016-05-29 16:52:39 -0700870
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800871 if (!mDevice.get()) {
872 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
873 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700874 res = SessionConfigurationUtils::checkPhysicalCameraId(mPhysicalCameraIds,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800875 physicalCameraId, mCameraIdStr);
Emilian Peev35ae8262018-11-08 13:11:32 +0000876 if (!res.isOk()) {
877 return res;
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800878 }
Emilian Peev35ae8262018-11-08 13:11:32 +0000879
Shuzhen Wang0129d522016-10-30 22:43:41 -0700880 std::vector<sp<Surface>> surfaces;
881 std::vector<sp<IBinder>> binders;
Zhijun He5d677d12016-05-29 16:52:39 -0700882 status_t err;
883
884 // Create stream for deferred surface case.
Shuzhen Wang0129d522016-10-30 22:43:41 -0700885 if (deferredConsumerOnly) {
Shuzhen Wang758c2152017-01-10 18:26:18 -0800886 return createDeferredSurfaceStreamLocked(outputConfiguration, isShared, newStreamId);
Zhijun He5d677d12016-05-29 16:52:39 -0700887 }
888
Shuzhen Wang758c2152017-01-10 18:26:18 -0800889 OutputStreamInfo streamInfo;
890 bool isStreamInfoValid = false;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800891 const std::vector<int32_t> &sensorPixelModesUsed =
892 outputConfiguration.getSensorPixelModesUsed();
Shuzhen Wang0129d522016-10-30 22:43:41 -0700893 for (auto& bufferProducer : bufferProducers) {
Shuzhen Wang0129d522016-10-30 22:43:41 -0700894 // Don't create multiple streams for the same target surface
Shuzhen Wang0129d522016-10-30 22:43:41 -0700895 sp<IBinder> binder = IInterface::asBinder(bufferProducer);
Shuzhen Wang758c2152017-01-10 18:26:18 -0800896 ssize_t index = mStreamMap.indexOfKey(binder);
897 if (index != NAME_NOT_FOUND) {
898 String8 msg = String8::format("Camera %s: Surface already has a stream created for it "
899 "(ID %zd)", mCameraIdStr.string(), index);
900 ALOGW("%s: %s", __FUNCTION__, msg.string());
901 return STATUS_ERROR(CameraService::ERROR_ALREADY_EXISTS, msg.string());
Shuzhen Wang0129d522016-10-30 22:43:41 -0700902 }
Igor Murashkine7ee7632013-06-11 18:10:18 -0700903
Shuzhen Wang758c2152017-01-10 18:26:18 -0800904 sp<Surface> surface;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700905 res = SessionConfigurationUtils::createSurfaceFromGbp(streamInfo,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800906 isStreamInfoValid, surface, bufferProducer, mCameraIdStr,
Shuzhen Wangc8ab4522021-12-14 20:12:42 -0800907 mDevice->infoPhysical(physicalCameraId), sensorPixelModesUsed, dynamicRangeProfile,
908 streamUseCase);
Shuzhen Wang758c2152017-01-10 18:26:18 -0800909
910 if (!res.isOk())
911 return res;
912
913 if (!isStreamInfoValid) {
914 isStreamInfoValid = true;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700915 }
916
Shuzhen Wang758c2152017-01-10 18:26:18 -0800917 binders.push_back(IInterface::asBinder(bufferProducer));
Shuzhen Wang0129d522016-10-30 22:43:41 -0700918 surfaces.push_back(surface);
Ruben Brunkbba75572014-11-20 17:29:50 -0800919 }
Shuzhen Wangd4abdf72021-05-28 11:22:50 -0700920
921 // If mOverrideForPerfClass is true, do not fail createStream() for small
922 // JPEG sizes because existing createSurfaceFromGbp() logic will find the
923 // closest possible supported size.
924
Zhijun He125684a2015-12-26 15:07:30 -0800925 int streamId = camera3::CAMERA3_STREAM_ID_INVALID;
Emilian Peev40ead602017-09-26 15:46:36 +0100926 std::vector<int> surfaceIds;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800927 bool isDepthCompositeStream =
928 camera3::DepthCompositeStream::isDepthCompositeStream(surfaces[0]);
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -0800929 bool isHeicCompisiteStream = camera3::HeicCompositeStream::isHeicCompositeStream(surfaces[0]);
930 if (isDepthCompositeStream || isHeicCompisiteStream) {
931 sp<CompositeStream> compositeStream;
932 if (isDepthCompositeStream) {
933 compositeStream = new camera3::DepthCompositeStream(mDevice, getRemoteCallback());
934 } else {
935 compositeStream = new camera3::HeicCompositeStream(mDevice, getRemoteCallback());
936 }
937
Emilian Peev538c90e2018-12-17 18:03:19 +0000938 err = compositeStream->createStream(surfaces, deferredConsumer, streamInfo.width,
939 streamInfo.height, streamInfo.format,
Emilian Peevf4816702020-04-03 15:44:51 -0700940 static_cast<camera_stream_rotation_t>(outputConfiguration.getRotation()),
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800941 &streamId, physicalCameraId, streamInfo.sensorPixelModesUsed, &surfaceIds,
942 outputConfiguration.getSurfaceSetID(), isShared, isMultiResolution);
Emilian Peev538c90e2018-12-17 18:03:19 +0000943 if (err == OK) {
Emilian Peev2f5d6012022-01-19 16:16:50 -0800944 Mutex::Autolock l(mCompositeLock);
Emilian Peev538c90e2018-12-17 18:03:19 +0000945 mCompositeStreamMap.add(IInterface::asBinder(surfaces[0]->getIGraphicBufferProducer()),
946 compositeStream);
947 }
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -0800948 } else {
949 err = mDevice->createStream(surfaces, deferredConsumer, streamInfo.width,
950 streamInfo.height, streamInfo.format, streamInfo.dataSpace,
Emilian Peevf4816702020-04-03 15:44:51 -0700951 static_cast<camera_stream_rotation_t>(outputConfiguration.getRotation()),
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800952 &streamId, physicalCameraId, streamInfo.sensorPixelModesUsed, &surfaceIds,
Emilian Peev2295df72021-11-12 18:14:10 -0800953 outputConfiguration.getSurfaceSetID(), isShared, isMultiResolution,
Shuzhen Wangc8ab4522021-12-14 20:12:42 -0800954 /*consumerUsage*/0, streamInfo.dynamicRangeProfile, streamInfo.streamUseCase);
Emilian Peev538c90e2018-12-17 18:03:19 +0000955 }
Igor Murashkine7ee7632013-06-11 18:10:18 -0700956
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800957 if (err != OK) {
958 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800959 "Camera %s: Error creating output stream (%d x %d, fmt %x, dataSpace %x): %s (%d)",
Shuzhen Wang758c2152017-01-10 18:26:18 -0800960 mCameraIdStr.string(), streamInfo.width, streamInfo.height, streamInfo.format,
961 streamInfo.dataSpace, strerror(-err), err);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800962 } else {
Shuzhen Wang0129d522016-10-30 22:43:41 -0700963 int i = 0;
964 for (auto& binder : binders) {
965 ALOGV("%s: mStreamMap add binder %p streamId %d, surfaceId %d",
966 __FUNCTION__, binder.get(), streamId, i);
Emilian Peev40ead602017-09-26 15:46:36 +0100967 mStreamMap.add(binder, StreamSurfaceId(streamId, surfaceIds[i]));
968 i++;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700969 }
Shuzhen Wang758c2152017-01-10 18:26:18 -0800970
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -0800971 mConfiguredOutputs.add(streamId, outputConfiguration);
Shuzhen Wang758c2152017-01-10 18:26:18 -0800972 mStreamInfoMap[streamId] = streamInfo;
973
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -0800974 ALOGV("%s: Camera %s: Successfully created a new stream ID %d for output surface"
Shuzhen Wang0129d522016-10-30 22:43:41 -0700975 " (%d x %d) with format 0x%x.",
Shuzhen Wang758c2152017-01-10 18:26:18 -0800976 __FUNCTION__, mCameraIdStr.string(), streamId, streamInfo.width,
977 streamInfo.height, streamInfo.format);
Igor Murashkinf8b2a6f2013-09-17 17:03:28 -0700978
Zhijun He5d677d12016-05-29 16:52:39 -0700979 // Set transform flags to ensure preview to be rotated correctly.
980 res = setStreamTransformLocked(streamId);
Igor Murashkinf8b2a6f2013-09-17 17:03:28 -0700981
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800982 // Fill in mHighResolutionCameraIdToStreamIdSet map
983 const String8 &cameraIdUsed =
984 physicalCameraId.size() != 0 ? physicalCameraId : mCameraIdStr;
985 const char *cameraIdUsedCStr = cameraIdUsed.string();
986 // Only needed for high resolution sensors
987 if (mHighResolutionSensors.find(cameraIdUsedCStr) !=
988 mHighResolutionSensors.end()) {
989 mHighResolutionCameraIdToStreamIdSet[cameraIdUsedCStr].insert(streamId);
990 }
991
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -0800992 *newStreamId = streamId;
Igor Murashkine7ee7632013-06-11 18:10:18 -0700993 }
994
995 return res;
996}
997
Zhijun He5d677d12016-05-29 16:52:39 -0700998binder::Status CameraDeviceClient::createDeferredSurfaceStreamLocked(
999 const hardware::camera2::params::OutputConfiguration &outputConfiguration,
Shuzhen Wang758c2152017-01-10 18:26:18 -08001000 bool isShared,
Zhijun He5d677d12016-05-29 16:52:39 -07001001 /*out*/
1002 int* newStreamId) {
1003 int width, height, format, surfaceType;
Emilian Peev050f5dc2017-05-18 14:43:56 +01001004 uint64_t consumerUsage;
Zhijun He5d677d12016-05-29 16:52:39 -07001005 android_dataspace dataSpace;
1006 status_t err;
1007 binder::Status res;
1008
1009 if (!mDevice.get()) {
1010 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
1011 }
1012
1013 // Infer the surface info for deferred surface stream creation.
1014 width = outputConfiguration.getWidth();
1015 height = outputConfiguration.getHeight();
1016 surfaceType = outputConfiguration.getSurfaceType();
1017 format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
1018 dataSpace = android_dataspace_t::HAL_DATASPACE_UNKNOWN;
1019 // Hardcode consumer usage flags: SurfaceView--0x900, SurfaceTexture--0x100.
1020 consumerUsage = GraphicBuffer::USAGE_HW_TEXTURE;
1021 if (surfaceType == OutputConfiguration::SURFACE_TYPE_SURFACE_VIEW) {
1022 consumerUsage |= GraphicBuffer::USAGE_HW_COMPOSER;
1023 }
1024 int streamId = camera3::CAMERA3_STREAM_ID_INVALID;
Shuzhen Wang0129d522016-10-30 22:43:41 -07001025 std::vector<sp<Surface>> noSurface;
Emilian Peev40ead602017-09-26 15:46:36 +01001026 std::vector<int> surfaceIds;
Shuzhen Wangc28189a2017-11-27 23:05:10 -08001027 String8 physicalCameraId(outputConfiguration.getPhysicalCameraId());
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001028 const String8 &cameraIdUsed =
1029 physicalCameraId.size() != 0 ? physicalCameraId : mCameraIdStr;
1030 // Here, we override sensor pixel modes
1031 std::unordered_set<int32_t> overriddenSensorPixelModesUsed;
1032 const std::vector<int32_t> &sensorPixelModesUsed =
1033 outputConfiguration.getSensorPixelModesUsed();
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001034 if (SessionConfigurationUtils::checkAndOverrideSensorPixelModesUsed(
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001035 sensorPixelModesUsed, format, width, height, getStaticInfo(cameraIdUsed),
1036 /*allowRounding*/ false, &overriddenSensorPixelModesUsed) != OK) {
1037 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
1038 "sensor pixel modes used not valid for deferred stream");
1039 }
1040
Shuzhen Wang0129d522016-10-30 22:43:41 -07001041 err = mDevice->createStream(noSurface, /*hasDeferredConsumer*/true, width,
1042 height, format, dataSpace,
Emilian Peevf4816702020-04-03 15:44:51 -07001043 static_cast<camera_stream_rotation_t>(outputConfiguration.getRotation()),
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001044 &streamId, physicalCameraId,
1045 overriddenSensorPixelModesUsed,
1046 &surfaceIds,
Shuzhen Wangc28189a2017-11-27 23:05:10 -08001047 outputConfiguration.getSurfaceSetID(), isShared,
Emilian Peev2295df72021-11-12 18:14:10 -08001048 outputConfiguration.isMultiResolution(), consumerUsage,
Shuzhen Wangc8ab4522021-12-14 20:12:42 -08001049 outputConfiguration.getDynamicRangeProfile(),
1050 outputConfiguration.getStreamUseCase());
Zhijun He5d677d12016-05-29 16:52:39 -07001051
1052 if (err != OK) {
1053 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001054 "Camera %s: Error creating output stream (%d x %d, fmt %x, dataSpace %x): %s (%d)",
1055 mCameraIdStr.string(), width, height, format, dataSpace, strerror(-err), err);
Zhijun He5d677d12016-05-29 16:52:39 -07001056 } else {
1057 // Can not add streamId to mStreamMap here, as the surface is deferred. Add it to
1058 // a separate list to track. Once the deferred surface is set, this id will be
1059 // relocated to mStreamMap.
1060 mDeferredStreams.push_back(streamId);
Shuzhen Wang758c2152017-01-10 18:26:18 -08001061 mStreamInfoMap.emplace(std::piecewise_construct, std::forward_as_tuple(streamId),
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001062 std::forward_as_tuple(width, height, format, dataSpace, consumerUsage,
Emilian Peev2295df72021-11-12 18:14:10 -08001063 overriddenSensorPixelModesUsed,
Shuzhen Wangc8ab4522021-12-14 20:12:42 -08001064 outputConfiguration.getDynamicRangeProfile(),
1065 outputConfiguration.getStreamUseCase()));
Shuzhen Wang758c2152017-01-10 18:26:18 -08001066
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001067 ALOGV("%s: Camera %s: Successfully created a new stream ID %d for a deferred surface"
Zhijun He5d677d12016-05-29 16:52:39 -07001068 " (%d x %d) stream with format 0x%x.",
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001069 __FUNCTION__, mCameraIdStr.string(), streamId, width, height, format);
Zhijun He5d677d12016-05-29 16:52:39 -07001070
1071 // Set transform flags to ensure preview to be rotated correctly.
1072 res = setStreamTransformLocked(streamId);
1073
1074 *newStreamId = streamId;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001075 // Fill in mHighResolutionCameraIdToStreamIdSet
1076 const char *cameraIdUsedCStr = cameraIdUsed.string();
1077 // Only needed for high resolution sensors
1078 if (mHighResolutionSensors.find(cameraIdUsedCStr) !=
1079 mHighResolutionSensors.end()) {
1080 mHighResolutionCameraIdToStreamIdSet[cameraIdUsed.string()].insert(streamId);
1081 }
Zhijun He5d677d12016-05-29 16:52:39 -07001082 }
1083 return res;
1084}
1085
1086binder::Status CameraDeviceClient::setStreamTransformLocked(int streamId) {
1087 int32_t transform = 0;
1088 status_t err;
1089 binder::Status res;
1090
1091 if (!mDevice.get()) {
1092 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
1093 }
1094
1095 err = getRotationTransformLocked(&transform);
1096 if (err != OK) {
1097 // Error logged by getRotationTransformLocked.
1098 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION,
1099 "Unable to calculate rotation transform for new stream");
1100 }
1101
1102 err = mDevice->setStreamTransform(streamId, transform);
1103 if (err != OK) {
1104 String8 msg = String8::format("Failed to set stream transform (stream id %d)",
1105 streamId);
1106 ALOGE("%s: %s", __FUNCTION__, msg.string());
1107 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
1108 }
1109
1110 return res;
1111}
Ruben Brunkbba75572014-11-20 17:29:50 -08001112
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001113binder::Status CameraDeviceClient::createInputStream(
Shuzhen Wang83bff122020-11-20 15:51:39 -08001114 int width, int height, int format, bool isMultiResolution,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001115 /*out*/
1116 int32_t* newStreamId) {
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001117
1118 ATRACE_CALL();
Shuzhen Wang83bff122020-11-20 15:51:39 -08001119 ALOGV("%s (w = %d, h = %d, f = 0x%x, isMultiResolution %d)", __FUNCTION__,
1120 width, height, format, isMultiResolution);
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001121
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001122 binder::Status res;
1123 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001124
1125 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001126
1127 if (!mDevice.get()) {
1128 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
1129 }
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001130
1131 if (mInputStream.configured) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001132 String8 msg = String8::format("Camera %s: Already has an input stream "
Yi Kong0f414de2017-12-15 13:48:50 -08001133 "configured (ID %d)", mCameraIdStr.string(), mInputStream.id);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001134 ALOGE("%s: %s", __FUNCTION__, msg.string() );
1135 return STATUS_ERROR(CameraService::ERROR_ALREADY_EXISTS, msg.string());
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001136 }
1137
1138 int streamId = -1;
Shuzhen Wang83bff122020-11-20 15:51:39 -08001139 status_t err = mDevice->createInputStream(width, height, format, isMultiResolution, &streamId);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001140 if (err == OK) {
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001141 mInputStream.configured = true;
1142 mInputStream.width = width;
1143 mInputStream.height = height;
1144 mInputStream.format = format;
1145 mInputStream.id = streamId;
1146
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001147 ALOGV("%s: Camera %s: Successfully created a new input stream ID %d",
1148 __FUNCTION__, mCameraIdStr.string(), streamId);
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001149
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001150 *newStreamId = streamId;
1151 } else {
1152 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001153 "Camera %s: Error creating new input stream: %s (%d)", mCameraIdStr.string(),
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001154 strerror(-err), err);
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001155 }
1156
1157 return res;
1158}
1159
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001160binder::Status CameraDeviceClient::getInputSurface(/*out*/ view::Surface *inputSurface) {
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001161
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001162 binder::Status res;
1163 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
1164
1165 if (inputSurface == NULL) {
1166 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Null input surface");
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001167 }
1168
1169 Mutex::Autolock icl(mBinderSerializationLock);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001170 if (!mDevice.get()) {
1171 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
1172 }
1173 sp<IGraphicBufferProducer> producer;
1174 status_t err = mDevice->getInputBufferProducer(&producer);
1175 if (err != OK) {
1176 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001177 "Camera %s: Error getting input Surface: %s (%d)",
1178 mCameraIdStr.string(), strerror(-err), err);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001179 } else {
1180 inputSurface->name = String16("CameraInput");
1181 inputSurface->graphicBufferProducer = producer;
1182 }
1183 return res;
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001184}
1185
Emilian Peev40ead602017-09-26 15:46:36 +01001186binder::Status CameraDeviceClient::updateOutputConfiguration(int streamId,
1187 const hardware::camera2::params::OutputConfiguration &outputConfiguration) {
1188 ATRACE_CALL();
1189
1190 binder::Status res;
1191 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
1192
1193 Mutex::Autolock icl(mBinderSerializationLock);
1194
1195 if (!mDevice.get()) {
1196 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
1197 }
1198
1199 const std::vector<sp<IGraphicBufferProducer> >& bufferProducers =
1200 outputConfiguration.getGraphicBufferProducers();
Shuzhen Wang2e7f58f2018-07-11 14:00:29 -07001201 String8 physicalCameraId(outputConfiguration.getPhysicalCameraId());
1202
Emilian Peev40ead602017-09-26 15:46:36 +01001203 auto producerCount = bufferProducers.size();
1204 if (producerCount == 0) {
1205 ALOGE("%s: bufferProducers must not be empty", __FUNCTION__);
1206 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
1207 "bufferProducers must not be empty");
1208 }
1209
1210 // The first output is the one associated with the output configuration.
1211 // It should always be present, valid and the corresponding stream id should match.
1212 sp<IBinder> binder = IInterface::asBinder(bufferProducers[0]);
1213 ssize_t index = mStreamMap.indexOfKey(binder);
1214 if (index == NAME_NOT_FOUND) {
1215 ALOGE("%s: Outputconfiguration is invalid", __FUNCTION__);
1216 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
1217 "OutputConfiguration is invalid");
1218 }
1219 if (mStreamMap.valueFor(binder).streamId() != streamId) {
1220 ALOGE("%s: Stream Id: %d provided doesn't match the id: %d in the stream map",
1221 __FUNCTION__, streamId, mStreamMap.valueFor(binder).streamId());
1222 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
1223 "Stream id is invalid");
1224 }
1225
1226 std::vector<size_t> removedSurfaceIds;
1227 std::vector<sp<IBinder>> removedOutputs;
1228 std::vector<sp<Surface>> newOutputs;
1229 std::vector<OutputStreamInfo> streamInfos;
1230 KeyedVector<sp<IBinder>, sp<IGraphicBufferProducer>> newOutputsMap;
1231 for (auto &it : bufferProducers) {
1232 newOutputsMap.add(IInterface::asBinder(it), it);
1233 }
1234
1235 for (size_t i = 0; i < mStreamMap.size(); i++) {
1236 ssize_t idx = newOutputsMap.indexOfKey(mStreamMap.keyAt(i));
1237 if (idx == NAME_NOT_FOUND) {
1238 if (mStreamMap[i].streamId() == streamId) {
1239 removedSurfaceIds.push_back(mStreamMap[i].surfaceId());
1240 removedOutputs.push_back(mStreamMap.keyAt(i));
1241 }
1242 } else {
1243 if (mStreamMap[i].streamId() != streamId) {
1244 ALOGE("%s: Output surface already part of a different stream", __FUNCTION__);
1245 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
1246 "Target Surface is invalid");
1247 }
1248 newOutputsMap.removeItemsAt(idx);
1249 }
1250 }
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001251 const std::vector<int32_t> &sensorPixelModesUsed =
1252 outputConfiguration.getSensorPixelModesUsed();
Shuzhen Wangc8ab4522021-12-14 20:12:42 -08001253 int streamUseCase = outputConfiguration.getStreamUseCase();
Emilian Peev40ead602017-09-26 15:46:36 +01001254
Emilian Peev2295df72021-11-12 18:14:10 -08001255 int dynamicRangeProfile = outputConfiguration.getDynamicRangeProfile();
1256
Emilian Peev40ead602017-09-26 15:46:36 +01001257 for (size_t i = 0; i < newOutputsMap.size(); i++) {
1258 OutputStreamInfo outInfo;
1259 sp<Surface> surface;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001260 res = SessionConfigurationUtils::createSurfaceFromGbp(outInfo,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001261 /*isStreamInfoValid*/ false, surface, newOutputsMap.valueAt(i), mCameraIdStr,
Shuzhen Wangc8ab4522021-12-14 20:12:42 -08001262 mDevice->infoPhysical(physicalCameraId), sensorPixelModesUsed, dynamicRangeProfile,
1263 streamUseCase);
Emilian Peev40ead602017-09-26 15:46:36 +01001264 if (!res.isOk())
1265 return res;
1266
Emilian Peev40ead602017-09-26 15:46:36 +01001267 streamInfos.push_back(outInfo);
1268 newOutputs.push_back(surface);
1269 }
1270
1271 //Trivial case no changes required
1272 if (removedSurfaceIds.empty() && newOutputs.empty()) {
1273 return binder::Status::ok();
1274 }
1275
1276 KeyedVector<sp<Surface>, size_t> outputMap;
1277 auto ret = mDevice->updateStream(streamId, newOutputs, streamInfos, removedSurfaceIds,
1278 &outputMap);
1279 if (ret != OK) {
1280 switch (ret) {
1281 case NAME_NOT_FOUND:
1282 case BAD_VALUE:
1283 case -EBUSY:
1284 res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
1285 "Camera %s: Error updating stream: %s (%d)",
1286 mCameraIdStr.string(), strerror(ret), ret);
1287 break;
1288 default:
1289 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
1290 "Camera %s: Error updating stream: %s (%d)",
1291 mCameraIdStr.string(), strerror(ret), ret);
1292 break;
1293 }
1294 } else {
1295 for (const auto &it : removedOutputs) {
1296 mStreamMap.removeItem(it);
1297 }
1298
1299 for (size_t i = 0; i < outputMap.size(); i++) {
1300 mStreamMap.add(IInterface::asBinder(outputMap.keyAt(i)->getIGraphicBufferProducer()),
1301 StreamSurfaceId(streamId, outputMap.valueAt(i)));
1302 }
1303
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -08001304 mConfiguredOutputs.replaceValueFor(streamId, outputConfiguration);
1305
Emilian Peev40ead602017-09-26 15:46:36 +01001306 ALOGV("%s: Camera %s: Successful stream ID %d update",
1307 __FUNCTION__, mCameraIdStr.string(), streamId);
1308 }
1309
1310 return res;
1311}
1312
Igor Murashkine7ee7632013-06-11 18:10:18 -07001313// Create a request object from a template.
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001314binder::Status CameraDeviceClient::createDefaultRequest(int templateId,
1315 /*out*/
1316 hardware::camera2::impl::CameraMetadataNative* request)
Igor Murashkine7ee7632013-06-11 18:10:18 -07001317{
1318 ATRACE_CALL();
1319 ALOGV("%s (templateId = 0x%x)", __FUNCTION__, templateId);
1320
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001321 binder::Status res;
1322 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
Igor Murashkine7ee7632013-06-11 18:10:18 -07001323
1324 Mutex::Autolock icl(mBinderSerializationLock);
1325
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001326 if (!mDevice.get()) {
1327 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
1328 }
Igor Murashkine7ee7632013-06-11 18:10:18 -07001329
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001330 status_t err;
Emilian Peevf4816702020-04-03 15:44:51 -07001331 camera_request_template_t tempId = camera_request_template_t::CAMERA_TEMPLATE_COUNT;
1332 if (!(res = mapRequestTemplate(templateId, &tempId)).isOk()) return res;
1333
1334 CameraMetadata metadata;
1335 if ( (err = mDevice->createDefaultRequest(tempId, &metadata) ) == OK &&
Igor Murashkine7ee7632013-06-11 18:10:18 -07001336 request != NULL) {
1337
1338 request->swap(metadata);
Chien-Yu Chen9cd14022016-03-09 12:21:01 -08001339 } else if (err == BAD_VALUE) {
1340 res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001341 "Camera %s: Template ID %d is invalid or not supported: %s (%d)",
1342 mCameraIdStr.string(), templateId, strerror(-err), err);
Chien-Yu Chen9cd14022016-03-09 12:21:01 -08001343
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001344 } else {
1345 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001346 "Camera %s: Error creating default request for template %d: %s (%d)",
1347 mCameraIdStr.string(), templateId, strerror(-err), err);
Igor Murashkine7ee7632013-06-11 18:10:18 -07001348 }
Igor Murashkine7ee7632013-06-11 18:10:18 -07001349 return res;
1350}
1351
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001352binder::Status CameraDeviceClient::getCameraInfo(
1353 /*out*/
1354 hardware::camera2::impl::CameraMetadataNative* info)
Igor Murashkine7ee7632013-06-11 18:10:18 -07001355{
1356 ATRACE_CALL();
1357 ALOGV("%s", __FUNCTION__);
1358
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001359 binder::Status res;
Igor Murashkine7ee7632013-06-11 18:10:18 -07001360
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001361 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
Igor Murashkine7ee7632013-06-11 18:10:18 -07001362
1363 Mutex::Autolock icl(mBinderSerializationLock);
1364
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001365 if (!mDevice.get()) {
1366 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
1367 }
Igor Murashkine7ee7632013-06-11 18:10:18 -07001368
Igor Murashkin099b4572013-07-12 17:52:16 -07001369 if (info != NULL) {
1370 *info = mDevice->info(); // static camera metadata
1371 // TODO: merge with device-specific camera metadata
1372 }
Igor Murashkine7ee7632013-06-11 18:10:18 -07001373
1374 return res;
1375}
1376
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001377binder::Status CameraDeviceClient::waitUntilIdle()
Zhijun He2ab500c2013-07-23 08:02:53 -07001378{
1379 ATRACE_CALL();
1380 ALOGV("%s", __FUNCTION__);
1381
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001382 binder::Status res;
1383 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
Zhijun He2ab500c2013-07-23 08:02:53 -07001384
1385 Mutex::Autolock icl(mBinderSerializationLock);
1386
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001387 if (!mDevice.get()) {
1388 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
1389 }
Zhijun He2ab500c2013-07-23 08:02:53 -07001390
1391 // FIXME: Also need check repeating burst.
Shuzhen Wangc9ca6782016-04-26 13:40:31 -07001392 Mutex::Autolock idLock(mStreamingRequestIdLock);
Chien-Yu Chene8c535e2016-04-14 12:18:26 -07001393 if (mStreamingRequestId != REQUEST_ID_NONE) {
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001394 String8 msg = String8::format(
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001395 "Camera %s: Try to waitUntilIdle when there are active streaming requests",
1396 mCameraIdStr.string());
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001397 ALOGE("%s: %s", __FUNCTION__, msg.string());
1398 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
Zhijun He2ab500c2013-07-23 08:02:53 -07001399 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001400 status_t err = mDevice->waitUntilDrained();
1401 if (err != OK) {
1402 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001403 "Camera %s: Error waiting to drain: %s (%d)",
1404 mCameraIdStr.string(), strerror(-err), err);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001405 }
Zhijun He2ab500c2013-07-23 08:02:53 -07001406 ALOGV("%s Done", __FUNCTION__);
Zhijun He2ab500c2013-07-23 08:02:53 -07001407 return res;
1408}
1409
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001410binder::Status CameraDeviceClient::flush(
1411 /*out*/
1412 int64_t* lastFrameNumber) {
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -07001413 ATRACE_CALL();
1414 ALOGV("%s", __FUNCTION__);
1415
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001416 binder::Status res;
1417 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -07001418
1419 Mutex::Autolock icl(mBinderSerializationLock);
1420
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001421 if (!mDevice.get()) {
1422 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
1423 }
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -07001424
Shuzhen Wangc9ca6782016-04-26 13:40:31 -07001425 Mutex::Autolock idLock(mStreamingRequestIdLock);
Chien-Yu Chene8c535e2016-04-14 12:18:26 -07001426 mStreamingRequestId = REQUEST_ID_NONE;
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001427 status_t err = mDevice->flush(lastFrameNumber);
1428 if (err != OK) {
1429 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001430 "Camera %s: Error flushing device: %s (%d)", mCameraIdStr.string(), strerror(-err), err);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001431 }
1432 return res;
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -07001433}
1434
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001435binder::Status CameraDeviceClient::prepare(int streamId) {
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001436 ATRACE_CALL();
1437 ALOGV("%s", __FUNCTION__);
1438
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001439 binder::Status res;
1440 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001441
1442 Mutex::Autolock icl(mBinderSerializationLock);
1443
1444 // Guard against trying to prepare non-created streams
1445 ssize_t index = NAME_NOT_FOUND;
1446 for (size_t i = 0; i < mStreamMap.size(); ++i) {
Shuzhen Wang0129d522016-10-30 22:43:41 -07001447 if (streamId == mStreamMap.valueAt(i).streamId()) {
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001448 index = i;
1449 break;
1450 }
1451 }
1452
1453 if (index == NAME_NOT_FOUND) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001454 String8 msg = String8::format("Camera %s: Invalid stream ID (%d) specified, no stream "
1455 "with that ID exists", mCameraIdStr.string(), streamId);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001456 ALOGW("%s: %s", __FUNCTION__, msg.string());
1457 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001458 }
1459
Eino-Ville Talvala261394e2015-05-13 14:28:38 -07001460 // Also returns BAD_VALUE if stream ID was not valid, or stream already
1461 // has been used
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001462 status_t err = mDevice->prepare(streamId);
1463 if (err == BAD_VALUE) {
1464 res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001465 "Camera %s: Stream %d has already been used, and cannot be prepared",
1466 mCameraIdStr.string(), streamId);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001467 } else if (err != OK) {
1468 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001469 "Camera %s: Error preparing stream %d: %s (%d)", mCameraIdStr.string(), streamId,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001470 strerror(-err), err);
1471 }
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001472 return res;
1473}
1474
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001475binder::Status CameraDeviceClient::prepare2(int maxCount, int streamId) {
Ruben Brunkc78ac262015-08-13 17:58:46 -07001476 ATRACE_CALL();
1477 ALOGV("%s", __FUNCTION__);
1478
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001479 binder::Status res;
1480 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
Ruben Brunkc78ac262015-08-13 17:58:46 -07001481
1482 Mutex::Autolock icl(mBinderSerializationLock);
1483
1484 // Guard against trying to prepare non-created streams
1485 ssize_t index = NAME_NOT_FOUND;
1486 for (size_t i = 0; i < mStreamMap.size(); ++i) {
Shuzhen Wang0129d522016-10-30 22:43:41 -07001487 if (streamId == mStreamMap.valueAt(i).streamId()) {
Ruben Brunkc78ac262015-08-13 17:58:46 -07001488 index = i;
1489 break;
1490 }
1491 }
1492
1493 if (index == NAME_NOT_FOUND) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001494 String8 msg = String8::format("Camera %s: Invalid stream ID (%d) specified, no stream "
1495 "with that ID exists", mCameraIdStr.string(), streamId);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001496 ALOGW("%s: %s", __FUNCTION__, msg.string());
1497 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
Ruben Brunkc78ac262015-08-13 17:58:46 -07001498 }
1499
1500 if (maxCount <= 0) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001501 String8 msg = String8::format("Camera %s: maxCount (%d) must be greater than 0",
1502 mCameraIdStr.string(), maxCount);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001503 ALOGE("%s: %s", __FUNCTION__, msg.string());
1504 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
Ruben Brunkc78ac262015-08-13 17:58:46 -07001505 }
1506
1507 // Also returns BAD_VALUE if stream ID was not valid, or stream already
1508 // has been used
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001509 status_t err = mDevice->prepare(maxCount, streamId);
1510 if (err == BAD_VALUE) {
1511 res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001512 "Camera %s: Stream %d has already been used, and cannot be prepared",
1513 mCameraIdStr.string(), streamId);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001514 } else if (err != OK) {
1515 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001516 "Camera %s: Error preparing stream %d: %s (%d)", mCameraIdStr.string(), streamId,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001517 strerror(-err), err);
1518 }
Ruben Brunkc78ac262015-08-13 17:58:46 -07001519
1520 return res;
1521}
1522
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001523binder::Status CameraDeviceClient::tearDown(int streamId) {
Eino-Ville Talvalab25e3c82015-07-15 16:04:27 -07001524 ATRACE_CALL();
1525 ALOGV("%s", __FUNCTION__);
1526
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001527 binder::Status res;
1528 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
Eino-Ville Talvalab25e3c82015-07-15 16:04:27 -07001529
1530 Mutex::Autolock icl(mBinderSerializationLock);
1531
1532 // Guard against trying to prepare non-created streams
1533 ssize_t index = NAME_NOT_FOUND;
1534 for (size_t i = 0; i < mStreamMap.size(); ++i) {
Shuzhen Wang0129d522016-10-30 22:43:41 -07001535 if (streamId == mStreamMap.valueAt(i).streamId()) {
Eino-Ville Talvalab25e3c82015-07-15 16:04:27 -07001536 index = i;
1537 break;
1538 }
1539 }
1540
1541 if (index == NAME_NOT_FOUND) {
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001542 String8 msg = String8::format("Camera %s: Invalid stream ID (%d) specified, no stream "
1543 "with that ID exists", mCameraIdStr.string(), streamId);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001544 ALOGW("%s: %s", __FUNCTION__, msg.string());
1545 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
Eino-Ville Talvalab25e3c82015-07-15 16:04:27 -07001546 }
1547
1548 // Also returns BAD_VALUE if stream ID was not valid or if the stream is in
1549 // use
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001550 status_t err = mDevice->tearDown(streamId);
1551 if (err == BAD_VALUE) {
1552 res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001553 "Camera %s: Stream %d is still in use, cannot be torn down",
1554 mCameraIdStr.string(), streamId);
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001555 } else if (err != OK) {
1556 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001557 "Camera %s: Error tearing down stream %d: %s (%d)", mCameraIdStr.string(), streamId,
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001558 strerror(-err), err);
1559 }
Eino-Ville Talvalab25e3c82015-07-15 16:04:27 -07001560
1561 return res;
1562}
1563
Shuzhen Wang758c2152017-01-10 18:26:18 -08001564binder::Status CameraDeviceClient::finalizeOutputConfigurations(int32_t streamId,
Zhijun He5d677d12016-05-29 16:52:39 -07001565 const hardware::camera2::params::OutputConfiguration &outputConfiguration) {
1566 ATRACE_CALL();
1567
1568 binder::Status res;
1569 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
1570
1571 Mutex::Autolock icl(mBinderSerializationLock);
1572
Shuzhen Wang0129d522016-10-30 22:43:41 -07001573 const std::vector<sp<IGraphicBufferProducer> >& bufferProducers =
1574 outputConfiguration.getGraphicBufferProducers();
Shuzhen Wang2e7f58f2018-07-11 14:00:29 -07001575 String8 physicalId(outputConfiguration.getPhysicalCameraId());
Zhijun He5d677d12016-05-29 16:52:39 -07001576
Shuzhen Wang0129d522016-10-30 22:43:41 -07001577 if (bufferProducers.size() == 0) {
1578 ALOGE("%s: bufferProducers must not be empty", __FUNCTION__);
Zhijun He5d677d12016-05-29 16:52:39 -07001579 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Target Surface is invalid");
1580 }
Shuzhen Wang0129d522016-10-30 22:43:41 -07001581
Shuzhen Wang758c2152017-01-10 18:26:18 -08001582 // streamId should be in mStreamMap if this stream already has a surface attached
1583 // to it. Otherwise, it should be in mDeferredStreams.
1584 bool streamIdConfigured = false;
1585 ssize_t deferredStreamIndex = NAME_NOT_FOUND;
1586 for (size_t i = 0; i < mStreamMap.size(); i++) {
1587 if (mStreamMap.valueAt(i).streamId() == streamId) {
1588 streamIdConfigured = true;
1589 break;
1590 }
Zhijun He5d677d12016-05-29 16:52:39 -07001591 }
Shuzhen Wang758c2152017-01-10 18:26:18 -08001592 for (size_t i = 0; i < mDeferredStreams.size(); i++) {
1593 if (streamId == mDeferredStreams[i]) {
1594 deferredStreamIndex = i;
1595 break;
Shuzhen Wang0129d522016-10-30 22:43:41 -07001596 }
1597
Shuzhen Wang758c2152017-01-10 18:26:18 -08001598 }
1599 if (deferredStreamIndex == NAME_NOT_FOUND && !streamIdConfigured) {
1600 String8 msg = String8::format("Camera %s: deferred surface is set to a unknown stream"
1601 "(ID %d)", mCameraIdStr.string(), streamId);
1602 ALOGW("%s: %s", __FUNCTION__, msg.string());
1603 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
Zhijun He5d677d12016-05-29 16:52:39 -07001604 }
1605
Shuzhen Wang88fd0052017-02-09 16:40:07 -08001606 if (mStreamInfoMap[streamId].finalized) {
1607 String8 msg = String8::format("Camera %s: finalizeOutputConfigurations has been called"
1608 " on stream ID %d", mCameraIdStr.string(), streamId);
1609 ALOGW("%s: %s", __FUNCTION__, msg.string());
1610 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
1611 }
1612
Zhijun He5d677d12016-05-29 16:52:39 -07001613 if (!mDevice.get()) {
1614 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
1615 }
1616
Shuzhen Wang758c2152017-01-10 18:26:18 -08001617 std::vector<sp<Surface>> consumerSurfaces;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08001618 const std::vector<int32_t> &sensorPixelModesUsed =
1619 outputConfiguration.getSensorPixelModesUsed();
Emilian Peev2295df72021-11-12 18:14:10 -08001620 int dynamicRangeProfile = outputConfiguration.getDynamicRangeProfile();
Shuzhen Wangc8ab4522021-12-14 20:12:42 -08001621 int streamUseCase= outputConfiguration.getStreamUseCase();
Shuzhen Wang758c2152017-01-10 18:26:18 -08001622 for (auto& bufferProducer : bufferProducers) {
1623 // Don't create multiple streams for the same target surface
Zhijun He5d677d12016-05-29 16:52:39 -07001624 ssize_t index = mStreamMap.indexOfKey(IInterface::asBinder(bufferProducer));
1625 if (index != NAME_NOT_FOUND) {
Shuzhen Wang758c2152017-01-10 18:26:18 -08001626 ALOGV("Camera %s: Surface already has a stream created "
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001627 " for it (ID %zd)", mCameraIdStr.string(), index);
Shuzhen Wang758c2152017-01-10 18:26:18 -08001628 continue;
Zhijun He5d677d12016-05-29 16:52:39 -07001629 }
Shuzhen Wang758c2152017-01-10 18:26:18 -08001630
1631 sp<Surface> surface;
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07001632 res = SessionConfigurationUtils::createSurfaceFromGbp(mStreamInfoMap[streamId],
Colin Crossb8a9dbb2020-08-27 04:12:26 +00001633 true /*isStreamInfoValid*/, surface, bufferProducer, mCameraIdStr,
Shuzhen Wangc8ab4522021-12-14 20:12:42 -08001634 mDevice->infoPhysical(physicalId), sensorPixelModesUsed, dynamicRangeProfile,
1635 streamUseCase);
Shuzhen Wang758c2152017-01-10 18:26:18 -08001636
1637 if (!res.isOk())
1638 return res;
1639
1640 consumerSurfaces.push_back(surface);
Zhijun He5d677d12016-05-29 16:52:39 -07001641 }
1642
Shuzhen Wanga81ce342017-04-13 15:18:36 -07001643 // Gracefully handle case where finalizeOutputConfigurations is called
1644 // without any new surface.
1645 if (consumerSurfaces.size() == 0) {
1646 mStreamInfoMap[streamId].finalized = true;
1647 return res;
1648 }
1649
Zhijun He5d677d12016-05-29 16:52:39 -07001650 // Finish the deferred stream configuration with the surface.
Shuzhen Wang758c2152017-01-10 18:26:18 -08001651 status_t err;
Emilian Peev40ead602017-09-26 15:46:36 +01001652 std::vector<int> consumerSurfaceIds;
1653 err = mDevice->setConsumerSurfaces(streamId, consumerSurfaces, &consumerSurfaceIds);
Zhijun He5d677d12016-05-29 16:52:39 -07001654 if (err == OK) {
Shuzhen Wang758c2152017-01-10 18:26:18 -08001655 for (size_t i = 0; i < consumerSurfaces.size(); i++) {
1656 sp<IBinder> binder = IInterface::asBinder(
1657 consumerSurfaces[i]->getIGraphicBufferProducer());
Emilian Peev40ead602017-09-26 15:46:36 +01001658 ALOGV("%s: mStreamMap add binder %p streamId %d, surfaceId %d", __FUNCTION__,
Shuzhen Wang758c2152017-01-10 18:26:18 -08001659 binder.get(), streamId, consumerSurfaceIds[i]);
1660 mStreamMap.add(binder, StreamSurfaceId(streamId, consumerSurfaceIds[i]));
1661 }
1662 if (deferredStreamIndex != NAME_NOT_FOUND) {
1663 mDeferredStreams.removeItemsAt(deferredStreamIndex);
Shuzhen Wang0129d522016-10-30 22:43:41 -07001664 }
Shuzhen Wang88fd0052017-02-09 16:40:07 -08001665 mStreamInfoMap[streamId].finalized = true;
Yin-Chia Yeh4dfa4cc2017-11-10 20:00:09 -08001666 mConfiguredOutputs.replaceValueFor(streamId, outputConfiguration);
Zhijun He5d677d12016-05-29 16:52:39 -07001667 } else if (err == NO_INIT) {
1668 res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001669 "Camera %s: Deferred surface is invalid: %s (%d)",
1670 mCameraIdStr.string(), strerror(-err), err);
Zhijun He5d677d12016-05-29 16:52:39 -07001671 } else {
1672 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001673 "Camera %s: Error setting output stream deferred surface: %s (%d)",
1674 mCameraIdStr.string(), strerror(-err), err);
Zhijun He5d677d12016-05-29 16:52:39 -07001675 }
1676
1677 return res;
1678}
1679
Yin-Chia Yehcfab4e12019-09-09 13:08:28 -07001680binder::Status CameraDeviceClient::setCameraAudioRestriction(int32_t mode) {
Yin-Chia Yehdba03232019-08-19 15:54:28 -07001681 ATRACE_CALL();
1682 binder::Status res;
1683 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
1684
1685 if (!isValidAudioRestriction(mode)) {
1686 String8 msg = String8::format("Camera %s: invalid audio restriction mode %d",
1687 mCameraIdStr.string(), mode);
1688 ALOGW("%s: %s", __FUNCTION__, msg.string());
1689 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
1690 }
1691
1692 Mutex::Autolock icl(mBinderSerializationLock);
Yin-Chia Yehcfab4e12019-09-09 13:08:28 -07001693 BasicClient::setAudioRestriction(mode);
1694 return binder::Status::ok();
1695}
1696
1697binder::Status CameraDeviceClient::getGlobalAudioRestriction(/*out*/ int32_t* outMode) {
1698 ATRACE_CALL();
1699 binder::Status res;
1700 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
1701 Mutex::Autolock icl(mBinderSerializationLock);
Yin-Chia Yehdba03232019-08-19 15:54:28 -07001702 if (outMode != nullptr) {
Yin-Chia Yehcfab4e12019-09-09 13:08:28 -07001703 *outMode = BasicClient::getServiceAudioRestriction();
Yin-Chia Yehdba03232019-08-19 15:54:28 -07001704 }
1705 return binder::Status::ok();
1706}
1707
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -08001708status_t CameraDeviceClient::setRotateAndCropOverride(uint8_t rotateAndCrop) {
1709 if (rotateAndCrop > ANDROID_SCALER_ROTATE_AND_CROP_AUTO) return BAD_VALUE;
1710
1711 return mDevice->setRotateAndCropAutoBehavior(
1712 static_cast<camera_metadata_enum_android_scaler_rotate_and_crop_t>(rotateAndCrop));
1713}
1714
Eino-Ville Talvala305cec62020-11-12 14:18:17 -08001715bool CameraDeviceClient::supportsCameraMute() {
1716 return mDevice->supportsCameraMute();
1717}
1718
1719status_t CameraDeviceClient::setCameraMute(bool enabled) {
1720 return mDevice->setCameraMute(enabled);
1721}
1722
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001723binder::Status CameraDeviceClient::switchToOffline(
1724 const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb,
Emilian Peevb2bc5a42019-11-20 16:02:14 -08001725 const std::vector<int>& offlineOutputIds,
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001726 /*out*/
1727 sp<hardware::camera2::ICameraOfflineSession>* session) {
1728 ATRACE_CALL();
1729
1730 binder::Status res;
1731 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res;
1732
1733 Mutex::Autolock icl(mBinderSerializationLock);
1734
1735 if (!mDevice.get()) {
1736 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
1737 }
1738
Emilian Peevb2bc5a42019-11-20 16:02:14 -08001739 if (offlineOutputIds.empty()) {
Emilian Peevcc0b7952020-01-07 13:54:47 -08001740 String8 msg = String8::format("Offline surfaces must not be empty");
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001741 ALOGE("%s: %s", __FUNCTION__, msg.string());
1742 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
1743 }
1744
1745 if (session == nullptr) {
1746 String8 msg = String8::format("Invalid offline session");
1747 ALOGE("%s: %s", __FUNCTION__, msg.string());
1748 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
1749 }
1750
Yin-Chia Yeh87fccca2020-01-28 09:37:18 -08001751 std::vector<int32_t> offlineStreamIds;
1752 offlineStreamIds.reserve(offlineOutputIds.size());
Emilian Peev4697b642019-11-19 17:11:14 -08001753 KeyedVector<sp<IBinder>, sp<CompositeStream>> offlineCompositeStreamMap;
Emilian Peevb2bc5a42019-11-20 16:02:14 -08001754 for (const auto& streamId : offlineOutputIds) {
1755 ssize_t index = mConfiguredOutputs.indexOfKey(streamId);
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001756 if (index == NAME_NOT_FOUND) {
Emilian Peevcc0b7952020-01-07 13:54:47 -08001757 String8 msg = String8::format("Offline surface with id: %d is not registered",
1758 streamId);
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001759 ALOGE("%s: %s", __FUNCTION__, msg.string());
1760 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
1761 }
Emilian Peevcc0b7952020-01-07 13:54:47 -08001762
1763 if (!mStreamInfoMap[streamId].supportsOffline) {
1764 String8 msg = String8::format("Offline surface with id: %d doesn't support "
1765 "offline mode", streamId);
1766 ALOGE("%s: %s", __FUNCTION__, msg.string());
1767 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
1768 }
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001769
Emilian Peev2f5d6012022-01-19 16:16:50 -08001770 Mutex::Autolock l(mCompositeLock);
Emilian Peevb2bc5a42019-11-20 16:02:14 -08001771 bool isCompositeStream = false;
Emilian Peev2f5d6012022-01-19 16:16:50 -08001772 for (const auto& gbp : mConfiguredOutputs.valueAt(index).getGraphicBufferProducers()) {
Emilian Peevb2bc5a42019-11-20 16:02:14 -08001773 sp<Surface> s = new Surface(gbp, false /*controlledByApp*/);
Pirama Arumuga Nainar8db21062022-01-28 10:15:12 -08001774 isCompositeStream = camera3::DepthCompositeStream::isDepthCompositeStream(s) ||
Emilian Peevb2bc5a42019-11-20 16:02:14 -08001775 camera3::HeicCompositeStream::isHeicCompositeStream(s);
Emilian Peev4697b642019-11-19 17:11:14 -08001776 if (isCompositeStream) {
1777 auto compositeIdx = mCompositeStreamMap.indexOfKey(IInterface::asBinder(gbp));
1778 if (compositeIdx == NAME_NOT_FOUND) {
1779 ALOGE("%s: Unknown composite stream", __FUNCTION__);
1780 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT,
1781 "Unknown composite stream");
1782 }
1783
1784 mCompositeStreamMap.valueAt(compositeIdx)->insertCompositeStreamIds(
1785 &offlineStreamIds);
1786 offlineCompositeStreamMap.add(mCompositeStreamMap.keyAt(compositeIdx),
1787 mCompositeStreamMap.valueAt(compositeIdx));
1788 break;
1789 }
Emilian Peevb2bc5a42019-11-20 16:02:14 -08001790 }
1791
Emilian Peev4697b642019-11-19 17:11:14 -08001792 if (!isCompositeStream) {
Emilian Peevb2bc5a42019-11-20 16:02:14 -08001793 offlineStreamIds.push_back(streamId);
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001794 }
1795 }
1796
1797 sp<CameraOfflineSessionBase> offlineSession;
1798 auto ret = mDevice->switchToOffline(offlineStreamIds, &offlineSession);
1799 if (ret != OK) {
1800 return STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
1801 "Camera %s: Error switching to offline mode: %s (%d)",
1802 mCameraIdStr.string(), strerror(ret), ret);
1803 }
1804
Emilian Peevcc0b7952020-01-07 13:54:47 -08001805 sp<CameraOfflineSessionClient> offlineClient;
1806 if (offlineSession.get() != nullptr) {
1807 offlineClient = new CameraOfflineSessionClient(sCameraService,
1808 offlineSession, offlineCompositeStreamMap, cameraCb, mClientPackageName,
Emilian Peev8b64f282021-03-25 16:49:57 -07001809 mClientFeatureId, mCameraIdStr, mCameraFacing, mOrientation, mClientPid, mClientUid,
1810 mServicePid);
Emilian Peevcc0b7952020-01-07 13:54:47 -08001811 ret = sCameraService->addOfflineClient(mCameraIdStr, offlineClient);
1812 }
1813
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001814 if (ret == OK) {
Emilian Peevd99c8ae2019-11-26 13:19:13 -08001815 // A successful offline session switch must reset the current camera client
1816 // and release any resources occupied by previously configured streams.
1817 mStreamMap.clear();
1818 mConfiguredOutputs.clear();
1819 mDeferredStreams.clear();
1820 mStreamInfoMap.clear();
Emilian Peev2f5d6012022-01-19 16:16:50 -08001821 Mutex::Autolock l(mCompositeLock);
Emilian Peevd99c8ae2019-11-26 13:19:13 -08001822 mCompositeStreamMap.clear();
1823 mInputStream = {false, 0, 0, 0, 0};
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001824 } else {
Emilian Peevb2bc5a42019-11-20 16:02:14 -08001825 switch(ret) {
1826 case BAD_VALUE:
1827 return STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
1828 "Illegal argument to HAL module for camera \"%s\"", mCameraIdStr.c_str());
1829 case TIMED_OUT:
1830 return STATUS_ERROR_FMT(CameraService::ERROR_CAMERA_IN_USE,
1831 "Camera \"%s\" is already open", mCameraIdStr.c_str());
1832 default:
1833 return STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
1834 "Failed to initialize camera \"%s\": %s (%d)", mCameraIdStr.c_str(),
1835 strerror(-ret), ret);
1836 }
Yin-Chia Yehb978c382019-10-30 00:22:37 -07001837 }
1838
1839 *session = offlineClient;
1840
1841 return binder::Status::ok();
1842}
1843
Igor Murashkine7ee7632013-06-11 18:10:18 -07001844status_t CameraDeviceClient::dump(int fd, const Vector<String16>& args) {
Eino-Ville Talvalac4003962016-01-13 10:07:04 -08001845 return BasicClient::dump(fd, args);
1846}
1847
1848status_t CameraDeviceClient::dumpClient(int fd, const Vector<String16>& args) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001849 dprintf(fd, " CameraDeviceClient[%s] (%p) dump:\n",
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001850 mCameraIdStr.string(),
Eino-Ville Talvalae992e752014-11-07 16:17:48 -08001851 (getRemoteCallback() != NULL ?
Marco Nelissenf8880202014-11-14 07:58:25 -08001852 IInterface::asBinder(getRemoteCallback()).get() : NULL) );
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001853 dprintf(fd, " Current client UID %u\n", mClientUid);
Igor Murashkine7ee7632013-06-11 18:10:18 -07001854
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001855 dprintf(fd, " State:\n");
1856 dprintf(fd, " Request ID counter: %d\n", mRequestIdCounter);
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001857 if (mInputStream.configured) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001858 dprintf(fd, " Current input stream ID: %d\n", mInputStream.id);
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001859 } else {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001860 dprintf(fd, " No input stream configured.\n");
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -07001861 }
Eino-Ville Talvala67489d22014-09-18 15:52:02 -07001862 if (!mStreamMap.isEmpty()) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001863 dprintf(fd, " Current output stream/surface IDs:\n");
Eino-Ville Talvala67489d22014-09-18 15:52:02 -07001864 for (size_t i = 0; i < mStreamMap.size(); i++) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001865 dprintf(fd, " Stream %d Surface %d\n",
Shuzhen Wang0129d522016-10-30 22:43:41 -07001866 mStreamMap.valueAt(i).streamId(),
1867 mStreamMap.valueAt(i).surfaceId());
Eino-Ville Talvala67489d22014-09-18 15:52:02 -07001868 }
Zhijun He5d677d12016-05-29 16:52:39 -07001869 } else if (!mDeferredStreams.isEmpty()) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001870 dprintf(fd, " Current deferred surface output stream IDs:\n");
Zhijun He5d677d12016-05-29 16:52:39 -07001871 for (auto& streamId : mDeferredStreams) {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001872 dprintf(fd, " Stream %d\n", streamId);
Zhijun He5d677d12016-05-29 16:52:39 -07001873 }
Eino-Ville Talvala67489d22014-09-18 15:52:02 -07001874 } else {
Eino-Ville Talvalad00111e2017-01-31 11:59:12 -08001875 dprintf(fd, " No output streams configured.\n");
Eino-Ville Talvala67489d22014-09-18 15:52:02 -07001876 }
Igor Murashkine7ee7632013-06-11 18:10:18 -07001877 // TODO: print dynamic/request section from most recent requests
1878 mFrameProcessor->dump(fd, args);
1879
1880 return dumpDevice(fd, args);
1881}
1882
Avichal Rakesh7e53cad2021-10-05 13:46:30 -07001883status_t CameraDeviceClient::startWatchingTags(const String8 &tags, int out) {
1884 sp<CameraDeviceBase> device = mDevice;
1885 if (!device) {
1886 dprintf(out, " Device is detached.");
1887 return OK;
1888 }
1889 device->startWatchingTags(tags);
1890 return OK;
1891}
1892
1893status_t CameraDeviceClient::stopWatchingTags(int out) {
1894 sp<CameraDeviceBase> device = mDevice;
1895 if (!device) {
1896 dprintf(out, " Device is detached.");
1897 return OK;
1898 }
1899 device->stopWatchingTags();
1900 return OK;
1901}
1902
1903status_t CameraDeviceClient::dumpWatchedEventsToVector(std::vector<std::string> &out) {
1904 sp<CameraDeviceBase> device = mDevice;
1905 if (!device) {
1906 return OK;
1907 }
1908 device->dumpWatchedEventsToVector(out);
1909 return OK;
1910}
1911
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001912void CameraDeviceClient::notifyError(int32_t errorCode,
Jianing Weicb0652e2014-03-12 18:29:36 -07001913 const CaptureResultExtras& resultExtras) {
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001914 // Thread safe. Don't bother locking.
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001915 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001916
Emilian Peev538c90e2018-12-17 18:03:19 +00001917 bool skipClientNotification = false;
Emilian Peev2f5d6012022-01-19 16:16:50 -08001918 {
1919 // Access to the composite stream map must be synchronized
1920 Mutex::Autolock l(mCompositeLock);
1921 // Composites can have multiple internal streams. Error notifications coming from such
1922 // internal streams may need to remain within camera service.
1923 for (size_t i = 0; i < mCompositeStreamMap.size(); i++) {
1924 skipClientNotification |= mCompositeStreamMap.valueAt(i)->onError(errorCode,
1925 resultExtras);
1926 }
Emilian Peev538c90e2018-12-17 18:03:19 +00001927 }
1928
1929 if ((remoteCb != 0) && (!skipClientNotification)) {
Jianing Weicb0652e2014-03-12 18:29:36 -07001930 remoteCb->onDeviceError(errorCode, resultExtras);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001931 }
1932}
1933
Chien-Yu Chene8c535e2016-04-14 12:18:26 -07001934void CameraDeviceClient::notifyRepeatingRequestError(long lastFrameNumber) {
1935 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback();
1936
1937 if (remoteCb != 0) {
Yin-Chia Yeh8ca23dc2017-09-05 18:15:56 -07001938 remoteCb->onRepeatingRequestError(lastFrameNumber, mStreamingRequestId);
Chien-Yu Chene8c535e2016-04-14 12:18:26 -07001939 }
1940
Shuzhen Wangc9ca6782016-04-26 13:40:31 -07001941 Mutex::Autolock idLock(mStreamingRequestIdLock);
Chien-Yu Chene8c535e2016-04-14 12:18:26 -07001942 mStreamingRequestId = REQUEST_ID_NONE;
1943}
1944
Shuzhen Wang316781a2020-08-18 18:11:01 -07001945void CameraDeviceClient::notifyIdle(
1946 int64_t requestCount, int64_t resultErrorCount, bool deviceError,
1947 const std::vector<hardware::CameraStreamStats>& streamStats) {
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001948 // Thread safe. Don't bother locking.
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001949 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001950
1951 if (remoteCb != 0) {
1952 remoteCb->onDeviceIdle();
1953 }
Shuzhen Wang316781a2020-08-18 18:11:01 -07001954 Camera2ClientBase::notifyIdle(requestCount, resultErrorCount, deviceError, streamStats);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001955}
1956
Jianing Weicb0652e2014-03-12 18:29:36 -07001957void CameraDeviceClient::notifyShutter(const CaptureResultExtras& resultExtras,
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001958 nsecs_t timestamp) {
1959 // Thread safe. Don't bother locking.
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001960 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback();
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001961 if (remoteCb != 0) {
Jianing Weicb0652e2014-03-12 18:29:36 -07001962 remoteCb->onCaptureStarted(resultExtras, timestamp);
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001963 }
Eino-Ville Talvala412fe562015-08-20 17:08:32 -07001964 Camera2ClientBase::notifyShutter(resultExtras, timestamp);
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001965
Emilian Peev2f5d6012022-01-19 16:16:50 -08001966 // Access to the composite stream map must be synchronized
1967 Mutex::Autolock l(mCompositeLock);
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -08001968 for (size_t i = 0; i < mCompositeStreamMap.size(); i++) {
1969 mCompositeStreamMap.valueAt(i)->onShutter(resultExtras, timestamp);
1970 }
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -07001971}
1972
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001973void CameraDeviceClient::notifyPrepared(int streamId) {
1974 // Thread safe. Don't bother locking.
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08001975 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback();
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -07001976 if (remoteCb != 0) {
1977 remoteCb->onPrepared(streamId);
1978 }
1979}
1980
Shuzhen Wang9d066012016-09-30 11:30:20 -07001981void CameraDeviceClient::notifyRequestQueueEmpty() {
1982 // Thread safe. Don't bother locking.
1983 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback();
1984 if (remoteCb != 0) {
1985 remoteCb->onRequestQueueEmpty();
1986 }
1987}
1988
Igor Murashkine7ee7632013-06-11 18:10:18 -07001989void CameraDeviceClient::detachDevice() {
1990 if (mDevice == 0) return;
1991
Shuzhen Wang316781a2020-08-18 18:11:01 -07001992 nsecs_t startTime = systemTime();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001993 ALOGV("Camera %s: Stopping processors", mCameraIdStr.string());
Igor Murashkine7ee7632013-06-11 18:10:18 -07001994
Emilian Peevfaa4bde2020-01-23 12:19:37 -08001995 mFrameProcessor->removeListener(camera2::FrameProcessorBase::FRAME_PROCESSOR_LISTENER_MIN_ID,
1996 camera2::FrameProcessorBase::FRAME_PROCESSOR_LISTENER_MAX_ID,
Igor Murashkine7ee7632013-06-11 18:10:18 -07001997 /*listener*/this);
1998 mFrameProcessor->requestExit();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08001999 ALOGV("Camera %s: Waiting for threads", mCameraIdStr.string());
Igor Murashkine7ee7632013-06-11 18:10:18 -07002000 mFrameProcessor->join();
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -08002001 ALOGV("Camera %s: Disconnecting device", mCameraIdStr.string());
Igor Murashkine7ee7632013-06-11 18:10:18 -07002002
2003 // WORKAROUND: HAL refuses to disconnect while there's streams in flight
2004 {
Emilian Peev6b51d7d2018-07-23 11:41:44 +01002005 int64_t lastFrameNumber;
Igor Murashkine7ee7632013-06-11 18:10:18 -07002006 status_t code;
Emilian Peev6b51d7d2018-07-23 11:41:44 +01002007 if ((code = mDevice->flush(&lastFrameNumber)) != OK) {
2008 ALOGE("%s: flush failed with code 0x%x", __FUNCTION__, code);
2009 }
2010
Igor Murashkine7ee7632013-06-11 18:10:18 -07002011 if ((code = mDevice->waitUntilDrained()) != OK) {
2012 ALOGE("%s: waitUntilDrained failed with code 0x%x", __FUNCTION__,
2013 code);
2014 }
2015 }
2016
Emilian Peev2f5d6012022-01-19 16:16:50 -08002017 {
2018 Mutex::Autolock l(mCompositeLock);
2019 for (size_t i = 0; i < mCompositeStreamMap.size(); i++) {
2020 auto ret = mCompositeStreamMap.valueAt(i)->deleteInternalStreams();
2021 if (ret != OK) {
2022 ALOGE("%s: Failed removing composite stream %s (%d)", __FUNCTION__,
2023 strerror(-ret), ret);
2024 }
Emilian Peev5e4c7322019-10-22 14:20:52 -07002025 }
Emilian Peev2f5d6012022-01-19 16:16:50 -08002026 mCompositeStreamMap.clear();
Emilian Peev5e4c7322019-10-22 14:20:52 -07002027 }
Emilian Peev5e4c7322019-10-22 14:20:52 -07002028
Igor Murashkine7ee7632013-06-11 18:10:18 -07002029 Camera2ClientBase::detachDevice();
Shuzhen Wang316781a2020-08-18 18:11:01 -07002030
2031 int32_t closeLatencyMs = ns2ms(systemTime() - startTime);
2032 CameraServiceProxyWrapper::logClose(mCameraIdStr, closeLatencyMs);
Igor Murashkine7ee7632013-06-11 18:10:18 -07002033}
2034
2035/** Device-related methods */
Jianing Weicb0652e2014-03-12 18:29:36 -07002036void CameraDeviceClient::onResultAvailable(const CaptureResult& result) {
Igor Murashkine7ee7632013-06-11 18:10:18 -07002037 ATRACE_CALL();
2038 ALOGV("%s", __FUNCTION__);
2039
Igor Murashkin4fb55c12013-08-29 17:43:01 -07002040 // Thread-safe. No lock necessary.
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002041 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = mRemoteCallback;
Igor Murashkin4fb55c12013-08-29 17:43:01 -07002042 if (remoteCb != NULL) {
Shuzhen Wang5c22c152017-12-31 17:12:25 -08002043 remoteCb->onResultReceived(result.mMetadata, result.mResultExtras,
2044 result.mPhysicalMetadatas);
Igor Murashkine7ee7632013-06-11 18:10:18 -07002045 }
Emilian Peev538c90e2018-12-17 18:03:19 +00002046
Emilian Peev2f5d6012022-01-19 16:16:50 -08002047 // Access to the composite stream map must be synchronized
2048 Mutex::Autolock l(mCompositeLock);
Emilian Peev538c90e2018-12-17 18:03:19 +00002049 for (size_t i = 0; i < mCompositeStreamMap.size(); i++) {
2050 mCompositeStreamMap.valueAt(i)->onResultAvailable(result);
2051 }
Igor Murashkine7ee7632013-06-11 18:10:18 -07002052}
2053
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002054binder::Status CameraDeviceClient::checkPidStatus(const char* checkLocation) {
Eino-Ville Talvala6192b892016-04-04 12:31:18 -07002055 if (mDisconnected) {
2056 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED,
2057 "The camera device has been disconnected");
2058 }
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -08002059 status_t res = checkPid(checkLocation);
2060 return (res == OK) ? binder::Status::ok() :
2061 STATUS_ERROR(CameraService::ERROR_PERMISSION_DENIED,
2062 "Attempt to use camera from a different process than original client");
2063}
2064
Igor Murashkine7ee7632013-06-11 18:10:18 -07002065// TODO: move to Camera2ClientBase
2066bool CameraDeviceClient::enforceRequestPermissions(CameraMetadata& metadata) {
2067
Jayant Chowdhary12361932018-08-27 14:46:13 -07002068 const int pid = CameraThreadState::getCallingPid();
Igor Murashkine7ee7632013-06-11 18:10:18 -07002069 const int selfPid = getpid();
2070 camera_metadata_entry_t entry;
2071
2072 /**
2073 * Mixin default important security values
2074 * - android.led.transmit = defaulted ON
2075 */
2076 CameraMetadata staticInfo = mDevice->info();
2077 entry = staticInfo.find(ANDROID_LED_AVAILABLE_LEDS);
2078 for(size_t i = 0; i < entry.count; ++i) {
2079 uint8_t led = entry.data.u8[i];
2080
2081 switch(led) {
2082 case ANDROID_LED_AVAILABLE_LEDS_TRANSMIT: {
2083 uint8_t transmitDefault = ANDROID_LED_TRANSMIT_ON;
2084 if (!metadata.exists(ANDROID_LED_TRANSMIT)) {
2085 metadata.update(ANDROID_LED_TRANSMIT,
2086 &transmitDefault, 1);
2087 }
2088 break;
2089 }
2090 }
2091 }
2092
2093 // We can do anything!
2094 if (pid == selfPid) {
2095 return true;
2096 }
2097
2098 /**
2099 * Permission check special fields in the request
2100 * - android.led.transmit = android.permission.CAMERA_DISABLE_TRANSMIT
2101 */
2102 entry = metadata.find(ANDROID_LED_TRANSMIT);
2103 if (entry.count > 0 && entry.data.u8[0] != ANDROID_LED_TRANSMIT_ON) {
2104 String16 permissionString =
2105 String16("android.permission.CAMERA_DISABLE_TRANSMIT_LED");
2106 if (!checkCallingPermission(permissionString)) {
Jayant Chowdhary12361932018-08-27 14:46:13 -07002107 const int uid = CameraThreadState::getCallingUid();
Igor Murashkine7ee7632013-06-11 18:10:18 -07002108 ALOGE("Permission Denial: "
2109 "can't disable transmit LED pid=%d, uid=%d", pid, uid);
2110 return false;
2111 }
2112 }
2113
2114 return true;
2115}
2116
Igor Murashkinf8b2a6f2013-09-17 17:03:28 -07002117status_t CameraDeviceClient::getRotationTransformLocked(int32_t* transform) {
2118 ALOGV("%s: begin", __FUNCTION__);
2119
Igor Murashkinf8b2a6f2013-09-17 17:03:28 -07002120 const CameraMetadata& staticInfo = mDevice->info();
Ruben Brunk5698d442014-06-18 10:39:40 -07002121 return CameraUtils::getRotationTransform(staticInfo, transform);
Igor Murashkinf8b2a6f2013-09-17 17:03:28 -07002122}
2123
Emilian Peevf4816702020-04-03 15:44:51 -07002124binder::Status CameraDeviceClient::mapRequestTemplate(int templateId,
2125 camera_request_template_t* tempId /*out*/) {
2126 binder::Status ret = binder::Status::ok();
2127
2128 if (tempId == nullptr) {
2129 ret = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
2130 "Camera %s: Invalid template argument", mCameraIdStr.string());
2131 return ret;
2132 }
2133 switch(templateId) {
2134 case ICameraDeviceUser::TEMPLATE_PREVIEW:
2135 *tempId = camera_request_template_t::CAMERA_TEMPLATE_PREVIEW;
2136 break;
2137 case ICameraDeviceUser::TEMPLATE_RECORD:
2138 *tempId = camera_request_template_t::CAMERA_TEMPLATE_VIDEO_RECORD;
2139 break;
2140 case ICameraDeviceUser::TEMPLATE_STILL_CAPTURE:
2141 *tempId = camera_request_template_t::CAMERA_TEMPLATE_STILL_CAPTURE;
2142 break;
2143 case ICameraDeviceUser::TEMPLATE_VIDEO_SNAPSHOT:
2144 *tempId = camera_request_template_t::CAMERA_TEMPLATE_VIDEO_SNAPSHOT;
2145 break;
2146 case ICameraDeviceUser::TEMPLATE_ZERO_SHUTTER_LAG:
2147 *tempId = camera_request_template_t::CAMERA_TEMPLATE_ZERO_SHUTTER_LAG;
2148 break;
2149 case ICameraDeviceUser::TEMPLATE_MANUAL:
2150 *tempId = camera_request_template_t::CAMERA_TEMPLATE_MANUAL;
2151 break;
2152 default:
2153 ret = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
2154 "Camera %s: Template ID %d is invalid or not supported",
2155 mCameraIdStr.string(), templateId);
2156 return ret;
2157 }
2158
2159 return ret;
2160}
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002161
2162const CameraMetadata &CameraDeviceClient::getStaticInfo(const String8 &cameraId) {
2163 if (mDevice->getId() == cameraId) {
2164 return mDevice->info();
2165 }
2166 return mDevice->infoPhysical(cameraId);
2167}
2168
2169bool CameraDeviceClient::isUltraHighResolutionSensor(const String8 &cameraId) {
2170 const CameraMetadata &deviceInfo = getStaticInfo(cameraId);
Shuzhen Wangd4abdf72021-05-28 11:22:50 -07002171 return SessionConfigurationUtils::isUltraHighResolutionSensor(deviceInfo);
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -08002172}
2173
2174bool CameraDeviceClient::isSensorPixelModeConsistent(
2175 const std::list<int> &streamIdList, const CameraMetadata &settings) {
2176 // First we get the sensorPixelMode from the settings metadata.
2177 int32_t sensorPixelMode = ANDROID_SENSOR_PIXEL_MODE_DEFAULT;
2178 camera_metadata_ro_entry sensorPixelModeEntry = settings.find(ANDROID_SENSOR_PIXEL_MODE);
2179 if (sensorPixelModeEntry.count != 0) {
2180 sensorPixelMode = sensorPixelModeEntry.data.u8[0];
2181 if (sensorPixelMode != ANDROID_SENSOR_PIXEL_MODE_DEFAULT &&
2182 sensorPixelMode != ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION) {
2183 ALOGE("%s: Request sensor pixel mode not is not one of the valid values %d",
2184 __FUNCTION__, sensorPixelMode);
2185 return false;
2186 }
2187 }
2188 // Check whether each stream has max resolution allowed.
2189 bool consistent = true;
2190 for (auto it : streamIdList) {
2191 auto const streamInfoIt = mStreamInfoMap.find(it);
2192 if (streamInfoIt == mStreamInfoMap.end()) {
2193 ALOGE("%s: stream id %d not created, skipping", __FUNCTION__, it);
2194 return false;
2195 }
2196 consistent =
2197 streamInfoIt->second.sensorPixelModesUsed.find(sensorPixelMode) !=
2198 streamInfoIt->second.sensorPixelModesUsed.end();
2199 if (!consistent) {
2200 ALOGE("sensorPixelMode used %i not consistent with configured modes", sensorPixelMode);
2201 for (auto m : streamInfoIt->second.sensorPixelModesUsed) {
2202 ALOGE("sensor pixel mode used list: %i", m);
2203 }
2204 break;
2205 }
2206 }
2207
2208 return consistent;
2209}
2210
Igor Murashkine7ee7632013-06-11 18:10:18 -07002211} // namespace android