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