1 /*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
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 "HidlCamera3-Device"
18 #define ATRACE_TAG ATRACE_TAG_CAMERA
19 //#define LOG_NDEBUG 0
20 //#define LOG_NNDEBUG 0 // Per-frame verbose logging
21
22 #ifdef LOG_NNDEBUG
23 #define ALOGVV(...) ALOGV(__VA_ARGS__)
24 #else
25 #define ALOGVV(...) ((void)0)
26 #endif
27
28 // Convenience macro for transient errors
29 #define CLOGE(fmt, ...) ALOGE("Camera %s: %s: " fmt, mId.c_str(), __FUNCTION__, \
30 ##__VA_ARGS__)
31
32 // Convenience macros for transitioning to the error state
33 #define SET_ERR(fmt, ...) setErrorState( \
34 "%s: " fmt, __FUNCTION__, \
35 ##__VA_ARGS__)
36 #define SET_ERR_L(fmt, ...) setErrorStateLocked( \
37 "%s: " fmt, __FUNCTION__, \
38 ##__VA_ARGS__)
39
40
41 #include <inttypes.h>
42
43 #include <utility>
44
45 #include <utils/Log.h>
46 #include <utils/Trace.h>
47 #include <utils/Timers.h>
48 #include <cutils/properties.h>
49 #include <camera/StringUtils.h>
50 #include <com_android_internal_camera_flags.h>
51
52 #include <android/hardware/camera/device/3.7/ICameraInjectionSession.h>
53 #include <android/hardware/camera2/ICameraDeviceUser.h>
54
55 #include "device3/hidl/HidlCamera3OutputUtils.h"
56 #include "device3/hidl/HidlCamera3OfflineSession.h"
57 #include "utils/SessionConfigurationUtilsHidl.h"
58 #include "utils/TraceHFR.h"
59 #include "utils/Utils.h"
60
61 #include "../../common/hidl/HidlProviderInfo.h"
62 #include "HidlCamera3Device.h"
63
64 #include <algorithm>
65 #include <tuple>
66
67 using namespace android::camera3;
68 using namespace android::hardware::camera;
69 using namespace android::hardware::camera::device::V3_2;
70 using android::hardware::camera::metadata::V3_6::CameraMetadataEnumAndroidSensorPixelMode;
71 namespace flags = com::android::internal::camera::flags;
72
73 namespace android {
74
mapToPixelFormat(int frameworkFormat)75 hardware::graphics::common::V1_0::PixelFormat HidlCamera3Device::mapToPixelFormat(
76 int frameworkFormat) {
77 return (hardware::graphics::common::V1_0::PixelFormat) frameworkFormat;
78 }
79
mapToHidlDataspace(android_dataspace dataSpace)80 DataspaceFlags HidlCamera3Device::mapToHidlDataspace(
81 android_dataspace dataSpace) {
82 return dataSpace;
83 }
84
mapToConsumerUsage(uint64_t usage)85 BufferUsageFlags HidlCamera3Device::mapToConsumerUsage(
86 uint64_t usage) {
87 return usage;
88 }
89
mapToStreamRotation(camera_stream_rotation_t rotation)90 StreamRotation HidlCamera3Device::mapToStreamRotation(camera_stream_rotation_t rotation) {
91 switch (rotation) {
92 case CAMERA_STREAM_ROTATION_0:
93 return StreamRotation::ROTATION_0;
94 case CAMERA_STREAM_ROTATION_90:
95 return StreamRotation::ROTATION_90;
96 case CAMERA_STREAM_ROTATION_180:
97 return StreamRotation::ROTATION_180;
98 case CAMERA_STREAM_ROTATION_270:
99 return StreamRotation::ROTATION_270;
100 }
101 ALOGE("%s: Unknown stream rotation %d", __FUNCTION__, rotation);
102 return StreamRotation::ROTATION_0;
103 }
104
mapToStreamConfigurationMode(camera_stream_configuration_mode_t operationMode,StreamConfigurationMode * mode)105 status_t HidlCamera3Device::mapToStreamConfigurationMode(
106 camera_stream_configuration_mode_t operationMode, StreamConfigurationMode *mode) {
107 if (mode == nullptr) return BAD_VALUE;
108 if (operationMode < CAMERA_VENDOR_STREAM_CONFIGURATION_MODE_START) {
109 switch(operationMode) {
110 case CAMERA_STREAM_CONFIGURATION_NORMAL_MODE:
111 *mode = StreamConfigurationMode::NORMAL_MODE;
112 break;
113 case CAMERA_STREAM_CONFIGURATION_CONSTRAINED_HIGH_SPEED_MODE:
114 *mode = StreamConfigurationMode::CONSTRAINED_HIGH_SPEED_MODE;
115 break;
116 default:
117 ALOGE("%s: Unknown stream configuration mode %d", __FUNCTION__, operationMode);
118 return BAD_VALUE;
119 }
120 } else {
121 *mode = static_cast<StreamConfigurationMode>(operationMode);
122 }
123 return OK;
124 }
125
mapToFrameworkFormat(hardware::graphics::common::V1_0::PixelFormat pixelFormat)126 int HidlCamera3Device::mapToFrameworkFormat(
127 hardware::graphics::common::V1_0::PixelFormat pixelFormat) {
128 return static_cast<uint32_t>(pixelFormat);
129 }
130
mapToFrameworkDataspace(DataspaceFlags dataSpace)131 android_dataspace HidlCamera3Device::mapToFrameworkDataspace(
132 DataspaceFlags dataSpace) {
133 return static_cast<android_dataspace>(dataSpace);
134 }
135
mapConsumerToFrameworkUsage(BufferUsageFlags usage)136 uint64_t HidlCamera3Device::mapConsumerToFrameworkUsage(
137 BufferUsageFlags usage) {
138 return usage;
139 }
140
mapProducerToFrameworkUsage(BufferUsageFlags usage)141 uint64_t HidlCamera3Device::mapProducerToFrameworkUsage(
142 BufferUsageFlags usage) {
143 return usage;
144 }
145
initialize(sp<CameraProviderManager> manager,const std::string & monitorTags)146 status_t HidlCamera3Device::initialize(sp<CameraProviderManager> manager,
147 const std::string& monitorTags) {
148 ATRACE_CALL();
149 Mutex::Autolock il(mInterfaceLock);
150 Mutex::Autolock l(mLock);
151
152 ALOGV("%s: Initializing HIDL device for camera %s", __FUNCTION__, mId.c_str());
153 if (mStatus != STATUS_UNINITIALIZED) {
154 CLOGE("Already initialized!");
155 return INVALID_OPERATION;
156 }
157 if (manager == nullptr) return INVALID_OPERATION;
158
159 sp<ICameraDeviceSession> session;
160 ATRACE_BEGIN("CameraHal::openSession");
161 status_t res = manager->openHidlSession(mId, this,
162 /*out*/ &session);
163 ATRACE_END();
164 if (res != OK) {
165 SET_ERR_L("Could not open camera session: %s (%d)", strerror(-res), res);
166 return res;
167 }
168
169 res = manager->getCameraCharacteristics(mId, mOverrideForPerfClass, &mDeviceInfo,
170 hardware::ICameraService::ROTATION_OVERRIDE_NONE);
171 if (res != OK) {
172 SET_ERR_L("Could not retrieve camera characteristics: %s (%d)", strerror(-res), res);
173 session->close();
174 return res;
175 }
176 mSupportNativeZoomRatio = manager->supportNativeZoomRatio(mId);
177
178 std::vector<std::string> physicalCameraIds;
179 bool isLogical = manager->isLogicalCamera(mId, &physicalCameraIds);
180 if (isLogical) {
181 for (auto& physicalId : physicalCameraIds) {
182 // Do not override characteristics for physical cameras
183 res = manager->getCameraCharacteristics(
184 physicalId, /*overrideForPerfClass*/false, &mPhysicalDeviceInfoMap[physicalId],
185 hardware::ICameraService::ROTATION_OVERRIDE_NONE);
186 if (res != OK) {
187 SET_ERR_L("Could not retrieve camera %s characteristics: %s (%d)",
188 physicalId.c_str(), strerror(-res), res);
189 session->close();
190 return res;
191 }
192
193 bool usePrecorrectArray =
194 DistortionMapper::isDistortionSupported(mPhysicalDeviceInfoMap[physicalId]);
195 if (usePrecorrectArray) {
196 res = mDistortionMappers[physicalId].setupStaticInfo(
197 mPhysicalDeviceInfoMap[physicalId]);
198 if (res != OK) {
199 SET_ERR_L("Unable to read camera %s's calibration fields for distortion "
200 "correction", physicalId.c_str());
201 session->close();
202 return res;
203 }
204 }
205
206 mZoomRatioMappers[physicalId] = ZoomRatioMapper(
207 &mPhysicalDeviceInfoMap[physicalId],
208 mSupportNativeZoomRatio, usePrecorrectArray);
209
210 if (SessionConfigurationUtils::supportsUltraHighResolutionCapture(
211 mPhysicalDeviceInfoMap[physicalId])) {
212 mUHRCropAndMeteringRegionMappers[physicalId] =
213 UHRCropAndMeteringRegionMapper(mPhysicalDeviceInfoMap[physicalId],
214 usePrecorrectArray);
215 }
216 }
217 }
218
219 std::shared_ptr<RequestMetadataQueue> queue;
220 auto requestQueueRet = session->getCaptureRequestMetadataQueue(
221 [&queue](const auto& descriptor) {
222 queue = std::make_shared<RequestMetadataQueue>(descriptor);
223 if (!queue->isValid() || queue->availableToWrite() <= 0) {
224 ALOGE("HAL returns empty request metadata fmq, not use it");
225 queue = nullptr;
226 // don't use the queue onwards.
227 }
228 });
229 if (!requestQueueRet.isOk()) {
230 ALOGE("Transaction error when getting request metadata fmq: %s, not use it",
231 requestQueueRet.description().c_str());
232 return DEAD_OBJECT;
233 }
234
235 std::unique_ptr<ResultMetadataQueue>& resQueue = mResultMetadataQueue;
236 auto resultQueueRet = session->getCaptureResultMetadataQueue(
237 [&resQueue](const auto& descriptor) {
238 resQueue = std::make_unique<ResultMetadataQueue>(descriptor);
239 if (!resQueue->isValid() || resQueue->availableToWrite() <= 0) {
240 ALOGE("HAL returns empty result metadata fmq, not use it");
241 resQueue = nullptr;
242 // Don't use the resQueue onwards.
243 }
244 });
245 if (!resultQueueRet.isOk()) {
246 ALOGE("Transaction error when getting result metadata queue from camera session: %s",
247 resultQueueRet.description().c_str());
248 return DEAD_OBJECT;
249 }
250 IF_ALOGV() {
251 session->interfaceChain([](
252 ::android::hardware::hidl_vec<::android::hardware::hidl_string> interfaceChain) {
253 ALOGV("Session interface chain:");
254 for (const auto& iface : interfaceChain) {
255 ALOGV(" %s", iface.c_str());
256 }
257 });
258 }
259
260 camera_metadata_entry bufMgrMode =
261 mDeviceInfo.find(ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION);
262 if (bufMgrMode.count > 0) {
263 mUseHalBufManager = (bufMgrMode.data.u8[0] ==
264 ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5);
265 }
266
267 camera_metadata_entry_t capabilities = mDeviceInfo.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
268 for (size_t i = 0; i < capabilities.count; i++) {
269 uint8_t capability = capabilities.data.u8[i];
270 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_OFFLINE_PROCESSING) {
271 mSupportOfflineProcessing = true;
272 }
273 }
274
275 mInterface = new HidlHalInterface(session, queue, mUseHalBufManager, mSupportOfflineProcessing);
276
277 std::string providerType;
278 mVendorTagId = manager->getProviderTagIdLocked(mId);
279 mTagMonitor.initialize(mVendorTagId);
280 if (!monitorTags.empty()) {
281 mTagMonitor.parseTagsToMonitor(monitorTags);
282 }
283
284 // Metadata tags needs fixup for monochrome camera device version less
285 // than 3.5.
286 hardware::hidl_version maxVersion{0,0};
287 IPCTransport transport = IPCTransport::HIDL;
288 res = manager->getHighestSupportedVersion(mId, &maxVersion, &transport);
289 if (res != OK) {
290 ALOGE("%s: Error in getting camera device version id: %s (%d)",
291 __FUNCTION__, strerror(-res), res);
292 return res;
293 }
294 int deviceVersion = HARDWARE_DEVICE_API_VERSION(
295 maxVersion.get_major(), maxVersion.get_minor());
296
297 bool isMonochrome = false;
298 for (size_t i = 0; i < capabilities.count; i++) {
299 uint8_t capability = capabilities.data.u8[i];
300 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME) {
301 isMonochrome = true;
302 }
303 }
304 mNeedFixupMonochromeTags = (isMonochrome && deviceVersion < CAMERA_DEVICE_API_VERSION_3_5);
305
306 return initializeCommonLocked(manager);
307 }
308
getCaptureResultFMQSize()309 int32_t HidlCamera3Device::getCaptureResultFMQSize() {
310 return Camera3Device::calculateFMQSize<ResultMetadataQueue>(mResultMetadataQueue);
311 }
312
requestStreamBuffers(const hardware::hidl_vec<hardware::camera::device::V3_5::BufferRequest> & bufReqs,requestStreamBuffers_cb _hidl_cb)313 hardware::Return<void> HidlCamera3Device::requestStreamBuffers(
314 const hardware::hidl_vec<hardware::camera::device::V3_5::BufferRequest>& bufReqs,
315 requestStreamBuffers_cb _hidl_cb) {
316 RequestBufferStates states {
317 mId, mRequestBufferInterfaceLock, mUseHalBufManager, mHalBufManagedStreamIds,
318 mOutputStreams, mSessionStatsBuilder,
319 *this, *mInterface, *this};
320 camera3::requestStreamBuffers(states, bufReqs, _hidl_cb);
321 return hardware::Void();
322 }
323
returnStreamBuffers(const hardware::hidl_vec<hardware::camera::device::V3_2::StreamBuffer> & buffers)324 hardware::Return<void> HidlCamera3Device::returnStreamBuffers(
325 const hardware::hidl_vec<hardware::camera::device::V3_2::StreamBuffer>& buffers) {
326 ReturnBufferStates states {
327 mId, mUseHalBufManager, mHalBufManagedStreamIds, mOutputStreams,
328 mSessionStatsBuilder, *mInterface};
329 camera3::returnStreamBuffers(states, buffers);
330 return hardware::Void();
331 }
332
processCaptureResult_3_4(const hardware::hidl_vec<hardware::camera::device::V3_4::CaptureResult> & results)333 hardware::Return<void> HidlCamera3Device::processCaptureResult_3_4(
334 const hardware::hidl_vec<
335 hardware::camera::device::V3_4::CaptureResult>& results) {
336 // Ideally we should grab mLock, but that can lead to deadlock, and
337 // it's not super important to get up to date value of mStatus for this
338 // warning print, hence skipping the lock here
339 if (mStatus == STATUS_ERROR) {
340 // Per API contract, HAL should act as closed after device error
341 // But mStatus can be set to error by framework as well, so just log
342 // a warning here.
343 ALOGW("%s: received capture result in error state.", __FUNCTION__);
344 }
345
346 sp<NotificationListener> listener;
347 {
348 std::lock_guard<std::mutex> l(mOutputLock);
349 listener = mListener.promote();
350 }
351
352 if (mProcessCaptureResultLock.tryLock() != OK) {
353 // This should never happen; it indicates a wrong client implementation
354 // that doesn't follow the contract. But, we can be tolerant here.
355 ALOGE("%s: callback overlapped! waiting 1s...",
356 __FUNCTION__);
357 if (mProcessCaptureResultLock.timedLock(1000000000 /* 1s */) != OK) {
358 ALOGE("%s: cannot acquire lock in 1s, dropping results",
359 __FUNCTION__);
360 // really don't know what to do, so bail out.
361 return hardware::Void();
362 }
363 }
364 HidlCaptureOutputStates states {
365 {
366 mId,
367 mInFlightLock, mLastCompletedRegularFrameNumber,
368 mLastCompletedReprocessFrameNumber, mLastCompletedZslFrameNumber,
369 mInFlightMap, mOutputLock, mResultQueue, mResultSignal,
370 mNextShutterFrameNumber,
371 mNextReprocessShutterFrameNumber, mNextZslStillShutterFrameNumber,
372 mNextResultFrameNumber,
373 mNextReprocessResultFrameNumber, mNextZslStillResultFrameNumber,
374 mUseHalBufManager, mHalBufManagedStreamIds, mUsePartialResult, mNeedFixupMonochromeTags,
375 mNumPartialResults, mVendorTagId, mDeviceInfo, mPhysicalDeviceInfoMap,
376 mDistortionMappers, mZoomRatioMappers, mRotateAndCropMappers,
377 mTagMonitor, mInputStream, mOutputStreams, mSessionStatsBuilder, listener, *this, *this,
378 *mInterface, mLegacyClient, mMinExpectedDuration, mIsFixedFps, mRotationOverride,
379 mActivePhysicalId}, mResultMetadataQueue
380 };
381
382 //HidlCaptureOutputStates hidlStates {
383 //}
384
385 for (const auto& result : results) {
386 processOneCaptureResultLocked(states, result.v3_2, result.physicalCameraMetadata);
387 }
388 mProcessCaptureResultLock.unlock();
389 return hardware::Void();
390 }
391
392 // Only one processCaptureResult should be called at a time, so
393 // the locks won't block. The locks are present here simply to enforce this.
processCaptureResult(const hardware::hidl_vec<hardware::camera::device::V3_2::CaptureResult> & results)394 hardware::Return<void> HidlCamera3Device::processCaptureResult(
395 const hardware::hidl_vec<
396 hardware::camera::device::V3_2::CaptureResult>& results) {
397 hardware::hidl_vec<hardware::camera::device::V3_4::PhysicalCameraMetadata> noPhysMetadata;
398
399 // Ideally we should grab mLock, but that can lead to deadlock, and
400 // it's not super important to get up to date value of mStatus for this
401 // warning print, hence skipping the lock here
402 if (mStatus == STATUS_ERROR) {
403 // Per API contract, HAL should act as closed after device error
404 // But mStatus can be set to error by framework as well, so just log
405 // a warning here.
406 ALOGW("%s: received capture result in error state.", __FUNCTION__);
407 }
408
409 sp<NotificationListener> listener;
410 {
411 std::lock_guard<std::mutex> l(mOutputLock);
412 listener = mListener.promote();
413 }
414
415 if (mProcessCaptureResultLock.tryLock() != OK) {
416 // This should never happen; it indicates a wrong client implementation
417 // that doesn't follow the contract. But, we can be tolerant here.
418 ALOGE("%s: callback overlapped! waiting 1s...",
419 __FUNCTION__);
420 if (mProcessCaptureResultLock.timedLock(1000000000 /* 1s */) != OK) {
421 ALOGE("%s: cannot acquire lock in 1s, dropping results",
422 __FUNCTION__);
423 // really don't know what to do, so bail out.
424 return hardware::Void();
425 }
426 }
427
428 HidlCaptureOutputStates states {
429 { mId,
430 mInFlightLock, mLastCompletedRegularFrameNumber,
431 mLastCompletedReprocessFrameNumber, mLastCompletedZslFrameNumber,
432 mInFlightMap, mOutputLock, mResultQueue, mResultSignal,
433 mNextShutterFrameNumber,
434 mNextReprocessShutterFrameNumber, mNextZslStillShutterFrameNumber,
435 mNextResultFrameNumber,
436 mNextReprocessResultFrameNumber, mNextZslStillResultFrameNumber,
437 mUseHalBufManager, mHalBufManagedStreamIds, mUsePartialResult, mNeedFixupMonochromeTags,
438 mNumPartialResults, mVendorTagId, mDeviceInfo, mPhysicalDeviceInfoMap,
439 mDistortionMappers, mZoomRatioMappers, mRotateAndCropMappers,
440 mTagMonitor, mInputStream, mOutputStreams, mSessionStatsBuilder, listener, *this, *this,
441 *mInterface, mLegacyClient, mMinExpectedDuration, mIsFixedFps, mRotationOverride,
442 mActivePhysicalId}, mResultMetadataQueue
443 };
444
445 for (const auto& result : results) {
446 processOneCaptureResultLocked(states, result, noPhysMetadata);
447 }
448 mProcessCaptureResultLock.unlock();
449 return hardware::Void();
450 }
451
notify(const hardware::hidl_vec<hardware::camera::device::V3_2::NotifyMsg> & msgs)452 hardware::Return<void> HidlCamera3Device::notify(
453 const hardware::hidl_vec<hardware::camera::device::V3_2::NotifyMsg>& msgs) {
454 return notifyHelper<hardware::camera::device::V3_2::NotifyMsg>(msgs);
455 }
456
457 template<typename NotifyMsgType>
notifyHelper(const hardware::hidl_vec<NotifyMsgType> & msgs)458 hardware::Return<void> HidlCamera3Device::notifyHelper(
459 const hardware::hidl_vec<NotifyMsgType>& msgs) {
460 // Ideally we should grab mLock, but that can lead to deadlock, and
461 // it's not super important to get up to date value of mStatus for this
462 // warning print, hence skipping the lock here
463 if (mStatus == STATUS_ERROR) {
464 // Per API contract, HAL should act as closed after device error
465 // But mStatus can be set to error by framework as well, so just log
466 // a warning here.
467 ALOGW("%s: received notify message in error state.", __FUNCTION__);
468 }
469
470 sp<NotificationListener> listener;
471 {
472 std::lock_guard<std::mutex> l(mOutputLock);
473 listener = mListener.promote();
474 }
475
476 HidlCaptureOutputStates states {
477 { mId,
478 mInFlightLock, mLastCompletedRegularFrameNumber,
479 mLastCompletedReprocessFrameNumber, mLastCompletedZslFrameNumber,
480 mInFlightMap, mOutputLock, mResultQueue, mResultSignal,
481 mNextShutterFrameNumber,
482 mNextReprocessShutterFrameNumber, mNextZslStillShutterFrameNumber,
483 mNextResultFrameNumber,
484 mNextReprocessResultFrameNumber, mNextZslStillResultFrameNumber,
485 mUseHalBufManager, mHalBufManagedStreamIds, mUsePartialResult, mNeedFixupMonochromeTags,
486 mNumPartialResults, mVendorTagId, mDeviceInfo, mPhysicalDeviceInfoMap,
487 mDistortionMappers, mZoomRatioMappers, mRotateAndCropMappers,
488 mTagMonitor, mInputStream, mOutputStreams, mSessionStatsBuilder, listener, *this, *this,
489 *mInterface, mLegacyClient, mMinExpectedDuration, mIsFixedFps, mRotationOverride,
490 mActivePhysicalId}, mResultMetadataQueue
491 };
492 for (const auto& msg : msgs) {
493 camera3::notify(states, msg);
494 }
495 return hardware::Void();
496 }
497
switchToOffline(const std::vector<int32_t> & streamsToKeep,sp<CameraOfflineSessionBase> * session)498 status_t HidlCamera3Device::switchToOffline(
499 const std::vector<int32_t>& streamsToKeep,
500 /*out*/ sp<CameraOfflineSessionBase>* session) {
501 ATRACE_CALL();
502 if (session == nullptr) {
503 ALOGE("%s: session must not be null", __FUNCTION__);
504 return BAD_VALUE;
505 }
506
507 Mutex::Autolock il(mInterfaceLock);
508
509 bool hasInputStream = mInputStream != nullptr;
510 int32_t inputStreamId = hasInputStream ? mInputStream->getId() : -1;
511 bool inputStreamSupportsOffline = hasInputStream ?
512 mInputStream->getOfflineProcessingSupport() : false;
513 auto outputStreamIds = mOutputStreams.getStreamIds();
514 auto streamIds = outputStreamIds;
515 if (hasInputStream) {
516 streamIds.push_back(mInputStream->getId());
517 }
518
519 // Check all streams in streamsToKeep supports offline mode
520 for (auto id : streamsToKeep) {
521 if (std::find(streamIds.begin(), streamIds.end(), id) == streamIds.end()) {
522 ALOGE("%s: Unknown stream ID %d", __FUNCTION__, id);
523 return BAD_VALUE;
524 } else if (id == inputStreamId) {
525 if (!inputStreamSupportsOffline) {
526 ALOGE("%s: input stream %d cannot be switched to offline",
527 __FUNCTION__, id);
528 return BAD_VALUE;
529 }
530 } else {
531 sp<camera3::Camera3OutputStreamInterface> stream = mOutputStreams.get(id);
532 if (!stream->getOfflineProcessingSupport()) {
533 ALOGE("%s: output stream %d cannot be switched to offline",
534 __FUNCTION__, id);
535 return BAD_VALUE;
536 }
537 }
538 }
539 // TODO: block surface sharing and surface group streams until we can support them
540
541 // Stop repeating request, wait until all remaining requests are submitted, then call into
542 // HAL switchToOffline
543 hardware::camera::device::V3_6::CameraOfflineSessionInfo offlineSessionInfo;
544 sp<hardware::camera::device::V3_6::ICameraOfflineSession> offlineSession;
545 camera3::BufferRecords bufferRecords;
546 status_t ret = static_cast<HidlRequestThread *>(mRequestThread.get())->switchToOffline(
547 streamsToKeep, &offlineSessionInfo, &offlineSession, &bufferRecords);
548
549 if (ret != OK) {
550 SET_ERR("Switch to offline failed: %s (%d)", strerror(-ret), ret);
551 return ret;
552 }
553
554 bool succ = mRequestBufferSM.onSwitchToOfflineSuccess();
555 if (!succ) {
556 SET_ERR("HAL must not be calling requestStreamBuffers call");
557 // TODO: block ALL callbacks from HAL till app configured new streams?
558 return UNKNOWN_ERROR;
559 }
560
561 // Verify offlineSessionInfo
562 std::vector<int32_t> offlineStreamIds;
563 offlineStreamIds.reserve(offlineSessionInfo.offlineStreams.size());
564 for (auto offlineStream : offlineSessionInfo.offlineStreams) {
565 // verify stream IDs
566 int32_t id = offlineStream.id;
567 if (std::find(streamIds.begin(), streamIds.end(), id) == streamIds.end()) {
568 SET_ERR("stream ID %d not found!", id);
569 return UNKNOWN_ERROR;
570 }
571
572 // When not using HAL buf manager, only allow streams requested by app to be preserved
573 if (!mUseHalBufManager) {
574 if (std::find(streamsToKeep.begin(), streamsToKeep.end(), id) == streamsToKeep.end()) {
575 SET_ERR("stream ID %d must not be switched to offline!", id);
576 return UNKNOWN_ERROR;
577 }
578 }
579
580 offlineStreamIds.push_back(id);
581 sp<Camera3StreamInterface> stream = (id == inputStreamId) ?
582 static_cast<sp<Camera3StreamInterface>>(mInputStream) :
583 static_cast<sp<Camera3StreamInterface>>(mOutputStreams.get(id));
584 // Verify number of outstanding buffers
585 if (stream->getOutstandingBuffersCount() != offlineStream.numOutstandingBuffers) {
586 SET_ERR("Offline stream %d # of remaining buffer mismatch: (%zu,%d) (service/HAL)",
587 id, stream->getOutstandingBuffersCount(), offlineStream.numOutstandingBuffers);
588 return UNKNOWN_ERROR;
589 }
590 }
591
592 // Verify all streams to be deleted don't have any outstanding buffers
593 if (hasInputStream && std::find(offlineStreamIds.begin(), offlineStreamIds.end(),
594 inputStreamId) == offlineStreamIds.end()) {
595 if (mInputStream->hasOutstandingBuffers()) {
596 SET_ERR("Input stream %d still has %zu outstanding buffer!",
597 inputStreamId, mInputStream->getOutstandingBuffersCount());
598 return UNKNOWN_ERROR;
599 }
600 }
601
602 for (const auto& outStreamId : outputStreamIds) {
603 if (std::find(offlineStreamIds.begin(), offlineStreamIds.end(),
604 outStreamId) == offlineStreamIds.end()) {
605 auto outStream = mOutputStreams.get(outStreamId);
606 if (outStream->hasOutstandingBuffers()) {
607 SET_ERR("Output stream %d still has %zu outstanding buffer!",
608 outStreamId, outStream->getOutstandingBuffersCount());
609 return UNKNOWN_ERROR;
610 }
611 }
612 }
613
614 InFlightRequestMap offlineReqs;
615 // Verify inflight requests and their pending buffers
616 {
617 std::lock_guard<std::mutex> l(mInFlightLock);
618 for (auto offlineReq : offlineSessionInfo.offlineRequests) {
619 int idx = mInFlightMap.indexOfKey(offlineReq.frameNumber);
620 if (idx == NAME_NOT_FOUND) {
621 SET_ERR("Offline request frame number %d not found!", offlineReq.frameNumber);
622 return UNKNOWN_ERROR;
623 }
624
625 const auto& inflightReq = mInFlightMap.valueAt(idx);
626 // TODO: check specific stream IDs
627 size_t numBuffersLeft = static_cast<size_t>(inflightReq.numBuffersLeft);
628 if (numBuffersLeft != offlineReq.pendingStreams.size()) {
629 SET_ERR("Offline request # of remaining buffer mismatch: (%d,%d) (service/HAL)",
630 inflightReq.numBuffersLeft, offlineReq.pendingStreams.size());
631 return UNKNOWN_ERROR;
632 }
633 offlineReqs.add(offlineReq.frameNumber, inflightReq);
634 }
635 }
636
637 // Create Camera3OfflineSession and transfer object ownership
638 // (streams, inflight requests, buffer caches)
639 camera3::StreamSet offlineStreamSet;
640 sp<camera3::Camera3Stream> inputStream;
641 for (auto offlineStream : offlineSessionInfo.offlineStreams) {
642 int32_t id = offlineStream.id;
643 if (mInputStream != nullptr && id == mInputStream->getId()) {
644 inputStream = mInputStream;
645 } else {
646 offlineStreamSet.add(id, mOutputStreams.get(id));
647 }
648 }
649
650 // TODO: check if we need to lock before copying states
651 // though technically no other thread should be talking to Camera3Device at this point
652 Camera3OfflineStates offlineStates(
653 mTagMonitor, mVendorTagId, mUseHalBufManager, mHalBufManagedStreamIds,
654 mNeedFixupMonochromeTags, mUsePartialResult, mNumPartialResults,
655 mLastCompletedRegularFrameNumber, mLastCompletedReprocessFrameNumber,
656 mLastCompletedZslFrameNumber, mNextResultFrameNumber,
657 mNextReprocessResultFrameNumber, mNextZslStillResultFrameNumber,
658 mNextShutterFrameNumber, mNextReprocessShutterFrameNumber,
659 mNextZslStillShutterFrameNumber, mDeviceInfo, mPhysicalDeviceInfoMap,
660 mDistortionMappers, mZoomRatioMappers, mRotateAndCropMappers);
661
662 *session = new HidlCamera3OfflineSession(mId, inputStream, offlineStreamSet,
663 std::move(bufferRecords), offlineReqs, offlineStates, offlineSession);
664
665 // Delete all streams that has been transferred to offline session
666 Mutex::Autolock l(mLock);
667 for (auto offlineStream : offlineSessionInfo.offlineStreams) {
668 int32_t id = offlineStream.id;
669 if (mInputStream != nullptr && id == mInputStream->getId()) {
670 mInputStream.clear();
671 } else {
672 mOutputStreams.remove(id);
673 }
674 }
675
676 // disconnect all other streams and switch to UNCONFIGURED state
677 if (mInputStream != nullptr) {
678 ret = mInputStream->disconnect();
679 if (ret != OK) {
680 SET_ERR_L("disconnect input stream failed!");
681 return UNKNOWN_ERROR;
682 }
683 }
684
685 for (auto streamId : mOutputStreams.getStreamIds()) {
686 sp<Camera3StreamInterface> stream = mOutputStreams.get(streamId);
687 ret = stream->disconnect();
688 if (ret != OK) {
689 SET_ERR_L("disconnect output stream %d failed!", streamId);
690 return UNKNOWN_ERROR;
691 }
692 }
693
694 mInputStream.clear();
695 mOutputStreams.clear();
696 mNeedConfig = true;
697 internalUpdateStatusLocked(STATUS_UNCONFIGURED);
698 mOperatingMode = NO_MODE;
699 mIsConstrainedHighSpeedConfiguration = false;
700 mRequestThread->clearPreviousRequest();
701
702 return OK;
703 // TO be done by CameraDeviceClient/Camera3OfflineSession
704 // register the offline client to camera service
705 // Setup result passthing threads etc
706 // Initialize offline session so HAL can start sending callback to it (result Fmq)
707 // TODO: check how many onIdle callback will be sent
708 // Java side to make sure the CameraCaptureSession is properly closed
709 }
710
applyMaxBatchSizeLocked(RequestList * requestList,const sp<camera3::Camera3OutputStreamInterface> & stream)711 void HidlCamera3Device::applyMaxBatchSizeLocked(
712 RequestList* requestList, const sp<camera3::Camera3OutputStreamInterface>& stream) {
713 int batchSize = requestList->size();
714
715 (*requestList->begin())->mBatchSize = batchSize;
716 stream->setBatchSize(batchSize);
717 }
718
createNewRequestThread(wp<Camera3Device> parent,sp<camera3::StatusTracker> statusTracker,sp<Camera3Device::HalInterface> interface,const Vector<int32_t> & sessionParamKeys,bool useHalBufManager,bool supportCameraMute,int rotationOverride,bool supportSettingsOverride)719 sp<Camera3Device::RequestThread> HidlCamera3Device::createNewRequestThread(
720 wp<Camera3Device> parent, sp<camera3::StatusTracker> statusTracker,
721 sp<Camera3Device::HalInterface> interface,
722 const Vector<int32_t>& sessionParamKeys,
723 bool useHalBufManager,
724 bool supportCameraMute,
725 int rotationOverride,
726 bool supportSettingsOverride) {
727 return new HidlRequestThread(parent, statusTracker, interface, sessionParamKeys,
728 useHalBufManager, supportCameraMute, rotationOverride,
729 supportSettingsOverride);
730 };
731
732 sp<Camera3Device::Camera3DeviceInjectionMethods>
createCamera3DeviceInjectionMethods(wp<Camera3Device> parent)733 HidlCamera3Device::createCamera3DeviceInjectionMethods(wp<Camera3Device> parent) {
734 return new HidlCamera3DeviceInjectionMethods(parent);
735 }
736
injectionCameraInitialize(const std::string & injectedCamId,sp<CameraProviderManager> manager)737 status_t HidlCamera3Device::injectionCameraInitialize(const std::string &injectedCamId,
738 sp<CameraProviderManager> manager) {
739 return (static_cast<HidlCamera3DeviceInjectionMethods *>(
740 mInjectionMethods.get()))->injectionInitialize(injectedCamId, manager, this);
741 };
742
743
HidlHalInterface(sp<device::V3_2::ICameraDeviceSession> & session,std::shared_ptr<RequestMetadataQueue> queue,bool useHalBufManager,bool supportOfflineProcessing)744 HidlCamera3Device::HidlHalInterface::HidlHalInterface(
745 sp<device::V3_2::ICameraDeviceSession> &session,
746 std::shared_ptr<RequestMetadataQueue> queue,
747 bool useHalBufManager, bool supportOfflineProcessing) :
748 HalInterface(useHalBufManager, supportOfflineProcessing),
749 mHidlSession(session),
750 mRequestMetadataQueue(queue) {
751 // Check with hardware service manager if we can downcast these interfaces
752 // Somewhat expensive, so cache the results at startup
753 auto castResult_3_7 = device::V3_7::ICameraDeviceSession::castFrom(mHidlSession);
754 if (castResult_3_7.isOk()) {
755 mHidlSession_3_7 = castResult_3_7;
756 }
757 auto castResult_3_6 = device::V3_6::ICameraDeviceSession::castFrom(mHidlSession);
758 if (castResult_3_6.isOk()) {
759 mHidlSession_3_6 = castResult_3_6;
760 }
761 auto castResult_3_5 = device::V3_5::ICameraDeviceSession::castFrom(mHidlSession);
762 if (castResult_3_5.isOk()) {
763 mHidlSession_3_5 = castResult_3_5;
764 }
765 auto castResult_3_4 = device::V3_4::ICameraDeviceSession::castFrom(mHidlSession);
766 if (castResult_3_4.isOk()) {
767 mHidlSession_3_4 = castResult_3_4;
768 }
769 auto castResult_3_3 = device::V3_3::ICameraDeviceSession::castFrom(mHidlSession);
770 if (castResult_3_3.isOk()) {
771 mHidlSession_3_3 = castResult_3_3;
772 }
773 }
774
valid()775 bool HidlCamera3Device::HidlHalInterface::valid() {
776 return (mHidlSession != nullptr);
777 }
778
clear()779 void HidlCamera3Device::HidlHalInterface::clear() {
780 mHidlSession_3_7.clear();
781 mHidlSession_3_6.clear();
782 mHidlSession_3_5.clear();
783 mHidlSession_3_4.clear();
784 mHidlSession_3_3.clear();
785 mHidlSession.clear();
786 }
787
constructDefaultRequestSettings(camera_request_template_t templateId,camera_metadata_t ** requestTemplate)788 status_t HidlCamera3Device::HidlHalInterface::constructDefaultRequestSettings(
789 camera_request_template_t templateId,
790 /*out*/ camera_metadata_t **requestTemplate) {
791 ATRACE_NAME("CameraHidlHal::constructDefaultRequestSettings");
792 if (!valid()) return INVALID_OPERATION;
793 status_t res = OK;
794
795 common::V1_0::Status status;
796
797 auto requestCallback = [&status, &requestTemplate]
798 (common::V1_0::Status s, const device::V3_2::CameraMetadata& request) {
799 status = s;
800 if (status == common::V1_0::Status::OK) {
801 const camera_metadata *r =
802 reinterpret_cast<const camera_metadata_t*>(request.data());
803 size_t expectedSize = request.size();
804 int ret = validate_camera_metadata_structure(r, &expectedSize);
805 if (ret == OK || ret == CAMERA_METADATA_VALIDATION_SHIFTED) {
806 *requestTemplate = clone_camera_metadata(r);
807 if (*requestTemplate == nullptr) {
808 ALOGE("%s: Unable to clone camera metadata received from HAL",
809 __FUNCTION__);
810 status = common::V1_0::Status::INTERNAL_ERROR;
811 }
812 } else {
813 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
814 status = common::V1_0::Status::INTERNAL_ERROR;
815 }
816 }
817 };
818 hardware::Return<void> err;
819 RequestTemplate id;
820 switch (templateId) {
821 case CAMERA_TEMPLATE_PREVIEW:
822 id = RequestTemplate::PREVIEW;
823 break;
824 case CAMERA_TEMPLATE_STILL_CAPTURE:
825 id = RequestTemplate::STILL_CAPTURE;
826 break;
827 case CAMERA_TEMPLATE_VIDEO_RECORD:
828 id = RequestTemplate::VIDEO_RECORD;
829 break;
830 case CAMERA_TEMPLATE_VIDEO_SNAPSHOT:
831 id = RequestTemplate::VIDEO_SNAPSHOT;
832 break;
833 case CAMERA_TEMPLATE_ZERO_SHUTTER_LAG:
834 id = RequestTemplate::ZERO_SHUTTER_LAG;
835 break;
836 case CAMERA_TEMPLATE_MANUAL:
837 id = RequestTemplate::MANUAL;
838 break;
839 default:
840 // Unknown template ID, or this HAL is too old to support it
841 return BAD_VALUE;
842 }
843 err = mHidlSession->constructDefaultRequestSettings(id, requestCallback);
844
845 if (!err.isOk()) {
846 ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str());
847 res = DEAD_OBJECT;
848 } else {
849 res = HidlProviderInfo::mapToStatusT(status);
850 }
851
852 return res;
853 }
854
isReconfigurationRequired(CameraMetadata & oldSessionParams,CameraMetadata & newSessionParams)855 bool HidlCamera3Device::HidlHalInterface::isReconfigurationRequired(
856 CameraMetadata& oldSessionParams, CameraMetadata& newSessionParams) {
857 // We do reconfiguration by default;
858 bool ret = true;
859 if ((mHidlSession_3_5 != nullptr) && mIsReconfigurationQuerySupported) {
860 android::hardware::hidl_vec<uint8_t> oldParams, newParams;
861 camera_metadata_t* oldSessioMeta = const_cast<camera_metadata_t*>(
862 oldSessionParams.getAndLock());
863 camera_metadata_t* newSessioMeta = const_cast<camera_metadata_t*>(
864 newSessionParams.getAndLock());
865 oldParams.setToExternal(reinterpret_cast<uint8_t*>(oldSessioMeta),
866 get_camera_metadata_size(oldSessioMeta));
867 newParams.setToExternal(reinterpret_cast<uint8_t*>(newSessioMeta),
868 get_camera_metadata_size(newSessioMeta));
869 hardware::camera::common::V1_0::Status callStatus;
870 bool required;
871 auto hidlCb = [&callStatus, &required] (hardware::camera::common::V1_0::Status s,
872 bool requiredFlag) {
873 callStatus = s;
874 required = requiredFlag;
875 };
876 auto err = mHidlSession_3_5->isReconfigurationRequired(oldParams, newParams, hidlCb);
877 oldSessionParams.unlock(oldSessioMeta);
878 newSessionParams.unlock(newSessioMeta);
879 if (err.isOk()) {
880 switch (callStatus) {
881 case hardware::camera::common::V1_0::Status::OK:
882 ret = required;
883 break;
884 case hardware::camera::common::V1_0::Status::METHOD_NOT_SUPPORTED:
885 mIsReconfigurationQuerySupported = false;
886 ret = true;
887 break;
888 default:
889 ALOGV("%s: Reconfiguration query failed: %d", __FUNCTION__, eToI(callStatus));
890 ret = true;
891 }
892 } else {
893 ALOGE("%s: Unexpected binder error: %s", __FUNCTION__, err.description().c_str());
894 ret = true;
895 }
896 }
897
898 return ret;
899 }
900
configureStreams(const camera_metadata_t * sessionParams,camera_stream_configuration * config,const std::vector<uint32_t> & bufferSizes,int64_t)901 status_t HidlCamera3Device::HidlHalInterface::configureStreams(
902 const camera_metadata_t *sessionParams,
903 camera_stream_configuration *config, const std::vector<uint32_t>& bufferSizes,
904 int64_t /*logId*/) {
905 ATRACE_NAME("CameraHal::configureStreams");
906 if (!valid()) return INVALID_OPERATION;
907 status_t res = OK;
908
909 if (config->input_is_multi_resolution && mHidlSession_3_7 == nullptr) {
910 ALOGE("%s: Camera device doesn't support multi-resolution input stream", __FUNCTION__);
911 return BAD_VALUE;
912 }
913
914 // Convert stream config to HIDL
915 std::set<int> activeStreams;
916 device::V3_2::StreamConfiguration requestedConfiguration3_2;
917 device::V3_4::StreamConfiguration requestedConfiguration3_4;
918 device::V3_7::StreamConfiguration requestedConfiguration3_7;
919 requestedConfiguration3_2.streams.resize(config->num_streams);
920 requestedConfiguration3_4.streams.resize(config->num_streams);
921 requestedConfiguration3_7.streams.resize(config->num_streams);
922 mHalBufManagedStreamIds.clear();
923 for (size_t i = 0; i < config->num_streams; i++) {
924 device::V3_2::Stream &dst3_2 = requestedConfiguration3_2.streams[i];
925 device::V3_4::Stream &dst3_4 = requestedConfiguration3_4.streams[i];
926 device::V3_7::Stream &dst3_7 = requestedConfiguration3_7.streams[i];
927 camera3::camera_stream_t *src = config->streams[i];
928
929 Camera3Stream* cam3stream = Camera3Stream::cast(src);
930 cam3stream->setBufferFreedListener(this);
931 int streamId = cam3stream->getId();
932 StreamType streamType;
933 switch (src->stream_type) {
934 case CAMERA_STREAM_OUTPUT:
935 streamType = StreamType::OUTPUT;
936 if (mUseHalBufManager) {
937 mHalBufManagedStreamIds.insert(streamId);
938 }
939 break;
940 case CAMERA_STREAM_INPUT:
941 streamType = StreamType::INPUT;
942 break;
943 default:
944 ALOGE("%s: Stream %d: Unsupported stream type %d",
945 __FUNCTION__, streamId, config->streams[i]->stream_type);
946 return BAD_VALUE;
947 }
948
949 dst3_2.id = streamId;
950 dst3_2.streamType = streamType;
951 dst3_2.width = src->width;
952 dst3_2.height = src->height;
953 dst3_2.usage = mapToConsumerUsage(cam3stream->getUsage());
954 dst3_2.rotation = mapToStreamRotation((camera_stream_rotation_t) src->rotation);
955 // For HidlSession version 3.5 or newer, the format and dataSpace sent
956 // to HAL are original, not the overridden ones.
957 if (mHidlSession_3_5 != nullptr) {
958 dst3_2.format = mapToPixelFormat(cam3stream->isFormatOverridden() ?
959 cam3stream->getOriginalFormat() : src->format);
960 dst3_2.dataSpace = mapToHidlDataspace(cam3stream->isDataSpaceOverridden() ?
961 cam3stream->getOriginalDataSpace() : src->data_space);
962 } else {
963 dst3_2.format = mapToPixelFormat(src->format);
964 dst3_2.dataSpace = mapToHidlDataspace(src->data_space);
965 }
966 dst3_4.v3_2 = dst3_2;
967 dst3_4.bufferSize = bufferSizes[i];
968 if (!src->physical_camera_id.empty()) {
969 dst3_4.physicalCameraId = src->physical_camera_id;
970 }
971 dst3_7.v3_4 = dst3_4;
972 dst3_7.groupId = cam3stream->getHalStreamGroupId();
973 dst3_7.sensorPixelModesUsed.resize(src->sensor_pixel_modes_used.size());
974 size_t j = 0;
975 for (int mode : src->sensor_pixel_modes_used) {
976 dst3_7.sensorPixelModesUsed[j++] =
977 static_cast<CameraMetadataEnumAndroidSensorPixelMode>(mode);
978 }
979 if (src->dynamic_range_profile !=
980 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD) {
981 ALOGE("%s: Camera device doesn't support non-standard dynamic range profiles: %" PRIx64,
982 __FUNCTION__, src->dynamic_range_profile);
983 return BAD_VALUE;
984 }
985 if (src->use_case != ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT) {
986 ALOGE("%s: Camera device doesn't support non-default stream use case %" PRId64 "!",
987 __FUNCTION__, src->use_case);
988 return BAD_VALUE;
989 }
990 activeStreams.insert(streamId);
991 // Create Buffer ID map if necessary
992 mBufferRecords.tryCreateBufferCache(streamId);
993 }
994 // remove BufferIdMap for deleted streams
995 mBufferRecords.removeInactiveBufferCaches(activeStreams);
996
997 StreamConfigurationMode operationMode;
998 res = mapToStreamConfigurationMode(
999 (camera_stream_configuration_mode_t) config->operation_mode,
1000 /*out*/ &operationMode);
1001 if (res != OK) {
1002 return res;
1003 }
1004 requestedConfiguration3_2.operationMode = operationMode;
1005 requestedConfiguration3_4.operationMode = operationMode;
1006 requestedConfiguration3_7.operationMode = operationMode;
1007 size_t sessionParamSize = get_camera_metadata_size(sessionParams);
1008 requestedConfiguration3_4.sessionParams.setToExternal(
1009 reinterpret_cast<uint8_t*>(const_cast<camera_metadata_t*>(sessionParams)),
1010 sessionParamSize);
1011 requestedConfiguration3_7.sessionParams.setToExternal(
1012 reinterpret_cast<uint8_t*>(const_cast<camera_metadata_t*>(sessionParams)),
1013 sessionParamSize);
1014
1015 // Invoke configureStreams
1016 device::V3_3::HalStreamConfiguration finalConfiguration;
1017 device::V3_4::HalStreamConfiguration finalConfiguration3_4;
1018 device::V3_6::HalStreamConfiguration finalConfiguration3_6;
1019 common::V1_0::Status status;
1020
1021 auto configStream34Cb = [&status, &finalConfiguration3_4]
1022 (common::V1_0::Status s, const device::V3_4::HalStreamConfiguration& halConfiguration) {
1023 finalConfiguration3_4 = halConfiguration;
1024 status = s;
1025 };
1026
1027 auto configStream36Cb = [&status, &finalConfiguration3_6]
1028 (common::V1_0::Status s, const device::V3_6::HalStreamConfiguration& halConfiguration) {
1029 finalConfiguration3_6 = halConfiguration;
1030 status = s;
1031 };
1032
1033 auto postprocConfigStream34 = [&finalConfiguration, &finalConfiguration3_4]
1034 (hardware::Return<void>& err) -> status_t {
1035 if (!err.isOk()) {
1036 ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str());
1037 return DEAD_OBJECT;
1038 }
1039 finalConfiguration.streams.resize(finalConfiguration3_4.streams.size());
1040 for (size_t i = 0; i < finalConfiguration3_4.streams.size(); i++) {
1041 finalConfiguration.streams[i] = finalConfiguration3_4.streams[i].v3_3;
1042 }
1043 return OK;
1044 };
1045
1046 auto postprocConfigStream36 = [&finalConfiguration, &finalConfiguration3_6]
1047 (hardware::Return<void>& err) -> status_t {
1048 if (!err.isOk()) {
1049 ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str());
1050 return DEAD_OBJECT;
1051 }
1052 finalConfiguration.streams.resize(finalConfiguration3_6.streams.size());
1053 for (size_t i = 0; i < finalConfiguration3_6.streams.size(); i++) {
1054 finalConfiguration.streams[i] = finalConfiguration3_6.streams[i].v3_4.v3_3;
1055 }
1056 return OK;
1057 };
1058
1059 if (mHidlSession_3_7 != nullptr) {
1060 ALOGV("%s: v3.7 device found", __FUNCTION__);
1061 requestedConfiguration3_7.streamConfigCounter = mNextStreamConfigCounter++;
1062 requestedConfiguration3_7.multiResolutionInputImage = config->input_is_multi_resolution;
1063 auto err = mHidlSession_3_7->configureStreams_3_7(
1064 requestedConfiguration3_7, configStream36Cb);
1065 res = postprocConfigStream36(err);
1066 if (res != OK) {
1067 return res;
1068 }
1069 } else if (mHidlSession_3_6 != nullptr) {
1070 ALOGV("%s: v3.6 device found", __FUNCTION__);
1071 device::V3_5::StreamConfiguration requestedConfiguration3_5;
1072 requestedConfiguration3_5.v3_4 = requestedConfiguration3_4;
1073 requestedConfiguration3_5.streamConfigCounter = mNextStreamConfigCounter++;
1074 auto err = mHidlSession_3_6->configureStreams_3_6(
1075 requestedConfiguration3_5, configStream36Cb);
1076 res = postprocConfigStream36(err);
1077 if (res != OK) {
1078 return res;
1079 }
1080 } else if (mHidlSession_3_5 != nullptr) {
1081 ALOGV("%s: v3.5 device found", __FUNCTION__);
1082 device::V3_5::StreamConfiguration requestedConfiguration3_5;
1083 requestedConfiguration3_5.v3_4 = requestedConfiguration3_4;
1084 requestedConfiguration3_5.streamConfigCounter = mNextStreamConfigCounter++;
1085 auto err = mHidlSession_3_5->configureStreams_3_5(
1086 requestedConfiguration3_5, configStream34Cb);
1087 res = postprocConfigStream34(err);
1088 if (res != OK) {
1089 return res;
1090 }
1091 } else if (mHidlSession_3_4 != nullptr) {
1092 // We do; use v3.4 for the call
1093 ALOGV("%s: v3.4 device found", __FUNCTION__);
1094 auto err = mHidlSession_3_4->configureStreams_3_4(
1095 requestedConfiguration3_4, configStream34Cb);
1096 res = postprocConfigStream34(err);
1097 if (res != OK) {
1098 return res;
1099 }
1100 } else if (mHidlSession_3_3 != nullptr) {
1101 // We do; use v3.3 for the call
1102 ALOGV("%s: v3.3 device found", __FUNCTION__);
1103 auto err = mHidlSession_3_3->configureStreams_3_3(requestedConfiguration3_2,
1104 [&status, &finalConfiguration]
1105 (common::V1_0::Status s, const device::V3_3::HalStreamConfiguration& halConfiguration) {
1106 finalConfiguration = halConfiguration;
1107 status = s;
1108 });
1109 if (!err.isOk()) {
1110 ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str());
1111 return DEAD_OBJECT;
1112 }
1113 } else {
1114 // We don't; use v3.2 call and construct a v3.3 HalStreamConfiguration
1115 ALOGV("%s: v3.2 device found", __FUNCTION__);
1116 HalStreamConfiguration finalConfiguration_3_2;
1117 auto err = mHidlSession->configureStreams(requestedConfiguration3_2,
1118 [&status, &finalConfiguration_3_2]
1119 (common::V1_0::Status s, const HalStreamConfiguration& halConfiguration) {
1120 finalConfiguration_3_2 = halConfiguration;
1121 status = s;
1122 });
1123 if (!err.isOk()) {
1124 ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str());
1125 return DEAD_OBJECT;
1126 }
1127 finalConfiguration.streams.resize(finalConfiguration_3_2.streams.size());
1128 for (size_t i = 0; i < finalConfiguration_3_2.streams.size(); i++) {
1129 finalConfiguration.streams[i].v3_2 = finalConfiguration_3_2.streams[i];
1130 finalConfiguration.streams[i].overrideDataSpace =
1131 requestedConfiguration3_2.streams[i].dataSpace;
1132 }
1133 }
1134
1135 if (status != common::V1_0::Status::OK ) {
1136 return HidlProviderInfo::mapToStatusT(status);
1137 }
1138
1139 // And convert output stream configuration from HIDL
1140
1141 for (size_t i = 0; i < config->num_streams; i++) {
1142 camera3::camera_stream_t *dst = config->streams[i];
1143 int streamId = Camera3Stream::cast(dst)->getId();
1144
1145 // Start scan at i, with the assumption that the stream order matches
1146 size_t realIdx = i;
1147 bool found = false;
1148 size_t halStreamCount = finalConfiguration.streams.size();
1149 for (size_t idx = 0; idx < halStreamCount; idx++) {
1150 if (finalConfiguration.streams[realIdx].v3_2.id == streamId) {
1151 found = true;
1152 break;
1153 }
1154 realIdx = (realIdx >= halStreamCount - 1) ? 0 : realIdx + 1;
1155 }
1156 if (!found) {
1157 ALOGE("%s: Stream %d not found in stream configuration response from HAL",
1158 __FUNCTION__, streamId);
1159 return INVALID_OPERATION;
1160 }
1161 device::V3_3::HalStream &src = finalConfiguration.streams[realIdx];
1162 device::V3_6::HalStream &src_36 = finalConfiguration3_6.streams[realIdx];
1163
1164 Camera3Stream* dstStream = Camera3Stream::cast(dst);
1165 int overrideFormat = mapToFrameworkFormat(src.v3_2.overrideFormat);
1166 android_dataspace overrideDataSpace = mapToFrameworkDataspace(src.overrideDataSpace);
1167
1168 if (mHidlSession_3_6 != nullptr) {
1169 dstStream->setOfflineProcessingSupport(src_36.supportOffline);
1170 }
1171
1172 if (dstStream->getOriginalFormat() != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
1173 dstStream->setFormatOverride(false);
1174 dstStream->setDataSpaceOverride(false);
1175 if (dst->format != overrideFormat) {
1176 ALOGE("%s: Stream %d: Format override not allowed for format 0x%x", __FUNCTION__,
1177 streamId, dst->format);
1178 }
1179 if (dst->data_space != overrideDataSpace) {
1180 ALOGE("%s: Stream %d: DataSpace override not allowed for format 0x%x", __FUNCTION__,
1181 streamId, dst->format);
1182 }
1183 } else {
1184 bool needFormatOverride =
1185 requestedConfiguration3_2.streams[i].format != src.v3_2.overrideFormat;
1186 bool needDataspaceOverride =
1187 requestedConfiguration3_2.streams[i].dataSpace != src.overrideDataSpace;
1188 // Override allowed with IMPLEMENTATION_DEFINED
1189 dstStream->setFormatOverride(needFormatOverride);
1190 dstStream->setDataSpaceOverride(needDataspaceOverride);
1191 dst->format = overrideFormat;
1192 dst->data_space = overrideDataSpace;
1193 }
1194
1195 if (dst->stream_type == CAMERA_STREAM_INPUT) {
1196 if (src.v3_2.producerUsage != 0) {
1197 ALOGE("%s: Stream %d: INPUT streams must have 0 for producer usage",
1198 __FUNCTION__, streamId);
1199 return INVALID_OPERATION;
1200 }
1201 dstStream->setUsage(
1202 mapConsumerToFrameworkUsage(src.v3_2.consumerUsage));
1203 } else {
1204 // OUTPUT
1205 if (src.v3_2.consumerUsage != 0) {
1206 ALOGE("%s: Stream %d: OUTPUT streams must have 0 for consumer usage",
1207 __FUNCTION__, streamId);
1208 return INVALID_OPERATION;
1209 }
1210 dstStream->setUsage(
1211 mapProducerToFrameworkUsage(src.v3_2.producerUsage));
1212 }
1213 dst->max_buffers = src.v3_2.maxBuffers;
1214 }
1215
1216 return res;
1217 }
1218
configureInjectedStreams(const camera_metadata_t * sessionParams,camera_stream_configuration * config,const std::vector<uint32_t> & bufferSizes,const CameraMetadata & cameraCharacteristics)1219 status_t HidlCamera3Device::HidlHalInterface::configureInjectedStreams(
1220 const camera_metadata_t* sessionParams, camera_stream_configuration* config,
1221 const std::vector<uint32_t>& bufferSizes,
1222 const CameraMetadata& cameraCharacteristics) {
1223 ATRACE_NAME("InjectionCameraHal::configureStreams");
1224 if (!valid()) return INVALID_OPERATION;
1225 status_t res = OK;
1226
1227 if (config->input_is_multi_resolution) {
1228 ALOGE("%s: Injection camera device doesn't support multi-resolution input "
1229 "stream", __FUNCTION__);
1230 return BAD_VALUE;
1231 }
1232
1233 // Convert stream config to HIDL
1234 std::set<int> activeStreams;
1235 device::V3_2::StreamConfiguration requestedConfiguration3_2;
1236 device::V3_4::StreamConfiguration requestedConfiguration3_4;
1237 device::V3_7::StreamConfiguration requestedConfiguration3_7;
1238 requestedConfiguration3_2.streams.resize(config->num_streams);
1239 requestedConfiguration3_4.streams.resize(config->num_streams);
1240 requestedConfiguration3_7.streams.resize(config->num_streams);
1241 for (size_t i = 0; i < config->num_streams; i++) {
1242 device::V3_2::Stream& dst3_2 = requestedConfiguration3_2.streams[i];
1243 device::V3_4::Stream& dst3_4 = requestedConfiguration3_4.streams[i];
1244 device::V3_7::Stream& dst3_7 = requestedConfiguration3_7.streams[i];
1245 camera3::camera_stream_t* src = config->streams[i];
1246
1247 Camera3Stream* cam3stream = Camera3Stream::cast(src);
1248 cam3stream->setBufferFreedListener(this);
1249 int streamId = cam3stream->getId();
1250 StreamType streamType;
1251 switch (src->stream_type) {
1252 case CAMERA_STREAM_OUTPUT:
1253 streamType = StreamType::OUTPUT;
1254 break;
1255 case CAMERA_STREAM_INPUT:
1256 streamType = StreamType::INPUT;
1257 break;
1258 default:
1259 ALOGE("%s: Stream %d: Unsupported stream type %d", __FUNCTION__,
1260 streamId, config->streams[i]->stream_type);
1261 return BAD_VALUE;
1262 }
1263 dst3_2.id = streamId;
1264 dst3_2.streamType = streamType;
1265 dst3_2.width = src->width;
1266 dst3_2.height = src->height;
1267 dst3_2.usage = mapToConsumerUsage(cam3stream->getUsage());
1268 dst3_2.rotation =
1269 mapToStreamRotation((camera_stream_rotation_t)src->rotation);
1270 // For HidlSession version 3.5 or newer, the format and dataSpace sent
1271 // to HAL are original, not the overridden ones.
1272 if (mHidlSession_3_5 != nullptr) {
1273 dst3_2.format = mapToPixelFormat(cam3stream->isFormatOverridden()
1274 ? cam3stream->getOriginalFormat()
1275 : src->format);
1276 dst3_2.dataSpace =
1277 mapToHidlDataspace(cam3stream->isDataSpaceOverridden()
1278 ? cam3stream->getOriginalDataSpace()
1279 : src->data_space);
1280 } else {
1281 dst3_2.format = mapToPixelFormat(src->format);
1282 dst3_2.dataSpace = mapToHidlDataspace(src->data_space);
1283 }
1284 dst3_4.v3_2 = dst3_2;
1285 dst3_4.bufferSize = bufferSizes[i];
1286 if (!src->physical_camera_id.empty()) {
1287 dst3_4.physicalCameraId = src->physical_camera_id;
1288 }
1289 dst3_7.v3_4 = dst3_4;
1290 dst3_7.groupId = cam3stream->getHalStreamGroupId();
1291 dst3_7.sensorPixelModesUsed.resize(src->sensor_pixel_modes_used.size());
1292 size_t j = 0;
1293 for (int mode : src->sensor_pixel_modes_used) {
1294 dst3_7.sensorPixelModesUsed[j++] =
1295 static_cast<CameraMetadataEnumAndroidSensorPixelMode>(mode);
1296 }
1297 activeStreams.insert(streamId);
1298 // Create Buffer ID map if necessary
1299 mBufferRecords.tryCreateBufferCache(streamId);
1300 }
1301 // remove BufferIdMap for deleted streams
1302 mBufferRecords.removeInactiveBufferCaches(activeStreams);
1303
1304 StreamConfigurationMode operationMode;
1305 res = mapToStreamConfigurationMode(
1306 (camera_stream_configuration_mode_t)config->operation_mode,
1307 /*out*/ &operationMode);
1308 if (res != OK) {
1309 return res;
1310 }
1311 requestedConfiguration3_7.operationMode = operationMode;
1312 size_t sessionParamSize = get_camera_metadata_size(sessionParams);
1313 requestedConfiguration3_7.operationMode = operationMode;
1314 requestedConfiguration3_7.sessionParams.setToExternal(
1315 reinterpret_cast<uint8_t*>(const_cast<camera_metadata_t*>(sessionParams)),
1316 sessionParamSize);
1317
1318 // See which version of HAL we have
1319 if (mHidlSession_3_7 != nullptr) {
1320 requestedConfiguration3_7.streamConfigCounter = mNextStreamConfigCounter++;
1321 requestedConfiguration3_7.multiResolutionInputImage =
1322 config->input_is_multi_resolution;
1323
1324 const camera_metadata_t* rawMetadata = cameraCharacteristics.getAndLock();
1325 ::android::hardware::camera::device::V3_2::CameraMetadata hidlChars = {};
1326 hidlChars.setToExternal(
1327 reinterpret_cast<uint8_t*>(const_cast<camera_metadata_t*>(rawMetadata)),
1328 get_camera_metadata_size(rawMetadata));
1329 cameraCharacteristics.unlock(rawMetadata);
1330
1331 sp<hardware::camera::device::V3_7::ICameraInjectionSession>
1332 hidlInjectionSession_3_7;
1333 auto castInjectionResult_3_7 =
1334 device::V3_7::ICameraInjectionSession::castFrom(mHidlSession_3_7);
1335 if (castInjectionResult_3_7.isOk()) {
1336 hidlInjectionSession_3_7 = castInjectionResult_3_7;
1337 } else {
1338 ALOGE("%s: Transaction error: %s", __FUNCTION__,
1339 castInjectionResult_3_7.description().c_str());
1340 return DEAD_OBJECT;
1341 }
1342
1343 auto err = hidlInjectionSession_3_7->configureInjectionStreams(
1344 requestedConfiguration3_7, hidlChars);
1345 if (!err.isOk()) {
1346 ALOGE("%s: Transaction error: %s", __FUNCTION__,
1347 err.description().c_str());
1348 return DEAD_OBJECT;
1349 }
1350 } else {
1351 ALOGE("%s: mHidlSession_3_7 does not exist, the lowest version of injection "
1352 "session is 3.7", __FUNCTION__);
1353 return DEAD_OBJECT;
1354 }
1355
1356 return res;
1357 }
1358
wrapAsHidlRequest(camera_capture_request_t * request,device::V3_2::CaptureRequest * captureRequest,std::vector<native_handle_t * > * handlesCreated,std::vector<std::pair<int32_t,int32_t>> * inflightBuffers)1359 status_t HidlCamera3Device::HidlHalInterface::wrapAsHidlRequest(camera_capture_request_t* request,
1360 /*out*/device::V3_2::CaptureRequest* captureRequest,
1361 /*out*/std::vector<native_handle_t*>* handlesCreated,
1362 /*out*/std::vector<std::pair<int32_t, int32_t>>* inflightBuffers) {
1363 ATRACE_CALL();
1364 if (captureRequest == nullptr || handlesCreated == nullptr || inflightBuffers == nullptr) {
1365 ALOGE("%s: captureRequest (%p), handlesCreated (%p), and inflightBuffers(%p) "
1366 "must not be null", __FUNCTION__, captureRequest, handlesCreated, inflightBuffers);
1367 return BAD_VALUE;
1368 }
1369
1370 captureRequest->frameNumber = request->frame_number;
1371
1372 captureRequest->fmqSettingsSize = 0;
1373
1374 {
1375 if (request->input_buffer != nullptr) {
1376 int32_t streamId = Camera3Stream::cast(request->input_buffer->stream)->getId();
1377 buffer_handle_t buf = *(request->input_buffer->buffer);
1378 auto pair = getBufferId(buf, streamId);
1379 bool isNewBuffer = pair.first;
1380 uint64_t bufferId = pair.second;
1381 captureRequest->inputBuffer.streamId = streamId;
1382 captureRequest->inputBuffer.bufferId = bufferId;
1383 captureRequest->inputBuffer.buffer = (isNewBuffer) ? buf : nullptr;
1384 captureRequest->inputBuffer.status = BufferStatus::OK;
1385 native_handle_t *acquireFence = nullptr;
1386 if (request->input_buffer->acquire_fence != -1) {
1387 acquireFence = native_handle_create(1,0);
1388 acquireFence->data[0] = request->input_buffer->acquire_fence;
1389 handlesCreated->push_back(acquireFence);
1390 }
1391 captureRequest->inputBuffer.acquireFence = acquireFence;
1392 captureRequest->inputBuffer.releaseFence = nullptr;
1393
1394 mBufferRecords.pushInflightBuffer(captureRequest->frameNumber, streamId,
1395 request->input_buffer->buffer);
1396 inflightBuffers->push_back(std::make_pair(captureRequest->frameNumber, streamId));
1397 } else {
1398 captureRequest->inputBuffer.streamId = -1;
1399 captureRequest->inputBuffer.bufferId = BUFFER_ID_NO_BUFFER;
1400 }
1401
1402 captureRequest->outputBuffers.resize(request->num_output_buffers);
1403 for (size_t i = 0; i < request->num_output_buffers; i++) {
1404 const camera_stream_buffer_t *src = request->output_buffers + i;
1405 StreamBuffer &dst = captureRequest->outputBuffers[i];
1406 int32_t streamId = Camera3Stream::cast(src->stream)->getId();
1407 if (src->buffer != nullptr) {
1408 buffer_handle_t buf = *(src->buffer);
1409 auto pair = getBufferId(buf, streamId);
1410 bool isNewBuffer = pair.first;
1411 dst.bufferId = pair.second;
1412 dst.buffer = isNewBuffer ? buf : nullptr;
1413 native_handle_t *acquireFence = nullptr;
1414 if (src->acquire_fence != -1) {
1415 acquireFence = native_handle_create(1,0);
1416 acquireFence->data[0] = src->acquire_fence;
1417 handlesCreated->push_back(acquireFence);
1418 }
1419 dst.acquireFence = acquireFence;
1420 } else if (mUseHalBufManager) {
1421 // HAL buffer management path
1422 dst.bufferId = BUFFER_ID_NO_BUFFER;
1423 dst.buffer = nullptr;
1424 dst.acquireFence = nullptr;
1425 } else {
1426 ALOGE("%s: cannot send a null buffer in capture request!", __FUNCTION__);
1427 return BAD_VALUE;
1428 }
1429 dst.streamId = streamId;
1430 dst.status = BufferStatus::OK;
1431 dst.releaseFence = nullptr;
1432
1433 // Output buffers are empty when using HAL buffer manager
1434 if (!mUseHalBufManager) {
1435 mBufferRecords.pushInflightBuffer(
1436 captureRequest->frameNumber, streamId, src->buffer);
1437 inflightBuffers->push_back(std::make_pair(captureRequest->frameNumber, streamId));
1438 }
1439 }
1440 }
1441 return OK;
1442 }
1443
flush()1444 status_t HidlCamera3Device::HidlHalInterface::flush() {
1445 ATRACE_NAME("CameraHal::flush");
1446 if (!valid()) return INVALID_OPERATION;
1447 status_t res = OK;
1448
1449 auto err = mHidlSession->flush();
1450 if (!err.isOk()) {
1451 ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str());
1452 res = DEAD_OBJECT;
1453 } else {
1454 res = HidlProviderInfo::mapToStatusT(err);
1455 }
1456
1457 return res;
1458 }
1459
dump(int)1460 status_t HidlCamera3Device::HidlHalInterface::dump(int /*fd*/) {
1461 ATRACE_NAME("CameraHal::dump");
1462 if (!valid()) return INVALID_OPERATION;
1463
1464 // Handled by CameraProviderManager::dump
1465
1466 return OK;
1467 }
1468
repeatingRequestEnd(uint32_t,const std::vector<int32_t> &)1469 status_t HidlCamera3Device::HidlHalInterface::repeatingRequestEnd(uint32_t /*frameNumber*/,
1470 const std::vector<int32_t> &/*streamIds*/) {
1471 ATRACE_NAME("CameraHal::repeatingRequestEnd");
1472 return INVALID_OPERATION;
1473 }
1474
close()1475 status_t HidlCamera3Device::HidlHalInterface::close() {
1476 ATRACE_NAME("CameraHal::close()");
1477 if (!valid()) return INVALID_OPERATION;
1478 status_t res = OK;
1479
1480 auto err = mHidlSession->close();
1481 // Interface will be dead shortly anyway, so don't log errors
1482 if (!err.isOk()) {
1483 res = DEAD_OBJECT;
1484 }
1485
1486 return res;
1487 }
1488
signalPipelineDrain(const std::vector<int> & streamIds)1489 void HidlCamera3Device::HidlHalInterface::signalPipelineDrain(const std::vector<int>& streamIds) {
1490 ATRACE_NAME("CameraHal::signalPipelineDrain");
1491 if (!valid() || mHidlSession_3_5 == nullptr) {
1492 ALOGE("%s called on invalid camera!", __FUNCTION__);
1493 return;
1494 }
1495
1496 auto err = mHidlSession_3_5->signalStreamFlush(streamIds, mNextStreamConfigCounter - 1);
1497 if (!err.isOk()) {
1498 ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str());
1499 return;
1500 }
1501 }
1502
processBatchCaptureRequests(std::vector<camera_capture_request_t * > & requests,uint32_t * numRequestProcessed)1503 status_t HidlCamera3Device::HidlHalInterface::processBatchCaptureRequests(
1504 std::vector<camera_capture_request_t*>& requests,/*out*/uint32_t* numRequestProcessed) {
1505 ATRACE_NAME("CameraHal::processBatchCaptureRequests");
1506 if (!valid()) return INVALID_OPERATION;
1507
1508 sp<device::V3_4::ICameraDeviceSession> hidlSession_3_4;
1509 sp<device::V3_7::ICameraDeviceSession> hidlSession_3_7;
1510 auto castResult_3_7 = device::V3_7::ICameraDeviceSession::castFrom(mHidlSession);
1511 if (castResult_3_7.isOk()) {
1512 hidlSession_3_7 = castResult_3_7;
1513 }
1514 auto castResult_3_4 = device::V3_4::ICameraDeviceSession::castFrom(mHidlSession);
1515 if (castResult_3_4.isOk()) {
1516 hidlSession_3_4 = castResult_3_4;
1517 }
1518
1519 hardware::hidl_vec<device::V3_2::CaptureRequest> captureRequests;
1520 hardware::hidl_vec<device::V3_4::CaptureRequest> captureRequests_3_4;
1521 hardware::hidl_vec<device::V3_7::CaptureRequest> captureRequests_3_7;
1522 size_t batchSize = requests.size();
1523 if (hidlSession_3_7 != nullptr) {
1524 captureRequests_3_7.resize(batchSize);
1525 } else if (hidlSession_3_4 != nullptr) {
1526 captureRequests_3_4.resize(batchSize);
1527 } else {
1528 captureRequests.resize(batchSize);
1529 }
1530 std::vector<native_handle_t*> handlesCreated;
1531 std::vector<std::pair<int32_t, int32_t>> inflightBuffers;
1532
1533 status_t res = OK;
1534 for (size_t i = 0; i < batchSize; i++) {
1535 if (hidlSession_3_7 != nullptr) {
1536 res = wrapAsHidlRequest(requests[i], /*out*/&captureRequests_3_7[i].v3_4.v3_2,
1537 /*out*/&handlesCreated, /*out*/&inflightBuffers);
1538 } else if (hidlSession_3_4 != nullptr) {
1539 res = wrapAsHidlRequest(requests[i], /*out*/&captureRequests_3_4[i].v3_2,
1540 /*out*/&handlesCreated, /*out*/&inflightBuffers);
1541 } else {
1542 res = wrapAsHidlRequest(requests[i], /*out*/&captureRequests[i],
1543 /*out*/&handlesCreated, /*out*/&inflightBuffers);
1544 }
1545 if (res != OK) {
1546 mBufferRecords.popInflightBuffers(inflightBuffers);
1547 cleanupNativeHandles(&handlesCreated);
1548 return res;
1549 }
1550 }
1551
1552 std::vector<device::V3_2::BufferCache> cachesToRemove;
1553 {
1554 std::lock_guard<std::mutex> lock(mFreedBuffersLock);
1555 for (auto& pair : mFreedBuffers) {
1556 // The stream might have been removed since onBufferFreed
1557 if (mBufferRecords.isStreamCached(pair.first)) {
1558 cachesToRemove.push_back({pair.first, pair.second});
1559 }
1560 }
1561 mFreedBuffers.clear();
1562 }
1563
1564 common::V1_0::Status status = common::V1_0::Status::INTERNAL_ERROR;
1565 *numRequestProcessed = 0;
1566
1567 // Write metadata to FMQ.
1568 for (size_t i = 0; i < batchSize; i++) {
1569 camera_capture_request_t* request = requests[i];
1570 device::V3_2::CaptureRequest* captureRequest;
1571 if (hidlSession_3_7 != nullptr) {
1572 captureRequest = &captureRequests_3_7[i].v3_4.v3_2;
1573 } else if (hidlSession_3_4 != nullptr) {
1574 captureRequest = &captureRequests_3_4[i].v3_2;
1575 } else {
1576 captureRequest = &captureRequests[i];
1577 }
1578
1579 if (request->settings != nullptr) {
1580 size_t settingsSize = get_camera_metadata_size(request->settings);
1581 if (mRequestMetadataQueue != nullptr && mRequestMetadataQueue->write(
1582 reinterpret_cast<const uint8_t*>(request->settings), settingsSize)) {
1583 captureRequest->settings.resize(0);
1584 captureRequest->fmqSettingsSize = settingsSize;
1585 } else {
1586 if (mRequestMetadataQueue != nullptr) {
1587 ALOGW("%s: couldn't utilize fmq, fallback to hwbinder", __FUNCTION__);
1588 }
1589 captureRequest->settings.setToExternal(
1590 reinterpret_cast<uint8_t*>(const_cast<camera_metadata_t*>(
1591 request->settings)),
1592 get_camera_metadata_size(request->settings));
1593 captureRequest->fmqSettingsSize = 0u;
1594 }
1595 } else {
1596 // A null request settings maps to a size-0 CameraMetadata
1597 captureRequest->settings.resize(0);
1598 captureRequest->fmqSettingsSize = 0u;
1599 }
1600
1601 // hidl session 3.7 specific handling.
1602 if (hidlSession_3_7 != nullptr) {
1603 captureRequests_3_7[i].inputWidth = request->input_width;
1604 captureRequests_3_7[i].inputHeight = request->input_height;
1605 }
1606
1607 // hidl session 3.7 and 3.4 specific handling.
1608 if (hidlSession_3_7 != nullptr || hidlSession_3_4 != nullptr) {
1609 hardware::hidl_vec<device::V3_4::PhysicalCameraSetting>& physicalCameraSettings =
1610 (hidlSession_3_7 != nullptr) ?
1611 captureRequests_3_7[i].v3_4.physicalCameraSettings :
1612 captureRequests_3_4[i].physicalCameraSettings;
1613 physicalCameraSettings.resize(request->num_physcam_settings);
1614 for (size_t j = 0; j < request->num_physcam_settings; j++) {
1615 if (request->physcam_settings != nullptr) {
1616 size_t settingsSize = get_camera_metadata_size(request->physcam_settings[j]);
1617 if (mRequestMetadataQueue != nullptr && mRequestMetadataQueue->write(
1618 reinterpret_cast<const uint8_t*>(request->physcam_settings[j]),
1619 settingsSize)) {
1620 physicalCameraSettings[j].settings.resize(0);
1621 physicalCameraSettings[j].fmqSettingsSize = settingsSize;
1622 } else {
1623 if (mRequestMetadataQueue != nullptr) {
1624 ALOGW("%s: couldn't utilize fmq, fallback to hwbinder", __FUNCTION__);
1625 }
1626 physicalCameraSettings[j].settings.setToExternal(
1627 reinterpret_cast<uint8_t*>(const_cast<camera_metadata_t*>(
1628 request->physcam_settings[j])),
1629 get_camera_metadata_size(request->physcam_settings[j]));
1630 physicalCameraSettings[j].fmqSettingsSize = 0u;
1631 }
1632 } else {
1633 physicalCameraSettings[j].fmqSettingsSize = 0u;
1634 physicalCameraSettings[j].settings.resize(0);
1635 }
1636 physicalCameraSettings[j].physicalCameraId = request->physcam_id[j];
1637 }
1638 }
1639 }
1640
1641 hardware::details::return_status err;
1642 auto resultCallback =
1643 [&status, &numRequestProcessed] (auto s, uint32_t n) {
1644 status = s;
1645 *numRequestProcessed = n;
1646 };
1647 if (hidlSession_3_7 != nullptr) {
1648 err = hidlSession_3_7->processCaptureRequest_3_7(captureRequests_3_7, cachesToRemove,
1649 resultCallback);
1650 } else if (hidlSession_3_4 != nullptr) {
1651 err = hidlSession_3_4->processCaptureRequest_3_4(captureRequests_3_4, cachesToRemove,
1652 resultCallback);
1653 } else {
1654 err = mHidlSession->processCaptureRequest(captureRequests, cachesToRemove,
1655 resultCallback);
1656 }
1657 if (!err.isOk()) {
1658 ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str());
1659 status = common::V1_0::Status::CAMERA_DISCONNECTED;
1660 }
1661
1662 if (status == common::V1_0::Status::OK && *numRequestProcessed != batchSize) {
1663 ALOGE("%s: processCaptureRequest returns OK but processed %d/%zu requests",
1664 __FUNCTION__, *numRequestProcessed, batchSize);
1665 status = common::V1_0::Status::INTERNAL_ERROR;
1666 }
1667
1668 res = HidlProviderInfo::mapToStatusT(status);
1669 if (res == OK) {
1670 if (mHidlSession->isRemote()) {
1671 // Only close acquire fence FDs when the HIDL transaction succeeds (so the FDs have been
1672 // sent to camera HAL processes)
1673 cleanupNativeHandles(&handlesCreated, /*closeFd*/true);
1674 } else {
1675 // In passthrough mode the FDs are now owned by HAL
1676 cleanupNativeHandles(&handlesCreated);
1677 }
1678 } else {
1679 mBufferRecords.popInflightBuffers(inflightBuffers);
1680 cleanupNativeHandles(&handlesCreated);
1681 }
1682 return res;
1683 }
1684
switchToOffline(const std::vector<int32_t> & streamsToKeep,hardware::camera::device::V3_6::CameraOfflineSessionInfo * offlineSessionInfo,sp<hardware::camera::device::V3_6::ICameraOfflineSession> * offlineSession,camera3::BufferRecords * bufferRecords)1685 status_t HidlCamera3Device::HidlHalInterface::switchToOffline(
1686 const std::vector<int32_t>& streamsToKeep,
1687 /*out*/hardware::camera::device::V3_6::CameraOfflineSessionInfo* offlineSessionInfo,
1688 /*out*/sp<hardware::camera::device::V3_6::ICameraOfflineSession>* offlineSession,
1689 /*out*/camera3::BufferRecords* bufferRecords) {
1690 ATRACE_NAME("CameraHal::switchToOffline");
1691 if (!valid() || mHidlSession_3_6 == nullptr) {
1692 ALOGE("%s called on invalid camera!", __FUNCTION__);
1693 return INVALID_OPERATION;
1694 }
1695
1696 if (offlineSessionInfo == nullptr || offlineSession == nullptr || bufferRecords == nullptr) {
1697 ALOGE("%s: output arguments must not be null!", __FUNCTION__);
1698 return INVALID_OPERATION;
1699 }
1700
1701 common::V1_0::Status status = common::V1_0::Status::INTERNAL_ERROR;
1702 auto resultCallback =
1703 [&status, &offlineSessionInfo, &offlineSession] (auto s, auto info, auto session) {
1704 status = s;
1705 *offlineSessionInfo = info;
1706 *offlineSession = session;
1707 };
1708 auto err = mHidlSession_3_6->switchToOffline(streamsToKeep, resultCallback);
1709
1710 if (!err.isOk()) {
1711 ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str());
1712 return DEAD_OBJECT;
1713 }
1714
1715 status_t ret = HidlProviderInfo::mapToStatusT(status);
1716 if (ret != OK) {
1717 return ret;
1718 }
1719
1720 return verifyBufferCaches(offlineSessionInfo, bufferRecords);
1721 }
1722
HidlRequestThread(wp<Camera3Device> parent,sp<camera3::StatusTracker> statusTracker,sp<HalInterface> interface,const Vector<int32_t> & sessionParamKeys,bool useHalBufManager,bool supportCameraMute,int rotationOverride,bool supportSettingsOverride)1723 HidlCamera3Device::HidlRequestThread::HidlRequestThread(wp<Camera3Device> parent,
1724 sp<camera3::StatusTracker> statusTracker,
1725 sp<HalInterface> interface,
1726 const Vector<int32_t>& sessionParamKeys,
1727 bool useHalBufManager,
1728 bool supportCameraMute,
1729 int rotationOverride,
1730 bool supportSettingsOverride) :
1731 RequestThread(parent, statusTracker, interface, sessionParamKeys, useHalBufManager,
1732 supportCameraMute, rotationOverride, supportSettingsOverride) {}
1733
switchToOffline(const std::vector<int32_t> & streamsToKeep,hardware::camera::device::V3_6::CameraOfflineSessionInfo * offlineSessionInfo,sp<hardware::camera::device::V3_6::ICameraOfflineSession> * offlineSession,camera3::BufferRecords * bufferRecords)1734 status_t HidlCamera3Device::HidlRequestThread::switchToOffline(
1735 const std::vector<int32_t>& streamsToKeep,
1736 /*out*/hardware::camera::device::V3_6::CameraOfflineSessionInfo* offlineSessionInfo,
1737 /*out*/sp<hardware::camera::device::V3_6::ICameraOfflineSession>* offlineSession,
1738 /*out*/camera3::BufferRecords* bufferRecords) {
1739 Mutex::Autolock l(mRequestLock);
1740 clearRepeatingRequestsLocked(/*lastFrameNumber*/nullptr);
1741
1742 // Wait until request thread is fully stopped
1743 // TBD: check if request thread is being paused by other APIs (shouldn't be)
1744
1745 // We could also check for mRepeatingRequests.empty(), but the API interface
1746 // is serialized by Camera3Device::mInterfaceLock so no one should be able to submit any
1747 // new requests during the call; hence skip that check.
1748 bool queueEmpty = mNextRequests.empty() && mRequestQueue.empty();
1749 while (!queueEmpty) {
1750 status_t res = mRequestSubmittedSignal.waitRelative(mRequestLock, kRequestSubmitTimeout);
1751 if (res == TIMED_OUT) {
1752 ALOGE("%s: request thread failed to submit one request within timeout!", __FUNCTION__);
1753 return res;
1754 } else if (res != OK) {
1755 ALOGE("%s: request thread failed to submit a request: %s (%d)!",
1756 __FUNCTION__, strerror(-res), res);
1757 return res;
1758 }
1759 queueEmpty = mNextRequests.empty() && mRequestQueue.empty();
1760 }
1761 return (static_cast<HidlHalInterface *>(mInterface.get()))->switchToOffline(
1762 streamsToKeep, offlineSessionInfo, offlineSession, bufferRecords);
1763 }
1764
injectionInitialize(const std::string & injectedCamId,sp<CameraProviderManager> manager,const sp<android::hardware::camera::device::V3_2::ICameraDeviceCallback> & callback)1765 status_t HidlCamera3Device::HidlCamera3DeviceInjectionMethods::injectionInitialize(
1766 const std::string& injectedCamId, sp<CameraProviderManager> manager,
1767 const sp<android::hardware::camera::device::V3_2::ICameraDeviceCallback>&
1768 callback) {
1769 ATRACE_CALL();
1770 Mutex::Autolock lock(mInjectionLock);
1771
1772 if (manager == nullptr) {
1773 ALOGE("%s: manager does not exist!", __FUNCTION__);
1774 return INVALID_OPERATION;
1775 }
1776
1777 sp<Camera3Device> parent = mParent.promote();
1778 if (parent == nullptr) {
1779 ALOGE("%s: parent does not exist!", __FUNCTION__);
1780 return INVALID_OPERATION;
1781 }
1782
1783 mInjectedCamId = injectedCamId;
1784 sp<ICameraDeviceSession> session;
1785 ATRACE_BEGIN("Injection CameraHal::openSession");
1786 status_t res = manager->openHidlSession(injectedCamId, callback,
1787 /*out*/ &session);
1788 ATRACE_END();
1789 if (res != OK) {
1790 ALOGE("Injection camera could not open camera session: %s (%d)",
1791 strerror(-res), res);
1792 return res;
1793 }
1794
1795 std::shared_ptr<RequestMetadataQueue> queue;
1796 auto requestQueueRet =
1797 session->getCaptureRequestMetadataQueue([&queue](const auto& descriptor) {
1798 queue = std::make_shared<RequestMetadataQueue>(descriptor);
1799 if (!queue->isValid() || queue->availableToWrite() <= 0) {
1800 ALOGE("Injection camera HAL returns empty request metadata fmq, not "
1801 "use it");
1802 queue = nullptr;
1803 // don't use the queue onwards.
1804 }
1805 });
1806 if (!requestQueueRet.isOk()) {
1807 ALOGE("Injection camera transaction error when getting request metadata fmq: "
1808 "%s, not use it", requestQueueRet.description().c_str());
1809 return DEAD_OBJECT;
1810 }
1811
1812 std::unique_ptr<ResultMetadataQueue>& resQueue = mInjectionResultMetadataQueue;
1813 auto resultQueueRet = session->getCaptureResultMetadataQueue(
1814 [&resQueue](const auto& descriptor) {
1815 resQueue = std::make_unique<ResultMetadataQueue>(descriptor);
1816 if (!resQueue->isValid() || resQueue->availableToWrite() <= 0) {
1817 ALOGE("Injection camera HAL returns empty result metadata fmq, not use "
1818 "it");
1819 resQueue = nullptr;
1820 // Don't use the resQueue onwards.
1821 }
1822 });
1823 if (!resultQueueRet.isOk()) {
1824 ALOGE("Injection camera transaction error when getting result metadata queue "
1825 "from camera session: %s", resultQueueRet.description().c_str());
1826 return DEAD_OBJECT;
1827 }
1828 IF_ALOGV() {
1829 session->interfaceChain(
1830 [](::android::hardware::hidl_vec<::android::hardware::hidl_string>
1831 interfaceChain) {
1832 ALOGV("Injection camera session interface chain:");
1833 for (const auto& iface : interfaceChain) {
1834 ALOGV(" %s", iface.c_str());
1835 }
1836 });
1837 }
1838
1839 ALOGV("%s: Injection camera interface = new HalInterface()", __FUNCTION__);
1840
1841 mInjectedCamHalInterface =
1842 new HidlHalInterface(session, queue, parent->mUseHalBufManager,
1843 parent->mSupportOfflineProcessing);
1844 if (mInjectedCamHalInterface == nullptr) {
1845 ALOGE("%s: mInjectedCamHalInterface does not exist!", __FUNCTION__);
1846 return DEAD_OBJECT;
1847 }
1848
1849 return OK;
1850 }
1851
replaceHalInterface(sp<HalInterface> newHalInterface,bool keepBackup)1852 status_t HidlCamera3Device::HidlCamera3DeviceInjectionMethods::replaceHalInterface(
1853 sp<HalInterface> newHalInterface, bool keepBackup) {
1854 Mutex::Autolock lock(mInjectionLock);
1855 if (newHalInterface.get() == nullptr) {
1856 ALOGE("%s: The newHalInterface does not exist, to stop replacing.",
1857 __FUNCTION__);
1858 return DEAD_OBJECT;
1859 }
1860
1861 sp<Camera3Device> parent = mParent.promote();
1862 if (parent == nullptr) {
1863 ALOGE("%s: parent does not exist!", __FUNCTION__);
1864 return INVALID_OPERATION;
1865 }
1866 if (newHalInterface->getTransportType() != IPCTransport::HIDL) {
1867 ALOGE("%s Replacing HIDL HalInterface with another transport unsupported", __FUNCTION__);
1868 return INVALID_OPERATION;
1869 }
1870
1871 HidlCamera3Device *hidlParent = static_cast<HidlCamera3Device *>(parent.get());
1872 if (keepBackup) {
1873 if (mBackupHalInterface == nullptr) {
1874 mBackupHalInterface = parent->mInterface;
1875 }
1876 if (mBackupResultMetadataQueue == nullptr) {
1877 mBackupResultMetadataQueue = std::move(hidlParent->mResultMetadataQueue);
1878 hidlParent->mResultMetadataQueue = std::move(mInjectionResultMetadataQueue);
1879 }
1880 } else {
1881 mBackupHalInterface = nullptr;
1882 hidlParent->mResultMetadataQueue = std::move(mBackupResultMetadataQueue);
1883 mBackupResultMetadataQueue = nullptr;
1884 }
1885 parent->mInterface = newHalInterface;
1886
1887 return OK;
1888 }
1889
1890 }; // namespace android
1891