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