xref: /aosp_15_r20/frameworks/av/services/camera/libcameraservice/device3/hidl/HidlCamera3Device.cpp (revision ec779b8e0859a360c3d303172224686826e6e0e1)
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