xref: /aosp_15_r20/frameworks/av/services/camera/libcameraservice/device3/Camera3Device.cpp (revision ec779b8e0859a360c3d303172224686826e6e0e1)
1 /*
2  * Copyright (C) 2013-2018 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 "Camera3-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 #define CLOGW(fmt, ...) ALOGW("Camera %s: %s: " fmt, mId.c_str(), __FUNCTION__, \
33             ##__VA_ARGS__)
34 
35 // Convenience macros for transitioning to the error state
36 #define SET_ERR(fmt, ...) setErrorState(   \
37     "%s: " fmt, __FUNCTION__,              \
38     ##__VA_ARGS__)
39 #define SET_ERR_L(fmt, ...) setErrorStateLocked( \
40     "%s: " fmt, __FUNCTION__,                    \
41     ##__VA_ARGS__)
42 
43 #include <inttypes.h>
44 
45 #include <utility>
46 
47 #include <android/data_space.h>
48 #include <android-base/stringprintf.h>
49 #include <sched.h>
50 #include <utils/Log.h>
51 #include <utils/Trace.h>
52 #include <utils/Timers.h>
53 #include <cutils/properties.h>
54 #include <camera/CameraUtils.h>
55 #include <camera/StringUtils.h>
56 
57 #include <android-base/properties.h>
58 #include <android/hardware/camera/device/3.7/ICameraInjectionSession.h>
59 #include <android/hardware/camera2/ICameraDeviceUser.h>
60 #include <com_android_internal_camera_flags.h>
61 #include <com_android_window_flags.h>
62 
63 #include "CameraService.h"
64 #include "FwkOnlyMetadataTags.h"
65 #include "aidl/android/hardware/graphics/common/Dataspace.h"
66 #include "aidl/AidlUtils.h"
67 #include "device3/Camera3Device.h"
68 #include "device3/Camera3FakeStream.h"
69 #include "device3/Camera3InputStream.h"
70 #include "device3/Camera3OutputStream.h"
71 #include "device3/Camera3SharedOutputStream.h"
72 #include "utils/CameraTraces.h"
73 #include "utils/SchedulingPolicyUtils.h"
74 #include "utils/SessionConfigurationUtils.h"
75 #include "utils/TraceHFR.h"
76 #include "utils/Utils.h"
77 
78 #include <algorithm>
79 #include <optional>
80 #include <tuple>
81 
82 using namespace android::camera3;
83 using namespace android::camera3::SessionConfigurationUtils;
84 using namespace android::hardware::camera;
85 using namespace android::hardware::cameraservice::utils::conversion::aidl;
86 
87 namespace flags = com::android::internal::camera::flags;
88 namespace wm_flags = com::android::window::flags;
89 
90 namespace android {
91 
Camera3Device(std::shared_ptr<CameraServiceProxyWrapper> & cameraServiceProxyWrapper,std::shared_ptr<AttributionAndPermissionUtils> attributionAndPermissionUtils,const std::string & id,bool overrideForPerfClass,int rotationOverride,bool legacyClient)92 Camera3Device::Camera3Device(std::shared_ptr<CameraServiceProxyWrapper>& cameraServiceProxyWrapper,
93         std::shared_ptr<AttributionAndPermissionUtils> attributionAndPermissionUtils,
94         const std::string &id, bool overrideForPerfClass, int rotationOverride,
95         bool legacyClient):
96         AttributionAndPermissionUtilsEncapsulator(attributionAndPermissionUtils),
97         mCameraServiceProxyWrapper(cameraServiceProxyWrapper),
98         mId(id),
99         mLegacyClient(legacyClient),
100         mOperatingMode(NO_MODE),
101         mIsConstrainedHighSpeedConfiguration(false),
102         mIsCompositeJpegRDisabled(false),
103         mStatus(STATUS_UNINITIALIZED),
104         mStatusWaiters(0),
105         mUsePartialResult(false),
106         mNumPartialResults(1),
107         mDeviceTimeBaseIsRealtime(false),
108         mTimestampOffset(0),
109         mNextResultFrameNumber(0),
110         mNextReprocessResultFrameNumber(0),
111         mNextZslStillResultFrameNumber(0),
112         mNextShutterFrameNumber(0),
113         mNextReprocessShutterFrameNumber(0),
114         mNextZslStillShutterFrameNumber(0),
115         mListener(NULL),
116         mVendorTagId(CAMERA_METADATA_INVALID_VENDOR_ID),
117         mLastTemplateId(-1),
118         mNeedFixupMonochromeTags(false),
119         mOverrideForPerfClass(overrideForPerfClass),
120         mRotationOverride(rotationOverride),
121         mRotateAndCropOverride(ANDROID_SCALER_ROTATE_AND_CROP_NONE),
122         mComposerOutput(false),
123         mAutoframingOverride(ANDROID_CONTROL_AUTOFRAMING_OFF),
124         mSettingsOverride(-1),
125         mActivePhysicalId("")
126 {
127     ATRACE_CALL();
128     ALOGV("%s: Created device for camera %s", __FUNCTION__, mId.c_str());
129 }
130 
~Camera3Device()131 Camera3Device::~Camera3Device()
132 {
133     ATRACE_CALL();
134     ALOGV("%s: Tearing down for camera id %s", __FUNCTION__, mId.c_str());
135     disconnectImpl();
136 }
137 
getId() const138 const std::string& Camera3Device::getId() const {
139     return mId;
140 }
141 
initializeCommonLocked(sp<CameraProviderManager> manager)142 status_t Camera3Device::initializeCommonLocked(sp<CameraProviderManager> manager) {
143 
144     /** Start up status tracker thread */
145     mStatusTracker = new StatusTracker(this);
146     status_t res = mStatusTracker->run((std::string("C3Dev-") + mId + "-Status").c_str());
147     if (res != OK) {
148         SET_ERR_L("Unable to start status tracking thread: %s (%d)",
149                 strerror(-res), res);
150         mInterface->close();
151         mStatusTracker.clear();
152         return res;
153     }
154 
155     /** Register in-flight map to the status tracker */
156     mInFlightStatusId = mStatusTracker->addComponent("InflightRequests");
157 
158     /** Create buffer manager */
159     mBufferManager = new Camera3BufferManager();
160 
161     Vector<int32_t> sessionParamKeys;
162     camera_metadata_entry_t sessionKeysEntry = mDeviceInfo.find(
163             ANDROID_REQUEST_AVAILABLE_SESSION_KEYS);
164     if (sessionKeysEntry.count > 0) {
165         sessionParamKeys.insertArrayAt(sessionKeysEntry.data.i32, 0, sessionKeysEntry.count);
166     }
167 
168     camera_metadata_entry_t availableTestPatternModes = mDeviceInfo.find(
169             ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES);
170     for (size_t i = 0; i < availableTestPatternModes.count; i++) {
171         if (availableTestPatternModes.data.i32[i] ==
172                 ANDROID_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR) {
173             mSupportCameraMute = true;
174             mSupportTestPatternSolidColor = true;
175             break;
176         } else if (availableTestPatternModes.data.i32[i] ==
177                 ANDROID_SENSOR_TEST_PATTERN_MODE_BLACK) {
178             mSupportCameraMute = true;
179             mSupportTestPatternSolidColor = false;
180         }
181     }
182 
183     camera_metadata_entry_t availableSettingsOverrides = mDeviceInfo.find(
184             ANDROID_CONTROL_AVAILABLE_SETTINGS_OVERRIDES);
185     for (size_t i = 0; i < availableSettingsOverrides.count; i++) {
186         if (availableSettingsOverrides.data.i32[i] ==
187                 ANDROID_CONTROL_SETTINGS_OVERRIDE_ZOOM) {
188             mSupportZoomOverride = true;
189             break;
190         }
191     }
192 
193     /** Start up request queue thread */
194     mRequestThread = createNewRequestThread(
195             this, mStatusTracker, mInterface, sessionParamKeys,
196             mUseHalBufManager, mSupportCameraMute, mRotationOverride,
197             mSupportZoomOverride);
198     res = mRequestThread->run((std::string("C3Dev-") + mId + "-ReqQueue").c_str());
199     if (res != OK) {
200         SET_ERR_L("Unable to start request queue thread: %s (%d)",
201                 strerror(-res), res);
202         mInterface->close();
203         mRequestThread.clear();
204         return res;
205     }
206 
207     setCameraMuteLocked(mCameraMuteInitial);
208 
209     mPreparerThread = new PreparerThread();
210 
211     internalUpdateStatusLocked(STATUS_UNCONFIGURED);
212     mNextStreamId = 0;
213     mFakeStreamId = NO_STREAM;
214     mNeedConfig = true;
215     mPauseStateNotify = false;
216     mIsInputStreamMultiResolution = false;
217 
218     // Measure the clock domain offset between camera and video/hw_composer
219     mTimestampOffset = getMonoToBoottimeOffset();
220     camera_metadata_entry timestampSource =
221             mDeviceInfo.find(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE);
222     if (timestampSource.count > 0 && timestampSource.data.u8[0] ==
223             ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME) {
224         mDeviceTimeBaseIsRealtime = true;
225     }
226 
227     // Will the HAL be sending in early partial result metadata?
228     camera_metadata_entry partialResultsCount =
229             mDeviceInfo.find(ANDROID_REQUEST_PARTIAL_RESULT_COUNT);
230     if (partialResultsCount.count > 0) {
231         mNumPartialResults = partialResultsCount.data.i32[0];
232         mUsePartialResult = (mNumPartialResults > 1);
233     }
234 
235     bool usePrecorrectArray = DistortionMapper::isDistortionSupported(mDeviceInfo);
236     if (usePrecorrectArray) {
237         res = mDistortionMappers[mId].setupStaticInfo(mDeviceInfo);
238         if (res != OK) {
239             SET_ERR_L("Unable to read necessary calibration fields for distortion correction");
240             return res;
241         }
242     }
243 
244     mZoomRatioMappers[mId] = ZoomRatioMapper(&mDeviceInfo,
245             mSupportNativeZoomRatio, usePrecorrectArray);
246 
247     if (SessionConfigurationUtils::supportsUltraHighResolutionCapture(mDeviceInfo)) {
248         mUHRCropAndMeteringRegionMappers[mId] =
249                 UHRCropAndMeteringRegionMapper(mDeviceInfo, usePrecorrectArray);
250     }
251 
252     if (RotateAndCropMapper::isNeeded(&mDeviceInfo)) {
253         mRotateAndCropMappers.emplace(mId, &mDeviceInfo);
254     }
255 
256     // Hidl/AidlCamera3DeviceInjectionMethods
257     mInjectionMethods = createCamera3DeviceInjectionMethods(this);
258 
259     /** Start watchdog thread */
260     mCameraServiceWatchdog = new CameraServiceWatchdog(
261             manager->getProviderPids(), mId, mCameraServiceProxyWrapper);
262     res = mCameraServiceWatchdog->run("CameraServiceWatchdog");
263     if (res != OK) {
264         SET_ERR_L("Unable to start camera service watchdog thread: %s (%d)",
265                 strerror(-res), res);
266         return res;
267     }
268 
269     mSupportsExtensionKeys = areExtensionKeysSupported(mDeviceInfo);
270 
271     return OK;
272 }
273 
disconnect()274 status_t Camera3Device::disconnect() {
275     return disconnectImpl();
276 }
277 
disconnectImpl()278 status_t Camera3Device::disconnectImpl() {
279     ATRACE_CALL();
280     Mutex::Autolock il(mInterfaceLock);
281 
282     ALOGI("%s: E", __FUNCTION__);
283 
284     status_t res = OK;
285     std::vector<wp<Camera3StreamInterface>> streams;
286     nsecs_t maxExpectedDuration = getExpectedInFlightDuration();
287     {
288         Mutex::Autolock l(mLock);
289         if (mStatus == STATUS_UNINITIALIZED) return res;
290 
291         if (mRequestThread != NULL) {
292             if (mStatus == STATUS_ACTIVE || mStatus == STATUS_ERROR) {
293                 res = mRequestThread->clear();
294                 if (res != OK) {
295                     SET_ERR_L("Can't stop streaming");
296                     // Continue to close device even in case of error
297                 } else {
298                     res = waitUntilStateThenRelock(/*active*/ false, maxExpectedDuration,
299                                   /*requestThreadInvocation*/ false);
300                     if (res != OK) {
301                         SET_ERR_L("Timeout waiting for HAL to drain (% " PRIi64 " ns)",
302                                 maxExpectedDuration);
303                         // Continue to close device even in case of error
304                     }
305                 }
306             }
307         }
308 
309         if (mStatus == STATUS_ERROR) {
310             CLOGE("Shutting down in an error state");
311         }
312 
313         if (mStatusTracker != NULL) {
314             mStatusTracker->requestExit();
315         }
316 
317         if (mRequestThread != NULL) {
318             mRequestThread->requestExit();
319         }
320 
321         streams.reserve(mOutputStreams.size() + (mInputStream != nullptr ? 1 : 0));
322         for (size_t i = 0; i < mOutputStreams.size(); i++) {
323             streams.push_back(mOutputStreams[i]);
324         }
325         if (mInputStream != nullptr) {
326             streams.push_back(mInputStream);
327         }
328     }
329 
330     // Joining done without holding mLock, otherwise deadlocks may ensue
331     // as the threads try to access parent state
332     if (mRequestThread != NULL && mStatus != STATUS_ERROR) {
333         // HAL may be in a bad state, so waiting for request thread
334         // (which may be stuck in the HAL processCaptureRequest call)
335         // could be dangerous.
336         mRequestThread->join();
337     }
338 
339     if (mStatusTracker != NULL) {
340         mStatusTracker->join();
341     }
342 
343     if (mInjectionMethods->isInjecting()) {
344         mInjectionMethods->stopInjection();
345     }
346 
347     HalInterface* interface;
348     {
349         Mutex::Autolock l(mLock);
350         mRequestThread.clear();
351         Mutex::Autolock stLock(mTrackerLock);
352         mStatusTracker.clear();
353         interface = mInterface.get();
354     }
355 
356     // Call close without internal mutex held, as the HAL close may need to
357     // wait on assorted callbacks,etc, to complete before it can return.
358     mCameraServiceWatchdog->WATCH(interface->close());
359 
360     flushInflightRequests();
361 
362     {
363         Mutex::Autolock l(mLock);
364         mInterface->clear();
365         mOutputStreams.clear();
366         mInputStream.clear();
367         mDeletedStreams.clear();
368         mBufferManager.clear();
369         internalUpdateStatusLocked(STATUS_UNINITIALIZED);
370     }
371 
372     for (auto& weakStream : streams) {
373         sp<Camera3StreamInterface> stream = weakStream.promote();
374         if (stream != nullptr) {
375             ALOGE("%s: Stream %d leaked! strong reference (%d)!",
376                     __FUNCTION__, stream->getId(), stream->getStrongCount() - 1);
377         }
378     }
379     ALOGI("%s: X", __FUNCTION__);
380 
381     if (mCameraServiceWatchdog != NULL) {
382         mCameraServiceWatchdog->requestExit();
383         mCameraServiceWatchdog.clear();
384     }
385 
386     return res;
387 }
388 
389 // For dumping/debugging only -
390 // try to acquire a lock a few times, eventually give up to proceed with
391 // debug/dump operations
tryLockSpinRightRound(Mutex & lock)392 bool Camera3Device::tryLockSpinRightRound(Mutex& lock) {
393     bool gotLock = false;
394     for (size_t i = 0; i < kDumpLockAttempts; ++i) {
395         if (lock.tryLock() == NO_ERROR) {
396             gotLock = true;
397             break;
398         } else {
399             usleep(kDumpSleepDuration);
400         }
401     }
402     return gotLock;
403 }
404 
getMonoToBoottimeOffset()405 nsecs_t Camera3Device::getMonoToBoottimeOffset() {
406     // try three times to get the clock offset, choose the one
407     // with the minimum gap in measurements.
408     const int tries = 3;
409     nsecs_t bestGap, measured;
410     for (int i = 0; i < tries; ++i) {
411         const nsecs_t tmono = systemTime(SYSTEM_TIME_MONOTONIC);
412         const nsecs_t tbase = systemTime(SYSTEM_TIME_BOOTTIME);
413         const nsecs_t tmono2 = systemTime(SYSTEM_TIME_MONOTONIC);
414         const nsecs_t gap = tmono2 - tmono;
415         if (i == 0 || gap < bestGap) {
416             bestGap = gap;
417             measured = tbase - ((tmono + tmono2) >> 1);
418         }
419     }
420     return measured;
421 }
422 
getJpegBufferSize(const CameraMetadata & info,uint32_t width,uint32_t height) const423 ssize_t Camera3Device::getJpegBufferSize(const CameraMetadata &info, uint32_t width,
424         uint32_t height) const {
425     // Get max jpeg size (area-wise) for default sensor pixel mode
426     camera3::Size maxDefaultJpegResolution =
427             SessionConfigurationUtils::getMaxJpegResolution(info,
428                     /*supportsUltraHighResolutionCapture*/false);
429     // Get max jpeg size (area-wise) for max resolution sensor pixel mode / 0 if
430     // not ultra high res sensor
431     camera3::Size uhrMaxJpegResolution =
432             SessionConfigurationUtils::getMaxJpegResolution(info,
433                     /*isUltraHighResolution*/true);
434     if (maxDefaultJpegResolution.width == 0) {
435         ALOGE("%s: Camera %s: Can't find valid available jpeg sizes in static metadata!",
436                 __FUNCTION__, mId.c_str());
437         return BAD_VALUE;
438     }
439     bool useMaxSensorPixelModeThreshold = false;
440     if (uhrMaxJpegResolution.width != 0 &&
441             width * height > maxDefaultJpegResolution.width * maxDefaultJpegResolution.height) {
442         // Use the ultra high res max jpeg size and max jpeg buffer size
443         useMaxSensorPixelModeThreshold = true;
444     }
445 
446     // Get max jpeg buffer size
447     ssize_t maxJpegBufferSize = 0;
448     camera_metadata_ro_entry jpegBufMaxSize = info.find(ANDROID_JPEG_MAX_SIZE);
449     if (jpegBufMaxSize.count == 0) {
450         ALOGE("%s: Camera %s: Can't find maximum JPEG size in static metadata!", __FUNCTION__,
451                 mId.c_str());
452         return BAD_VALUE;
453     }
454     maxJpegBufferSize = jpegBufMaxSize.data.i32[0];
455 
456     camera3::Size chosenMaxJpegResolution = maxDefaultJpegResolution;
457     if (useMaxSensorPixelModeThreshold) {
458         maxJpegBufferSize =
459                 SessionConfigurationUtils::getUHRMaxJpegBufferSize(uhrMaxJpegResolution,
460                         maxDefaultJpegResolution, maxJpegBufferSize);
461         chosenMaxJpegResolution = uhrMaxJpegResolution;
462     }
463     assert(kMinJpegBufferSize < maxJpegBufferSize);
464 
465     // Calculate final jpeg buffer size for the given resolution.
466     float scaleFactor = ((float) (width * height)) /
467             (chosenMaxJpegResolution.width * chosenMaxJpegResolution.height);
468     ssize_t jpegBufferSize = scaleFactor * (maxJpegBufferSize - kMinJpegBufferSize) +
469             kMinJpegBufferSize;
470     if (jpegBufferSize > maxJpegBufferSize) {
471         ALOGI("%s: jpeg buffer size calculated is > maxJpeg bufferSize(%zd), clamping",
472                   __FUNCTION__, maxJpegBufferSize);
473         jpegBufferSize = maxJpegBufferSize;
474     }
475     return jpegBufferSize;
476 }
477 
getPointCloudBufferSize(const CameraMetadata & info) const478 ssize_t Camera3Device::getPointCloudBufferSize(const CameraMetadata &info) const {
479     const int FLOATS_PER_POINT=4;
480     camera_metadata_ro_entry maxPointCount = info.find(ANDROID_DEPTH_MAX_DEPTH_SAMPLES);
481     if (maxPointCount.count == 0) {
482         ALOGE("%s: Camera %s: Can't find maximum depth point cloud size in static metadata!",
483                 __FUNCTION__, mId.c_str());
484         return BAD_VALUE;
485     }
486     ssize_t maxBytesForPointCloud = sizeof(android_depth_points) +
487             maxPointCount.data.i32[0] * sizeof(float) * FLOATS_PER_POINT;
488     return maxBytesForPointCloud;
489 }
490 
getRawOpaqueBufferSize(const CameraMetadata & info,int32_t width,int32_t height,bool maxResolution) const491 ssize_t Camera3Device::getRawOpaqueBufferSize(const CameraMetadata &info, int32_t width,
492         int32_t height, bool maxResolution) const {
493     const int PER_CONFIGURATION_SIZE = 3;
494     const int WIDTH_OFFSET = 0;
495     const int HEIGHT_OFFSET = 1;
496     const int SIZE_OFFSET = 2;
497     camera_metadata_ro_entry rawOpaqueSizes =
498         info.find(
499             camera3::SessionConfigurationUtils::getAppropriateModeTag(
500                     ANDROID_SENSOR_OPAQUE_RAW_SIZE,
501                     maxResolution));
502     size_t count = rawOpaqueSizes.count;
503     if (count == 0 || (count % PER_CONFIGURATION_SIZE)) {
504         ALOGE("%s: Camera %s: bad opaque RAW size static metadata length(%zu)!",
505                 __FUNCTION__, mId.c_str(), count);
506         return BAD_VALUE;
507     }
508 
509     for (size_t i = 0; i < count; i += PER_CONFIGURATION_SIZE) {
510         if (width == rawOpaqueSizes.data.i32[i + WIDTH_OFFSET] &&
511                 height == rawOpaqueSizes.data.i32[i + HEIGHT_OFFSET]) {
512             return rawOpaqueSizes.data.i32[i + SIZE_OFFSET];
513         }
514     }
515 
516     ALOGE("%s: Camera %s: cannot find size for %dx%d opaque RAW image!",
517             __FUNCTION__, mId.c_str(), width, height);
518     return BAD_VALUE;
519 }
520 
dump(int fd,const Vector<String16> & args)521 status_t Camera3Device::dump(int fd, [[maybe_unused]] const Vector<String16> &args) {
522     ATRACE_CALL();
523 
524     // Try to lock, but continue in case of failure (to avoid blocking in
525     // deadlocks)
526     bool gotInterfaceLock = tryLockSpinRightRound(mInterfaceLock);
527     bool gotLock = tryLockSpinRightRound(mLock);
528 
529     ALOGW_IF(!gotInterfaceLock,
530             "Camera %s: %s: Unable to lock interface lock, proceeding anyway",
531             mId.c_str(), __FUNCTION__);
532     ALOGW_IF(!gotLock,
533             "Camera %s: %s: Unable to lock main lock, proceeding anyway",
534             mId.c_str(), __FUNCTION__);
535 
536     bool dumpTemplates = false;
537 
538     String16 templatesOption("-t");
539     int n = args.size();
540     for (int i = 0; i < n; i++) {
541         if (args[i] == templatesOption) {
542             dumpTemplates = true;
543         }
544         if (args[i] == toString16(TagMonitor::kMonitorOption)) {
545             if (i + 1 < n) {
546                 std::string monitorTags = toStdString(args[i + 1]);
547                 if (monitorTags == "off") {
548                     mTagMonitor.disableMonitoring();
549                 } else {
550                     mTagMonitor.parseTagsToMonitor(monitorTags);
551                 }
552             } else {
553                 mTagMonitor.disableMonitoring();
554             }
555         }
556     }
557 
558     std::string lines;
559 
560     const char *status =
561             mStatus == STATUS_ERROR         ? "ERROR" :
562             mStatus == STATUS_UNINITIALIZED ? "UNINITIALIZED" :
563             mStatus == STATUS_UNCONFIGURED  ? "UNCONFIGURED" :
564             mStatus == STATUS_CONFIGURED    ? "CONFIGURED" :
565             mStatus == STATUS_ACTIVE        ? "ACTIVE" :
566             "Unknown";
567 
568     lines += fmt::sprintf("    Device status: %s\n", status);
569     if (mStatus == STATUS_ERROR) {
570         lines += fmt::sprintf("    Error cause: %s\n", mErrorCause.c_str());
571     }
572     lines += "    Stream configuration:\n";
573     const char *mode =
574             mOperatingMode == CAMERA_STREAM_CONFIGURATION_NORMAL_MODE ? "NORMAL" :
575             mOperatingMode == CAMERA_STREAM_CONFIGURATION_CONSTRAINED_HIGH_SPEED_MODE ?
576                     "CONSTRAINED_HIGH_SPEED" : "CUSTOM";
577     lines += fmt::sprintf("    Operation mode: %s (%d) \n", mode, mOperatingMode);
578 
579     if (mInputStream != NULL) {
580         write(fd, lines.c_str(), lines.size());
581         mInputStream->dump(fd, args);
582     } else {
583         lines += "      No input stream.\n";
584         write(fd, lines.c_str(), lines.size());
585     }
586     for (size_t i = 0; i < mOutputStreams.size(); i++) {
587         mOutputStreams[i]->dump(fd,args);
588     }
589 
590     if (mBufferManager != NULL) {
591         lines = "    Camera3 Buffer Manager:\n";
592         write(fd, lines.c_str(), lines.size());
593         mBufferManager->dump(fd, args);
594     }
595 
596     lines = "    In-flight requests:\n";
597     if (mInFlightLock.try_lock()) {
598         if (mInFlightMap.size() == 0) {
599             lines += "      None\n";
600         } else {
601             for (size_t i = 0; i < mInFlightMap.size(); i++) {
602                 InFlightRequest r = mInFlightMap.valueAt(i);
603                 lines += fmt::sprintf("      Frame %d |  Timestamp: %" PRId64 ", metadata"
604                         " arrived: %s, buffers left: %d\n", mInFlightMap.keyAt(i),
605                         r.shutterTimestamp, r.haveResultMetadata ? "true" : "false",
606                         r.numBuffersLeft);
607             }
608         }
609         mInFlightLock.unlock();
610     } else {
611         lines += "      Failed to acquire In-flight lock!\n";
612     }
613     write(fd, lines.c_str(), lines.size());
614 
615     if (mRequestThread != NULL) {
616         mRequestThread->dumpCaptureRequestLatency(fd,
617                 "    ProcessCaptureRequest latency histogram:");
618     }
619 
620     {
621         lines = "    Last request sent:\n";
622         LatestRequestInfo lastRequestInfo = getLatestRequestInfoLocked();
623         // Print out output and input stream ids
624         if (flags::dumpsys_request_stream_ids()) {
625             if (lastRequestInfo.outputStreamIds.size() != 0) {
626                 lines += "      Output Stream Ids:\n";
627                 for (const auto &streamId: lastRequestInfo.outputStreamIds) {
628                     lines +=  "         " + std::to_string(streamId) + "\n";
629                 }
630             }
631             if (lastRequestInfo.inputStreamId != -1) {
632                 lines += "       Input Stream Id: " + std::to_string(lastRequestInfo.inputStreamId)
633                         + "\n";
634             }
635         }
636         // Keeping this write() outside the flagged if makes it easier while
637         // removing the flag.
638         write(fd, lines.c_str(), lines.size());
639         lines = "    Logical request settings:\n";
640         CameraMetadata lastRequestSettings = lastRequestInfo.requestSettings;
641         write(fd, lines.c_str(), lines.size());
642 
643         lastRequestSettings.dump(fd, /*verbosity=all info*/2, /*indentation*/6);
644         if (flags::dumpsys_request_stream_ids()) {
645             for (const auto& pair: lastRequestInfo.physicalRequestSettings) {
646                 lines = "    Physical request settings for camera id " + pair.first + ":\n";
647                 write(fd, lines.c_str(), lines.size());
648                 pair.second.dump(fd, /*verbosity=all info*/2, /*indentation*/8);
649             }
650         }
651     }
652 
653     if (dumpTemplates) {
654         const char *templateNames[CAMERA_TEMPLATE_COUNT] = {
655             "TEMPLATE_PREVIEW",
656             "TEMPLATE_STILL_CAPTURE",
657             "TEMPLATE_VIDEO_RECORD",
658             "TEMPLATE_VIDEO_SNAPSHOT",
659             "TEMPLATE_ZERO_SHUTTER_LAG",
660             "TEMPLATE_MANUAL",
661         };
662 
663         for (int i = 1; i < CAMERA_TEMPLATE_COUNT; i++) {
664             camera_metadata_t *templateRequest = nullptr;
665             mInterface->constructDefaultRequestSettings(
666                     (camera_request_template_t) i, &templateRequest);
667             lines = fmt::sprintf("    HAL Request %s:\n", templateNames[i-1]);
668             if (templateRequest == nullptr) {
669                 lines += "       Not supported\n";
670                 write(fd, lines.c_str(), lines.size());
671             } else {
672                 write(fd, lines.c_str(), lines.size());
673                 dump_indented_camera_metadata(templateRequest,
674                         fd, /*verbosity*/2, /*indentation*/8);
675             }
676             free_camera_metadata(templateRequest);
677         }
678     }
679 
680     mTagMonitor.dumpMonitoredMetadata(fd);
681 
682     if (mInterface->valid()) {
683         lines = "     HAL device dump:\n";
684         write(fd, lines.c_str(), lines.size());
685         mInterface->dump(fd);
686     }
687 
688     if (gotLock) mLock.unlock();
689     if (gotInterfaceLock) mInterfaceLock.unlock();
690 
691     return OK;
692 }
693 
startWatchingTags(const std::string & tags)694 status_t Camera3Device::startWatchingTags(const std::string &tags) {
695     mTagMonitor.parseTagsToMonitor(tags);
696     return OK;
697 }
698 
stopWatchingTags()699 status_t Camera3Device::stopWatchingTags() {
700     mTagMonitor.disableMonitoring();
701     return OK;
702 }
703 
dumpWatchedEventsToVector(std::vector<std::string> & out)704 status_t Camera3Device::dumpWatchedEventsToVector(std::vector<std::string> &out) {
705     mTagMonitor.getLatestMonitoredTagEvents(out);
706     return OK;
707 }
708 
infoPhysical(const std::string & physicalId) const709 const CameraMetadata& Camera3Device::infoPhysical(const std::string& physicalId) const {
710     ALOGVV("%s: E", __FUNCTION__);
711     if (CC_UNLIKELY(mStatus == STATUS_UNINITIALIZED ||
712                     mStatus == STATUS_ERROR)) {
713         ALOGW("%s: Access to static info %s!", __FUNCTION__,
714                 mStatus == STATUS_ERROR ?
715                 "when in error state" : "before init");
716     }
717     if (physicalId.empty()) {
718         return mDeviceInfo;
719     } else {
720         if (mPhysicalDeviceInfoMap.find(physicalId) != mPhysicalDeviceInfoMap.end()) {
721             return mPhysicalDeviceInfoMap.at(physicalId);
722         } else {
723             ALOGE("%s: Invalid physical camera id %s", __FUNCTION__, physicalId.c_str());
724             return mDeviceInfo;
725         }
726     }
727 }
728 
info() const729 const CameraMetadata& Camera3Device::info() const {
730     return infoPhysical(/*physicalId*/ std::string());
731 }
732 
checkStatusOkToCaptureLocked()733 status_t Camera3Device::checkStatusOkToCaptureLocked() {
734     switch (mStatus) {
735         case STATUS_ERROR:
736             CLOGE("Device has encountered a serious error");
737             return INVALID_OPERATION;
738         case STATUS_UNINITIALIZED:
739             CLOGE("Device not initialized");
740             return INVALID_OPERATION;
741         case STATUS_UNCONFIGURED:
742         case STATUS_CONFIGURED:
743         case STATUS_ACTIVE:
744             // OK
745             break;
746         default:
747             SET_ERR_L("Unexpected status: %d", mStatus);
748             return INVALID_OPERATION;
749     }
750     return OK;
751 }
752 
convertMetadataListToRequestListLocked(const List<const PhysicalCameraSettingsList> & metadataList,const std::list<SurfaceMap> & surfaceMaps,bool repeating,nsecs_t requestTimeNs,RequestList * requestList)753 status_t Camera3Device::convertMetadataListToRequestListLocked(
754         const List<const PhysicalCameraSettingsList> &metadataList,
755         const std::list<SurfaceMap> &surfaceMaps,
756         bool repeating, nsecs_t requestTimeNs,
757         RequestList *requestList) {
758     if (requestList == NULL) {
759         CLOGE("requestList cannot be NULL.");
760         return BAD_VALUE;
761     }
762 
763     int32_t burstId = 0;
764     List<const PhysicalCameraSettingsList>::const_iterator metadataIt = metadataList.begin();
765     std::list<SurfaceMap>::const_iterator surfaceMapIt = surfaceMaps.begin();
766     for (; metadataIt != metadataList.end() && surfaceMapIt != surfaceMaps.end();
767             ++metadataIt, ++surfaceMapIt) {
768         sp<CaptureRequest> newRequest = setUpRequestLocked(*metadataIt, *surfaceMapIt);
769         if (newRequest == 0) {
770             CLOGE("Can't create capture request");
771             return BAD_VALUE;
772         }
773 
774         newRequest->mRepeating = repeating;
775         newRequest->mRequestTimeNs = requestTimeNs;
776 
777         // Setup burst Id and request Id
778         newRequest->mResultExtras.burstId = burstId++;
779         auto requestIdEntry = metadataIt->begin()->metadata.find(ANDROID_REQUEST_ID);
780         if (requestIdEntry.count == 0) {
781             CLOGE("RequestID does not exist in metadata");
782             return BAD_VALUE;
783         }
784         newRequest->mResultExtras.requestId = requestIdEntry.data.i32[0];
785 
786         requestList->push_back(newRequest);
787 
788         ALOGV("%s: requestId = %" PRId32, __FUNCTION__, newRequest->mResultExtras.requestId);
789     }
790     if (metadataIt != metadataList.end() || surfaceMapIt != surfaceMaps.end()) {
791         ALOGE("%s: metadataList and surfaceMaps are not the same size!", __FUNCTION__);
792         return BAD_VALUE;
793     }
794 
795     // Setup batch size if this is a high speed video recording request.
796     if (mIsConstrainedHighSpeedConfiguration && requestList->size() > 0) {
797         auto firstRequest = requestList->begin();
798         for (auto& outputStream : (*firstRequest)->mOutputStreams) {
799             if (outputStream->isVideoStream()) {
800                 applyMaxBatchSizeLocked(requestList, outputStream);
801                 break;
802             }
803         }
804     }
805 
806     return OK;
807 }
808 
capture(CameraMetadata & request,int64_t * lastFrameNumber)809 status_t Camera3Device::capture(CameraMetadata &request, int64_t* lastFrameNumber) {
810     ATRACE_CALL();
811 
812     List<const PhysicalCameraSettingsList> requestsList;
813     std::list<SurfaceMap> surfaceMaps;
814     convertToRequestList(requestsList, surfaceMaps, request);
815 
816     return captureList(requestsList, surfaceMaps, lastFrameNumber);
817 }
818 
convertToRequestList(List<const PhysicalCameraSettingsList> & requestsList,std::list<SurfaceMap> & surfaceMaps,const CameraMetadata & request)819 void Camera3Device::convertToRequestList(List<const PhysicalCameraSettingsList>& requestsList,
820         std::list<SurfaceMap>& surfaceMaps,
821         const CameraMetadata& request) {
822     PhysicalCameraSettingsList requestList;
823     requestList.push_back({getId(), request});
824     requestsList.push_back(requestList);
825 
826     SurfaceMap surfaceMap;
827     camera_metadata_ro_entry streams = request.find(ANDROID_REQUEST_OUTPUT_STREAMS);
828     // With no surface list passed in, stream and surface will have 1-to-1
829     // mapping. So the surface index is 0 for each stream in the surfaceMap.
830     for (size_t i = 0; i < streams.count; i++) {
831         surfaceMap[streams.data.i32[i]].push_back(0);
832     }
833     surfaceMaps.push_back(surfaceMap);
834 }
835 
submitRequestsHelper(const List<const PhysicalCameraSettingsList> & requests,const std::list<SurfaceMap> & surfaceMaps,bool repeating,int64_t * lastFrameNumber)836 status_t Camera3Device::submitRequestsHelper(
837         const List<const PhysicalCameraSettingsList> &requests,
838         const std::list<SurfaceMap> &surfaceMaps,
839         bool repeating,
840         /*out*/
841         int64_t *lastFrameNumber) {
842     ATRACE_CALL();
843     nsecs_t requestTimeNs = systemTime();
844 
845     Mutex::Autolock il(mInterfaceLock);
846     Mutex::Autolock l(mLock);
847 
848     status_t res = checkStatusOkToCaptureLocked();
849     if (res != OK) {
850         // error logged by previous call
851         return res;
852     }
853 
854     RequestList requestList;
855 
856     res = convertMetadataListToRequestListLocked(requests, surfaceMaps,
857             repeating, requestTimeNs, /*out*/&requestList);
858     if (res != OK) {
859         // error logged by previous call
860         return res;
861     }
862 
863     if (repeating) {
864         res = mRequestThread->setRepeatingRequests(requestList, lastFrameNumber);
865     } else {
866         res = mRequestThread->queueRequestList(requestList, lastFrameNumber);
867     }
868 
869     if (res == OK) {
870         waitUntilStateThenRelock(/*active*/true, kActiveTimeout, /*requestThreadInvocation*/false);
871         if (res != OK) {
872             SET_ERR_L("Can't transition to active in %f seconds!",
873                     kActiveTimeout/1e9);
874         }
875         ALOGV("Camera %s: Capture request %" PRId32 " enqueued", mId.c_str(),
876               (*(requestList.begin()))->mResultExtras.requestId);
877     } else {
878         CLOGE("Cannot queue request. Impossible.");
879         return BAD_VALUE;
880     }
881 
882     return res;
883 }
884 
captureList(const List<const PhysicalCameraSettingsList> & requestsList,const std::list<SurfaceMap> & surfaceMaps,int64_t * lastFrameNumber)885 status_t Camera3Device::captureList(const List<const PhysicalCameraSettingsList> &requestsList,
886                                     const std::list<SurfaceMap> &surfaceMaps,
887                                     int64_t *lastFrameNumber) {
888     ATRACE_CALL();
889 
890     return submitRequestsHelper(requestsList, surfaceMaps, /*repeating*/false, lastFrameNumber);
891 }
892 
setStreamingRequest(const CameraMetadata & request,int64_t *)893 status_t Camera3Device::setStreamingRequest(const CameraMetadata &request,
894                                             int64_t* /*lastFrameNumber*/) {
895     ATRACE_CALL();
896 
897     List<const PhysicalCameraSettingsList> requestsList;
898     std::list<SurfaceMap> surfaceMaps;
899     convertToRequestList(requestsList, surfaceMaps, request);
900 
901     return setStreamingRequestList(requestsList, /*surfaceMap*/surfaceMaps,
902                                    /*lastFrameNumber*/NULL);
903 }
904 
setStreamingRequestList(const List<const PhysicalCameraSettingsList> & requestsList,const std::list<SurfaceMap> & surfaceMaps,int64_t * lastFrameNumber)905 status_t Camera3Device::setStreamingRequestList(
906         const List<const PhysicalCameraSettingsList> &requestsList,
907         const std::list<SurfaceMap> &surfaceMaps, int64_t *lastFrameNumber) {
908     ATRACE_CALL();
909 
910     return submitRequestsHelper(requestsList, surfaceMaps, /*repeating*/true, lastFrameNumber);
911 }
912 
setUpRequestLocked(const PhysicalCameraSettingsList & request,const SurfaceMap & surfaceMap)913 sp<Camera3Device::CaptureRequest> Camera3Device::setUpRequestLocked(
914         const PhysicalCameraSettingsList &request, const SurfaceMap &surfaceMap) {
915     status_t res;
916 
917     if (mStatus == STATUS_UNCONFIGURED || mNeedConfig) {
918         // This point should only be reached via API1 (API2 must explicitly call configureStreams)
919         // so unilaterally select normal operating mode.
920         res = filterParamsAndConfigureLocked(request.begin()->metadata,
921                 CAMERA_STREAM_CONFIGURATION_NORMAL_MODE);
922         // Stream configuration failed. Client might try other configuraitons.
923         if (res != OK) {
924             CLOGE("Can't set up streams: %s (%d)", strerror(-res), res);
925             return NULL;
926         } else if (mStatus == STATUS_UNCONFIGURED) {
927             // Stream configuration successfully configure to empty stream configuration.
928             CLOGE("No streams configured");
929             return NULL;
930         }
931     }
932 
933     sp<CaptureRequest> newRequest = createCaptureRequest(request, surfaceMap);
934     return newRequest;
935 }
936 
clearStreamingRequest(int64_t * lastFrameNumber)937 status_t Camera3Device::clearStreamingRequest(int64_t *lastFrameNumber) {
938     ATRACE_CALL();
939     Mutex::Autolock il(mInterfaceLock);
940     Mutex::Autolock l(mLock);
941 
942     switch (mStatus) {
943         case STATUS_ERROR:
944             CLOGE("Device has encountered a serious error");
945             return INVALID_OPERATION;
946         case STATUS_UNINITIALIZED:
947             CLOGE("Device not initialized");
948             return INVALID_OPERATION;
949         case STATUS_UNCONFIGURED:
950         case STATUS_CONFIGURED:
951         case STATUS_ACTIVE:
952             // OK
953             break;
954         default:
955             SET_ERR_L("Unexpected status: %d", mStatus);
956             return INVALID_OPERATION;
957     }
958     ALOGV("Camera %s: Clearing repeating request", mId.c_str());
959 
960     return mRequestThread->clearRepeatingRequests(lastFrameNumber);
961 }
962 
waitUntilRequestReceived(int32_t requestId,nsecs_t timeout)963 status_t Camera3Device::waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) {
964     ATRACE_CALL();
965     Mutex::Autolock il(mInterfaceLock);
966 
967     return mRequestThread->waitUntilRequestProcessed(requestId, timeout);
968 }
969 
createInputStream(uint32_t width,uint32_t height,int format,bool isMultiResolution,int * id)970 status_t Camera3Device::createInputStream(
971         uint32_t width, uint32_t height, int format, bool isMultiResolution, int *id) {
972     ATRACE_CALL();
973     Mutex::Autolock il(mInterfaceLock);
974     nsecs_t maxExpectedDuration = getExpectedInFlightDuration();
975     Mutex::Autolock l(mLock);
976     ALOGV("Camera %s: Creating new input stream %d: %d x %d, format %d",
977             mId.c_str(), mNextStreamId, width, height, format);
978 
979     status_t res;
980     bool wasActive = false;
981 
982     switch (mStatus) {
983         case STATUS_ERROR:
984             ALOGE("%s: Device has encountered a serious error", __FUNCTION__);
985             return INVALID_OPERATION;
986         case STATUS_UNINITIALIZED:
987             ALOGE("%s: Device not initialized", __FUNCTION__);
988             return INVALID_OPERATION;
989         case STATUS_UNCONFIGURED:
990         case STATUS_CONFIGURED:
991             // OK
992             break;
993         case STATUS_ACTIVE:
994             ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
995             res = internalPauseAndWaitLocked(maxExpectedDuration,
996                           /*requestThreadInvocation*/ false);
997             if (res != OK) {
998                 SET_ERR_L("Can't pause captures to reconfigure streams!");
999                 return res;
1000             }
1001             wasActive = true;
1002             break;
1003         default:
1004             SET_ERR_L("%s: Unexpected status: %d", mStatus);
1005             return INVALID_OPERATION;
1006     }
1007     assert(mStatus != STATUS_ACTIVE);
1008 
1009     if (mInputStream != 0) {
1010         ALOGE("%s: Cannot create more than 1 input stream", __FUNCTION__);
1011         return INVALID_OPERATION;
1012     }
1013 
1014     sp<Camera3InputStream> newStream = new Camera3InputStream(mNextStreamId,
1015                 width, height, format);
1016     newStream->setStatusTracker(mStatusTracker);
1017 
1018     mInputStream = newStream;
1019     mIsInputStreamMultiResolution = isMultiResolution;
1020 
1021     *id = mNextStreamId++;
1022 
1023     // Continue captures if active at start
1024     if (wasActive) {
1025         ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
1026         // Reuse current operating mode and session parameters for new stream config
1027         res = configureStreamsLocked(mOperatingMode, mSessionParams);
1028         if (res != OK) {
1029             ALOGE("%s: Can't reconfigure device for new stream %d: %s (%d)",
1030                     __FUNCTION__, mNextStreamId, strerror(-res), res);
1031             return res;
1032         }
1033         internalResumeLocked();
1034     }
1035 
1036     ALOGV("Camera %s: Created input stream", mId.c_str());
1037     return OK;
1038 }
1039 
createStream(sp<Surface> consumer,uint32_t width,uint32_t height,int format,android_dataspace dataSpace,camera_stream_rotation_t rotation,int * id,const std::string & physicalCameraId,const std::unordered_set<int32_t> & sensorPixelModesUsed,std::vector<int> * surfaceIds,int streamSetId,bool isShared,bool isMultiResolution,uint64_t consumerUsage,int64_t dynamicRangeProfile,int64_t streamUseCase,int timestampBase,int mirrorMode,int32_t colorSpace,bool useReadoutTimestamp)1040 status_t Camera3Device::createStream(sp<Surface> consumer,
1041             uint32_t width, uint32_t height, int format,
1042             android_dataspace dataSpace, camera_stream_rotation_t rotation, int *id,
1043             const std::string& physicalCameraId,
1044             const std::unordered_set<int32_t> &sensorPixelModesUsed,
1045             std::vector<int> *surfaceIds, int streamSetId, bool isShared, bool isMultiResolution,
1046             uint64_t consumerUsage, int64_t dynamicRangeProfile, int64_t streamUseCase,
1047             int timestampBase, int mirrorMode, int32_t colorSpace, bool useReadoutTimestamp) {
1048     ATRACE_CALL();
1049 
1050     if (consumer == nullptr) {
1051         ALOGE("%s: consumer must not be null", __FUNCTION__);
1052         return BAD_VALUE;
1053     }
1054 
1055     std::vector<SurfaceHolder> consumers;
1056     consumers.push_back(SurfaceHolder{consumer, mirrorMode});
1057 
1058     return createStream(consumers, /*hasDeferredConsumer*/ false, width, height,
1059             format, dataSpace, rotation, id, physicalCameraId, sensorPixelModesUsed, surfaceIds,
1060             streamSetId, isShared, isMultiResolution, consumerUsage, dynamicRangeProfile,
1061             streamUseCase, timestampBase, colorSpace, useReadoutTimestamp);
1062 }
1063 
isRawFormat(int format)1064 static bool isRawFormat(int format) {
1065     switch (format) {
1066         case HAL_PIXEL_FORMAT_RAW16:
1067         case HAL_PIXEL_FORMAT_RAW12:
1068         case HAL_PIXEL_FORMAT_RAW10:
1069         case HAL_PIXEL_FORMAT_RAW_OPAQUE:
1070             return true;
1071         default:
1072             return false;
1073     }
1074 }
1075 
createStream(const std::vector<SurfaceHolder> & consumers,bool hasDeferredConsumer,uint32_t width,uint32_t height,int format,android_dataspace dataSpace,camera_stream_rotation_t rotation,int * id,const std::string & physicalCameraId,const std::unordered_set<int32_t> & sensorPixelModesUsed,std::vector<int> * surfaceIds,int streamSetId,bool isShared,bool isMultiResolution,uint64_t consumerUsage,int64_t dynamicRangeProfile,int64_t streamUseCase,int timestampBase,int32_t colorSpace,bool useReadoutTimestamp)1076 status_t Camera3Device::createStream(const std::vector<SurfaceHolder>& consumers,
1077         bool hasDeferredConsumer, uint32_t width, uint32_t height, int format,
1078         android_dataspace dataSpace, camera_stream_rotation_t rotation, int *id,
1079         const std::string& physicalCameraId,
1080         const std::unordered_set<int32_t> &sensorPixelModesUsed,
1081         std::vector<int> *surfaceIds, int streamSetId, bool isShared, bool isMultiResolution,
1082         uint64_t consumerUsage, int64_t dynamicRangeProfile, int64_t streamUseCase,
1083         int timestampBase, int32_t colorSpace, bool useReadoutTimestamp) {
1084     ATRACE_CALL();
1085 
1086     Mutex::Autolock il(mInterfaceLock);
1087     nsecs_t maxExpectedDuration = getExpectedInFlightDuration();
1088     Mutex::Autolock l(mLock);
1089     ALOGV("Camera %s: Creating new stream %d: %d x %d, format %d, dataspace %d rotation %d"
1090             " consumer usage %" PRIu64 ", isShared %d, physicalCameraId %s, isMultiResolution %d"
1091             " dynamicRangeProfile 0x%" PRIx64 ", streamUseCase %" PRId64 ", timestampBase %d,"
1092             " colorSpace %d, useReadoutTimestamp %d",
1093             mId.c_str(), mNextStreamId, width, height, format, dataSpace, rotation,
1094             consumerUsage, isShared, physicalCameraId.c_str(), isMultiResolution,
1095             dynamicRangeProfile, streamUseCase, timestampBase, colorSpace,
1096             useReadoutTimestamp);
1097 
1098     status_t res;
1099     bool wasActive = false;
1100 
1101     switch (mStatus) {
1102         case STATUS_ERROR:
1103             CLOGE("Device has encountered a serious error");
1104             return INVALID_OPERATION;
1105         case STATUS_UNINITIALIZED:
1106             CLOGE("Device not initialized");
1107             return INVALID_OPERATION;
1108         case STATUS_UNCONFIGURED:
1109         case STATUS_CONFIGURED:
1110             // OK
1111             break;
1112         case STATUS_ACTIVE:
1113             ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__);
1114             res = internalPauseAndWaitLocked(maxExpectedDuration,
1115                           /*requestThreadInvocation*/ false);
1116             if (res != OK) {
1117                 SET_ERR_L("Can't pause captures to reconfigure streams!");
1118                 return res;
1119             }
1120             wasActive = true;
1121             break;
1122         default:
1123             SET_ERR_L("Unexpected status: %d", mStatus);
1124             return INVALID_OPERATION;
1125     }
1126     assert(mStatus != STATUS_ACTIVE);
1127 
1128     sp<Camera3OutputStream> newStream;
1129 
1130     if (consumers.size() == 0 && !hasDeferredConsumer) {
1131         ALOGE("%s: Number of consumers cannot be smaller than 1", __FUNCTION__);
1132         return BAD_VALUE;
1133     }
1134 
1135     if (hasDeferredConsumer && format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
1136         ALOGE("Deferred consumer stream creation only support IMPLEMENTATION_DEFINED format");
1137         return BAD_VALUE;
1138     }
1139 
1140     if (isRawFormat(format) && sensorPixelModesUsed.size() > 1) {
1141         // We can't use one stream with a raw format in both sensor pixel modes since its going to
1142         // be found in only one sensor pixel mode.
1143         ALOGE("%s: RAW opaque stream cannot be used with > 1 sensor pixel modes", __FUNCTION__);
1144         return BAD_VALUE;
1145     }
1146     IPCTransport transport = getTransportType();
1147     if (format == HAL_PIXEL_FORMAT_BLOB) {
1148         ssize_t blobBufferSize;
1149         if (dataSpace == HAL_DATASPACE_DEPTH) {
1150             blobBufferSize = getPointCloudBufferSize(infoPhysical(physicalCameraId));
1151             if (blobBufferSize <= 0) {
1152                 SET_ERR_L("Invalid point cloud buffer size %zd", blobBufferSize);
1153                 return BAD_VALUE;
1154             }
1155         } else if (dataSpace == static_cast<android_dataspace>(HAL_DATASPACE_JPEG_APP_SEGMENTS)) {
1156             blobBufferSize = width * height;
1157         } else {
1158             blobBufferSize = getJpegBufferSize(infoPhysical(physicalCameraId), width, height);
1159             if (blobBufferSize <= 0) {
1160                 SET_ERR_L("Invalid jpeg buffer size %zd", blobBufferSize);
1161                 return BAD_VALUE;
1162             }
1163         }
1164         newStream = new Camera3OutputStream(mNextStreamId, consumers[0].mSurface,
1165                 width, height, blobBufferSize, format, dataSpace, rotation,
1166                 mTimestampOffset, physicalCameraId, sensorPixelModesUsed, transport, streamSetId,
1167                 isMultiResolution, dynamicRangeProfile, streamUseCase, mDeviceTimeBaseIsRealtime,
1168                 timestampBase, consumers[0].mMirrorMode, colorSpace, useReadoutTimestamp);
1169     } else if (format == HAL_PIXEL_FORMAT_RAW_OPAQUE) {
1170         bool maxResolution =
1171                 sensorPixelModesUsed.find(ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION) !=
1172                         sensorPixelModesUsed.end();
1173         ssize_t rawOpaqueBufferSize = getRawOpaqueBufferSize(infoPhysical(physicalCameraId), width,
1174                 height, maxResolution);
1175         if (rawOpaqueBufferSize <= 0) {
1176             SET_ERR_L("Invalid RAW opaque buffer size %zd", rawOpaqueBufferSize);
1177             return BAD_VALUE;
1178         }
1179         newStream = new Camera3OutputStream(mNextStreamId, consumers[0].mSurface,
1180                 width, height, rawOpaqueBufferSize, format, dataSpace, rotation,
1181                 mTimestampOffset, physicalCameraId, sensorPixelModesUsed, transport, streamSetId,
1182                 isMultiResolution, dynamicRangeProfile, streamUseCase, mDeviceTimeBaseIsRealtime,
1183                 timestampBase, consumers[0].mMirrorMode, colorSpace, useReadoutTimestamp);
1184     } else if (isShared) {
1185         newStream = new Camera3SharedOutputStream(mNextStreamId, consumers,
1186                 width, height, format, consumerUsage, dataSpace, rotation,
1187                 mTimestampOffset, physicalCameraId, sensorPixelModesUsed, transport, streamSetId,
1188                 mUseHalBufManager, dynamicRangeProfile, streamUseCase, mDeviceTimeBaseIsRealtime,
1189                 timestampBase, colorSpace, useReadoutTimestamp);
1190     } else if (consumers.size() == 0 && hasDeferredConsumer) {
1191         newStream = new Camera3OutputStream(mNextStreamId,
1192                 width, height, format, consumerUsage, dataSpace, rotation,
1193                 mTimestampOffset, physicalCameraId, sensorPixelModesUsed, transport, streamSetId,
1194                 isMultiResolution, dynamicRangeProfile, streamUseCase, mDeviceTimeBaseIsRealtime,
1195                 timestampBase, colorSpace, useReadoutTimestamp);
1196     } else {
1197         newStream = new Camera3OutputStream(mNextStreamId, consumers[0].mSurface,
1198                 width, height, format, dataSpace, rotation,
1199                 mTimestampOffset, physicalCameraId, sensorPixelModesUsed, transport, streamSetId,
1200                 isMultiResolution, dynamicRangeProfile, streamUseCase, mDeviceTimeBaseIsRealtime,
1201                 timestampBase, consumers[0].mMirrorMode, colorSpace, useReadoutTimestamp);
1202     }
1203 
1204     size_t consumerCount = consumers.size();
1205     for (size_t i = 0; i < consumerCount; i++) {
1206         int id = newStream->getSurfaceId(consumers[i].mSurface);
1207         if (id < 0) {
1208             SET_ERR_L("Invalid surface id");
1209             return BAD_VALUE;
1210         }
1211         if (surfaceIds != nullptr) {
1212             surfaceIds->push_back(id);
1213         }
1214 
1215         res = deriveAndSetTransformLocked(*newStream, consumers[i].mMirrorMode, id);
1216         if (res < 0) {
1217             return res;
1218         }
1219     }
1220 
1221     newStream->setStatusTracker(mStatusTracker);
1222 
1223     newStream->setBufferManager(mBufferManager);
1224 
1225     newStream->setImageDumpMask(mImageDumpMask);
1226 
1227     res = mOutputStreams.add(mNextStreamId, newStream);
1228     if (res < 0) {
1229         SET_ERR_L("Can't add new stream to set: %s (%d)", strerror(-res), res);
1230         return res;
1231     }
1232 
1233     mSessionStatsBuilder.addStream(mNextStreamId);
1234 
1235     *id = mNextStreamId++;
1236     mNeedConfig = true;
1237 
1238     // Continue captures if active at start
1239     if (wasActive) {
1240         ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__);
1241         // Reuse current operating mode and session parameters for new stream config
1242         res = configureStreamsLocked(mOperatingMode, mSessionParams);
1243         if (res != OK) {
1244             CLOGE("Can't reconfigure device for new stream %d: %s (%d)",
1245                     mNextStreamId, strerror(-res), res);
1246             return res;
1247         }
1248         internalResumeLocked();
1249     }
1250     ALOGV("Camera %s: Created new stream", mId.c_str());
1251     return OK;
1252 }
1253 
getStreamInfo(int id,StreamInfo * streamInfo)1254 status_t Camera3Device::getStreamInfo(int id, StreamInfo *streamInfo) {
1255     ATRACE_CALL();
1256     if (nullptr == streamInfo) {
1257         return BAD_VALUE;
1258     }
1259     Mutex::Autolock il(mInterfaceLock);
1260     Mutex::Autolock l(mLock);
1261 
1262     switch (mStatus) {
1263         case STATUS_ERROR:
1264             CLOGE("Device has encountered a serious error");
1265             return INVALID_OPERATION;
1266         case STATUS_UNINITIALIZED:
1267             CLOGE("Device not initialized!");
1268             return INVALID_OPERATION;
1269         case STATUS_UNCONFIGURED:
1270         case STATUS_CONFIGURED:
1271         case STATUS_ACTIVE:
1272             // OK
1273             break;
1274         default:
1275             SET_ERR_L("Unexpected status: %d", mStatus);
1276             return INVALID_OPERATION;
1277     }
1278 
1279     sp<Camera3StreamInterface> stream = mOutputStreams.get(id);
1280     if (stream == nullptr) {
1281         CLOGE("Stream %d is unknown", id);
1282         return BAD_VALUE;
1283     }
1284 
1285     streamInfo->width  = stream->getWidth();
1286     streamInfo->height = stream->getHeight();
1287     streamInfo->format = stream->getFormat();
1288     streamInfo->dataSpace = stream->getDataSpace();
1289     streamInfo->formatOverridden = stream->isFormatOverridden();
1290     streamInfo->originalFormat = stream->getOriginalFormat();
1291     streamInfo->dataSpaceOverridden = stream->isDataSpaceOverridden();
1292     streamInfo->originalDataSpace = stream->getOriginalDataSpace();
1293     streamInfo->dynamicRangeProfile = stream->getDynamicRangeProfile();
1294     streamInfo->colorSpace = stream->getColorSpace();
1295     return OK;
1296 }
1297 
setStreamTransform(int id,int transform)1298 status_t Camera3Device::setStreamTransform(int id,
1299         int transform) {
1300     ATRACE_CALL();
1301     Mutex::Autolock il(mInterfaceLock);
1302     Mutex::Autolock l(mLock);
1303 
1304     switch (mStatus) {
1305         case STATUS_ERROR:
1306             CLOGE("Device has encountered a serious error");
1307             return INVALID_OPERATION;
1308         case STATUS_UNINITIALIZED:
1309             CLOGE("Device not initialized");
1310             return INVALID_OPERATION;
1311         case STATUS_UNCONFIGURED:
1312         case STATUS_CONFIGURED:
1313         case STATUS_ACTIVE:
1314             // OK
1315             break;
1316         default:
1317             SET_ERR_L("Unexpected status: %d", mStatus);
1318             return INVALID_OPERATION;
1319     }
1320 
1321     sp<Camera3OutputStreamInterface> stream = mOutputStreams.get(id);
1322     if (stream == nullptr) {
1323         CLOGE("Stream %d does not exist", id);
1324         return BAD_VALUE;
1325     }
1326     return stream->setTransform(transform, false /*mayChangeMirror*/);
1327 }
1328 
deleteStream(int id)1329 status_t Camera3Device::deleteStream(int id) {
1330     ATRACE_CALL();
1331     Mutex::Autolock il(mInterfaceLock);
1332     Mutex::Autolock l(mLock);
1333     status_t res;
1334 
1335     ALOGV("%s: Camera %s: Deleting stream %d", __FUNCTION__, mId.c_str(), id);
1336 
1337     // CameraDevice semantics require device to already be idle before
1338     // deleteStream is called, unlike for createStream.
1339     if (mStatus == STATUS_ACTIVE) {
1340         ALOGW("%s: Camera %s: Device not idle", __FUNCTION__, mId.c_str());
1341         return -EBUSY;
1342     }
1343 
1344     if (mStatus == STATUS_ERROR) {
1345         ALOGW("%s: Camera %s: deleteStream not allowed in ERROR state",
1346                 __FUNCTION__, mId.c_str());
1347         return -EBUSY;
1348     }
1349 
1350     sp<Camera3StreamInterface> deletedStream;
1351     sp<Camera3StreamInterface> stream = mOutputStreams.get(id);
1352     if (mInputStream != NULL && id == mInputStream->getId()) {
1353         deletedStream = mInputStream;
1354         mInputStream.clear();
1355     } else {
1356         if (stream == nullptr) {
1357             CLOGE("Stream %d does not exist", id);
1358             return BAD_VALUE;
1359         }
1360         mSessionStatsBuilder.removeStream(id);
1361     }
1362 
1363     // Delete output stream or the output part of a bi-directional stream.
1364     if (stream != nullptr) {
1365         deletedStream = stream;
1366         mOutputStreams.remove(id);
1367     }
1368 
1369     // Free up the stream endpoint so that it can be used by some other stream
1370     res = deletedStream->disconnect();
1371     if (res != OK) {
1372         SET_ERR_L("Can't disconnect deleted stream %d", id);
1373         // fall through since we want to still list the stream as deleted.
1374     }
1375     mDeletedStreams.add(deletedStream);
1376     mNeedConfig = true;
1377 
1378     return res;
1379 }
1380 
configureStreams(const CameraMetadata & sessionParams,int operatingMode)1381 status_t Camera3Device::configureStreams(const CameraMetadata& sessionParams, int operatingMode) {
1382     ATRACE_CALL();
1383     ALOGV("%s: E", __FUNCTION__);
1384 
1385     Mutex::Autolock il(mInterfaceLock);
1386     Mutex::Autolock l(mLock);
1387 
1388     // In case the client doesn't include any session parameter, try a
1389     // speculative configuration using the values from the last cached
1390     // default request.
1391     if (sessionParams.isEmpty() &&
1392             ((mLastTemplateId > 0) && (mLastTemplateId < CAMERA_TEMPLATE_COUNT)) &&
1393             (!mRequestTemplateCache[mLastTemplateId].isEmpty())) {
1394         ALOGV("%s: Speculative session param configuration with template id: %d", __func__,
1395                 mLastTemplateId);
1396         return filterParamsAndConfigureLocked(mRequestTemplateCache[mLastTemplateId],
1397                 operatingMode);
1398     }
1399 
1400     return filterParamsAndConfigureLocked(sessionParams, operatingMode);
1401 }
1402 
filterParamsAndConfigureLocked(const CameraMetadata & params,int operatingMode)1403 status_t Camera3Device::filterParamsAndConfigureLocked(const CameraMetadata& params,
1404         int operatingMode) {
1405     CameraMetadata filteredParams;
1406     SessionConfigurationUtils::filterParameters(params, mDeviceInfo,
1407             /*additionalKeys*/{}, mVendorTagId, filteredParams);
1408 
1409     camera_metadata_entry_t availableSessionKeys = mDeviceInfo.find(
1410             ANDROID_REQUEST_AVAILABLE_SESSION_KEYS);
1411 
1412     bool rotateAndCropSessionKey = false;
1413     bool autoframingSessionKey = false;
1414     for (size_t i = 0; i < availableSessionKeys.count; i++) {
1415         if (ANDROID_SCALER_ROTATE_AND_CROP == availableSessionKeys.data.i32[i]) {
1416             rotateAndCropSessionKey = true;
1417         }
1418         if (ANDROID_CONTROL_AUTOFRAMING == availableSessionKeys.data.i32[i]) {
1419             autoframingSessionKey = true;
1420         }
1421     }
1422 
1423     if (rotateAndCropSessionKey || autoframingSessionKey) {
1424         sp<CaptureRequest> request = new CaptureRequest();
1425         PhysicalCameraSettings settingsList;
1426         settingsList.metadata = filteredParams;
1427         request->mSettingsList.push_back(settingsList);
1428 
1429         if (rotateAndCropSessionKey) {
1430             auto rotateAndCropEntry = filteredParams.find(ANDROID_SCALER_ROTATE_AND_CROP);
1431             if (rotateAndCropEntry.count > 0 &&
1432                     rotateAndCropEntry.data.u8[0] == ANDROID_SCALER_ROTATE_AND_CROP_AUTO) {
1433                 request->mRotateAndCropAuto = true;
1434             } else {
1435                 request->mRotateAndCropAuto = false;
1436             }
1437 
1438             overrideAutoRotateAndCrop(request, mRotationOverride, mRotateAndCropOverride);
1439         }
1440 
1441         if (autoframingSessionKey) {
1442             auto autoframingEntry = filteredParams.find(ANDROID_CONTROL_AUTOFRAMING);
1443             if (autoframingEntry.count > 0 &&
1444                     autoframingEntry.data.u8[0] == ANDROID_CONTROL_AUTOFRAMING_AUTO) {
1445                 overrideAutoframing(request, mAutoframingOverride);
1446             }
1447         }
1448 
1449         filteredParams = request->mSettingsList.begin()->metadata;
1450     }
1451 
1452     return configureStreamsLocked(operatingMode, filteredParams);
1453 }
1454 
1455 #if WB_CAMERA3_AND_PROCESSORS_WITH_DEPENDENCIES
getInputSurface(sp<Surface> * surface)1456 status_t Camera3Device::getInputSurface(sp<Surface> *surface) {
1457     ATRACE_CALL();
1458     Mutex::Autolock il(mInterfaceLock);
1459     Mutex::Autolock l(mLock);
1460 
1461     if (surface == NULL) {
1462         return BAD_VALUE;
1463     } else if (mInputStream == NULL) {
1464         return INVALID_OPERATION;
1465     }
1466 
1467     return mInputStream->getInputSurface(surface);
1468 }
1469 #else
getInputBufferProducer(sp<IGraphicBufferProducer> * producer)1470 status_t Camera3Device::getInputBufferProducer(
1471         sp<IGraphicBufferProducer> *producer) {
1472     ATRACE_CALL();
1473     Mutex::Autolock il(mInterfaceLock);
1474     Mutex::Autolock l(mLock);
1475 
1476     if (producer == NULL) {
1477         return BAD_VALUE;
1478     } else if (mInputStream == NULL) {
1479         return INVALID_OPERATION;
1480     }
1481 
1482     return mInputStream->getInputBufferProducer(producer);
1483 }
1484 #endif
1485 
createDefaultRequest(camera_request_template_t templateId,CameraMetadata * request)1486 status_t Camera3Device::createDefaultRequest(camera_request_template_t templateId,
1487         CameraMetadata *request) {
1488     ATRACE_CALL();
1489     ALOGV("%s: for template %d", __FUNCTION__, templateId);
1490 
1491     if (templateId <= 0 || templateId >= CAMERA_TEMPLATE_COUNT) {
1492         android_errorWriteWithInfoLog(CameraService::SN_EVENT_LOG_ID, "26866110",
1493                 getCallingUid(), nullptr, 0);
1494         return BAD_VALUE;
1495     }
1496 
1497     Mutex::Autolock il(mInterfaceLock);
1498 
1499     {
1500         Mutex::Autolock l(mLock);
1501         switch (mStatus) {
1502             case STATUS_ERROR:
1503                 CLOGE("Device has encountered a serious error");
1504                 return INVALID_OPERATION;
1505             case STATUS_UNINITIALIZED:
1506                 CLOGE("Device is not initialized!");
1507                 return INVALID_OPERATION;
1508             case STATUS_UNCONFIGURED:
1509             case STATUS_CONFIGURED:
1510             case STATUS_ACTIVE:
1511                 // OK
1512                 break;
1513             default:
1514                 SET_ERR_L("Unexpected status: %d", mStatus);
1515                 return INVALID_OPERATION;
1516         }
1517 
1518         if (!mRequestTemplateCache[templateId].isEmpty()) {
1519             *request = mRequestTemplateCache[templateId];
1520             mLastTemplateId = templateId;
1521             return OK;
1522         }
1523     }
1524 
1525     camera_metadata_t *rawRequest;
1526     status_t res = mInterface->constructDefaultRequestSettings(
1527             (camera_request_template_t) templateId, &rawRequest);
1528 
1529     {
1530         Mutex::Autolock l(mLock);
1531         if (res == BAD_VALUE) {
1532             ALOGI("%s: template %d is not supported on this camera device",
1533                   __FUNCTION__, templateId);
1534             return res;
1535         } else if (res != OK) {
1536             CLOGE("Unable to construct request template %d: %s (%d)",
1537                     templateId, strerror(-res), res);
1538             return res;
1539         }
1540 
1541         set_camera_metadata_vendor_id(rawRequest, mVendorTagId);
1542         mRequestTemplateCache[templateId].acquire(rawRequest);
1543 
1544         res = overrideDefaultRequestKeys(&mRequestTemplateCache[templateId]);
1545         if (res != OK) {
1546             CLOGE("Failed to overrideDefaultRequestKeys for template %d: %s (%d)",
1547                     templateId, strerror(-res), res);
1548             return res;
1549         }
1550 
1551         *request = mRequestTemplateCache[templateId];
1552         mLastTemplateId = templateId;
1553     }
1554     return OK;
1555 }
1556 
waitUntilDrained()1557 status_t Camera3Device::waitUntilDrained() {
1558     ATRACE_CALL();
1559     Mutex::Autolock il(mInterfaceLock);
1560     nsecs_t maxExpectedDuration = getExpectedInFlightDuration();
1561     Mutex::Autolock l(mLock);
1562 
1563     return waitUntilDrainedLocked(maxExpectedDuration);
1564 }
1565 
waitUntilDrainedLocked(nsecs_t maxExpectedDuration)1566 status_t Camera3Device::waitUntilDrainedLocked(nsecs_t maxExpectedDuration) {
1567     switch (mStatus) {
1568         case STATUS_UNINITIALIZED:
1569         case STATUS_UNCONFIGURED:
1570             ALOGV("%s: Already idle", __FUNCTION__);
1571             return OK;
1572         case STATUS_CONFIGURED:
1573             // To avoid race conditions, check with tracker to be sure
1574         case STATUS_ERROR:
1575         case STATUS_ACTIVE:
1576             // Need to verify shut down
1577             break;
1578         default:
1579             SET_ERR_L("Unexpected status: %d",mStatus);
1580             return INVALID_OPERATION;
1581     }
1582     ALOGV("%s: Camera %s: Waiting until idle (%" PRIi64 "ns)", __FUNCTION__, mId.c_str(),
1583             maxExpectedDuration);
1584     status_t res = waitUntilStateThenRelock(/*active*/ false, maxExpectedDuration,
1585                            /*requestThreadInvocation*/ false);
1586     if (res != OK) {
1587         mStatusTracker->dumpActiveComponents();
1588         SET_ERR_L("Error waiting for HAL to drain: %s (%d)", strerror(-res),
1589                 res);
1590     }
1591     return res;
1592 }
1593 
internalUpdateStatusLocked(Status status)1594 void Camera3Device::internalUpdateStatusLocked(Status status) {
1595     mStatus = status;
1596     mStatusIsInternal = mPauseStateNotify ? true : false;
1597     mRecentStatusUpdates.add({mStatus, mStatusIsInternal});
1598     mStatusChanged.broadcast();
1599 }
1600 
1601 // Pause to reconfigure
internalPauseAndWaitLocked(nsecs_t maxExpectedDuration,bool requestThreadInvocation)1602 status_t Camera3Device::internalPauseAndWaitLocked(nsecs_t maxExpectedDuration,
1603         bool requestThreadInvocation) {
1604     if (mRequestThread.get() != nullptr) {
1605         mRequestThread->setPaused(true);
1606     } else {
1607         return NO_INIT;
1608     }
1609 
1610     ALOGV("%s: Camera %s: Internal wait until idle (% " PRIi64 " ns)", __FUNCTION__, mId.c_str(),
1611           maxExpectedDuration);
1612     status_t res = waitUntilStateThenRelock(/*active*/ false, maxExpectedDuration,
1613                            requestThreadInvocation);
1614     if (res != OK) {
1615         mStatusTracker->dumpActiveComponents();
1616         SET_ERR_L("Can't idle device in %f seconds!",
1617                 maxExpectedDuration/1e9);
1618     }
1619 
1620     return res;
1621 }
1622 
1623 // Resume after internalPauseAndWaitLocked
internalResumeLocked()1624 status_t Camera3Device::internalResumeLocked() {
1625     status_t res;
1626 
1627     mRequestThread->setPaused(false);
1628 
1629     ALOGV("%s: Camera %s: Internal wait until active (% " PRIi64 " ns)", __FUNCTION__, mId.c_str(),
1630             kActiveTimeout);
1631     // internalResumeLocked is always called from a binder thread.
1632     res = waitUntilStateThenRelock(/*active*/ true, kActiveTimeout,
1633                   /*requestThreadInvocation*/ false);
1634     if (res != OK) {
1635         SET_ERR_L("Can't transition to active in %f seconds!",
1636                 kActiveTimeout/1e9);
1637     }
1638     mPauseStateNotify = false;
1639     return OK;
1640 }
1641 
waitUntilStateThenRelock(bool active,nsecs_t timeout,bool requestThreadInvocation)1642 status_t Camera3Device::waitUntilStateThenRelock(bool active, nsecs_t timeout,
1643         bool requestThreadInvocation) {
1644     status_t res = OK;
1645 
1646     size_t startIndex = 0;
1647     if (mStatusWaiters == 0) {
1648         // Clear the list of recent statuses if there are no existing threads waiting on updates to
1649         // this status list
1650         mRecentStatusUpdates.clear();
1651     } else {
1652         // If other threads are waiting on updates to this status list, set the position of the
1653         // first element that this list will check rather than clearing the list.
1654         startIndex = mRecentStatusUpdates.size();
1655     }
1656 
1657     mStatusWaiters++;
1658 
1659     bool signalPipelineDrain = false;
1660     if (!active &&
1661             (mUseHalBufManager ||
1662                     (mHalBufManagedStreamIds.size() != 0))) {
1663         auto streamIds = mOutputStreams.getStreamIds();
1664         if (mStatus == STATUS_ACTIVE) {
1665             mRequestThread->signalPipelineDrain(streamIds);
1666             signalPipelineDrain = true;
1667         }
1668         mRequestBufferSM.onWaitUntilIdle();
1669     }
1670 
1671     bool stateSeen = false;
1672     nsecs_t startTime = systemTime();
1673     do {
1674         if (mStatus == STATUS_ERROR) {
1675             // Device in error state. Return right away.
1676             break;
1677         }
1678         if (active == (mStatus == STATUS_ACTIVE) &&
1679             (requestThreadInvocation || !mStatusIsInternal)) {
1680             // Desired state is current
1681             break;
1682         }
1683 
1684         nsecs_t timeElapsed = systemTime() - startTime;
1685         nsecs_t timeToWait = timeout - timeElapsed;
1686         if (timeToWait <= 0) {
1687             // Thread woke up spuriously but has timed out since.
1688             // Force out of loop with TIMED_OUT result.
1689             res = TIMED_OUT;
1690             break;
1691         }
1692         res = mStatusChanged.waitRelative(mLock, timeToWait);
1693         if (res != OK) break;
1694 
1695         // This is impossible, but if not, could result in subtle deadlocks and invalid state
1696         // transitions.
1697         LOG_ALWAYS_FATAL_IF(startIndex > mRecentStatusUpdates.size(),
1698                 "%s: Skipping status updates in Camera3Device, may result in deadlock.",
1699                 __FUNCTION__);
1700 
1701         // Encountered desired state since we began waiting. Internal invocations coming from
1702         // request threads (such as reconfigureCamera) should be woken up immediately, whereas
1703         // invocations from binder threads (such as createInputStream) should only be woken up if
1704         // they are not paused. This avoids intermediate pause signals from reconfigureCamera as it
1705         // changes the status to active right after.
1706         for (size_t i = startIndex; i < mRecentStatusUpdates.size(); i++) {
1707             if (mRecentStatusUpdates[i].status == STATUS_ERROR) {
1708                 // Device in error state. Return right away.
1709                 stateSeen = true;
1710                 break;
1711             }
1712             if (active == (mRecentStatusUpdates[i].status == STATUS_ACTIVE) &&
1713                 (requestThreadInvocation || !mRecentStatusUpdates[i].isInternal)) {
1714                 stateSeen = true;
1715                 break;
1716             }
1717         }
1718     } while (!stateSeen);
1719 
1720     if (signalPipelineDrain) {
1721         mRequestThread->resetPipelineDrain();
1722     }
1723 
1724     mStatusWaiters--;
1725 
1726     return res;
1727 }
1728 
1729 
setNotifyCallback(wp<NotificationListener> listener)1730 status_t Camera3Device::setNotifyCallback(wp<NotificationListener> listener) {
1731     ATRACE_CALL();
1732     std::lock_guard<std::mutex> l(mOutputLock);
1733 
1734     if (listener != NULL && mListener != NULL) {
1735         ALOGW("%s: Replacing old callback listener", __FUNCTION__);
1736     }
1737     mListener = listener;
1738     mRequestThread->setNotificationListener(listener);
1739     mPreparerThread->setNotificationListener(listener);
1740 
1741     return OK;
1742 }
1743 
willNotify3A()1744 bool Camera3Device::willNotify3A() {
1745     return false;
1746 }
1747 
waitForNextFrame(nsecs_t timeout)1748 status_t Camera3Device::waitForNextFrame(nsecs_t timeout) {
1749     ATRACE_CALL();
1750     std::unique_lock<std::mutex> l(mOutputLock);
1751 
1752     while (mResultQueue.empty()) {
1753         auto st = mResultSignal.wait_for(l, std::chrono::nanoseconds(timeout));
1754         if (st == std::cv_status::timeout) {
1755             return TIMED_OUT;
1756         }
1757     }
1758     return OK;
1759 }
1760 
getNextResult(CaptureResult * frame)1761 status_t Camera3Device::getNextResult(CaptureResult *frame) {
1762     ATRACE_CALL();
1763     std::lock_guard<std::mutex> l(mOutputLock);
1764 
1765     if (mResultQueue.empty()) {
1766         return NOT_ENOUGH_DATA;
1767     }
1768 
1769     if (frame == NULL) {
1770         ALOGE("%s: argument cannot be NULL", __FUNCTION__);
1771         return BAD_VALUE;
1772     }
1773 
1774     CaptureResult &result = *(mResultQueue.begin());
1775     frame->mResultExtras = result.mResultExtras;
1776     frame->mMetadata.acquire(result.mMetadata);
1777     frame->mPhysicalMetadatas = std::move(result.mPhysicalMetadatas);
1778     mResultQueue.erase(mResultQueue.begin());
1779 
1780     return OK;
1781 }
1782 
triggerAutofocus(uint32_t id)1783 status_t Camera3Device::triggerAutofocus(uint32_t id) {
1784     ATRACE_CALL();
1785     Mutex::Autolock il(mInterfaceLock);
1786 
1787     ALOGV("%s: Triggering autofocus, id %d", __FUNCTION__, id);
1788     // Mix-in this trigger into the next request and only the next request.
1789     RequestTrigger trigger[] = {
1790         {
1791             ANDROID_CONTROL_AF_TRIGGER,
1792             ANDROID_CONTROL_AF_TRIGGER_START
1793         },
1794         {
1795             ANDROID_CONTROL_AF_TRIGGER_ID,
1796             static_cast<int32_t>(id)
1797         }
1798     };
1799 
1800     return mRequestThread->queueTrigger(trigger,
1801                                         sizeof(trigger)/sizeof(trigger[0]));
1802 }
1803 
triggerCancelAutofocus(uint32_t id)1804 status_t Camera3Device::triggerCancelAutofocus(uint32_t id) {
1805     ATRACE_CALL();
1806     Mutex::Autolock il(mInterfaceLock);
1807 
1808     ALOGV("%s: Triggering cancel autofocus, id %d", __FUNCTION__, id);
1809     // Mix-in this trigger into the next request and only the next request.
1810     RequestTrigger trigger[] = {
1811         {
1812             ANDROID_CONTROL_AF_TRIGGER,
1813             ANDROID_CONTROL_AF_TRIGGER_CANCEL
1814         },
1815         {
1816             ANDROID_CONTROL_AF_TRIGGER_ID,
1817             static_cast<int32_t>(id)
1818         }
1819     };
1820 
1821     return mRequestThread->queueTrigger(trigger,
1822                                         sizeof(trigger)/sizeof(trigger[0]));
1823 }
1824 
triggerPrecaptureMetering(uint32_t id)1825 status_t Camera3Device::triggerPrecaptureMetering(uint32_t id) {
1826     ATRACE_CALL();
1827     Mutex::Autolock il(mInterfaceLock);
1828 
1829     ALOGV("%s: Triggering precapture metering, id %d", __FUNCTION__, id);
1830     // Mix-in this trigger into the next request and only the next request.
1831     RequestTrigger trigger[] = {
1832         {
1833             ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
1834             ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START
1835         },
1836         {
1837             ANDROID_CONTROL_AE_PRECAPTURE_ID,
1838             static_cast<int32_t>(id)
1839         }
1840     };
1841 
1842     return mRequestThread->queueTrigger(trigger,
1843                                         sizeof(trigger)/sizeof(trigger[0]));
1844 }
1845 
flush(int64_t * frameNumber)1846 status_t Camera3Device::flush(int64_t *frameNumber) {
1847     ATRACE_CALL();
1848     ALOGV("%s: Camera %s: Flushing all requests", __FUNCTION__, mId.c_str());
1849     Mutex::Autolock il(mInterfaceLock);
1850 
1851     {
1852         Mutex::Autolock l(mLock);
1853 
1854         // b/116514106 "disconnect()" can get called twice for the same device. The
1855         // camera device will not be initialized during the second run.
1856         if (mStatus == STATUS_UNINITIALIZED) {
1857             return OK;
1858         }
1859 
1860         mRequestThread->clear(/*out*/frameNumber);
1861 
1862         // Stop session and stream counter
1863         mSessionStatsBuilder.stopCounter();
1864     }
1865 
1866     status_t res = mCameraServiceWatchdog->WATCH(mRequestThread->flush());
1867 
1868     return res;
1869 }
1870 
prepare(int streamId)1871 status_t Camera3Device::prepare(int streamId) {
1872     return prepare(camera3::Camera3StreamInterface::ALLOCATE_PIPELINE_MAX, streamId);
1873 }
1874 
prepare(int maxCount,int streamId)1875 status_t Camera3Device::prepare(int maxCount, int streamId) {
1876     ATRACE_CALL();
1877     ALOGV("%s: Camera %s: Preparing stream %d", __FUNCTION__, mId.c_str(), streamId);
1878     Mutex::Autolock il(mInterfaceLock);
1879     Mutex::Autolock l(mLock);
1880 
1881     sp<Camera3StreamInterface> stream = mOutputStreams.get(streamId);
1882     if (stream == nullptr) {
1883         CLOGE("Stream %d does not exist", streamId);
1884         return BAD_VALUE;
1885     }
1886 
1887     if (stream->isUnpreparable() || stream->hasOutstandingBuffers() ) {
1888         CLOGE("Stream %d has already been a request target", streamId);
1889         return BAD_VALUE;
1890     }
1891 
1892     if (mRequestThread->isStreamPending(stream)) {
1893         CLOGE("Stream %d is already a target in a pending request", streamId);
1894         return BAD_VALUE;
1895     }
1896 
1897     return mPreparerThread->prepare(maxCount, stream);
1898 }
1899 
tearDown(int streamId)1900 status_t Camera3Device::tearDown(int streamId) {
1901     ATRACE_CALL();
1902     ALOGV("%s: Camera %s: Tearing down stream %d", __FUNCTION__, mId.c_str(), streamId);
1903     Mutex::Autolock il(mInterfaceLock);
1904     Mutex::Autolock l(mLock);
1905 
1906     sp<Camera3StreamInterface> stream = mOutputStreams.get(streamId);
1907     if (stream == nullptr) {
1908         CLOGE("Stream %d does not exist", streamId);
1909         return BAD_VALUE;
1910     }
1911 
1912     if (stream->hasOutstandingBuffers() || mRequestThread->isStreamPending(stream)) {
1913         CLOGE("Stream %d is a target of a in-progress request", streamId);
1914         return BAD_VALUE;
1915     }
1916 
1917     return stream->tearDown();
1918 }
1919 
addBufferListenerForStream(int streamId,wp<Camera3StreamBufferListener> listener)1920 status_t Camera3Device::addBufferListenerForStream(int streamId,
1921         wp<Camera3StreamBufferListener> listener) {
1922     ATRACE_CALL();
1923     ALOGV("%s: Camera %s: Adding buffer listener for stream %d", __FUNCTION__, mId.c_str(),
1924             streamId);
1925     Mutex::Autolock il(mInterfaceLock);
1926     Mutex::Autolock l(mLock);
1927 
1928     sp<Camera3StreamInterface> stream = mOutputStreams.get(streamId);
1929     if (stream == nullptr) {
1930         CLOGE("Stream %d does not exist", streamId);
1931         return BAD_VALUE;
1932     }
1933     stream->addBufferListener(listener);
1934 
1935     return OK;
1936 }
1937 
getMaxPreviewFps(sp<camera3::Camera3OutputStreamInterface> stream)1938 float Camera3Device::getMaxPreviewFps(sp<camera3::Camera3OutputStreamInterface> stream) {
1939     camera_metadata_entry minDurations =
1940             mDeviceInfo.find(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS);
1941     for (size_t i = 0; i < minDurations.count; i += 4) {
1942         if (minDurations.data.i64[i] == stream->getOriginalFormat()
1943                 && minDurations.data.i64[i+1] == stream->getWidth()
1944                 && minDurations.data.i64[i+2] == stream->getHeight()) {
1945             int64_t minFrameDuration = minDurations.data.i64[i+3];
1946             return 1e9f / minFrameDuration;
1947         }
1948     }
1949     return 0.0f;
1950 }
1951 
1952 /**
1953  * Methods called by subclasses
1954  */
1955 
notifyStatus(bool idle)1956 void Camera3Device::notifyStatus(bool idle) {
1957     ATRACE_CALL();
1958     std::vector<int> streamIds;
1959     std::vector<hardware::CameraStreamStats> streamStats;
1960     float sessionMaxPreviewFps = 0.0f;
1961 
1962     {
1963         // Need mLock to safely update state and synchronize to current
1964         // state of methods in flight.
1965         Mutex::Autolock l(mLock);
1966         // We can get various system-idle notices from the status tracker
1967         // while starting up. Only care about them if we've actually sent
1968         // in some requests recently.
1969         if (mStatus != STATUS_ACTIVE && mStatus != STATUS_CONFIGURED) {
1970             return;
1971         }
1972         ALOGV("%s: Camera %s: Now %s, pauseState: %s", __FUNCTION__, mId.c_str(),
1973                 idle ? "idle" : "active", mPauseStateNotify ? "true" : "false");
1974         internalUpdateStatusLocked(idle ? STATUS_CONFIGURED : STATUS_ACTIVE);
1975 
1976         // Skip notifying listener if we're doing some user-transparent
1977         // state changes
1978         if (mPauseStateNotify) return;
1979 
1980         for (size_t i = 0; i < mOutputStreams.size(); i++) {
1981             auto stream = mOutputStreams[i];
1982             if (stream.get() == nullptr) continue;
1983 
1984             float streamMaxPreviewFps = getMaxPreviewFps(stream);
1985             sessionMaxPreviewFps = std::max(sessionMaxPreviewFps, streamMaxPreviewFps);
1986 
1987             // Populate stream statistics in case of Idle
1988             if (idle) {
1989                 streamIds.push_back(stream->getId());
1990                 Camera3Stream* camera3Stream = Camera3Stream::cast(stream->asHalStream());
1991                 int64_t usage = 0LL;
1992                 int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT;
1993                 if (camera3Stream != nullptr) {
1994                     usage = camera3Stream->getUsage();
1995                     streamUseCase = camera3Stream->getStreamUseCase();
1996                 }
1997                 streamStats.emplace_back(stream->getWidth(), stream->getHeight(),
1998                     stream->getOriginalFormat(), streamMaxPreviewFps, stream->getDataSpace(), usage,
1999                     stream->getMaxHalBuffers(),
2000                     stream->getMaxTotalBuffers() - stream->getMaxHalBuffers(),
2001                     stream->getDynamicRangeProfile(), streamUseCase,
2002                     stream->getColorSpace());
2003             }
2004         }
2005     }
2006 
2007     sp<NotificationListener> listener;
2008     {
2009         std::lock_guard<std::mutex> l(mOutputLock);
2010         listener = mListener.promote();
2011     }
2012     status_t res = OK;
2013     if (listener != nullptr) {
2014         if (idle) {
2015             // Get session stats from the builder, and notify the listener.
2016             int64_t requestCount, resultErrorCount;
2017             bool deviceError;
2018             std::pair<int32_t, int32_t> mostRequestedFpsRange;
2019             std::map<int, StreamStats> streamStatsMap;
2020             mSessionStatsBuilder.buildAndReset(&requestCount, &resultErrorCount,
2021                     &deviceError, &mostRequestedFpsRange, &streamStatsMap);
2022             for (size_t i = 0; i < streamIds.size(); i++) {
2023                 int streamId = streamIds[i];
2024                 auto stats = streamStatsMap.find(streamId);
2025                 if (stats != streamStatsMap.end()) {
2026                     streamStats[i].mRequestCount = stats->second.mRequestedFrameCount;
2027                     streamStats[i].mErrorCount = stats->second.mDroppedFrameCount;
2028                     streamStats[i].mStartLatencyMs = stats->second.mStartLatencyMs;
2029                     streamStats[i].mHistogramType =
2030                             hardware::CameraStreamStats::HISTOGRAM_TYPE_CAPTURE_LATENCY;
2031                     streamStats[i].mHistogramBins.assign(
2032                             stats->second.mCaptureLatencyBins.begin(),
2033                             stats->second.mCaptureLatencyBins.end());
2034                     streamStats[i].mHistogramCounts.assign(
2035                            stats->second.mCaptureLatencyHistogram.begin(),
2036                            stats->second.mCaptureLatencyHistogram.end());
2037                 }
2038             }
2039             listener->notifyIdle(requestCount, resultErrorCount, deviceError,
2040                 mostRequestedFpsRange, streamStats);
2041         } else {
2042             res = listener->notifyActive(sessionMaxPreviewFps);
2043         }
2044     }
2045     if (res != OK) {
2046         SET_ERR("Camera access permission lost mid-operation: %s (%d)",
2047                 strerror(-res), res);
2048     }
2049 }
2050 
setConsumerSurfaces(int streamId,const std::vector<SurfaceHolder> & consumers,std::vector<int> * surfaceIds)2051 status_t Camera3Device::setConsumerSurfaces(int streamId,
2052         const std::vector<SurfaceHolder>& consumers, std::vector<int> *surfaceIds) {
2053     ATRACE_CALL();
2054     ALOGV("%s: Camera %s: set consumer surface for stream %d",
2055             __FUNCTION__, mId.c_str(), streamId);
2056 
2057     if (surfaceIds == nullptr) {
2058         return BAD_VALUE;
2059     }
2060 
2061     Mutex::Autolock il(mInterfaceLock);
2062     Mutex::Autolock l(mLock);
2063 
2064     if (consumers.size() == 0) {
2065         CLOGE("No consumer is passed!");
2066         return BAD_VALUE;
2067     }
2068 
2069     sp<Camera3OutputStreamInterface> stream = mOutputStreams.get(streamId);
2070     if (stream == nullptr) {
2071         CLOGE("Stream %d is unknown", streamId);
2072         return BAD_VALUE;
2073     }
2074 
2075     // isConsumerConfigurationDeferred will be off after setConsumers
2076     bool isDeferred = stream->isConsumerConfigurationDeferred();
2077     status_t res = stream->setConsumers(consumers);
2078     if (res != OK) {
2079         CLOGE("Stream %d set consumer failed (error %d %s) ", streamId, res, strerror(-res));
2080         return res;
2081     }
2082 
2083     for (auto &consumer : consumers) {
2084         int id = stream->getSurfaceId(consumer.mSurface);
2085         if (id < 0) {
2086             CLOGE("Invalid surface id!");
2087             return BAD_VALUE;
2088         }
2089         surfaceIds->push_back(id);
2090 
2091         res = deriveAndSetTransformLocked(*stream, consumer.mMirrorMode, id);
2092         if (res != OK) {
2093             return res;
2094         }
2095     }
2096 
2097     if (isDeferred) {
2098         if (!stream->isConfiguring()) {
2099             CLOGE("Stream %d was already fully configured.", streamId);
2100             return INVALID_OPERATION;
2101         }
2102 
2103         res = stream->finishConfiguration();
2104         if (res != OK) {
2105             // If finishConfiguration fails due to abandoned surface, do not set
2106             // device to error state.
2107             bool isSurfaceAbandoned =
2108                     (res == NO_INIT || res == DEAD_OBJECT) && stream->isAbandoned();
2109             if (!isSurfaceAbandoned) {
2110                 SET_ERR_L("Can't finish configuring output stream %d: %s (%d)",
2111                         stream->getId(), strerror(-res), res);
2112             }
2113             return res;
2114         }
2115     }
2116 
2117     return OK;
2118 }
2119 
updateStream(int streamId,const std::vector<SurfaceHolder> & newSurfaces,const std::vector<OutputStreamInfo> & outputInfo,const std::vector<size_t> & removedSurfaceIds,KeyedVector<sp<Surface>,size_t> * outputMap)2120 status_t Camera3Device::updateStream(int streamId, const std::vector<SurfaceHolder> &newSurfaces,
2121         const std::vector<OutputStreamInfo> &outputInfo,
2122         const std::vector<size_t> &removedSurfaceIds, KeyedVector<sp<Surface>, size_t> *outputMap) {
2123     Mutex::Autolock il(mInterfaceLock);
2124     Mutex::Autolock l(mLock);
2125 
2126     sp<Camera3OutputStreamInterface> stream = mOutputStreams.get(streamId);
2127     if (stream == nullptr) {
2128         CLOGE("Stream %d is unknown", streamId);
2129         return BAD_VALUE;
2130     }
2131 
2132     for (const auto &it : removedSurfaceIds) {
2133         if (mRequestThread->isOutputSurfacePending(streamId, it)) {
2134             CLOGE("Shared surface still part of a pending request!");
2135             return -EBUSY;
2136         }
2137     }
2138 
2139     status_t res = stream->updateStream(newSurfaces, outputInfo, removedSurfaceIds, outputMap);
2140     if (res != OK) {
2141         CLOGE("Stream %d failed to update stream (error %d %s) ",
2142               streamId, res, strerror(-res));
2143         if (res == UNKNOWN_ERROR) {
2144             SET_ERR_L("%s: Stream update failed to revert to previous output configuration!",
2145                     __FUNCTION__);
2146         }
2147         return res;
2148     }
2149 
2150     for (size_t i = 0; i < outputMap->size(); i++) {
2151         res = deriveAndSetTransformLocked(
2152                 *stream, newSurfaces[i].mMirrorMode, outputMap->valueAt(i));
2153         if (res != OK) {
2154             return res;
2155         }
2156     }
2157 
2158     return res;
2159 }
2160 
dropStreamBuffers(bool dropping,int streamId)2161 status_t Camera3Device::dropStreamBuffers(bool dropping, int streamId) {
2162     Mutex::Autolock il(mInterfaceLock);
2163     Mutex::Autolock l(mLock);
2164 
2165     sp<Camera3OutputStreamInterface> stream = mOutputStreams.get(streamId);
2166     if (stream == nullptr) {
2167         ALOGE("%s: Stream %d is not found.", __FUNCTION__, streamId);
2168         return BAD_VALUE;
2169     }
2170 
2171     if (dropping) {
2172         mSessionStatsBuilder.stopCounter(streamId);
2173     } else {
2174         mSessionStatsBuilder.startCounter(streamId);
2175     }
2176     return stream->dropBuffers(dropping);
2177 }
2178 
2179 /**
2180  * Camera3Device private methods
2181  */
2182 
createCaptureRequest(const PhysicalCameraSettingsList & request,const SurfaceMap & surfaceMap)2183 sp<Camera3Device::CaptureRequest> Camera3Device::createCaptureRequest(
2184         const PhysicalCameraSettingsList &request, const SurfaceMap &surfaceMap) {
2185     ATRACE_CALL();
2186 
2187     sp<CaptureRequest> newRequest = new CaptureRequest();
2188     newRequest->mSettingsList = request;
2189 
2190     camera_metadata_entry_t inputStreams =
2191             newRequest->mSettingsList.begin()->metadata.find(ANDROID_REQUEST_INPUT_STREAMS);
2192     if (inputStreams.count > 0) {
2193         if (mInputStream == NULL ||
2194                 mInputStream->getId() != inputStreams.data.i32[0]) {
2195             CLOGE("Request references unknown input stream %d",
2196                     inputStreams.data.u8[0]);
2197             return NULL;
2198         }
2199 
2200         if (mInputStream->isConfiguring()) {
2201             SET_ERR_L("%s: input stream %d is not configured!",
2202                     __FUNCTION__, mInputStream->getId());
2203             return NULL;
2204         }
2205         // Check if stream prepare is blocking requests.
2206         if (mInputStream->isBlockedByPrepare()) {
2207             CLOGE("Request references an input stream that's being prepared!");
2208             return NULL;
2209         }
2210 
2211         newRequest->mInputStream = mInputStream;
2212         newRequest->mSettingsList.begin()->metadata.erase(ANDROID_REQUEST_INPUT_STREAMS);
2213     }
2214 
2215     camera_metadata_entry_t streams =
2216             newRequest->mSettingsList.begin()->metadata.find(ANDROID_REQUEST_OUTPUT_STREAMS);
2217     if (streams.count == 0) {
2218         CLOGE("Zero output streams specified!");
2219         return NULL;
2220     }
2221 
2222     for (size_t i = 0; i < streams.count; i++) {
2223         sp<Camera3OutputStreamInterface> stream = mOutputStreams.get(streams.data.i32[i]);
2224         if (stream == nullptr) {
2225             CLOGE("Request references unknown stream %d",
2226                     streams.data.i32[i]);
2227             return NULL;
2228         }
2229         // It is illegal to include a deferred consumer output stream into a request
2230         auto iter = surfaceMap.find(streams.data.i32[i]);
2231         if (iter != surfaceMap.end()) {
2232             const std::vector<size_t>& surfaces = iter->second;
2233             for (const auto& surface : surfaces) {
2234                 if (stream->isConsumerConfigurationDeferred(surface)) {
2235                     CLOGE("Stream %d surface %zu hasn't finished configuration yet "
2236                           "due to deferred consumer", stream->getId(), surface);
2237                     return NULL;
2238                 }
2239             }
2240             newRequest->mOutputSurfaces[streams.data.i32[i]] = surfaces;
2241         }
2242 
2243         if (stream->isConfiguring()) {
2244             SET_ERR_L("%s: stream %d is not configured!", __FUNCTION__, stream->getId());
2245             return NULL;
2246         }
2247         // Check if stream prepare is blocking requests.
2248         if (stream->isBlockedByPrepare()) {
2249             CLOGE("Request references an output stream that's being prepared!");
2250             return NULL;
2251         }
2252 
2253         newRequest->mOutputStreams.push(stream);
2254     }
2255     newRequest->mSettingsList.begin()->metadata.erase(ANDROID_REQUEST_OUTPUT_STREAMS);
2256     newRequest->mBatchSize = 1;
2257 
2258     auto rotateAndCropEntry =
2259             newRequest->mSettingsList.begin()->metadata.find(ANDROID_SCALER_ROTATE_AND_CROP);
2260     if (rotateAndCropEntry.count > 0 &&
2261             rotateAndCropEntry.data.u8[0] == ANDROID_SCALER_ROTATE_AND_CROP_AUTO) {
2262         newRequest->mRotateAndCropAuto = true;
2263     } else {
2264         newRequest->mRotateAndCropAuto = false;
2265     }
2266 
2267     auto autoframingEntry =
2268             newRequest->mSettingsList.begin()->metadata.find(ANDROID_CONTROL_AUTOFRAMING);
2269     if (autoframingEntry.count > 0 &&
2270             autoframingEntry.data.u8[0] == ANDROID_CONTROL_AUTOFRAMING_AUTO) {
2271         newRequest->mAutoframingAuto = true;
2272     } else {
2273         newRequest->mAutoframingAuto = false;
2274     }
2275 
2276     auto zoomRatioEntry =
2277             newRequest->mSettingsList.begin()->metadata.find(ANDROID_CONTROL_ZOOM_RATIO);
2278     if (zoomRatioEntry.count > 0 &&
2279             zoomRatioEntry.data.f[0] == 1.0f) {
2280         newRequest->mZoomRatioIs1x = true;
2281     } else {
2282         newRequest->mZoomRatioIs1x = false;
2283     }
2284 
2285     if (mSupportCameraMute) {
2286         for (auto& settings : newRequest->mSettingsList) {
2287             auto testPatternModeEntry =
2288                     settings.metadata.find(ANDROID_SENSOR_TEST_PATTERN_MODE);
2289             settings.mOriginalTestPatternMode = testPatternModeEntry.count > 0 ?
2290                     testPatternModeEntry.data.i32[0] :
2291                     ANDROID_SENSOR_TEST_PATTERN_MODE_OFF;
2292 
2293             auto testPatternDataEntry =
2294                     settings.metadata.find(ANDROID_SENSOR_TEST_PATTERN_DATA);
2295             if (testPatternDataEntry.count >= 4) {
2296                 memcpy(settings.mOriginalTestPatternData, testPatternDataEntry.data.i32,
2297                         sizeof(PhysicalCameraSettings::mOriginalTestPatternData));
2298             } else {
2299                 settings.mOriginalTestPatternData[0] = 0;
2300                 settings.mOriginalTestPatternData[1] = 0;
2301                 settings.mOriginalTestPatternData[2] = 0;
2302                 settings.mOriginalTestPatternData[3] = 0;
2303             }
2304         }
2305     }
2306 
2307     if (mSupportZoomOverride) {
2308         for (auto& settings : newRequest->mSettingsList) {
2309             auto settingsOverrideEntry =
2310                     settings.metadata.find(ANDROID_CONTROL_SETTINGS_OVERRIDE);
2311             settings.mOriginalSettingsOverride = settingsOverrideEntry.count > 0 ?
2312                     settingsOverrideEntry.data.i32[0] :
2313                     ANDROID_CONTROL_SETTINGS_OVERRIDE_OFF;
2314         }
2315     }
2316 
2317     return newRequest;
2318 }
2319 
cancelStreamsConfigurationLocked()2320 void Camera3Device::cancelStreamsConfigurationLocked() {
2321     int res = OK;
2322     if (mInputStream != NULL && mInputStream->isConfiguring()) {
2323         res = mInputStream->cancelConfiguration();
2324         if (res != OK) {
2325             CLOGE("Can't cancel configuring input stream %d: %s (%d)",
2326                     mInputStream->getId(), strerror(-res), res);
2327         }
2328     }
2329 
2330     for (size_t i = 0; i < mOutputStreams.size(); i++) {
2331         sp<Camera3OutputStreamInterface> outputStream = mOutputStreams[i];
2332         if (outputStream->isConfiguring()) {
2333             res = outputStream->cancelConfiguration();
2334             if (res != OK) {
2335                 CLOGE("Can't cancel configuring output stream %d: %s (%d)",
2336                         outputStream->getId(), strerror(-res), res);
2337             }
2338         }
2339     }
2340 
2341     // Return state to that at start of call, so that future configures
2342     // properly clean things up
2343     internalUpdateStatusLocked(STATUS_UNCONFIGURED);
2344     mNeedConfig = true;
2345 
2346     res = mPreparerThread->resume();
2347     if (res != OK) {
2348         ALOGE("%s: Camera %s: Preparer thread failed to resume!", __FUNCTION__, mId.c_str());
2349     }
2350 }
2351 
checkAbandonedStreamsLocked()2352 bool Camera3Device::checkAbandonedStreamsLocked() {
2353     if ((mInputStream.get() != nullptr) && (mInputStream->isAbandoned())) {
2354         return true;
2355     }
2356 
2357     for (size_t i = 0; i < mOutputStreams.size(); i++) {
2358         auto stream = mOutputStreams[i];
2359         if ((stream.get() != nullptr) && (stream->isAbandoned())) {
2360             return true;
2361         }
2362     }
2363 
2364     return false;
2365 }
2366 
reconfigureCamera(const CameraMetadata & sessionParams,int clientStatusId)2367 bool Camera3Device::reconfigureCamera(const CameraMetadata& sessionParams, int clientStatusId) {
2368     ATRACE_CALL();
2369     bool ret = false;
2370 
2371     nsecs_t startTime = systemTime();
2372 
2373     // We must not hold mInterfaceLock here since this function is called from
2374     // RequestThread::threadLoop and holding mInterfaceLock could lead to
2375     // deadlocks (http://b/143513518)
2376     nsecs_t maxExpectedDuration = getExpectedInFlightDuration();
2377 
2378     // Make sure status tracker is flushed
2379     mStatusTracker->flushPendingStates();
2380 
2381     Mutex::Autolock l(mLock);
2382     if (checkAbandonedStreamsLocked()) {
2383         ALOGW("%s: Abandoned stream detected, session parameters can't be applied correctly!",
2384                 __FUNCTION__);
2385         return true;
2386     }
2387 
2388     status_t rc = NO_ERROR;
2389     bool markClientActive = false;
2390     if (mStatus == STATUS_ACTIVE) {
2391         markClientActive = true;
2392         mPauseStateNotify = true;
2393         mStatusTracker->markComponentIdle(clientStatusId, Fence::NO_FENCE);
2394 
2395         // This is essentially the same as calling rc = internalPauseAndWaitLocked(..), except that
2396         // we don't want to call setPaused(true) to avoid it interfering with setPaused() called
2397         // from createInputStream/createStream.
2398         rc = waitUntilStateThenRelock(/*active*/ false, maxExpectedDuration,
2399                 /*requestThreadInvocation*/ true);
2400         if (rc != OK) {
2401             mStatusTracker->dumpActiveComponents();
2402             SET_ERR_L("Can't idle device in %f seconds!",
2403                 maxExpectedDuration/1e9);
2404         }
2405     }
2406 
2407     if (rc == NO_ERROR) {
2408         mNeedConfig = true;
2409         rc = configureStreamsLocked(mOperatingMode, sessionParams, /*notifyRequestThread*/ false);
2410         if (rc == NO_ERROR) {
2411             ret = true;
2412             mPauseStateNotify = false;
2413             //Moving to active state while holding 'mLock' is important.
2414             //There could be pending calls to 'create-/deleteStream' which
2415             //will trigger another stream configuration while the already
2416             //present streams end up with outstanding buffers that will
2417             //not get drained.
2418             internalUpdateStatusLocked(STATUS_ACTIVE);
2419 
2420             mCameraServiceProxyWrapper->logStreamConfigured(mId, mOperatingMode,
2421                     true /*internalReconfig*/, ns2ms(systemTime() - startTime));
2422         } else if (rc == DEAD_OBJECT) {
2423             // DEAD_OBJECT can be returned if either the consumer surface is
2424             // abandoned, or the HAL has died.
2425             // - If the HAL has died, configureStreamsLocked call will set
2426             // device to error state,
2427             // - If surface is abandoned, we should not set device to error
2428             // state.
2429             ALOGE("Failed to re-configure camera due to abandoned surface");
2430         } else {
2431             SET_ERR_L("Failed to re-configure camera: %d", rc);
2432         }
2433     } else {
2434         ALOGE("%s: Failed to pause streaming: %d", __FUNCTION__, rc);
2435     }
2436 
2437     if (markClientActive) {
2438         mStatusTracker->markComponentActive(clientStatusId);
2439     }
2440 
2441     return ret;
2442 }
2443 
2444 
configureStreamsLocked(int operatingMode,const CameraMetadata & sessionParams,bool notifyRequestThread)2445 status_t Camera3Device::configureStreamsLocked(int operatingMode,
2446         const CameraMetadata& sessionParams, bool notifyRequestThread) {
2447     ATRACE_CALL();
2448     status_t res;
2449     // Stream/surface setup can include a lot of binder IPC. Raise the
2450     // thread priority when running the binder IPC heavy configuration
2451     // sequence.
2452     RunThreadWithRealtimePriority priorityBump;
2453 
2454     if (mStatus != STATUS_UNCONFIGURED && mStatus != STATUS_CONFIGURED) {
2455         CLOGE("Not idle");
2456         return INVALID_OPERATION;
2457     }
2458 
2459     if (operatingMode < 0) {
2460         CLOGE("Invalid operating mode: %d", operatingMode);
2461         return BAD_VALUE;
2462     }
2463 
2464     bool isConstrainedHighSpeed =
2465             CAMERA_STREAM_CONFIGURATION_CONSTRAINED_HIGH_SPEED_MODE == operatingMode;
2466 
2467     if (mOperatingMode != operatingMode) {
2468         mNeedConfig = true;
2469         mIsConstrainedHighSpeedConfiguration = isConstrainedHighSpeed;
2470         mOperatingMode = operatingMode;
2471     }
2472 
2473     // Reset min expected duration when session is reconfigured.
2474     mMinExpectedDuration = 0;
2475 
2476     // In case called from configureStreams, abort queued input buffers not belonging to
2477     // any pending requests.
2478     if (mInputStream != NULL && notifyRequestThread) {
2479         while (true) {
2480             camera_stream_buffer_t inputBuffer;
2481             camera3::Size inputBufferSize;
2482             status_t res = mInputStream->getInputBuffer(&inputBuffer,
2483                     &inputBufferSize, /*respectHalLimit*/ false);
2484             if (res != OK) {
2485                 // Exhausted acquiring all input buffers.
2486                 break;
2487             }
2488 
2489             inputBuffer.status = CAMERA_BUFFER_STATUS_ERROR;
2490             res = mInputStream->returnInputBuffer(inputBuffer);
2491             if (res != OK) {
2492                 ALOGE("%s: %d: couldn't return input buffer while clearing input queue: "
2493                         "%s (%d)", __FUNCTION__, __LINE__, strerror(-res), res);
2494             }
2495         }
2496     }
2497 
2498     if (!mNeedConfig) {
2499         ALOGV("%s: Skipping config, no stream changes", __FUNCTION__);
2500         return OK;
2501     }
2502 
2503     // Workaround for device HALv3.2 or older spec bug - zero streams requires
2504     // adding a fake stream instead.
2505     // TODO: Bug: 17321404 for fixing the HAL spec and removing this workaround.
2506     if (mOutputStreams.size() == 0) {
2507         addFakeStreamLocked();
2508     } else {
2509         tryRemoveFakeStreamLocked();
2510     }
2511 
2512     // Override stream use case based on "adb shell command"
2513     overrideStreamUseCaseLocked();
2514 
2515     // Start configuring the streams
2516     ALOGV("%s: Camera %s: Starting stream configuration", __FUNCTION__, mId.c_str());
2517 
2518     mPreparerThread->pause();
2519 
2520     camera_stream_configuration config;
2521     config.operation_mode = mOperatingMode;
2522     config.num_streams = (mInputStream != NULL) + mOutputStreams.size();
2523     config.input_is_multi_resolution = false;
2524 
2525     Vector<camera3::camera_stream_t*> streams;
2526     streams.setCapacity(config.num_streams);
2527     std::vector<uint32_t> bufferSizes(config.num_streams, 0);
2528 
2529 
2530     if (mInputStream != NULL) {
2531         camera3::camera_stream_t *inputStream;
2532         inputStream = mInputStream->startConfiguration();
2533         if (inputStream == NULL) {
2534             CLOGE("Can't start input stream configuration");
2535             cancelStreamsConfigurationLocked();
2536             return INVALID_OPERATION;
2537         }
2538         streams.add(inputStream);
2539 
2540         config.input_is_multi_resolution = mIsInputStreamMultiResolution;
2541     }
2542 
2543     mGroupIdPhysicalCameraMap.clear();
2544     mComposerOutput = false;
2545     for (size_t i = 0; i < mOutputStreams.size(); i++) {
2546 
2547         // Don't configure bidi streams twice, nor add them twice to the list
2548         if (mOutputStreams[i].get() ==
2549             static_cast<Camera3StreamInterface*>(mInputStream.get())) {
2550 
2551             config.num_streams--;
2552             continue;
2553         }
2554 
2555         camera3::camera_stream_t *outputStream;
2556         outputStream = mOutputStreams[i]->startConfiguration();
2557         if (outputStream == NULL) {
2558             CLOGE("Can't start output stream configuration");
2559             cancelStreamsConfigurationLocked();
2560             return INVALID_OPERATION;
2561         }
2562         streams.add(outputStream);
2563 
2564         if (outputStream->format == HAL_PIXEL_FORMAT_BLOB) {
2565             size_t k = i + ((mInputStream != nullptr) ? 1 : 0); // Input stream if present should
2566                                                                 // always occupy the initial entry.
2567             if ((outputStream->data_space == HAL_DATASPACE_V0_JFIF) ||
2568                     (outputStream->data_space ==
2569                      static_cast<android_dataspace_t>(
2570                          aidl::android::hardware::graphics::common::Dataspace::HEIF_ULTRAHDR)) ||
2571                     (outputStream->data_space ==
2572                      static_cast<android_dataspace_t>(
2573                          aidl::android::hardware::graphics::common::Dataspace::JPEG_R))) {
2574                 bufferSizes[k] = static_cast<uint32_t>(
2575                         getJpegBufferSize(infoPhysical(outputStream->physical_camera_id),
2576                                 outputStream->width, outputStream->height));
2577             } else if (outputStream->data_space ==
2578                     static_cast<android_dataspace>(HAL_DATASPACE_JPEG_APP_SEGMENTS)) {
2579                 bufferSizes[k] = outputStream->width * outputStream->height;
2580             } else {
2581                 ALOGW("%s: Blob dataSpace %d not supported",
2582                         __FUNCTION__, outputStream->data_space);
2583             }
2584         }
2585 
2586         if (mOutputStreams[i]->isMultiResolution()) {
2587             int32_t streamGroupId = mOutputStreams[i]->getHalStreamGroupId();
2588             const std::string &physicalCameraId = mOutputStreams[i]->getPhysicalCameraId();
2589             mGroupIdPhysicalCameraMap[streamGroupId].insert(physicalCameraId);
2590         }
2591 
2592         if (outputStream->usage & GraphicBuffer::USAGE_HW_COMPOSER) {
2593             mComposerOutput = true;
2594         }
2595     }
2596 
2597     config.streams = streams.editArray();
2598     config.hal_buffer_managed_streams = mHalBufManagedStreamIds;
2599     config.use_hal_buf_manager = mUseHalBufManager;
2600 
2601     // Do the HAL configuration; will potentially touch stream
2602     // max_buffers, usage, priv fields, data_space and format
2603     // fields for IMPLEMENTATION_DEFINED formats as well as hal buffer managed
2604     // streams and use_hal_buf_manager (in case aconfig flag session_hal_buf_manager
2605     // is not enabled but the HAL supports session specific hal buffer manager).
2606 
2607     int64_t logId = mCameraServiceProxyWrapper->getCurrentLogIdForCamera(mId);
2608     const camera_metadata_t *sessionBuffer = sessionParams.getAndLock();
2609     res = mInterface->configureStreams(sessionBuffer, &config, bufferSizes, logId);
2610     sessionParams.unlock(sessionBuffer);
2611 
2612     if (res == BAD_VALUE) {
2613         // HAL rejected this set of streams as unsupported, clean up config
2614         // attempt and return to unconfigured state
2615         CLOGE("Set of requested inputs/outputs not supported by HAL");
2616         cancelStreamsConfigurationLocked();
2617         return BAD_VALUE;
2618     } else if (res != OK) {
2619         // Some other kind of error from configure_streams - this is not
2620         // expected
2621         SET_ERR_L("Unable to configure streams with HAL: %s (%d)",
2622                 strerror(-res), res);
2623         return res;
2624     }
2625     // It is possible that use hal buffer manager behavior was changed by the
2626     // configureStreams call.
2627     mUseHalBufManager = config.use_hal_buf_manager;
2628     bool prevSessionHalBufManager = (mHalBufManagedStreamIds.size() != 0);
2629     // It is possible that configureStreams() changed config.hal_buffer_managed_streams
2630     mHalBufManagedStreamIds = config.hal_buffer_managed_streams;
2631 
2632     bool thisSessionHalBufManager = mHalBufManagedStreamIds.size() != 0;
2633 
2634     if (prevSessionHalBufManager && !thisSessionHalBufManager) {
2635         mRequestBufferSM.deInit();
2636     } else if (!prevSessionHalBufManager && thisSessionHalBufManager) {
2637         res = mRequestBufferSM.initialize(mStatusTracker);
2638         if (res != OK) {
2639             SET_ERR_L("%s: Camera %s: RequestBuffer State machine couldn't be initialized!",
2640                         __FUNCTION__, mId.c_str());
2641             return res;
2642         }
2643     }
2644     mRequestThread->setHalBufferManagedStreams(mHalBufManagedStreamIds);
2645 
2646     // Finish all stream configuration immediately.
2647     // TODO: Try to relax this later back to lazy completion, which should be
2648     // faster
2649 
2650     if (mInputStream != NULL && mInputStream->isConfiguring()) {
2651         bool streamReConfigured = false;
2652         res = mInputStream->finishConfiguration(&streamReConfigured);
2653         if (res != OK) {
2654             CLOGE("Can't finish configuring input stream %d: %s (%d)", mInputStream->getId(),
2655                   strerror(-res), res);
2656             cancelStreamsConfigurationLocked();
2657             if ((res == NO_INIT || res == DEAD_OBJECT) && mInputStream->isAbandoned()) {
2658                 return DEAD_OBJECT;
2659             }
2660             return BAD_VALUE;
2661         }
2662         if (streamReConfigured) {
2663             mInterface->onStreamReConfigured(mInputStream->getId());
2664         }
2665     }
2666 
2667     for (size_t i = 0; i < mOutputStreams.size(); i++) {
2668         sp<Camera3OutputStreamInterface> outputStream = mOutputStreams[i];
2669         if (outputStream->isConfiguring() && !outputStream->isConsumerConfigurationDeferred()) {
2670             bool streamReConfigured = false;
2671             res = outputStream->finishConfiguration(&streamReConfigured);
2672             if (res != OK) {
2673                 CLOGE("Can't finish configuring output stream %d: %s (%d)", outputStream->getId(),
2674                       strerror(-res), res);
2675                 cancelStreamsConfigurationLocked();
2676                 if ((res == NO_INIT || res == DEAD_OBJECT) && outputStream->isAbandoned()) {
2677                     return DEAD_OBJECT;
2678                 }
2679                 return BAD_VALUE;
2680             }
2681             if (streamReConfigured) {
2682                 mInterface->onStreamReConfigured(outputStream->getId());
2683             }
2684         }
2685     }
2686 
2687     mRequestThread->setComposerSurface(mComposerOutput);
2688 
2689     // Request thread needs to know to avoid using repeat-last-settings protocol
2690     // across configure_streams() calls
2691     if (notifyRequestThread) {
2692         mRequestThread->configurationComplete(mIsConstrainedHighSpeedConfiguration,
2693                 sessionParams, mGroupIdPhysicalCameraMap);
2694     }
2695 
2696     char value[PROPERTY_VALUE_MAX];
2697     property_get("camera.fifo.disable", value, "0");
2698     int32_t disableFifo = atoi(value);
2699     if (disableFifo != 1) {
2700         // Boost priority of request thread to SCHED_FIFO.
2701         pid_t requestThreadTid = mRequestThread->getTid();
2702         res = SchedulingPolicyUtils::requestPriorityDirect(
2703                 getpid(), requestThreadTid, RunThreadWithRealtimePriority::kRequestThreadPriority);
2704         if (res != OK) {
2705             ALOGW("Can't set realtime priority for request processing thread: %s (%d)",
2706                     strerror(-res), res);
2707         } else {
2708             ALOGD("Set real time priority for request queue thread (tid %d)", requestThreadTid);
2709         }
2710     }
2711 
2712     // Update device state
2713     const camera_metadata_t *newSessionParams = sessionParams.getAndLock();
2714     const camera_metadata_t *currentSessionParams = mSessionParams.getAndLock();
2715     bool updateSessionParams = (newSessionParams != currentSessionParams) ? true : false;
2716     sessionParams.unlock(newSessionParams);
2717     mSessionParams.unlock(currentSessionParams);
2718     if (updateSessionParams)  {
2719         mSessionParams = sessionParams;
2720     }
2721 
2722     mNeedConfig = false;
2723 
2724     internalUpdateStatusLocked((mFakeStreamId == NO_STREAM) ?
2725             STATUS_CONFIGURED : STATUS_UNCONFIGURED);
2726 
2727     ALOGV("%s: Camera %s: Stream configuration complete", __FUNCTION__, mId.c_str());
2728 
2729     // tear down the deleted streams after configure streams.
2730     mDeletedStreams.clear();
2731 
2732     auto rc = mPreparerThread->resume();
2733     if (rc != OK) {
2734         SET_ERR_L("%s: Camera %s: Preparer thread failed to resume!", __FUNCTION__, mId.c_str());
2735         return rc;
2736     }
2737 
2738     if (mFakeStreamId == NO_STREAM) {
2739         mRequestBufferSM.onStreamsConfigured();
2740     }
2741 
2742     // First call injectCamera() and then run configureStreamsLocked() case:
2743     // Since the streams configuration of the injection camera is based on the internal camera, we
2744     // must wait until the internal camera configure streams before running the injection job to
2745     // configure the injection streams.
2746     if (mInjectionMethods->isInjecting()) {
2747         ALOGD("%s: Injection camera %s: Start to configure streams.",
2748               __FUNCTION__, mInjectionMethods->getInjectedCamId().c_str());
2749         res = mInjectionMethods->injectCamera(config, bufferSizes);
2750         if (res != OK) {
2751             ALOGE("Can't finish inject camera process!");
2752             return res;
2753         }
2754     } else {
2755         // First run configureStreamsLocked() and then call injectCamera() case:
2756         // If the stream configuration has been completed and camera deive is active, but the
2757         // injection camera has not been injected yet, we need to store the stream configuration of
2758         // the internal camera (because the stream configuration of the injection camera is based
2759         // on the internal camera). When injecting occurs later, this configuration can be used by
2760         // the injection camera.
2761         ALOGV("%s: The stream configuration is complete and the camera device is active, but the"
2762               " injection camera has not been injected yet.", __FUNCTION__);
2763         mInjectionMethods->storeInjectionConfig(config, bufferSizes);
2764     }
2765 
2766     return OK;
2767 }
2768 
addFakeStreamLocked()2769 status_t Camera3Device::addFakeStreamLocked() {
2770     ATRACE_CALL();
2771     status_t res;
2772 
2773     if (mFakeStreamId != NO_STREAM) {
2774         // Should never be adding a second fake stream when one is already
2775         // active
2776         SET_ERR_L("%s: Camera %s: A fake stream already exists!",
2777                 __FUNCTION__, mId.c_str());
2778         return INVALID_OPERATION;
2779     }
2780 
2781     ALOGV("%s: Camera %s: Adding a fake stream", __FUNCTION__, mId.c_str());
2782 
2783     sp<Camera3OutputStreamInterface> fakeStream =
2784             new Camera3FakeStream(mNextStreamId);
2785 
2786     res = mOutputStreams.add(mNextStreamId, fakeStream);
2787     if (res < 0) {
2788         SET_ERR_L("Can't add fake stream to set: %s (%d)", strerror(-res), res);
2789         return res;
2790     }
2791 
2792     mFakeStreamId = mNextStreamId;
2793     mNextStreamId++;
2794 
2795     return OK;
2796 }
2797 
tryRemoveFakeStreamLocked()2798 status_t Camera3Device::tryRemoveFakeStreamLocked() {
2799     ATRACE_CALL();
2800     status_t res;
2801 
2802     if (mFakeStreamId == NO_STREAM) return OK;
2803     if (mOutputStreams.size() == 1) return OK;
2804 
2805     ALOGV("%s: Camera %s: Removing the fake stream", __FUNCTION__, mId.c_str());
2806 
2807     // Ok, have a fake stream and there's at least one other output stream,
2808     // so remove the fake
2809 
2810     sp<Camera3StreamInterface> deletedStream = mOutputStreams.get(mFakeStreamId);
2811     if (deletedStream == nullptr) {
2812         SET_ERR_L("Fake stream %d does not appear to exist", mFakeStreamId);
2813         return INVALID_OPERATION;
2814     }
2815     mOutputStreams.remove(mFakeStreamId);
2816 
2817     // Free up the stream endpoint so that it can be used by some other stream
2818     res = deletedStream->disconnect();
2819     if (res != OK) {
2820         SET_ERR_L("Can't disconnect deleted fake stream %d", mFakeStreamId);
2821         // fall through since we want to still list the stream as deleted.
2822     }
2823     mDeletedStreams.add(deletedStream);
2824     mFakeStreamId = NO_STREAM;
2825 
2826     return res;
2827 }
2828 
setErrorState(const char * fmt,...)2829 void Camera3Device::setErrorState(const char *fmt, ...) {
2830     ATRACE_CALL();
2831     Mutex::Autolock l(mLock);
2832     va_list args;
2833     va_start(args, fmt);
2834 
2835     setErrorStateLockedV(fmt, args);
2836 
2837     va_end(args);
2838 }
2839 
setErrorStateV(const char * fmt,va_list args)2840 void Camera3Device::setErrorStateV(const char *fmt, va_list args) {
2841     ATRACE_CALL();
2842     Mutex::Autolock l(mLock);
2843     setErrorStateLockedV(fmt, args);
2844 }
2845 
setErrorStateLocked(const char * fmt,...)2846 void Camera3Device::setErrorStateLocked(const char *fmt, ...) {
2847     va_list args;
2848     va_start(args, fmt);
2849 
2850     setErrorStateLockedV(fmt, args);
2851 
2852     va_end(args);
2853 }
2854 
setErrorStateLockedV(const char * fmt,va_list args)2855 void Camera3Device::setErrorStateLockedV(const char *fmt, va_list args) {
2856     // Print out all error messages to log
2857     std::string errorCause;
2858     base::StringAppendV(&errorCause, fmt, args);
2859     ALOGE("Camera %s: %s", mId.c_str(), errorCause.c_str());
2860 
2861     // But only do error state transition steps for the first error
2862     if (mStatus == STATUS_ERROR || mStatus == STATUS_UNINITIALIZED) return;
2863 
2864     mErrorCause = errorCause;
2865 
2866     if (mRequestThread != nullptr) {
2867         mRequestThread->setPaused(true);
2868     }
2869     internalUpdateStatusLocked(STATUS_ERROR);
2870 
2871     // Notify upstream about a device error
2872     sp<NotificationListener> listener = mListener.promote();
2873     if (listener != NULL) {
2874         listener->notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE,
2875                 CaptureResultExtras());
2876         mSessionStatsBuilder.onDeviceError();
2877     }
2878 
2879     // Save stack trace. View by dumping it later.
2880     CameraTraces::saveTrace();
2881     // TODO: consider adding errorCause and client pid/procname
2882 }
2883 
2884 /**
2885  * In-flight request management
2886  */
2887 
registerInFlight(uint32_t frameNumber,int32_t numBuffers,CaptureResultExtras resultExtras,bool hasInput,bool hasAppCallback,nsecs_t minExpectedDuration,nsecs_t maxExpectedDuration,bool isFixedFps,const std::set<std::set<std::string>> & physicalCameraIds,bool isStillCapture,bool isZslCapture,bool rotateAndCropAuto,bool autoframingAuto,const std::set<std::string> & cameraIdsWithZoom,bool useZoomRatio,const SurfaceMap & outputSurfaces,nsecs_t requestTimeNs)2888 status_t Camera3Device::registerInFlight(uint32_t frameNumber,
2889         int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput,
2890         bool hasAppCallback, nsecs_t minExpectedDuration, nsecs_t maxExpectedDuration,
2891         bool isFixedFps, const std::set<std::set<std::string>>& physicalCameraIds,
2892         bool isStillCapture, bool isZslCapture, bool rotateAndCropAuto, bool autoframingAuto,
2893         const std::set<std::string>& cameraIdsWithZoom, bool useZoomRatio,
2894         const SurfaceMap& outputSurfaces, nsecs_t requestTimeNs) {
2895     ATRACE_CALL();
2896     std::lock_guard<std::mutex> l(mInFlightLock);
2897 
2898     ssize_t res;
2899     res = mInFlightMap.add(frameNumber, InFlightRequest(numBuffers, resultExtras, hasInput,
2900             hasAppCallback, minExpectedDuration, maxExpectedDuration, isFixedFps, physicalCameraIds,
2901             isStillCapture, isZslCapture, rotateAndCropAuto, autoframingAuto, cameraIdsWithZoom,
2902             requestTimeNs, useZoomRatio, outputSurfaces));
2903     if (res < 0) return res;
2904 
2905     if (mInFlightMap.size() == 1) {
2906         // Hold a separate dedicated tracker lock to prevent race with disconnect and also
2907         // avoid a deadlock during reprocess requests.
2908         Mutex::Autolock l(mTrackerLock);
2909         if (mStatusTracker != nullptr) {
2910             mStatusTracker->markComponentActive(mInFlightStatusId);
2911         }
2912     }
2913 
2914     mExpectedInflightDuration += maxExpectedDuration;
2915     return OK;
2916 }
2917 
onInflightEntryRemovedLocked(nsecs_t duration)2918 void Camera3Device::onInflightEntryRemovedLocked(nsecs_t duration) {
2919     // Indicate idle inFlightMap to the status tracker
2920     if (mInFlightMap.size() == 0) {
2921         mRequestBufferSM.onInflightMapEmpty();
2922         // Hold a separate dedicated tracker lock to prevent race with disconnect and also
2923         // avoid a deadlock during reprocess requests.
2924         Mutex::Autolock l(mTrackerLock);
2925         if (mStatusTracker != nullptr) {
2926             mStatusTracker->markComponentIdle(mInFlightStatusId, Fence::NO_FENCE);
2927         }
2928     }
2929     mExpectedInflightDuration -= duration;
2930 }
2931 
checkInflightMapLengthLocked()2932 void Camera3Device::checkInflightMapLengthLocked() {
2933     // Validation check - if we have too many in-flight frames with long total inflight duration,
2934     // something has likely gone wrong. This might still be legit only if application send in
2935     // a long burst of long exposure requests.
2936     if (mExpectedInflightDuration > kMinWarnInflightDuration) {
2937         if (!mIsConstrainedHighSpeedConfiguration && mInFlightMap.size() > kInFlightWarnLimit) {
2938             CLOGW("In-flight list too large: %zu, total inflight duration %" PRIu64,
2939                     mInFlightMap.size(), mExpectedInflightDuration);
2940         } else if (mIsConstrainedHighSpeedConfiguration && mInFlightMap.size() >
2941                 kInFlightWarnLimitHighSpeed) {
2942             CLOGW("In-flight list too large for high speed configuration: %zu,"
2943                     "total inflight duration %" PRIu64,
2944                     mInFlightMap.size(), mExpectedInflightDuration);
2945         }
2946     }
2947 }
2948 
onInflightMapFlushedLocked()2949 void Camera3Device::onInflightMapFlushedLocked() {
2950     mExpectedInflightDuration = 0;
2951 }
2952 
removeInFlightMapEntryLocked(int idx)2953 void Camera3Device::removeInFlightMapEntryLocked(int idx) {
2954     ATRACE_HFR_CALL();
2955     nsecs_t duration = mInFlightMap.valueAt(idx).maxExpectedDuration;
2956     mInFlightMap.removeItemsAt(idx, 1);
2957 
2958     onInflightEntryRemovedLocked(duration);
2959 }
2960 
2961 
flushInflightRequests()2962 void Camera3Device::flushInflightRequests() {
2963     ATRACE_CALL();
2964     sp<NotificationListener> listener;
2965     {
2966         std::lock_guard<std::mutex> l(mOutputLock);
2967         listener = mListener.promote();
2968     }
2969 
2970     FlushInflightReqStates states {
2971         mId, mInFlightLock, mInFlightMap, mUseHalBufManager,
2972         mHalBufManagedStreamIds, listener, *this, *mInterface, *this,
2973         mSessionStatsBuilder};
2974 
2975     camera3::flushInflightRequests(states);
2976 }
2977 
getLatestRequestInfoLocked()2978 Camera3Device::LatestRequestInfo Camera3Device::getLatestRequestInfoLocked() {
2979     ALOGV("%s", __FUNCTION__);
2980 
2981     LatestRequestInfo retVal;
2982 
2983     if (mRequestThread != NULL) {
2984         retVal = mRequestThread->getLatestRequestInfo();
2985     }
2986 
2987     return retVal;
2988 }
2989 
monitorMetadata(TagMonitor::eventSource source,int64_t frameNumber,nsecs_t timestamp,const CameraMetadata & metadata,const std::unordered_map<std::string,CameraMetadata> & physicalMetadata,const camera_stream_buffer_t * outputBuffers,uint32_t numOutputBuffers,int32_t inputStreamId)2990 void Camera3Device::monitorMetadata(TagMonitor::eventSource source,
2991         int64_t frameNumber, nsecs_t timestamp, const CameraMetadata& metadata,
2992         const std::unordered_map<std::string, CameraMetadata>& physicalMetadata,
2993         const camera_stream_buffer_t *outputBuffers, uint32_t numOutputBuffers,
2994         int32_t inputStreamId) {
2995 
2996     mTagMonitor.monitorMetadata(source, frameNumber, timestamp, metadata,
2997             physicalMetadata, outputBuffers, numOutputBuffers, inputStreamId);
2998 }
2999 
collectRequestStats(int64_t frameNumber,const CameraMetadata & request)3000 void Camera3Device::collectRequestStats(int64_t frameNumber, const CameraMetadata &request) {
3001     if (flags::analytics_24q3()) {
3002         auto entry = request.find(ANDROID_CONTROL_AE_TARGET_FPS_RANGE);
3003         if (entry.count >= 2) {
3004             mSessionStatsBuilder.incFpsRequestedCount(
3005                 entry.data.i32[0], entry.data.i32[1], frameNumber);
3006         }
3007     }
3008 }
3009 
cleanupNativeHandles(std::vector<native_handle_t * > * handles,bool closeFd)3010 void Camera3Device::cleanupNativeHandles(
3011         std::vector<native_handle_t*> *handles, bool closeFd) {
3012     if (handles == nullptr) {
3013         return;
3014     }
3015     if (closeFd) {
3016         for (auto& handle : *handles) {
3017             native_handle_close(handle);
3018         }
3019     }
3020     for (auto& handle : *handles) {
3021         native_handle_delete(handle);
3022     }
3023     handles->clear();
3024     return;
3025 }
3026 
3027 /**
3028  * HalInterface inner class methods
3029  */
3030 
getInflightBufferKeys(std::vector<std::pair<int32_t,int32_t>> * out)3031 void Camera3Device::HalInterface::getInflightBufferKeys(
3032         std::vector<std::pair<int32_t, int32_t>>* out) {
3033     mBufferRecords.getInflightBufferKeys(out);
3034     return;
3035 }
3036 
getInflightRequestBufferKeys(std::vector<uint64_t> * out)3037 void Camera3Device::HalInterface::getInflightRequestBufferKeys(
3038         std::vector<uint64_t>* out) {
3039     mBufferRecords.getInflightRequestBufferKeys(out);
3040     return;
3041 }
3042 
verifyBufferIds(int32_t streamId,std::vector<uint64_t> & bufIds)3043 bool Camera3Device::HalInterface::verifyBufferIds(
3044         int32_t streamId, std::vector<uint64_t>& bufIds) {
3045     return mBufferRecords.verifyBufferIds(streamId, bufIds);
3046 }
3047 
isHalBufferManagedStream(int32_t streamId) const3048 bool Camera3Device::HalInterface::isHalBufferManagedStream(int32_t streamId) const {
3049     return (mUseHalBufManager || contains(mHalBufManagedStreamIds, streamId));
3050 }
3051 
popInflightBuffer(int32_t frameNumber,int32_t streamId,buffer_handle_t ** buffer)3052 status_t Camera3Device::HalInterface::popInflightBuffer(
3053         int32_t frameNumber, int32_t streamId,
3054         /*out*/ buffer_handle_t **buffer) {
3055     return mBufferRecords.popInflightBuffer(frameNumber, streamId, buffer);
3056 }
3057 
pushInflightRequestBuffer(uint64_t bufferId,buffer_handle_t * buf,int32_t streamId)3058 status_t Camera3Device::HalInterface::pushInflightRequestBuffer(
3059         uint64_t bufferId, buffer_handle_t* buf, int32_t streamId) {
3060     return mBufferRecords.pushInflightRequestBuffer(bufferId, buf, streamId);
3061 }
3062 
3063 // Find and pop a buffer_handle_t based on bufferId
popInflightRequestBuffer(uint64_t bufferId,buffer_handle_t ** buffer,int32_t * streamId)3064 status_t Camera3Device::HalInterface::popInflightRequestBuffer(
3065         uint64_t bufferId,
3066         /*out*/ buffer_handle_t** buffer,
3067         /*optional out*/ int32_t* streamId) {
3068     return mBufferRecords.popInflightRequestBuffer(bufferId, buffer, streamId);
3069 }
3070 
getBufferId(const buffer_handle_t & buf,int streamId)3071 std::pair<bool, uint64_t> Camera3Device::HalInterface::getBufferId(
3072         const buffer_handle_t& buf, int streamId) {
3073     return mBufferRecords.getBufferId(buf, streamId);
3074 }
3075 
removeOneBufferCache(int streamId,const native_handle_t * handle)3076 uint64_t Camera3Device::HalInterface::removeOneBufferCache(int streamId,
3077         const native_handle_t* handle) {
3078     return mBufferRecords.removeOneBufferCache(streamId, handle);
3079 }
3080 
onBufferFreed(int streamId,const native_handle_t * handle)3081 void Camera3Device::HalInterface::onBufferFreed(
3082         int streamId, const native_handle_t* handle) {
3083     uint32_t bufferId = mBufferRecords.removeOneBufferCache(streamId, handle);
3084     std::lock_guard<std::mutex> lock(mFreedBuffersLock);
3085     if (bufferId != BUFFER_ID_NO_BUFFER) {
3086         mFreedBuffers.push_back(std::make_pair(streamId, bufferId));
3087     }
3088 }
3089 
onStreamReConfigured(int streamId)3090 void Camera3Device::HalInterface::onStreamReConfigured(int streamId) {
3091     std::vector<uint64_t> bufIds = mBufferRecords.clearBufferCaches(streamId);
3092     std::lock_guard<std::mutex> lock(mFreedBuffersLock);
3093     for (auto bufferId : bufIds) {
3094         mFreedBuffers.push_back(std::make_pair(streamId, bufferId));
3095     }
3096 }
3097 
3098 /**
3099  * RequestThread inner class methods
3100  */
3101 
RequestThread(wp<Camera3Device> parent,sp<StatusTracker> statusTracker,sp<HalInterface> interface,const Vector<int32_t> & sessionParamKeys,bool useHalBufManager,bool supportCameraMute,int rotationOverride,bool supportSettingsOverride)3102 Camera3Device::RequestThread::RequestThread(wp<Camera3Device> parent,
3103         sp<StatusTracker> statusTracker,
3104         sp<HalInterface> interface, const Vector<int32_t>& sessionParamKeys,
3105         bool useHalBufManager,
3106         bool supportCameraMute,
3107         int rotationOverride,
3108         bool supportSettingsOverride) :
3109         Thread(/*canCallJava*/false),
3110         mParent(parent),
3111         mStatusTracker(statusTracker),
3112         mInterface(interface),
3113         mListener(nullptr),
3114         mId(getId(parent)),
3115         mRequestClearing(false),
3116         mFirstRepeating(false),
3117         mReconfigured(false),
3118         mDoPause(false),
3119         mPaused(true),
3120         mNotifyPipelineDrain(false),
3121         mPrevTriggers(0),
3122         mFrameNumber(0),
3123         mLatestRequestId(NAME_NOT_FOUND),
3124         mLatestFailedRequestId(NAME_NOT_FOUND),
3125         mCurrentAfTriggerId(0),
3126         mCurrentPreCaptureTriggerId(0),
3127         mRotateAndCropOverride(ANDROID_SCALER_ROTATE_AND_CROP_NONE),
3128         mAutoframingOverride(ANDROID_CONTROL_AUTOFRAMING_OFF),
3129         mComposerOutput(false),
3130         mCameraMute(ANDROID_SENSOR_TEST_PATTERN_MODE_OFF),
3131         mSettingsOverride(ANDROID_CONTROL_SETTINGS_OVERRIDE_OFF),
3132         mRepeatingLastFrameNumber(
3133             hardware::camera2::ICameraDeviceUser::NO_IN_FLIGHT_REPEATING_FRAMES),
3134         mPrepareVideoStream(false),
3135         mConstrainedMode(false),
3136         mRequestLatency(kRequestLatencyBinSize),
3137         mSessionParamKeys(sessionParamKeys),
3138         mLatestSessionParams(sessionParamKeys.size()),
3139         mUseHalBufManager(useHalBufManager),
3140         mSupportCameraMute(supportCameraMute),
3141         mRotationOverride(rotationOverride),
3142         mSupportSettingsOverride(supportSettingsOverride) {
3143     mStatusId = statusTracker->addComponent("RequestThread");
3144     mVndkVersion = getVNDKVersionFromProp(__ANDROID_API_FUTURE__);
3145 }
3146 
~RequestThread()3147 Camera3Device::RequestThread::~RequestThread() {}
3148 
setNotificationListener(wp<NotificationListener> listener)3149 void Camera3Device::RequestThread::setNotificationListener(
3150         wp<NotificationListener> listener) {
3151     ATRACE_CALL();
3152     Mutex::Autolock l(mRequestLock);
3153     mListener = listener;
3154 }
3155 
configurationComplete(bool isConstrainedHighSpeed,const CameraMetadata & sessionParams,const std::map<int32_t,std::set<std::string>> & groupIdPhysicalCameraMap)3156 void Camera3Device::RequestThread::configurationComplete(bool isConstrainedHighSpeed,
3157         const CameraMetadata& sessionParams,
3158         const std::map<int32_t, std::set<std::string>>& groupIdPhysicalCameraMap) {
3159     ATRACE_CALL();
3160     Mutex::Autolock l(mRequestLock);
3161     mReconfigured = true;
3162     mLatestSessionParams = sessionParams;
3163     mGroupIdPhysicalCameraMap = groupIdPhysicalCameraMap;
3164     // Prepare video stream for high speed recording.
3165     mPrepareVideoStream = isConstrainedHighSpeed;
3166     mConstrainedMode = isConstrainedHighSpeed;
3167 }
3168 
queueRequestList(List<sp<CaptureRequest>> & requests,int64_t * lastFrameNumber)3169 status_t Camera3Device::RequestThread::queueRequestList(
3170         List<sp<CaptureRequest> > &requests,
3171         /*out*/
3172         int64_t *lastFrameNumber) {
3173     ATRACE_CALL();
3174     Mutex::Autolock l(mRequestLock);
3175     for (List<sp<CaptureRequest> >::iterator it = requests.begin(); it != requests.end();
3176             ++it) {
3177         mRequestQueue.push_back(*it);
3178     }
3179 
3180     if (lastFrameNumber != NULL) {
3181         *lastFrameNumber = mFrameNumber + mRequestQueue.size() - 1;
3182         ALOGV("%s: requestId %d, mFrameNumber %" PRId32 ", lastFrameNumber %" PRId64 ".",
3183               __FUNCTION__, (*(requests.begin()))->mResultExtras.requestId, mFrameNumber,
3184               *lastFrameNumber);
3185     }
3186 
3187     unpauseForNewRequests();
3188 
3189     return OK;
3190 }
3191 
3192 
queueTrigger(RequestTrigger trigger[],size_t count)3193 status_t Camera3Device::RequestThread::queueTrigger(
3194         RequestTrigger trigger[],
3195         size_t count) {
3196     ATRACE_CALL();
3197     Mutex::Autolock l(mTriggerMutex);
3198     status_t ret;
3199 
3200     for (size_t i = 0; i < count; ++i) {
3201         ret = queueTriggerLocked(trigger[i]);
3202 
3203         if (ret != OK) {
3204             return ret;
3205         }
3206     }
3207 
3208     return OK;
3209 }
3210 
getId(const wp<Camera3Device> & device)3211 const std::string& Camera3Device::RequestThread::getId(const wp<Camera3Device> &device) {
3212     static std::string deadId("<DeadDevice>");
3213     sp<Camera3Device> d = device.promote();
3214     if (d != nullptr) return d->mId;
3215     return deadId;
3216 }
3217 
queueTriggerLocked(RequestTrigger trigger)3218 status_t Camera3Device::RequestThread::queueTriggerLocked(
3219         RequestTrigger trigger) {
3220 
3221     uint32_t tag = trigger.metadataTag;
3222     ssize_t index = mTriggerMap.indexOfKey(tag);
3223 
3224     switch (trigger.getTagType()) {
3225         case TYPE_BYTE:
3226         // fall-through
3227         case TYPE_INT32:
3228             break;
3229         default:
3230             ALOGE("%s: Type not supported: 0x%x", __FUNCTION__,
3231                     trigger.getTagType());
3232             return INVALID_OPERATION;
3233     }
3234 
3235     /**
3236      * Collect only the latest trigger, since we only have 1 field
3237      * in the request settings per trigger tag, and can't send more than 1
3238      * trigger per request.
3239      */
3240     if (index != NAME_NOT_FOUND) {
3241         mTriggerMap.editValueAt(index) = trigger;
3242     } else {
3243         mTriggerMap.add(tag, trigger);
3244     }
3245 
3246     return OK;
3247 }
3248 
setRepeatingRequests(const RequestList & requests,int64_t * lastFrameNumber)3249 status_t Camera3Device::RequestThread::setRepeatingRequests(
3250         const RequestList &requests,
3251         /*out*/
3252         int64_t *lastFrameNumber) {
3253     ATRACE_CALL();
3254     Mutex::Autolock l(mRequestLock);
3255     if (lastFrameNumber != NULL) {
3256         *lastFrameNumber = mRepeatingLastFrameNumber;
3257     }
3258     mRepeatingRequests.clear();
3259     mFirstRepeating = true;
3260     mRepeatingRequests.insert(mRepeatingRequests.begin(),
3261             requests.begin(), requests.end());
3262 
3263     unpauseForNewRequests();
3264 
3265     mRepeatingLastFrameNumber = hardware::camera2::ICameraDeviceUser::NO_IN_FLIGHT_REPEATING_FRAMES;
3266     return OK;
3267 }
3268 
isRepeatingRequestLocked(const sp<CaptureRequest> & requestIn)3269 bool Camera3Device::RequestThread::isRepeatingRequestLocked(const sp<CaptureRequest>& requestIn) {
3270     if (mRepeatingRequests.empty()) {
3271         return false;
3272     }
3273     int32_t requestId = requestIn->mResultExtras.requestId;
3274     const RequestList &repeatRequests = mRepeatingRequests;
3275     // All repeating requests are guaranteed to have same id so only check first quest
3276     const sp<CaptureRequest> firstRequest = *repeatRequests.begin();
3277     return (firstRequest->mResultExtras.requestId == requestId);
3278 }
3279 
clearRepeatingRequests(int64_t * lastFrameNumber)3280 status_t Camera3Device::RequestThread::clearRepeatingRequests(/*out*/int64_t *lastFrameNumber) {
3281     ATRACE_CALL();
3282     Mutex::Autolock l(mRequestLock);
3283     return clearRepeatingRequestsLocked(lastFrameNumber);
3284 
3285 }
3286 
clearRepeatingRequestsLocked(int64_t * lastFrameNumber)3287 status_t Camera3Device::RequestThread::clearRepeatingRequestsLocked(
3288         /*out*/int64_t *lastFrameNumber) {
3289     std::vector<int32_t> streamIds;
3290     for (const auto& request : mRepeatingRequests) {
3291         for (const auto& stream : request->mOutputStreams) {
3292             streamIds.push_back(stream->getId());
3293         }
3294     }
3295 
3296     mRepeatingRequests.clear();
3297     if (lastFrameNumber != NULL) {
3298         *lastFrameNumber = mRepeatingLastFrameNumber;
3299     }
3300 
3301     mInterface->repeatingRequestEnd(mRepeatingLastFrameNumber, streamIds);
3302 
3303     mRepeatingLastFrameNumber = hardware::camera2::ICameraDeviceUser::NO_IN_FLIGHT_REPEATING_FRAMES;
3304     return OK;
3305 }
3306 
clear(int64_t * lastFrameNumber)3307 status_t Camera3Device::RequestThread::clear(
3308         /*out*/int64_t *lastFrameNumber) {
3309     ATRACE_CALL();
3310     Mutex::Autolock l(mRequestLock);
3311     ALOGV("RequestThread::%s:", __FUNCTION__);
3312 
3313     // Send errors for all requests pending in the request queue, including
3314     // pending repeating requests
3315     sp<NotificationListener> listener = mListener.promote();
3316     if (listener != NULL) {
3317         for (RequestList::iterator it = mRequestQueue.begin();
3318                  it != mRequestQueue.end(); ++it) {
3319             // Abort the input buffers for reprocess requests.
3320             if ((*it)->mInputStream != NULL) {
3321                 camera_stream_buffer_t inputBuffer;
3322                 camera3::Size inputBufferSize;
3323                 status_t res = (*it)->mInputStream->getInputBuffer(&inputBuffer,
3324                         &inputBufferSize, /*respectHalLimit*/ false);
3325                 if (res != OK) {
3326                     ALOGW("%s: %d: couldn't get input buffer while clearing the request "
3327                             "list: %s (%d)", __FUNCTION__, __LINE__, strerror(-res), res);
3328                 } else {
3329                     inputBuffer.status = CAMERA_BUFFER_STATUS_ERROR;
3330                     res = (*it)->mInputStream->returnInputBuffer(inputBuffer);
3331                     if (res != OK) {
3332                         ALOGE("%s: %d: couldn't return input buffer while clearing the request "
3333                                 "list: %s (%d)", __FUNCTION__, __LINE__, strerror(-res), res);
3334                     }
3335                 }
3336             }
3337             // Set the frame number this request would have had, if it
3338             // had been submitted; this frame number will not be reused.
3339             // The requestId and burstId fields were set when the request was
3340             // submitted originally (in convertMetadataListToRequestListLocked)
3341             (*it)->mResultExtras.frameNumber = mFrameNumber++;
3342             listener->notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST,
3343                     (*it)->mResultExtras);
3344         }
3345     }
3346     mRequestQueue.clear();
3347 
3348     Mutex::Autolock al(mTriggerMutex);
3349     mTriggerMap.clear();
3350     clearRepeatingRequestsLocked(lastFrameNumber);
3351     mRequestClearing = true;
3352     mRequestSignal.signal();
3353     return OK;
3354 }
3355 
flush()3356 status_t Camera3Device::RequestThread::flush() {
3357     ATRACE_CALL();
3358     Mutex::Autolock l(mFlushLock);
3359 
3360     return mInterface->flush();
3361 }
3362 
setPaused(bool paused)3363 void Camera3Device::RequestThread::setPaused(bool paused) {
3364     ATRACE_CALL();
3365     Mutex::Autolock l(mPauseLock);
3366     mDoPause = paused;
3367     mDoPauseSignal.signal();
3368 }
3369 
setHalBufferManagedStreams(const std::set<int32_t> & halBufferManagedStreams)3370 void Camera3Device::RequestThread::setHalBufferManagedStreams(
3371             const std::set<int32_t> &halBufferManagedStreams) {
3372     mHalBufManagedStreamIds = halBufferManagedStreams;
3373 }
3374 
waitUntilRequestProcessed(int32_t requestId,nsecs_t timeout)3375 status_t Camera3Device::RequestThread::waitUntilRequestProcessed(
3376         int32_t requestId, nsecs_t timeout) {
3377     ATRACE_CALL();
3378     Mutex::Autolock l(mLatestRequestMutex);
3379     status_t res;
3380     while (mLatestRequestId != requestId && mLatestFailedRequestId != requestId) {
3381         nsecs_t startTime = systemTime();
3382 
3383         res = mLatestRequestSignal.waitRelative(mLatestRequestMutex, timeout);
3384         if (res != OK) return res;
3385 
3386         timeout -= (systemTime() - startTime);
3387     }
3388 
3389     return OK;
3390 }
3391 
requestExit()3392 void Camera3Device::RequestThread::requestExit() {
3393     {
3394         Mutex::Autolock l(mRequestLock);
3395         mRequestClearing = true;
3396         // Call parent to set up shutdown
3397         Thread::requestExit();
3398     }
3399     // The exit from any possible waits
3400     mDoPauseSignal.signal();
3401     mRequestSignal.signal();
3402 
3403     mRequestLatency.log("ProcessCaptureRequest latency histogram");
3404     mRequestLatency.reset();
3405 }
3406 
checkAndStopRepeatingRequest()3407 void Camera3Device::RequestThread::checkAndStopRepeatingRequest() {
3408     ATRACE_CALL();
3409     bool surfaceAbandoned = false;
3410     int64_t lastFrameNumber = 0;
3411     sp<NotificationListener> listener;
3412     {
3413         Mutex::Autolock l(mRequestLock);
3414         // Check all streams needed by repeating requests are still valid. Otherwise, stop
3415         // repeating requests.
3416         for (const auto& request : mRepeatingRequests) {
3417             for (const auto& s : request->mOutputStreams) {
3418                 if (s->isAbandoned()) {
3419                     surfaceAbandoned = true;
3420                     clearRepeatingRequestsLocked(&lastFrameNumber);
3421                     break;
3422                 }
3423             }
3424             if (surfaceAbandoned) {
3425                 break;
3426             }
3427         }
3428         listener = mListener.promote();
3429     }
3430 
3431     if (listener != NULL && surfaceAbandoned) {
3432         listener->notifyRepeatingRequestError(lastFrameNumber);
3433     }
3434 }
3435 
sendRequestsBatch()3436 bool Camera3Device::RequestThread::sendRequestsBatch() {
3437     ATRACE_CALL();
3438     status_t res;
3439     size_t batchSize = mNextRequests.size();
3440     std::vector<camera_capture_request_t*> requests(batchSize);
3441     uint32_t numRequestProcessed = 0;
3442     for (size_t i = 0; i < batchSize; i++) {
3443         requests[i] = &mNextRequests.editItemAt(i).halRequest;
3444         ATRACE_ASYNC_BEGIN("frame capture", mNextRequests[i].halRequest.frame_number);
3445     }
3446 
3447     res = mInterface->processBatchCaptureRequests(requests, &numRequestProcessed);
3448 
3449     bool triggerRemoveFailed = false;
3450     NextRequest& triggerFailedRequest = mNextRequests.editItemAt(0);
3451     for (size_t i = 0; i < numRequestProcessed; i++) {
3452         NextRequest& nextRequest = mNextRequests.editItemAt(i);
3453         nextRequest.submitted = true;
3454 
3455         updateNextRequest(nextRequest);
3456 
3457         if (!triggerRemoveFailed) {
3458             // Remove any previously queued triggers (after unlock)
3459             status_t removeTriggerRes = removeTriggers(mPrevRequest);
3460             if (removeTriggerRes != OK) {
3461                 triggerRemoveFailed = true;
3462                 triggerFailedRequest = nextRequest;
3463             }
3464         }
3465     }
3466 
3467     if (triggerRemoveFailed) {
3468         SET_ERR("RequestThread: Unable to remove triggers "
3469               "(capture request %d, HAL device: %s (%d)",
3470               triggerFailedRequest.halRequest.frame_number, strerror(-res), res);
3471         cleanUpFailedRequests(/*sendRequestError*/ false);
3472         return false;
3473     }
3474 
3475     if (res != OK) {
3476         // Should only get a failure here for malformed requests or device-level
3477         // errors, so consider all errors fatal.  Bad metadata failures should
3478         // come through notify.
3479         SET_ERR("RequestThread: Unable to submit capture request %d to HAL device: %s (%d)",
3480                 mNextRequests[numRequestProcessed].halRequest.frame_number,
3481                 strerror(-res), res);
3482         cleanUpFailedRequests(/*sendRequestError*/ false);
3483         return false;
3484     }
3485     return true;
3486 }
3487 
3488 Camera3Device::RequestThread::ExpectedDurationInfo
calculateExpectedDurationRange(const camera_metadata_t * request)3489         Camera3Device::RequestThread::calculateExpectedDurationRange(
3490                 const camera_metadata_t *request) {
3491     ExpectedDurationInfo expectedDurationInfo = {
3492             InFlightRequest::kDefaultMinExpectedDuration,
3493             InFlightRequest::kDefaultMaxExpectedDuration,
3494             /*isFixedFps*/false};
3495     camera_metadata_ro_entry_t e = camera_metadata_ro_entry_t();
3496     find_camera_metadata_ro_entry(request,
3497             ANDROID_CONTROL_AE_MODE,
3498             &e);
3499     if (e.count == 0) return expectedDurationInfo;
3500 
3501     switch (e.data.u8[0]) {
3502         case ANDROID_CONTROL_AE_MODE_OFF:
3503             find_camera_metadata_ro_entry(request,
3504                     ANDROID_SENSOR_EXPOSURE_TIME,
3505                     &e);
3506             if (e.count > 0) {
3507                 expectedDurationInfo.minDuration = e.data.i64[0];
3508                 expectedDurationInfo.maxDuration = expectedDurationInfo.minDuration;
3509             }
3510             find_camera_metadata_ro_entry(request,
3511                     ANDROID_SENSOR_FRAME_DURATION,
3512                     &e);
3513             if (e.count > 0) {
3514                 expectedDurationInfo.minDuration =
3515                         std::max(e.data.i64[0], expectedDurationInfo.minDuration);
3516                 expectedDurationInfo.maxDuration = expectedDurationInfo.minDuration;
3517             }
3518             expectedDurationInfo.isFixedFps = false;
3519             break;
3520         default:
3521             find_camera_metadata_ro_entry(request,
3522                     ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
3523                     &e);
3524             if (e.count > 1) {
3525                 expectedDurationInfo.minDuration = 1e9 / e.data.i32[1];
3526                 expectedDurationInfo.maxDuration = 1e9 / e.data.i32[0];
3527             }
3528             expectedDurationInfo.isFixedFps = (e.data.i32[1] == e.data.i32[0]);
3529             break;
3530     }
3531 
3532     return expectedDurationInfo;
3533 }
3534 
skipHFRTargetFPSUpdate(int32_t tag,const camera_metadata_ro_entry_t & newEntry,const camera_metadata_entry_t & currentEntry)3535 bool Camera3Device::RequestThread::skipHFRTargetFPSUpdate(int32_t tag,
3536         const camera_metadata_ro_entry_t& newEntry, const camera_metadata_entry_t& currentEntry) {
3537     if (mConstrainedMode && (ANDROID_CONTROL_AE_TARGET_FPS_RANGE == tag) &&
3538             (newEntry.count == currentEntry.count) && (currentEntry.count == 2) &&
3539             (currentEntry.data.i32[1] == newEntry.data.i32[1])) {
3540         return true;
3541     }
3542 
3543     return false;
3544 }
3545 
updateNextRequest(NextRequest & nextRequest)3546 void Camera3Device::RequestThread::updateNextRequest(NextRequest& nextRequest) {
3547     // Update the latest request sent to HAL
3548     camera_capture_request_t& halRequest = nextRequest.halRequest;
3549     sp<Camera3Device> parent = mParent.promote();
3550     if (halRequest.settings != nullptr) { // Don't update if they were unchanged
3551         Mutex::Autolock al(mLatestRequestMutex);
3552 
3553         // Fill in latest request and physical request
3554         camera_metadata_t *cloned = clone_camera_metadata(halRequest.settings);
3555         mLatestRequestInfo.requestSettings.acquire(cloned);
3556 
3557         mLatestRequestInfo.physicalRequestSettings.clear();
3558         mLatestRequestInfo.outputStreamIds.clear();
3559         for (uint32_t i = 0; i < halRequest.num_physcam_settings; i++) {
3560             cloned = clone_camera_metadata(halRequest.physcam_settings[i]);
3561             mLatestRequestInfo.physicalRequestSettings.emplace(halRequest.physcam_id[i],
3562                                            CameraMetadata(cloned));
3563         }
3564 
3565         if (parent != nullptr) {
3566             int32_t inputStreamId = -1;
3567             if (halRequest.input_buffer != nullptr) {
3568               inputStreamId = Camera3Stream::cast(halRequest.input_buffer->stream)->getId();
3569               mLatestRequestInfo.inputStreamId = inputStreamId;
3570             }
3571 
3572            for (size_t i = 0; i < halRequest.num_output_buffers; i++) {
3573                int32_t outputStreamId =
3574                        Camera3Stream::cast(halRequest.output_buffers[i].stream)->getId();
3575                mLatestRequestInfo.outputStreamIds.emplace(outputStreamId);
3576            }
3577 
3578             parent->monitorMetadata(TagMonitor::REQUEST,
3579                     halRequest.frame_number,
3580                     0, mLatestRequestInfo.requestSettings,
3581                     mLatestRequestInfo.physicalRequestSettings, halRequest.output_buffers,
3582                     halRequest.num_output_buffers, inputStreamId);
3583         }
3584     }
3585     if (parent != nullptr) {
3586         parent->collectRequestStats(halRequest.frame_number, mLatestRequestInfo.requestSettings);
3587     }
3588 
3589     if (halRequest.settings != nullptr) {
3590         nextRequest.captureRequest->mSettingsList.begin()->metadata.unlock(
3591                 halRequest.settings);
3592     }
3593 
3594     cleanupPhysicalSettings(nextRequest.captureRequest, &halRequest);
3595 }
3596 
updateSessionParameters(const CameraMetadata & settings)3597 bool Camera3Device::RequestThread::updateSessionParameters(const CameraMetadata& settings) {
3598     ATRACE_CALL();
3599     bool updatesDetected = false;
3600 
3601     CameraMetadata updatedParams(mLatestSessionParams);
3602     for (auto tag : mSessionParamKeys) {
3603         camera_metadata_ro_entry entry = settings.find(tag);
3604         camera_metadata_entry lastEntry = updatedParams.find(tag);
3605 
3606         if (entry.count > 0) {
3607             bool isDifferent = false;
3608             if (lastEntry.count > 0) {
3609                 // Have a last value, compare to see if changed
3610                 if (lastEntry.type == entry.type &&
3611                         lastEntry.count == entry.count) {
3612                     // Same type and count, compare values
3613                     size_t bytesPerValue = camera_metadata_type_size[lastEntry.type];
3614                     size_t entryBytes = bytesPerValue * lastEntry.count;
3615                     int cmp = memcmp(entry.data.u8, lastEntry.data.u8, entryBytes);
3616                     if (cmp != 0) {
3617                         isDifferent = true;
3618                     }
3619                 } else {
3620                     // Count or type has changed
3621                     isDifferent = true;
3622                 }
3623             } else {
3624                 // No last entry, so always consider to be different
3625                 isDifferent = true;
3626             }
3627 
3628             if (isDifferent) {
3629                 ALOGV("%s: Session parameter tag id %d changed", __FUNCTION__, tag);
3630                 if (!skipHFRTargetFPSUpdate(tag, entry, lastEntry)) {
3631                     updatesDetected = true;
3632                 }
3633                 updatedParams.update(entry);
3634             }
3635         } else if (lastEntry.count > 0) {
3636             // Value has been removed
3637             ALOGV("%s: Session parameter tag id %d removed", __FUNCTION__, tag);
3638             updatedParams.erase(tag);
3639             updatesDetected = true;
3640         }
3641     }
3642 
3643     bool reconfigureRequired;
3644     if (updatesDetected) {
3645         reconfigureRequired = mInterface->isReconfigurationRequired(mLatestSessionParams,
3646                 updatedParams);
3647         mLatestSessionParams = updatedParams;
3648     } else {
3649         reconfigureRequired = false;
3650     }
3651 
3652     return reconfigureRequired;
3653 }
3654 
threadLoop()3655 bool Camera3Device::RequestThread::threadLoop() {
3656     ATRACE_CALL();
3657     status_t res;
3658     // Any function called from threadLoop() must not hold mInterfaceLock since
3659     // it could lead to deadlocks (disconnect() -> hold mInterfaceMutex -> wait for request thread
3660     // to finish -> request thread waits on mInterfaceMutex) http://b/143513518
3661 
3662     // Handle paused state.
3663     if (waitIfPaused()) {
3664         return true;
3665     }
3666 
3667     // Wait for the next batch of requests.
3668     waitForNextRequestBatch();
3669     if (mNextRequests.size() == 0) {
3670         return true;
3671     }
3672 
3673     // Get the latest request ID, if any
3674     int latestRequestId;
3675     camera_metadata_entry_t requestIdEntry = mNextRequests[mNextRequests.size() - 1].
3676             captureRequest->mSettingsList.begin()->metadata.find(ANDROID_REQUEST_ID);
3677     if (requestIdEntry.count > 0) {
3678         latestRequestId = requestIdEntry.data.i32[0];
3679     } else {
3680         ALOGW("%s: Did not have android.request.id set in the request.", __FUNCTION__);
3681         latestRequestId = NAME_NOT_FOUND;
3682     }
3683 
3684     for (size_t i = 0; i < mNextRequests.size(); i++) {
3685         auto& nextRequest = mNextRequests.editItemAt(i);
3686         sp<CaptureRequest> captureRequest = nextRequest.captureRequest;
3687         captureRequest->mTestPatternChanged = overrideTestPattern(captureRequest);
3688         // Do not override rotate&crop for stream configurations that include
3689         // SurfaceViews(HW_COMPOSER) output, unless mRotationOverride is set.
3690         // The display rotation there will be compensated by NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY
3691         using hardware::ICameraService::ROTATION_OVERRIDE_NONE;
3692         captureRequest->mRotateAndCropChanged =
3693                 (mComposerOutput && (mRotationOverride == ROTATION_OVERRIDE_NONE)) ?
3694                         false : overrideAutoRotateAndCrop(captureRequest);
3695         captureRequest->mAutoframingChanged = overrideAutoframing(captureRequest);
3696         if (flags::inject_session_params()) {
3697             injectSessionParams(captureRequest, mInjectedSessionParams);
3698         }
3699     }
3700 
3701     // 'mNextRequests' will at this point contain either a set of HFR batched requests
3702     //  or a single request from streaming or burst. In either case the first element
3703     //  should contain the latest camera settings that we need to check for any session
3704     //  parameter updates.
3705     if (updateSessionParameters(mNextRequests[0].captureRequest->mSettingsList.begin()->metadata)) {
3706         res = OK;
3707 
3708         //Input stream buffers are already acquired at this point so an input stream
3709         //will not be able to move to idle state unless we force it.
3710         if (mNextRequests[0].captureRequest->mInputStream != nullptr) {
3711             res = mNextRequests[0].captureRequest->mInputStream->forceToIdle();
3712             if (res != OK) {
3713                 ALOGE("%s: Failed to force idle input stream: %d", __FUNCTION__, res);
3714                 cleanUpFailedRequests(/*sendRequestError*/ false);
3715                 return false;
3716             }
3717         }
3718 
3719         if (res == OK) {
3720             sp<Camera3Device> parent = mParent.promote();
3721             if (parent != nullptr) {
3722                 if (parent->reconfigureCamera(mLatestSessionParams, mStatusId)) {
3723                     mForceNewRequestAfterReconfigure = true;
3724                     mReconfigured = true;
3725                 }
3726             }
3727 
3728             if (mNextRequests[0].captureRequest->mInputStream != nullptr) {
3729                 mNextRequests[0].captureRequest->mInputStream->restoreConfiguredState();
3730                 if (res != OK) {
3731                     ALOGE("%s: Failed to restore configured input stream: %d", __FUNCTION__, res);
3732                     cleanUpFailedRequests(/*sendRequestError*/ false);
3733                     return false;
3734                 }
3735             }
3736         }
3737     }
3738 
3739     // Prepare a batch of HAL requests and output buffers.
3740     res = prepareHalRequests();
3741     if (res == TIMED_OUT) {
3742         // Not a fatal error if getting output buffers time out.
3743         cleanUpFailedRequests(/*sendRequestError*/ true);
3744         // Check if any stream is abandoned.
3745         checkAndStopRepeatingRequest();
3746         // Inform waitUntilRequestProcessed thread of a failed request ID
3747         wakeupLatestRequest(/*failedRequestId*/true, latestRequestId);
3748         return true;
3749     } else if (res != OK) {
3750         cleanUpFailedRequests(/*sendRequestError*/ false);
3751         // Inform waitUntilRequestProcessed thread of a failed request ID
3752         wakeupLatestRequest(/*failedRequestId*/true, latestRequestId);
3753         return false;
3754     }
3755 
3756     // Inform waitUntilRequestProcessed thread of a new request ID
3757     wakeupLatestRequest(/*failedRequestId*/false, latestRequestId);
3758 
3759     // Submit a batch of requests to HAL.
3760     // Use flush lock only when submitting multilple requests in a batch.
3761     // TODO: The problem with flush lock is flush() will be blocked by process_capture_request()
3762     // which may take a long time to finish so synchronizing flush() and
3763     // process_capture_request() defeats the purpose of cancelling requests ASAP with flush().
3764     // For now, only synchronize for high speed recording and we should figure something out for
3765     // removing the synchronization.
3766     bool useFlushLock = mNextRequests.size() > 1;
3767 
3768     if (useFlushLock) {
3769         mFlushLock.lock();
3770     }
3771 
3772     ALOGVV("%s: %d: submitting %zu requests in a batch.", __FUNCTION__, __LINE__,
3773             mNextRequests.size());
3774 
3775     sp<Camera3Device> parent = mParent.promote();
3776     if (parent != nullptr) {
3777         parent->mRequestBufferSM.onSubmittingRequest();
3778     }
3779 
3780     bool submitRequestSuccess = false;
3781     nsecs_t tRequestStart = systemTime(SYSTEM_TIME_MONOTONIC);
3782     submitRequestSuccess = sendRequestsBatch();
3783 
3784     nsecs_t tRequestEnd = systemTime(SYSTEM_TIME_MONOTONIC);
3785     mRequestLatency.add(tRequestStart, tRequestEnd);
3786 
3787     if (useFlushLock) {
3788         mFlushLock.unlock();
3789     }
3790 
3791     // Unset as current request
3792     {
3793         Mutex::Autolock l(mRequestLock);
3794         mNextRequests.clear();
3795     }
3796     mRequestSubmittedSignal.signal();
3797 
3798     return submitRequestSuccess;
3799 }
3800 
removeFwkOnlyKeys(CameraMetadata * request)3801 status_t Camera3Device::removeFwkOnlyKeys(CameraMetadata *request) {
3802     if (request == nullptr) {
3803         ALOGE("%s request metadata nullptr", __FUNCTION__);
3804         return BAD_VALUE;
3805     }
3806     status_t res = OK;
3807     for (const auto &key : kFwkOnlyMetadataKeys) {
3808         if (request->exists(key)) {
3809             res = request->erase(key);
3810             if (res != OK) {
3811                 return res;
3812             }
3813         }
3814     }
3815     return OK;
3816 }
3817 
prepareHalRequests()3818 status_t Camera3Device::RequestThread::prepareHalRequests() {
3819     ATRACE_CALL();
3820 
3821     bool batchedRequest = mNextRequests[0].captureRequest->mBatchSize > 1;
3822     for (size_t i = 0; i < mNextRequests.size(); i++) {
3823         auto& nextRequest = mNextRequests.editItemAt(i);
3824         sp<CaptureRequest> captureRequest = nextRequest.captureRequest;
3825         camera_capture_request_t* halRequest = &nextRequest.halRequest;
3826         Vector<camera_stream_buffer_t>* outputBuffers = &nextRequest.outputBuffers;
3827 
3828         // Prepare a request to HAL
3829         halRequest->frame_number = captureRequest->mResultExtras.frameNumber;
3830 
3831         // Insert any queued triggers (before metadata is locked)
3832         status_t res = insertTriggers(captureRequest);
3833         if (res < 0) {
3834             SET_ERR("RequestThread: Unable to insert triggers "
3835                     "(capture request %d, HAL device: %s (%d)",
3836                     halRequest->frame_number, strerror(-res), res);
3837             return INVALID_OPERATION;
3838         }
3839 
3840         int triggerCount = res;
3841         bool triggersMixedIn = (triggerCount > 0 || mPrevTriggers > 0);
3842         mPrevTriggers = triggerCount;
3843 
3844         bool settingsOverrideChanged = overrideSettingsOverride(captureRequest);
3845 
3846         // If the request is the same as last, or we had triggers now or last time or
3847         // changing overrides this time
3848         bool newRequest =
3849                 (mPrevRequest != captureRequest || triggersMixedIn ||
3850                          captureRequest->mRotateAndCropChanged ||
3851                          captureRequest->mAutoframingChanged ||
3852                          captureRequest->mTestPatternChanged || settingsOverrideChanged ||
3853                          (flags::inject_session_params() && mForceNewRequestAfterReconfigure)) &&
3854                 // Request settings are all the same within one batch, so only treat the first
3855                 // request in a batch as new
3856                 !(batchedRequest && i > 0);
3857 
3858         if (newRequest) {
3859             std::set<std::string> cameraIdsWithZoom;
3860 
3861             if (flags::inject_session_params() && mForceNewRequestAfterReconfigure) {
3862                 // This only needs to happen once.
3863                 mForceNewRequestAfterReconfigure = false;
3864             }
3865 
3866             /**
3867              * HAL workaround:
3868              * Insert a fake trigger ID if a trigger is set but no trigger ID is
3869              */
3870             res = addFakeTriggerIds(captureRequest);
3871             if (res != OK) {
3872                 SET_ERR("RequestThread: Unable to insert fake trigger IDs "
3873                         "(capture request %d, HAL device: %s (%d)",
3874                         halRequest->frame_number, strerror(-res), res);
3875                 return INVALID_OPERATION;
3876             }
3877 
3878             {
3879                 sp<Camera3Device> parent = mParent.promote();
3880                 if (parent != nullptr) {
3881                     List<PhysicalCameraSettings>::iterator it;
3882                     for (it = captureRequest->mSettingsList.begin();
3883                             it != captureRequest->mSettingsList.end(); it++) {
3884                         if (parent->mUHRCropAndMeteringRegionMappers.find(it->cameraId) ==
3885                                 parent->mUHRCropAndMeteringRegionMappers.end()) {
3886                             continue;
3887                         }
3888 
3889                         if (!captureRequest->mUHRCropAndMeteringRegionsUpdated) {
3890                             res = parent->mUHRCropAndMeteringRegionMappers[it->cameraId].
3891                                     updateCaptureRequest(&(it->metadata));
3892                             if (res != OK) {
3893                                 SET_ERR("RequestThread: Unable to correct capture requests "
3894                                         "for scaler crop region and metering regions for request "
3895                                         "%d: %s (%d)", halRequest->frame_number, strerror(-res),
3896                                         res);
3897                                 return INVALID_OPERATION;
3898                             }
3899                             captureRequest->mUHRCropAndMeteringRegionsUpdated = true;
3900                         }
3901                     }
3902 
3903                     // Correct metadata regions for distortion correction if enabled
3904                     for (it = captureRequest->mSettingsList.begin();
3905                             it != captureRequest->mSettingsList.end(); it++) {
3906                         if (parent->mDistortionMappers.find(it->cameraId) ==
3907                                 parent->mDistortionMappers.end()) {
3908                             continue;
3909                         }
3910 
3911                         if (!captureRequest->mDistortionCorrectionUpdated) {
3912                             res = parent->mDistortionMappers[it->cameraId].correctCaptureRequest(
3913                                     &(it->metadata));
3914                             if (res != OK) {
3915                                 SET_ERR("RequestThread: Unable to correct capture requests "
3916                                         "for lens distortion for request %d: %s (%d)",
3917                                         halRequest->frame_number, strerror(-res), res);
3918                                 return INVALID_OPERATION;
3919                             }
3920                             captureRequest->mDistortionCorrectionUpdated = true;
3921                         }
3922                     }
3923 
3924                     for (it = captureRequest->mSettingsList.begin();
3925                             it != captureRequest->mSettingsList.end(); it++) {
3926                         if (parent->mZoomRatioMappers.find(it->cameraId) ==
3927                                 parent->mZoomRatioMappers.end()) {
3928                             continue;
3929                         }
3930 
3931                         if (!captureRequest->mZoomRatioIs1x) {
3932                             cameraIdsWithZoom.insert(it->cameraId);
3933                         }
3934 
3935                         if (!captureRequest->mZoomRatioUpdated) {
3936                             res = parent->mZoomRatioMappers[it->cameraId].updateCaptureRequest(
3937                                     &(it->metadata));
3938                             if (res != OK) {
3939                                 SET_ERR("RequestThread: Unable to correct capture requests "
3940                                         "for zoom ratio for request %d: %s (%d)",
3941                                         halRequest->frame_number, strerror(-res), res);
3942                                 return INVALID_OPERATION;
3943                             }
3944                             captureRequest->mZoomRatioUpdated = true;
3945                         }
3946                     }
3947                     if (captureRequest->mRotateAndCropAuto &&
3948                             !captureRequest->mRotationAndCropUpdated) {
3949                         for (it = captureRequest->mSettingsList.begin();
3950                                 it != captureRequest->mSettingsList.end(); it++) {
3951                             auto mapper = parent->mRotateAndCropMappers.find(it->cameraId);
3952                             if (mapper != parent->mRotateAndCropMappers.end()) {
3953                                 res = mapper->second.updateCaptureRequest(&(it->metadata));
3954                                 if (res != OK) {
3955                                     SET_ERR("RequestThread: Unable to correct capture requests "
3956                                             "for rotate-and-crop for request %d: %s (%d)",
3957                                             halRequest->frame_number, strerror(-res), res);
3958                                     return INVALID_OPERATION;
3959                                 }
3960                             }
3961                         }
3962                         captureRequest->mRotationAndCropUpdated = true;
3963                     }
3964 
3965                     for (it = captureRequest->mSettingsList.begin();
3966                             it != captureRequest->mSettingsList.end(); it++) {
3967                         res = filterVndkKeys(mVndkVersion, it->metadata, false /*isStatic*/);
3968                         if (res != OK) {
3969                             SET_ERR("RequestThread: Failed during VNDK filter of capture requests "
3970                                     "%d: %s (%d)", halRequest->frame_number, strerror(-res), res);
3971                             return INVALID_OPERATION;
3972                         }
3973                         res = removeFwkOnlyKeys(&(it->metadata));
3974                         if (res != OK) {
3975                             SET_ERR("RequestThread: Unable to remove fwk-only keys from request"
3976                                     "%d: %s (%d)", halRequest->frame_number, strerror(-res),
3977                                     res);
3978                             return INVALID_OPERATION;
3979                         }
3980                         if (!parent->mSupportsExtensionKeys) {
3981                             res = filterExtensionKeys(&it->metadata);
3982                             if (res != OK) {
3983                                 SET_ERR("RequestThread: Failed during extension filter of capture "
3984                                         "requests %d: %s (%d)", halRequest->frame_number,
3985                                         strerror(-res), res);
3986                                 return INVALID_OPERATION;
3987                             }
3988                         }
3989                     }
3990                 }
3991             }
3992 
3993             /**
3994              * The request should be presorted so accesses in HAL
3995              *   are O(logn). Sidenote, sorting a sorted metadata is nop.
3996              */
3997             captureRequest->mSettingsList.begin()->metadata.sort();
3998             halRequest->settings = captureRequest->mSettingsList.begin()->metadata.getAndLock();
3999             mPrevRequest = captureRequest;
4000             mPrevCameraIdsWithZoom = cameraIdsWithZoom;
4001             ALOGVV("%s: Request settings are NEW", __FUNCTION__);
4002 
4003             IF_ALOGV() {
4004                 camera_metadata_ro_entry_t e = camera_metadata_ro_entry_t();
4005                 find_camera_metadata_ro_entry(
4006                         halRequest->settings,
4007                         ANDROID_CONTROL_AF_TRIGGER,
4008                         &e
4009                 );
4010                 if (e.count > 0) {
4011                     ALOGV("%s: Request (frame num %d) had AF trigger 0x%x",
4012                           __FUNCTION__,
4013                           halRequest->frame_number,
4014                           e.data.u8[0]);
4015                 }
4016             }
4017         } else {
4018             // leave request.settings NULL to indicate 'reuse latest given'
4019             ALOGVV("%s: Request settings are REUSED",
4020                    __FUNCTION__);
4021         }
4022 
4023         if (captureRequest->mSettingsList.size() > 1) {
4024             halRequest->num_physcam_settings = captureRequest->mSettingsList.size() - 1;
4025             halRequest->physcam_id = new const char* [halRequest->num_physcam_settings];
4026             if (newRequest) {
4027                 halRequest->physcam_settings =
4028                     new const camera_metadata* [halRequest->num_physcam_settings];
4029             } else {
4030                 halRequest->physcam_settings = nullptr;
4031             }
4032             auto it = ++captureRequest->mSettingsList.begin();
4033             size_t i = 0;
4034             for (; it != captureRequest->mSettingsList.end(); it++, i++) {
4035                 halRequest->physcam_id[i] = it->cameraId.c_str();
4036                 if (newRequest) {
4037                     it->metadata.sort();
4038                     halRequest->physcam_settings[i] = it->metadata.getAndLock();
4039                 }
4040             }
4041         }
4042 
4043         uint32_t totalNumBuffers = 0;
4044 
4045         // Fill in buffers
4046         if (captureRequest->mInputStream != NULL) {
4047             halRequest->input_buffer = &captureRequest->mInputBuffer;
4048 
4049             halRequest->input_width = captureRequest->mInputBufferSize.width;
4050             halRequest->input_height = captureRequest->mInputBufferSize.height;
4051             totalNumBuffers += 1;
4052         } else {
4053             halRequest->input_buffer = NULL;
4054         }
4055 
4056         outputBuffers->insertAt(camera_stream_buffer_t(), 0,
4057                 captureRequest->mOutputStreams.size());
4058         halRequest->output_buffers = outputBuffers->array();
4059         std::set<std::set<std::string>> requestedPhysicalCameras;
4060 
4061         sp<Camera3Device> parent = mParent.promote();
4062         if (parent == NULL) {
4063             // Should not happen, and nowhere to send errors to, so just log it
4064             CLOGE("RequestThread: Parent is gone");
4065             return INVALID_OPERATION;
4066         }
4067         nsecs_t waitDuration = kBaseGetBufferWait + parent->getExpectedInFlightDuration();
4068 
4069         SurfaceMap uniqueSurfaceIdMap;
4070         bool containsHalBufferManagedStream = false;
4071         for (size_t j = 0; j < captureRequest->mOutputStreams.size(); j++) {
4072             sp<Camera3OutputStreamInterface> outputStream =
4073                     captureRequest->mOutputStreams.editItemAt(j);
4074             int streamId = outputStream->getId();
4075             if (!containsHalBufferManagedStream) {
4076                 containsHalBufferManagedStream =
4077                         contains(mHalBufManagedStreamIds, streamId);
4078             }
4079             // Prepare video buffers for high speed recording on the first video request.
4080             if (mPrepareVideoStream && outputStream->isVideoStream()) {
4081                 // Only try to prepare video stream on the first video request.
4082                 mPrepareVideoStream = false;
4083 
4084                 res = outputStream->startPrepare(Camera3StreamInterface::ALLOCATE_PIPELINE_MAX,
4085                         false /*blockRequest*/);
4086                 while (res == NOT_ENOUGH_DATA) {
4087                     res = outputStream->prepareNextBuffer();
4088                 }
4089                 if (res != OK) {
4090                     ALOGW("%s: Preparing video buffers for high speed failed: %s (%d)",
4091                         __FUNCTION__, strerror(-res), res);
4092                     outputStream->cancelPrepare();
4093                 }
4094             }
4095 
4096             std::vector<size_t> uniqueSurfaceIds;
4097             res = outputStream->getUniqueSurfaceIds(
4098                     captureRequest->mOutputSurfaces[streamId],
4099                     &uniqueSurfaceIds);
4100             // INVALID_OPERATION is normal output for streams not supporting surfaceIds
4101             if (res != OK && res != INVALID_OPERATION) {
4102                 ALOGE("%s: failed to query stream %d unique surface IDs",
4103                         __FUNCTION__, streamId);
4104                 return res;
4105             }
4106             if (res == OK) {
4107                 uniqueSurfaceIdMap.insert({streamId, std::move(uniqueSurfaceIds)});
4108             }
4109 
4110             if (parent->isHalBufferManagedStream(streamId)) {
4111                 if (outputStream->isAbandoned()) {
4112                     ALOGV("%s: stream %d is abandoned, skipping request", __FUNCTION__, streamId);
4113                     return TIMED_OUT;
4114                 }
4115                 // HAL will request buffer through requestStreamBuffer API
4116                 camera_stream_buffer_t& buffer = outputBuffers->editItemAt(j);
4117                 buffer.stream = outputStream->asHalStream();
4118                 buffer.buffer = nullptr;
4119                 buffer.status = CAMERA_BUFFER_STATUS_OK;
4120                 buffer.acquire_fence = -1;
4121                 buffer.release_fence = -1;
4122                 // Mark the output stream as unpreparable to block clients from calling
4123                 // 'prepare' after this request reaches CameraHal and before the respective
4124                 // buffers are requested.
4125                 outputStream->markUnpreparable();
4126             } else {
4127                 res = outputStream->getBuffer(&outputBuffers->editItemAt(j),
4128                         waitDuration,
4129                         captureRequest->mOutputSurfaces[streamId]);
4130                 if (res != OK) {
4131                     // Can't get output buffer from gralloc queue - this could be due to
4132                     // abandoned queue or other consumer misbehavior, so not a fatal
4133                     // error
4134                     ALOGV("RequestThread: Can't get output buffer, skipping request:"
4135                             " %s (%d)", strerror(-res), res);
4136 
4137                     return TIMED_OUT;
4138                 }
4139             }
4140 
4141             {
4142                 sp<Camera3Device> parent = mParent.promote();
4143                 if (parent != nullptr) {
4144                     const std::string& streamCameraId = outputStream->getPhysicalCameraId();
4145                     // Consider the case where clients are sending a single logical camera request
4146                     // to physical output/outputs
4147                     bool singleRequest = captureRequest->mSettingsList.size() == 1;
4148                     for (const auto& settings : captureRequest->mSettingsList) {
4149                         if (((streamCameraId.empty() || singleRequest) &&
4150                                 parent->getId() == settings.cameraId) ||
4151                                 streamCameraId == settings.cameraId) {
4152                             outputStream->fireBufferRequestForFrameNumber(
4153                                     captureRequest->mResultExtras.frameNumber,
4154                                     settings.metadata);
4155                         }
4156                     }
4157                 }
4158             }
4159 
4160             const std::string &physicalCameraId = outputStream->getPhysicalCameraId();
4161             int32_t streamGroupId = outputStream->getHalStreamGroupId();
4162             if (streamGroupId != -1 && mGroupIdPhysicalCameraMap.count(streamGroupId) == 1) {
4163                 requestedPhysicalCameras.insert(mGroupIdPhysicalCameraMap[streamGroupId]);
4164             } else if (!physicalCameraId.empty()) {
4165                 requestedPhysicalCameras.insert(std::set<std::string>({physicalCameraId}));
4166             }
4167             halRequest->num_output_buffers++;
4168         }
4169         totalNumBuffers += halRequest->num_output_buffers;
4170 
4171         // Log request in the in-flight queue
4172         // If this request list is for constrained high speed recording (not
4173         // preview), and the current request is not the last one in the batch,
4174         // do not send callback to the app.
4175         bool hasCallback = true;
4176         if (batchedRequest && i != mNextRequests.size()-1) {
4177             hasCallback = false;
4178         }
4179         bool isStillCapture = false;
4180         bool isZslCapture = false;
4181         bool useZoomRatio = false;
4182         const camera_metadata_t* settings = halRequest->settings;
4183         bool shouldUnlockSettings = false;
4184         if (settings == nullptr) {
4185             shouldUnlockSettings = true;
4186             settings = captureRequest->mSettingsList.begin()->metadata.getAndLock();
4187         }
4188         if (!mNextRequests[0].captureRequest->mSettingsList.begin()->metadata.isEmpty()) {
4189             camera_metadata_ro_entry_t e = camera_metadata_ro_entry_t();
4190             find_camera_metadata_ro_entry(settings, ANDROID_CONTROL_CAPTURE_INTENT, &e);
4191             if ((e.count > 0) && (e.data.u8[0] == ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE)) {
4192                 isStillCapture = true;
4193                 ATRACE_ASYNC_BEGIN("still capture", mNextRequests[i].halRequest.frame_number);
4194             }
4195 
4196             e = camera_metadata_ro_entry_t();
4197             find_camera_metadata_ro_entry(settings, ANDROID_CONTROL_ENABLE_ZSL, &e);
4198             if ((e.count > 0) && (e.data.u8[0] == ANDROID_CONTROL_ENABLE_ZSL_TRUE)) {
4199                 isZslCapture = true;
4200             }
4201 
4202             if (flags::zoom_method()) {
4203                 e = camera_metadata_ro_entry_t();
4204                 find_camera_metadata_ro_entry(settings, ANDROID_CONTROL_ZOOM_METHOD, &e);
4205                 if ((e.count > 0) && (e.data.u8[0] == ANDROID_CONTROL_ZOOM_METHOD_ZOOM_RATIO)) {
4206                     useZoomRatio = true;
4207                 }
4208             }
4209         }
4210         bool passSurfaceMap =
4211                 mUseHalBufManager || containsHalBufferManagedStream;
4212         auto expectedDurationInfo = calculateExpectedDurationRange(settings);
4213         res = parent->registerInFlight(halRequest->frame_number,
4214                 totalNumBuffers, captureRequest->mResultExtras,
4215                 /*hasInput*/halRequest->input_buffer != NULL,
4216                 hasCallback,
4217                 expectedDurationInfo.minDuration,
4218                 expectedDurationInfo.maxDuration,
4219                 expectedDurationInfo.isFixedFps,
4220                 requestedPhysicalCameras, isStillCapture, isZslCapture,
4221                 captureRequest->mRotateAndCropAuto, captureRequest->mAutoframingAuto,
4222                 mPrevCameraIdsWithZoom, useZoomRatio,
4223                 passSurfaceMap ? uniqueSurfaceIdMap :
4224                                       SurfaceMap{}, captureRequest->mRequestTimeNs);
4225         ALOGVV("%s: registered in flight requestId = %" PRId32 ", frameNumber = %" PRId64
4226                ", burstId = %" PRId32 ".",
4227                 __FUNCTION__,
4228                 captureRequest->mResultExtras.requestId, captureRequest->mResultExtras.frameNumber,
4229                 captureRequest->mResultExtras.burstId);
4230 
4231         if (shouldUnlockSettings) {
4232             captureRequest->mSettingsList.begin()->metadata.unlock(settings);
4233         }
4234 
4235         if (res != OK) {
4236             SET_ERR("RequestThread: Unable to register new in-flight request:"
4237                     " %s (%d)", strerror(-res), res);
4238             return INVALID_OPERATION;
4239         }
4240     }
4241 
4242     return OK;
4243 }
4244 
getLatestRequestInfo() const4245 Camera3Device::LatestRequestInfo Camera3Device::RequestThread::getLatestRequestInfo() const {
4246     ATRACE_CALL();
4247     Mutex::Autolock al(mLatestRequestMutex);
4248 
4249     ALOGV("RequestThread::%s", __FUNCTION__);
4250 
4251     return mLatestRequestInfo;
4252 }
4253 
isStreamPending(sp<Camera3StreamInterface> & stream)4254 bool Camera3Device::RequestThread::isStreamPending(
4255         sp<Camera3StreamInterface>& stream) {
4256     ATRACE_CALL();
4257     Mutex::Autolock l(mRequestLock);
4258 
4259     for (const auto& nextRequest : mNextRequests) {
4260         if (!nextRequest.submitted) {
4261             for (const auto& s : nextRequest.captureRequest->mOutputStreams) {
4262                 if (stream == s) return true;
4263             }
4264             if (stream == nextRequest.captureRequest->mInputStream) return true;
4265         }
4266     }
4267 
4268     for (const auto& request : mRequestQueue) {
4269         for (const auto& s : request->mOutputStreams) {
4270             if (stream == s) return true;
4271         }
4272         if (stream == request->mInputStream) return true;
4273     }
4274 
4275     for (const auto& request : mRepeatingRequests) {
4276         for (const auto& s : request->mOutputStreams) {
4277             if (stream == s) return true;
4278         }
4279         if (stream == request->mInputStream) return true;
4280     }
4281 
4282     return false;
4283 }
4284 
isOutputSurfacePending(int streamId,size_t surfaceId)4285 bool Camera3Device::RequestThread::isOutputSurfacePending(int streamId, size_t surfaceId) {
4286     ATRACE_CALL();
4287     Mutex::Autolock l(mRequestLock);
4288 
4289     for (const auto& nextRequest : mNextRequests) {
4290         for (const auto& s : nextRequest.captureRequest->mOutputSurfaces) {
4291             if (s.first == streamId) {
4292                 const auto &it = std::find(s.second.begin(), s.second.end(), surfaceId);
4293                 if (it != s.second.end()) {
4294                     return true;
4295                 }
4296             }
4297         }
4298     }
4299 
4300     for (const auto& request : mRequestQueue) {
4301         for (const auto& s : request->mOutputSurfaces) {
4302             if (s.first == streamId) {
4303                 const auto &it = std::find(s.second.begin(), s.second.end(), surfaceId);
4304                 if (it != s.second.end()) {
4305                     return true;
4306                 }
4307             }
4308         }
4309     }
4310 
4311     for (const auto& request : mRepeatingRequests) {
4312         for (const auto& s : request->mOutputSurfaces) {
4313             if (s.first == streamId) {
4314                 const auto &it = std::find(s.second.begin(), s.second.end(), surfaceId);
4315                 if (it != s.second.end()) {
4316                     return true;
4317                 }
4318             }
4319         }
4320     }
4321 
4322     return false;
4323 }
4324 
signalPipelineDrain(const std::vector<int> & streamIds)4325 void Camera3Device::RequestThread::signalPipelineDrain(const std::vector<int>& streamIds) {
4326     if (!mUseHalBufManager &&
4327             (mHalBufManagedStreamIds.size() == 0)) {
4328         ALOGE("%s called for camera device not supporting HAL buffer management", __FUNCTION__);
4329         return;
4330     }
4331 
4332     Mutex::Autolock pl(mPauseLock);
4333     if (mPaused) {
4334         mInterface->signalPipelineDrain(streamIds);
4335         return;
4336     }
4337     // If request thread is still busy, wait until paused then notify HAL
4338     mNotifyPipelineDrain = true;
4339     mStreamIdsToBeDrained = streamIds;
4340 }
4341 
resetPipelineDrain()4342 void Camera3Device::RequestThread::resetPipelineDrain() {
4343     Mutex::Autolock pl(mPauseLock);
4344     mNotifyPipelineDrain = false;
4345     mStreamIdsToBeDrained.clear();
4346 }
4347 
clearPreviousRequest()4348 void Camera3Device::RequestThread::clearPreviousRequest() {
4349     Mutex::Autolock l(mRequestLock);
4350     mPrevRequest.clear();
4351 }
4352 
setRotateAndCropAutoBehavior(camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropValue)4353 status_t Camera3Device::RequestThread::setRotateAndCropAutoBehavior(
4354         camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropValue) {
4355     ATRACE_CALL();
4356     Mutex::Autolock l(mTriggerMutex);
4357     mRotateAndCropOverride = rotateAndCropValue;
4358     return OK;
4359 }
4360 
setAutoframingAutoBehaviour(camera_metadata_enum_android_control_autoframing_t autoframingValue)4361 status_t Camera3Device::RequestThread::setAutoframingAutoBehaviour(
4362         camera_metadata_enum_android_control_autoframing_t autoframingValue) {
4363     ATRACE_CALL();
4364     Mutex::Autolock l(mTriggerMutex);
4365     mAutoframingOverride = autoframingValue;
4366     return OK;
4367 }
4368 
setComposerSurface(bool composerSurfacePresent)4369 status_t Camera3Device::RequestThread::setComposerSurface(bool composerSurfacePresent) {
4370     ATRACE_CALL();
4371     Mutex::Autolock l(mTriggerMutex);
4372     mComposerOutput = composerSurfacePresent;
4373     return OK;
4374 }
4375 
setCameraMute(int32_t muteMode)4376 status_t Camera3Device::RequestThread::setCameraMute(int32_t muteMode) {
4377     ATRACE_CALL();
4378     Mutex::Autolock l(mTriggerMutex);
4379     if (muteMode != mCameraMute) {
4380         mCameraMute = muteMode;
4381     }
4382     return OK;
4383 }
4384 
setZoomOverride(int32_t zoomOverride)4385 status_t Camera3Device::RequestThread::setZoomOverride(int32_t zoomOverride) {
4386     ATRACE_CALL();
4387     Mutex::Autolock l(mTriggerMutex);
4388     mSettingsOverride = zoomOverride;
4389     return OK;
4390 }
4391 
getExpectedInFlightDuration()4392 nsecs_t Camera3Device::getExpectedInFlightDuration() {
4393     ATRACE_CALL();
4394     std::lock_guard<std::mutex> l(mInFlightLock);
4395     return mExpectedInflightDuration > kMinInflightDuration ?
4396             mExpectedInflightDuration : kMinInflightDuration;
4397 }
4398 
cleanupPhysicalSettings(sp<CaptureRequest> request,camera_capture_request_t * halRequest)4399 void Camera3Device::RequestThread::cleanupPhysicalSettings(sp<CaptureRequest> request,
4400         camera_capture_request_t *halRequest) {
4401     if ((request == nullptr) || (halRequest == nullptr)) {
4402         ALOGE("%s: Invalid request!", __FUNCTION__);
4403         return;
4404     }
4405 
4406     if (halRequest->num_physcam_settings > 0) {
4407         if (halRequest->physcam_id != nullptr) {
4408             delete [] halRequest->physcam_id;
4409             halRequest->physcam_id = nullptr;
4410         }
4411         if (halRequest->physcam_settings != nullptr) {
4412             auto it = ++(request->mSettingsList.begin());
4413             size_t i = 0;
4414             for (; it != request->mSettingsList.end(); it++, i++) {
4415                 it->metadata.unlock(halRequest->physcam_settings[i]);
4416             }
4417             delete [] halRequest->physcam_settings;
4418             halRequest->physcam_settings = nullptr;
4419         }
4420     }
4421 }
4422 
setCameraServiceWatchdog(bool enabled)4423 status_t Camera3Device::setCameraServiceWatchdog(bool enabled) {
4424     Mutex::Autolock il(mInterfaceLock);
4425     Mutex::Autolock l(mLock);
4426 
4427     if (mCameraServiceWatchdog != NULL) {
4428         mCameraServiceWatchdog->setEnabled(enabled);
4429     }
4430 
4431     return OK;
4432 }
4433 
setStreamUseCaseOverrides(const std::vector<int64_t> & useCaseOverrides)4434 void Camera3Device::setStreamUseCaseOverrides(
4435         const std::vector<int64_t>& useCaseOverrides) {
4436     Mutex::Autolock il(mInterfaceLock);
4437     Mutex::Autolock l(mLock);
4438     mStreamUseCaseOverrides = useCaseOverrides;
4439 }
4440 
clearStreamUseCaseOverrides()4441 void Camera3Device::clearStreamUseCaseOverrides() {
4442     Mutex::Autolock il(mInterfaceLock);
4443     Mutex::Autolock l(mLock);
4444     mStreamUseCaseOverrides.clear();
4445 }
4446 
hasDeviceError()4447 bool Camera3Device::hasDeviceError() {
4448     Mutex::Autolock il(mInterfaceLock);
4449     Mutex::Autolock l(mLock);
4450     return mStatus == STATUS_ERROR;
4451 }
4452 
cleanUpFailedRequests(bool sendRequestError)4453 void Camera3Device::RequestThread::cleanUpFailedRequests(bool sendRequestError) {
4454     if (mNextRequests.empty()) {
4455         return;
4456     }
4457 
4458     for (auto& nextRequest : mNextRequests) {
4459         // Skip the ones that have been submitted successfully.
4460         if (nextRequest.submitted) {
4461             continue;
4462         }
4463 
4464         sp<CaptureRequest> captureRequest = nextRequest.captureRequest;
4465         camera_capture_request_t* halRequest = &nextRequest.halRequest;
4466         Vector<camera_stream_buffer_t>* outputBuffers = &nextRequest.outputBuffers;
4467 
4468         if (halRequest->settings != NULL) {
4469             captureRequest->mSettingsList.begin()->metadata.unlock(halRequest->settings);
4470         }
4471 
4472         cleanupPhysicalSettings(captureRequest, halRequest);
4473 
4474         if (captureRequest->mInputStream != NULL) {
4475             captureRequest->mInputBuffer.status = CAMERA_BUFFER_STATUS_ERROR;
4476             captureRequest->mInputStream->returnInputBuffer(captureRequest->mInputBuffer);
4477         }
4478 
4479         for (size_t i = 0; i < halRequest->num_output_buffers; i++) {
4480             //Buffers that failed processing could still have
4481             //valid acquire fence.
4482             Camera3Stream *stream = Camera3Stream::cast((*outputBuffers)[i].stream);
4483             int32_t streamId = stream->getId();
4484             bool skipBufferForStream =
4485                     mUseHalBufManager || (contains(mHalBufManagedStreamIds, streamId));
4486             if (skipBufferForStream) {
4487                 // No output buffer can be returned when using HAL buffer manager for its stream
4488                 continue;
4489             }
4490             int acquireFence = (*outputBuffers)[i].acquire_fence;
4491             if (0 <= acquireFence) {
4492                 close(acquireFence);
4493                 outputBuffers->editItemAt(i).acquire_fence = -1;
4494             }
4495             outputBuffers->editItemAt(i).status = CAMERA_BUFFER_STATUS_ERROR;
4496             captureRequest->mOutputStreams.editItemAt(i)->returnBuffer((*outputBuffers)[i],
4497                     /*timestamp*/0, /*readoutTimestamp*/0,
4498                     /*timestampIncreasing*/true, std::vector<size_t> (),
4499                     captureRequest->mResultExtras.frameNumber);
4500         }
4501 
4502         if (sendRequestError) {
4503             Mutex::Autolock l(mRequestLock);
4504             sp<NotificationListener> listener = mListener.promote();
4505             if (listener != NULL) {
4506                 listener->notifyError(
4507                         hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST,
4508                         captureRequest->mResultExtras);
4509             }
4510             wakeupLatestRequest(/*failedRequestId*/true, captureRequest->mResultExtras.requestId);
4511         }
4512 
4513         // Remove yet-to-be submitted inflight request from inflightMap
4514         {
4515           sp<Camera3Device> parent = mParent.promote();
4516           if (parent != NULL) {
4517               std::lock_guard<std::mutex> l(parent->mInFlightLock);
4518               ssize_t idx = parent->mInFlightMap.indexOfKey(captureRequest->mResultExtras.frameNumber);
4519               if (idx >= 0) {
4520                   ALOGV("%s: Remove inflight request from queue: frameNumber %" PRId64,
4521                         __FUNCTION__, captureRequest->mResultExtras.frameNumber);
4522                   parent->removeInFlightMapEntryLocked(idx);
4523               }
4524           }
4525         }
4526     }
4527 
4528     Mutex::Autolock l(mRequestLock);
4529     mNextRequests.clear();
4530 }
4531 
waitForNextRequestBatch()4532 void Camera3Device::RequestThread::waitForNextRequestBatch() {
4533     ATRACE_CALL();
4534     // Optimized a bit for the simple steady-state case (single repeating
4535     // request), to avoid putting that request in the queue temporarily.
4536     Mutex::Autolock l(mRequestLock);
4537 
4538     assert(mNextRequests.empty());
4539 
4540     NextRequest nextRequest;
4541     nextRequest.captureRequest = waitForNextRequestLocked();
4542     if (nextRequest.captureRequest == nullptr) {
4543         return;
4544     }
4545 
4546     nextRequest.halRequest = camera_capture_request_t();
4547     nextRequest.submitted = false;
4548     mNextRequests.add(nextRequest);
4549 
4550     // Wait for additional requests
4551     const size_t batchSize = nextRequest.captureRequest->mBatchSize;
4552 
4553     for (size_t i = 1; i < batchSize; i++) {
4554         NextRequest additionalRequest;
4555         additionalRequest.captureRequest = waitForNextRequestLocked();
4556         if (additionalRequest.captureRequest == nullptr) {
4557             break;
4558         }
4559 
4560         additionalRequest.halRequest = camera_capture_request_t();
4561         additionalRequest.submitted = false;
4562         mNextRequests.add(additionalRequest);
4563     }
4564 
4565     if (mNextRequests.size() < batchSize) {
4566         ALOGE("RequestThread: only get %zu out of %zu requests. Skipping requests.",
4567                 mNextRequests.size(), batchSize);
4568         cleanUpFailedRequests(/*sendRequestError*/true);
4569     }
4570 
4571     return;
4572 }
4573 
4574 sp<Camera3Device::CaptureRequest>
waitForNextRequestLocked()4575         Camera3Device::RequestThread::waitForNextRequestLocked() {
4576     status_t res;
4577     sp<CaptureRequest> nextRequest;
4578 
4579     while (mRequestQueue.empty()) {
4580         if (!mRepeatingRequests.empty()) {
4581             // Always atomically enqueue all requests in a repeating request
4582             // list. Guarantees a complete in-sequence set of captures to
4583             // application.
4584             const RequestList &requests = mRepeatingRequests;
4585             if (mFirstRepeating) {
4586                 mFirstRepeating = false;
4587             } else {
4588                 for (auto& request : requests) {
4589                     // For repeating requests, override timestamp request using
4590                     // the time a request is inserted into the request queue,
4591                     // because the original repeating request will have an old
4592                     // fixed timestamp.
4593                     request->mRequestTimeNs = systemTime();
4594                 }
4595             }
4596             RequestList::const_iterator firstRequest =
4597                     requests.begin();
4598             nextRequest = *firstRequest;
4599             mRequestQueue.insert(mRequestQueue.end(),
4600                     ++firstRequest,
4601                     requests.end());
4602             // No need to wait any longer
4603 
4604             mRepeatingLastFrameNumber = mFrameNumber + requests.size() - 1;
4605 
4606             break;
4607         }
4608 
4609         if (!mRequestClearing) {
4610             res = mRequestSignal.waitRelative(mRequestLock, kRequestTimeout);
4611         }
4612 
4613         if ((mRequestQueue.empty() && mRepeatingRequests.empty()) ||
4614                 exitPending()) {
4615             Mutex::Autolock pl(mPauseLock);
4616             if (mPaused == false) {
4617                 ALOGV("%s: RequestThread: Going idle", __FUNCTION__);
4618                 mPaused = true;
4619                 if (mNotifyPipelineDrain) {
4620                     mInterface->signalPipelineDrain(mStreamIdsToBeDrained);
4621                     mNotifyPipelineDrain = false;
4622                     mStreamIdsToBeDrained.clear();
4623                 }
4624                 // Let the tracker know
4625                 sp<StatusTracker> statusTracker = mStatusTracker.promote();
4626                 if (statusTracker != 0) {
4627                     statusTracker->markComponentIdle(mStatusId, Fence::NO_FENCE);
4628                 }
4629                 sp<Camera3Device> parent = mParent.promote();
4630                 if (parent != nullptr) {
4631                     parent->mRequestBufferSM.onRequestThreadPaused();
4632                 }
4633             }
4634             mRequestClearing = false;
4635             // Stop waiting for now and let thread management happen
4636             return NULL;
4637         }
4638     }
4639 
4640     if (nextRequest == NULL) {
4641         // Don't have a repeating request already in hand, so queue
4642         // must have an entry now.
4643         RequestList::iterator firstRequest =
4644                 mRequestQueue.begin();
4645         nextRequest = *firstRequest;
4646         mRequestQueue.erase(firstRequest);
4647         if (mRequestQueue.empty() && !nextRequest->mRepeating) {
4648             sp<NotificationListener> listener = mListener.promote();
4649             if (listener != NULL) {
4650                 listener->notifyRequestQueueEmpty();
4651             }
4652         }
4653     }
4654 
4655     // In case we've been unpaused by setPaused clearing mDoPause, need to
4656     // update internal pause state (capture/setRepeatingRequest unpause
4657     // directly).
4658     Mutex::Autolock pl(mPauseLock);
4659     if (mPaused) {
4660         ALOGV("%s: RequestThread: Unpaused", __FUNCTION__);
4661         sp<StatusTracker> statusTracker = mStatusTracker.promote();
4662         if (statusTracker != 0) {
4663             statusTracker->markComponentActive(mStatusId);
4664         }
4665     }
4666     mPaused = false;
4667 
4668     // Check if we've reconfigured since last time, and reset the preview
4669     // request if so. Can't use 'NULL request == repeat' across configure calls.
4670     if (mReconfigured) {
4671         mPrevRequest.clear();
4672         mReconfigured = false;
4673     }
4674 
4675     if (nextRequest != NULL) {
4676         nextRequest->mResultExtras.frameNumber = mFrameNumber++;
4677         nextRequest->mResultExtras.afTriggerId = mCurrentAfTriggerId;
4678         nextRequest->mResultExtras.precaptureTriggerId = mCurrentPreCaptureTriggerId;
4679 
4680         // Since RequestThread::clear() removes buffers from the input stream,
4681         // get the right buffer here before unlocking mRequestLock
4682         if (nextRequest->mInputStream != NULL) {
4683             res = nextRequest->mInputStream->getInputBuffer(&nextRequest->mInputBuffer,
4684                     &nextRequest->mInputBufferSize);
4685             if (res != OK) {
4686                 // Can't get input buffer from gralloc queue - this could be due to
4687                 // disconnected queue or other producer misbehavior, so not a fatal
4688                 // error
4689                 ALOGE("%s: Can't get input buffer, skipping request:"
4690                         " %s (%d)", __FUNCTION__, strerror(-res), res);
4691 
4692                 sp<NotificationListener> listener = mListener.promote();
4693                 if (listener != NULL) {
4694                     listener->notifyError(
4695                             hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST,
4696                             nextRequest->mResultExtras);
4697                 }
4698                 return NULL;
4699             }
4700         }
4701     }
4702 
4703     return nextRequest;
4704 }
4705 
waitIfPaused()4706 bool Camera3Device::RequestThread::waitIfPaused() {
4707     ATRACE_CALL();
4708     status_t res;
4709     Mutex::Autolock l(mPauseLock);
4710     while (mDoPause) {
4711         if (mPaused == false) {
4712             mPaused = true;
4713             ALOGV("%s: RequestThread: Paused", __FUNCTION__);
4714             if (mNotifyPipelineDrain) {
4715                 mInterface->signalPipelineDrain(mStreamIdsToBeDrained);
4716                 mNotifyPipelineDrain = false;
4717                 mStreamIdsToBeDrained.clear();
4718             }
4719             // Let the tracker know
4720             sp<StatusTracker> statusTracker = mStatusTracker.promote();
4721             if (statusTracker != 0) {
4722                 statusTracker->markComponentIdle(mStatusId, Fence::NO_FENCE);
4723             }
4724             sp<Camera3Device> parent = mParent.promote();
4725             if (parent != nullptr) {
4726                 parent->mRequestBufferSM.onRequestThreadPaused();
4727             }
4728         }
4729 
4730         res = mDoPauseSignal.waitRelative(mPauseLock, kRequestTimeout);
4731         if (res == TIMED_OUT || exitPending()) {
4732             return true;
4733         }
4734     }
4735     // We don't set mPaused to false here, because waitForNextRequest needs
4736     // to further manage the paused state in case of starvation.
4737     return false;
4738 }
4739 
unpauseForNewRequests()4740 void Camera3Device::RequestThread::unpauseForNewRequests() {
4741     ATRACE_CALL();
4742     // With work to do, mark thread as unpaused.
4743     // If paused by request (setPaused), don't resume, to avoid
4744     // extra signaling/waiting overhead to waitUntilPaused
4745     mRequestSignal.signal();
4746     Mutex::Autolock p(mPauseLock);
4747     if (!mDoPause) {
4748         ALOGV("%s: RequestThread: Going active", __FUNCTION__);
4749         if (mPaused) {
4750             sp<StatusTracker> statusTracker = mStatusTracker.promote();
4751             if (statusTracker != 0) {
4752                 statusTracker->markComponentActive(mStatusId);
4753             }
4754         }
4755         mPaused = false;
4756     }
4757 }
4758 
setErrorState(const char * fmt,...)4759 void Camera3Device::RequestThread::setErrorState(const char *fmt, ...) {
4760     sp<Camera3Device> parent = mParent.promote();
4761     if (parent != NULL) {
4762         va_list args;
4763         va_start(args, fmt);
4764 
4765         parent->setErrorStateV(fmt, args);
4766 
4767         va_end(args);
4768     }
4769 }
4770 
insertTriggers(const sp<CaptureRequest> & request)4771 status_t Camera3Device::RequestThread::insertTriggers(
4772         const sp<CaptureRequest> &request) {
4773     ATRACE_CALL();
4774     Mutex::Autolock al(mTriggerMutex);
4775 
4776     sp<Camera3Device> parent = mParent.promote();
4777     if (parent == NULL) {
4778         CLOGE("RequestThread: Parent is gone");
4779         return DEAD_OBJECT;
4780     }
4781 
4782     CameraMetadata &metadata = request->mSettingsList.begin()->metadata;
4783     size_t count = mTriggerMap.size();
4784 
4785     for (size_t i = 0; i < count; ++i) {
4786         RequestTrigger trigger = mTriggerMap.valueAt(i);
4787         uint32_t tag = trigger.metadataTag;
4788 
4789         if (tag == ANDROID_CONTROL_AF_TRIGGER_ID || tag == ANDROID_CONTROL_AE_PRECAPTURE_ID) {
4790             bool isAeTrigger = (trigger.metadataTag == ANDROID_CONTROL_AE_PRECAPTURE_ID);
4791             uint32_t triggerId = static_cast<uint32_t>(trigger.entryValue);
4792             if (isAeTrigger) {
4793                 request->mResultExtras.precaptureTriggerId = triggerId;
4794                 mCurrentPreCaptureTriggerId = triggerId;
4795             } else {
4796                 request->mResultExtras.afTriggerId = triggerId;
4797                 mCurrentAfTriggerId = triggerId;
4798             }
4799             continue;
4800         }
4801 
4802         camera_metadata_entry entry = metadata.find(tag);
4803 
4804         if (entry.count > 0) {
4805             /**
4806              * Already has an entry for this trigger in the request.
4807              * Rewrite it with our requested trigger value.
4808              */
4809             RequestTrigger oldTrigger = trigger;
4810 
4811             oldTrigger.entryValue = entry.data.u8[0];
4812 
4813             mTriggerReplacedMap.add(tag, oldTrigger);
4814         } else {
4815             /**
4816              * More typical, no trigger entry, so we just add it
4817              */
4818             mTriggerRemovedMap.add(tag, trigger);
4819         }
4820 
4821         status_t res;
4822 
4823         switch (trigger.getTagType()) {
4824             case TYPE_BYTE: {
4825                 uint8_t entryValue = static_cast<uint8_t>(trigger.entryValue);
4826                 res = metadata.update(tag,
4827                                       &entryValue,
4828                                       /*count*/1);
4829                 break;
4830             }
4831             case TYPE_INT32:
4832                 res = metadata.update(tag,
4833                                       &trigger.entryValue,
4834                                       /*count*/1);
4835                 break;
4836             default:
4837                 ALOGE("%s: Type not supported: 0x%x",
4838                       __FUNCTION__,
4839                       trigger.getTagType());
4840                 return INVALID_OPERATION;
4841         }
4842 
4843         if (res != OK) {
4844             ALOGE("%s: Failed to update request metadata with trigger tag %s"
4845                   ", value %d", __FUNCTION__, trigger.getTagName(),
4846                   trigger.entryValue);
4847             return res;
4848         }
4849 
4850         ALOGV("%s: Mixed in trigger %s, value %d", __FUNCTION__,
4851               trigger.getTagName(),
4852               trigger.entryValue);
4853     }
4854 
4855     mTriggerMap.clear();
4856 
4857     return count;
4858 }
4859 
removeTriggers(const sp<CaptureRequest> & request)4860 status_t Camera3Device::RequestThread::removeTriggers(
4861         const sp<CaptureRequest> &request) {
4862     ATRACE_CALL();
4863     Mutex::Autolock al(mTriggerMutex);
4864 
4865     CameraMetadata &metadata = request->mSettingsList.begin()->metadata;
4866 
4867     /**
4868      * Replace all old entries with their old values.
4869      */
4870     for (size_t i = 0; i < mTriggerReplacedMap.size(); ++i) {
4871         RequestTrigger trigger = mTriggerReplacedMap.valueAt(i);
4872 
4873         status_t res;
4874 
4875         uint32_t tag = trigger.metadataTag;
4876         switch (trigger.getTagType()) {
4877             case TYPE_BYTE: {
4878                 uint8_t entryValue = static_cast<uint8_t>(trigger.entryValue);
4879                 res = metadata.update(tag,
4880                                       &entryValue,
4881                                       /*count*/1);
4882                 break;
4883             }
4884             case TYPE_INT32:
4885                 res = metadata.update(tag,
4886                                       &trigger.entryValue,
4887                                       /*count*/1);
4888                 break;
4889             default:
4890                 ALOGE("%s: Type not supported: 0x%x",
4891                       __FUNCTION__,
4892                       trigger.getTagType());
4893                 return INVALID_OPERATION;
4894         }
4895 
4896         if (res != OK) {
4897             ALOGE("%s: Failed to restore request metadata with trigger tag %s"
4898                   ", trigger value %d", __FUNCTION__,
4899                   trigger.getTagName(), trigger.entryValue);
4900             return res;
4901         }
4902     }
4903     mTriggerReplacedMap.clear();
4904 
4905     /**
4906      * Remove all new entries.
4907      */
4908     for (size_t i = 0; i < mTriggerRemovedMap.size(); ++i) {
4909         RequestTrigger trigger = mTriggerRemovedMap.valueAt(i);
4910         status_t res = metadata.erase(trigger.metadataTag);
4911 
4912         if (res != OK) {
4913             ALOGE("%s: Failed to erase metadata with trigger tag %s"
4914                   ", trigger value %d", __FUNCTION__,
4915                   trigger.getTagName(), trigger.entryValue);
4916             return res;
4917         }
4918     }
4919     mTriggerRemovedMap.clear();
4920 
4921     return OK;
4922 }
4923 
addFakeTriggerIds(const sp<CaptureRequest> & request)4924 status_t Camera3Device::RequestThread::addFakeTriggerIds(
4925         const sp<CaptureRequest> &request) {
4926     // Trigger ID 0 had special meaning in the HAL2 spec, so avoid it here
4927     static const int32_t fakeTriggerId = 1;
4928     status_t res;
4929 
4930     CameraMetadata &metadata = request->mSettingsList.begin()->metadata;
4931 
4932     // If AF trigger is active, insert a fake AF trigger ID if none already
4933     // exists
4934     camera_metadata_entry afTrigger = metadata.find(ANDROID_CONTROL_AF_TRIGGER);
4935     camera_metadata_entry afId = metadata.find(ANDROID_CONTROL_AF_TRIGGER_ID);
4936     if (afTrigger.count > 0 &&
4937             afTrigger.data.u8[0] != ANDROID_CONTROL_AF_TRIGGER_IDLE &&
4938             afId.count == 0) {
4939         res = metadata.update(ANDROID_CONTROL_AF_TRIGGER_ID, &fakeTriggerId, 1);
4940         if (res != OK) return res;
4941     }
4942 
4943     // If AE precapture trigger is active, insert a fake precapture trigger ID
4944     // if none already exists
4945     camera_metadata_entry pcTrigger =
4946             metadata.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER);
4947     camera_metadata_entry pcId = metadata.find(ANDROID_CONTROL_AE_PRECAPTURE_ID);
4948     if (pcTrigger.count > 0 &&
4949             pcTrigger.data.u8[0] != ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE &&
4950             pcId.count == 0) {
4951         res = metadata.update(ANDROID_CONTROL_AE_PRECAPTURE_ID,
4952                 &fakeTriggerId, 1);
4953         if (res != OK) return res;
4954     }
4955 
4956     return OK;
4957 }
4958 
overrideAutoRotateAndCrop(const sp<CaptureRequest> & request)4959 bool Camera3Device::RequestThread::overrideAutoRotateAndCrop(const sp<CaptureRequest> &request) {
4960     ATRACE_CALL();
4961     Mutex::Autolock l(mTriggerMutex);
4962     return Camera3Device::overrideAutoRotateAndCrop(request, this->mRotationOverride,
4963             this->mRotateAndCropOverride);
4964 }
4965 
overrideAutoRotateAndCrop(const sp<CaptureRequest> & request,int rotationOverride,camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropOverride)4966 bool Camera3Device::overrideAutoRotateAndCrop(const sp<CaptureRequest> &request,
4967         int rotationOverride,
4968         camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropOverride) {
4969     ATRACE_CALL();
4970 
4971     if (rotationOverride != hardware::ICameraService::ROTATION_OVERRIDE_NONE) {
4972         uint8_t rotateAndCrop_u8 = rotateAndCropOverride;
4973         CameraMetadata &metadata = request->mSettingsList.begin()->metadata;
4974         metadata.update(ANDROID_SCALER_ROTATE_AND_CROP,
4975                 &rotateAndCrop_u8, 1);
4976         return true;
4977     }
4978 
4979     if (request->mRotateAndCropAuto) {
4980         CameraMetadata &metadata = request->mSettingsList.begin()->metadata;
4981 
4982         auto rotateAndCropEntry = metadata.find(ANDROID_SCALER_ROTATE_AND_CROP);
4983         if (rotateAndCropEntry.count > 0) {
4984             if (rotateAndCropEntry.data.u8[0] == rotateAndCropOverride) {
4985                 return false;
4986             } else {
4987                 rotateAndCropEntry.data.u8[0] = rotateAndCropOverride;
4988                 return true;
4989             }
4990         } else {
4991             uint8_t rotateAndCrop_u8 = rotateAndCropOverride;
4992             metadata.update(ANDROID_SCALER_ROTATE_AND_CROP, &rotateAndCrop_u8, 1);
4993             return true;
4994         }
4995     }
4996 
4997     return false;
4998 }
4999 
overrideAutoframing(const sp<CaptureRequest> & request,camera_metadata_enum_android_control_autoframing_t autoframingOverride)5000 bool Camera3Device::overrideAutoframing(const sp<CaptureRequest> &request /*out*/,
5001         camera_metadata_enum_android_control_autoframing_t autoframingOverride) {
5002     CameraMetadata &metadata = request->mSettingsList.begin()->metadata;
5003     auto autoframingEntry = metadata.find(ANDROID_CONTROL_AUTOFRAMING);
5004     if (autoframingEntry.count > 0) {
5005         if (autoframingEntry.data.u8[0] == autoframingOverride) {
5006             return false;
5007         } else {
5008             autoframingEntry.data.u8[0] = autoframingOverride;
5009             return true;
5010         }
5011     } else {
5012         uint8_t autoframing_u8 = autoframingOverride;
5013         metadata.update(ANDROID_CONTROL_AUTOFRAMING,
5014                 &autoframing_u8, 1);
5015         return true;
5016     }
5017 
5018     return false;
5019 }
5020 
overrideAutoframing(const sp<CaptureRequest> & request)5021 bool Camera3Device::RequestThread::overrideAutoframing(const sp<CaptureRequest> &request) {
5022     ATRACE_CALL();
5023 
5024     if (request->mAutoframingAuto) {
5025         Mutex::Autolock l(mTriggerMutex);
5026         return Camera3Device::overrideAutoframing(request, mAutoframingOverride);
5027     }
5028 
5029     return false;
5030 }
5031 
injectSessionParams(const sp<CaptureRequest> & request,const CameraMetadata & injectedSessionParams)5032 void Camera3Device::RequestThread::injectSessionParams(
5033     const sp<CaptureRequest> &request,
5034     const CameraMetadata& injectedSessionParams) {
5035     CameraMetadata &requestMetadata = request->mSettingsList.begin()->metadata;
5036     uint32_t tag_section;
5037     camera_metadata_ro_entry entry;
5038     for (auto tag : mSessionParamKeys) {
5039         tag_section = tag >> 16;
5040         if (tag_section < VENDOR_SECTION) {
5041             // Only allow injection of vendor tags.
5042             continue;
5043         }
5044         entry = injectedSessionParams.find(tag);
5045         if (entry.count > 0) {
5046             requestMetadata.update(entry);
5047         }
5048     }
5049 }
5050 
setInjectedSessionParams(const CameraMetadata & injectedSessionParams)5051 status_t Camera3Device::RequestThread::setInjectedSessionParams(
5052         const CameraMetadata& injectedSessionParams) {
5053     ATRACE_CALL();
5054     Mutex::Autolock l(mTriggerMutex);
5055     mInjectedSessionParams = injectedSessionParams;
5056     return OK;
5057 }
5058 
injectSessionParams(const CameraMetadata & injectedSessionParams)5059 status_t Camera3Device::injectSessionParams(const CameraMetadata& injectedSessionParams) {
5060     ATRACE_CALL();
5061     Mutex::Autolock il(mInterfaceLock);
5062     Mutex::Autolock l(mLock);
5063 
5064     if (mRequestThread == nullptr) {
5065         return INVALID_OPERATION;
5066     }
5067 
5068     return mRequestThread->setInjectedSessionParams(injectedSessionParams);
5069 }
5070 
overrideTestPattern(const sp<CaptureRequest> & request)5071 bool Camera3Device::RequestThread::overrideTestPattern(
5072         const sp<CaptureRequest> &request) {
5073     ATRACE_CALL();
5074 
5075     if (!mSupportCameraMute) return false;
5076 
5077     Mutex::Autolock l(mTriggerMutex);
5078 
5079     bool changed = false;
5080 
5081     // For a multi-camera, the physical cameras support the same set of
5082     // test pattern modes as the logical camera.
5083     for (auto& settings : request->mSettingsList) {
5084         CameraMetadata &metadata = settings.metadata;
5085 
5086         int32_t testPatternMode = settings.mOriginalTestPatternMode;
5087         int32_t testPatternData[4] = {
5088             settings.mOriginalTestPatternData[0],
5089             settings.mOriginalTestPatternData[1],
5090             settings.mOriginalTestPatternData[2],
5091             settings.mOriginalTestPatternData[3]
5092         };
5093         if (mCameraMute != ANDROID_SENSOR_TEST_PATTERN_MODE_OFF) {
5094             testPatternMode = mCameraMute;
5095             testPatternData[0] = 0;
5096             testPatternData[1] = 0;
5097             testPatternData[2] = 0;
5098             testPatternData[3] = 0;
5099         }
5100 
5101         auto testPatternEntry = metadata.find(ANDROID_SENSOR_TEST_PATTERN_MODE);
5102         bool supportTestPatternModeKey = settings.mHasTestPatternModeTag;
5103         if (testPatternEntry.count > 0) {
5104             if (testPatternEntry.data.i32[0] != testPatternMode) {
5105                 testPatternEntry.data.i32[0] = testPatternMode;
5106                 changed = true;
5107             }
5108         } else if (supportTestPatternModeKey) {
5109             metadata.update(ANDROID_SENSOR_TEST_PATTERN_MODE,
5110                     &testPatternMode, 1);
5111             changed = true;
5112         }
5113 
5114         auto testPatternColor = metadata.find(ANDROID_SENSOR_TEST_PATTERN_DATA);
5115         bool supportTestPatternDataKey = settings.mHasTestPatternDataTag;
5116         if (testPatternColor.count >= 4) {
5117             for (size_t i = 0; i < 4; i++) {
5118                 if (testPatternColor.data.i32[i] != testPatternData[i]) {
5119                     testPatternColor.data.i32[i] = testPatternData[i];
5120                     changed = true;
5121                 }
5122             }
5123         } else if (supportTestPatternDataKey) {
5124             metadata.update(ANDROID_SENSOR_TEST_PATTERN_DATA,
5125                     testPatternData, 4);
5126             changed = true;
5127         }
5128     }
5129 
5130     return changed;
5131 }
5132 
overrideSettingsOverride(const sp<CaptureRequest> & request)5133 bool Camera3Device::RequestThread::overrideSettingsOverride(
5134         const sp<CaptureRequest> &request) {
5135     ATRACE_CALL();
5136 
5137     if (!mSupportSettingsOverride) return false;
5138 
5139     Mutex::Autolock l(mTriggerMutex);
5140 
5141     // For a multi-camera, only override the logical camera's metadata.
5142     CameraMetadata &metadata = request->mSettingsList.begin()->metadata;
5143     camera_metadata_entry entry = metadata.find(ANDROID_CONTROL_SETTINGS_OVERRIDE);
5144     int32_t originalValue = request->mSettingsList.begin()->mOriginalSettingsOverride;
5145     if (mSettingsOverride != -1 &&
5146             (entry.count == 0 || entry.data.i32[0] != mSettingsOverride)) {
5147         metadata.update(ANDROID_CONTROL_SETTINGS_OVERRIDE,
5148                 &mSettingsOverride, 1);
5149         return true;
5150     } else if (mSettingsOverride == -1 &&
5151             (entry.count == 0 || entry.data.i32[0] != originalValue)) {
5152         metadata.update(ANDROID_CONTROL_SETTINGS_OVERRIDE,
5153                 &originalValue, 1);
5154         return true;
5155     }
5156 
5157     return false;
5158 }
5159 
setHalInterface(sp<HalInterface> newHalInterface)5160 status_t Camera3Device::RequestThread::setHalInterface(
5161         sp<HalInterface> newHalInterface) {
5162     if (newHalInterface.get() == nullptr) {
5163         ALOGE("%s: The newHalInterface does not exist!", __FUNCTION__);
5164         return DEAD_OBJECT;
5165     }
5166 
5167     mInterface = newHalInterface;
5168 
5169     return OK;
5170 }
5171 
wakeupLatestRequest(bool latestRequestFailed,int32_t latestRequestId)5172 void  Camera3Device::RequestThread::wakeupLatestRequest(
5173         bool latestRequestFailed,
5174         int32_t latestRequestId) {
5175     Mutex::Autolock al(mLatestRequestMutex);
5176 
5177     if (latestRequestFailed) {
5178         mLatestFailedRequestId = latestRequestId;
5179     } else {
5180         mLatestRequestId = latestRequestId;
5181     }
5182     mLatestRequestSignal.signal();
5183 }
5184 
5185 
5186 /**
5187  * PreparerThread inner class methods
5188  */
5189 
PreparerThread()5190 Camera3Device::PreparerThread::PreparerThread() :
5191         Thread(/*canCallJava*/false), mListener(nullptr),
5192         mActive(false), mCancelNow(false), mCurrentMaxCount(0), mCurrentPrepareComplete(false) {
5193 }
5194 
~PreparerThread()5195 Camera3Device::PreparerThread::~PreparerThread() {
5196     Thread::requestExitAndWait();
5197     if (mCurrentStream != nullptr) {
5198         mCurrentStream->cancelPrepare();
5199         ATRACE_ASYNC_END("stream prepare", mCurrentStream->getId());
5200         mCurrentStream.clear();
5201     }
5202     clear();
5203 }
5204 
prepare(int maxCount,sp<Camera3StreamInterface> & stream)5205 status_t Camera3Device::PreparerThread::prepare(int maxCount, sp<Camera3StreamInterface>& stream) {
5206     ATRACE_CALL();
5207     status_t res;
5208 
5209     Mutex::Autolock l(mLock);
5210     sp<NotificationListener> listener = mListener.promote();
5211 
5212     res = stream->startPrepare(maxCount, true /*blockRequest*/);
5213     if (res == OK) {
5214         // No preparation needed, fire listener right off
5215         ALOGV("%s: Stream %d already prepared", __FUNCTION__, stream->getId());
5216         if (listener != NULL) {
5217             listener->notifyPrepared(stream->getId());
5218         }
5219         return OK;
5220     } else if (res != NOT_ENOUGH_DATA) {
5221         return res;
5222     }
5223 
5224     // Need to prepare, start up thread if necessary
5225     if (!mActive) {
5226         // mRunning will change to false before the thread fully shuts down, so wait to be sure it
5227         // isn't running
5228         Thread::requestExitAndWait();
5229         res = Thread::run("C3PrepThread", PRIORITY_BACKGROUND);
5230         if (res != OK) {
5231             ALOGE("%s: Unable to start preparer stream: %d (%s)", __FUNCTION__, res, strerror(-res));
5232             if (listener != NULL) {
5233                 listener->notifyPrepared(stream->getId());
5234             }
5235             return res;
5236         }
5237         mCancelNow = false;
5238         mActive = true;
5239         ALOGV("%s: Preparer stream started", __FUNCTION__);
5240     }
5241 
5242     // queue up the work
5243     mPendingStreams.push_back(
5244             std::tuple<int, sp<camera3::Camera3StreamInterface>>(maxCount, stream));
5245     ALOGV("%s: Stream %d queued for preparing", __FUNCTION__, stream->getId());
5246 
5247     return OK;
5248 }
5249 
pause()5250 void Camera3Device::PreparerThread::pause() {
5251     ATRACE_CALL();
5252 
5253     Mutex::Autolock l(mLock);
5254 
5255     std::list<std::tuple<int, sp<camera3::Camera3StreamInterface>>> pendingStreams;
5256     pendingStreams.insert(pendingStreams.begin(), mPendingStreams.begin(), mPendingStreams.end());
5257     sp<camera3::Camera3StreamInterface> currentStream = mCurrentStream;
5258     int currentMaxCount = mCurrentMaxCount;
5259     mPendingStreams.clear();
5260     mCancelNow = true;
5261     while (mActive) {
5262         auto res = mThreadActiveSignal.waitRelative(mLock, kActiveTimeout);
5263         if (res == TIMED_OUT) {
5264             ALOGE("%s: Timed out waiting on prepare thread!", __FUNCTION__);
5265             return;
5266         } else if (res != OK) {
5267             ALOGE("%s: Encountered an error: %d waiting on prepare thread!", __FUNCTION__, res);
5268             return;
5269         }
5270     }
5271 
5272     //Check whether the prepare thread was able to complete the current
5273     //stream. In case work is still pending emplace it along with the rest
5274     //of the streams in the pending list.
5275     if (currentStream != nullptr) {
5276         if (!mCurrentPrepareComplete) {
5277             pendingStreams.push_back(std::tuple(currentMaxCount, currentStream));
5278         }
5279     }
5280 
5281     mPendingStreams.insert(mPendingStreams.begin(), pendingStreams.begin(), pendingStreams.end());
5282     for (const auto& it : mPendingStreams) {
5283         std::get<1>(it)->cancelPrepare();
5284     }
5285 }
5286 
resume()5287 status_t Camera3Device::PreparerThread::resume() {
5288     ATRACE_CALL();
5289     ALOGV("%s: PreparerThread", __FUNCTION__);
5290     status_t res;
5291 
5292     Mutex::Autolock l(mLock);
5293     sp<NotificationListener> listener = mListener.promote();
5294 
5295     if (mActive) {
5296         ALOGE("%s: Trying to resume an already active prepare thread!", __FUNCTION__);
5297         return NO_INIT;
5298     }
5299 
5300     auto it = mPendingStreams.begin();
5301     for (; it != mPendingStreams.end();) {
5302         res = std::get<1>(*it)->startPrepare(std::get<0>(*it), true /*blockRequest*/);
5303         if (res == OK) {
5304             if (listener != NULL) {
5305                 listener->notifyPrepared(std::get<1>(*it)->getId());
5306             }
5307             it = mPendingStreams.erase(it);
5308         } else if (res != NOT_ENOUGH_DATA) {
5309             ALOGE("%s: Unable to start preparer stream: %d (%s)", __FUNCTION__,
5310                     res, strerror(-res));
5311             it = mPendingStreams.erase(it);
5312         } else {
5313             it++;
5314         }
5315     }
5316 
5317     if (mPendingStreams.empty()) {
5318         return OK;
5319     }
5320 
5321     res = Thread::run("C3PrepThread", PRIORITY_BACKGROUND);
5322     if (res != OK) {
5323         ALOGE("%s: Unable to start preparer stream: %d (%s)",
5324                 __FUNCTION__, res, strerror(-res));
5325         return res;
5326     }
5327     mCancelNow = false;
5328     mActive = true;
5329     ALOGV("%s: Preparer stream started", __FUNCTION__);
5330 
5331     return OK;
5332 }
5333 
clear()5334 status_t Camera3Device::PreparerThread::clear() {
5335     ATRACE_CALL();
5336     Mutex::Autolock l(mLock);
5337 
5338     for (const auto& it : mPendingStreams) {
5339         std::get<1>(it)->cancelPrepare();
5340     }
5341     mPendingStreams.clear();
5342     mCancelNow = true;
5343 
5344     return OK;
5345 }
5346 
setNotificationListener(wp<NotificationListener> listener)5347 void Camera3Device::PreparerThread::setNotificationListener(wp<NotificationListener> listener) {
5348     ATRACE_CALL();
5349     Mutex::Autolock l(mLock);
5350     mListener = listener;
5351 }
5352 
threadLoop()5353 bool Camera3Device::PreparerThread::threadLoop() {
5354     status_t res;
5355     {
5356         Mutex::Autolock l(mLock);
5357         if (mCurrentStream == nullptr) {
5358             // End thread if done with work
5359             if (mPendingStreams.empty()) {
5360                 ALOGV("%s: Preparer stream out of work", __FUNCTION__);
5361                 // threadLoop _must not_ re-acquire mLock after it sets mActive to false; would
5362                 // cause deadlock with prepare()'s requestExitAndWait triggered by !mActive.
5363                 mActive = false;
5364                 mThreadActiveSignal.signal();
5365                 return false;
5366             }
5367 
5368             // Get next stream to prepare
5369             auto it = mPendingStreams.begin();
5370             mCurrentMaxCount = std::get<0>(*it);
5371             mCurrentStream = std::get<1>(*it);
5372             mCurrentPrepareComplete = false;
5373             mPendingStreams.erase(it);
5374             ATRACE_ASYNC_BEGIN("stream prepare", mCurrentStream->getId());
5375             ALOGV("%s: Preparing stream %d", __FUNCTION__, mCurrentStream->getId());
5376         } else if (mCancelNow) {
5377             mCurrentStream->cancelPrepare();
5378             ATRACE_ASYNC_END("stream prepare", mCurrentStream->getId());
5379             ALOGV("%s: Cancelling stream %d prepare", __FUNCTION__, mCurrentStream->getId());
5380             mCurrentStream.clear();
5381             mCancelNow = false;
5382             return true;
5383         }
5384     }
5385 
5386     res = mCurrentStream->prepareNextBuffer();
5387     if (res == NOT_ENOUGH_DATA) return true;
5388     if (res != OK) {
5389         // Something bad happened; try to recover by cancelling prepare and
5390         // signalling listener anyway
5391         ALOGE("%s: Stream %d returned error %d (%s) during prepare", __FUNCTION__,
5392                 mCurrentStream->getId(), res, strerror(-res));
5393         mCurrentStream->cancelPrepare();
5394     }
5395 
5396     // This stream has finished, notify listener
5397     Mutex::Autolock l(mLock);
5398     sp<NotificationListener> listener = mListener.promote();
5399     if (listener != NULL) {
5400         ALOGV("%s: Stream %d prepare done, signaling listener", __FUNCTION__,
5401                 mCurrentStream->getId());
5402         listener->notifyPrepared(mCurrentStream->getId());
5403     }
5404 
5405     ATRACE_ASYNC_END("stream prepare", mCurrentStream->getId());
5406     mCurrentStream.clear();
5407     mCurrentPrepareComplete = true;
5408 
5409     return true;
5410 }
5411 
initialize(sp<camera3::StatusTracker> statusTracker)5412 status_t Camera3Device::RequestBufferStateMachine::initialize(
5413         sp<camera3::StatusTracker> statusTracker) {
5414     if (statusTracker == nullptr) {
5415         ALOGE("%s: statusTracker is null", __FUNCTION__);
5416         return BAD_VALUE;
5417     }
5418 
5419     std::lock_guard<std::mutex> lock(mLock);
5420     mStatusTracker = statusTracker;
5421     mRequestBufferStatusId = statusTracker->addComponent("BufferRequestSM");
5422     return OK;
5423 }
5424 
deInit()5425 status_t Camera3Device::RequestBufferStateMachine::deInit() {
5426     std::lock_guard<std::mutex> lock(mLock);
5427     sp<StatusTracker> statusTracker = mStatusTracker.promote();
5428     if (statusTracker == nullptr) {
5429         ALOGE("%s: statusTracker is null", __FUNCTION__);
5430         return INVALID_OPERATION;
5431     }
5432     if (mRequestBufferStatusId == StatusTracker::NO_STATUS_ID) {
5433         ALOGE("%s: RequestBufferStateMachine not initialized", __FUNCTION__);
5434         return INVALID_OPERATION;
5435     }
5436     statusTracker->removeComponent(mRequestBufferStatusId);
5437     // Bring back to de-initialized state
5438     mRequestBufferStatusId = StatusTracker::NO_STATUS_ID;
5439     mRequestThreadPaused = true;
5440     mInflightMapEmpty = true;
5441     mRequestBufferOngoing = false;
5442     mSwitchedToOffline = false;
5443     return OK;
5444 }
5445 
startRequestBuffer()5446 bool Camera3Device::RequestBufferStateMachine::startRequestBuffer() {
5447     std::lock_guard<std::mutex> lock(mLock);
5448     if (mStatus == RB_STATUS_READY || mStatus == RB_STATUS_PENDING_STOP) {
5449         mRequestBufferOngoing = true;
5450         notifyTrackerLocked(/*active*/true);
5451         return true;
5452     }
5453     return false;
5454 }
5455 
endRequestBuffer()5456 void Camera3Device::RequestBufferStateMachine::endRequestBuffer() {
5457     std::lock_guard<std::mutex> lock(mLock);
5458     if (!mRequestBufferOngoing) {
5459         ALOGE("%s called without a successful startRequestBuffer call first!", __FUNCTION__);
5460         return;
5461     }
5462     mRequestBufferOngoing = false;
5463     if (mStatus == RB_STATUS_PENDING_STOP) {
5464         checkSwitchToStopLocked();
5465     }
5466     notifyTrackerLocked(/*active*/false);
5467 }
5468 
onStreamsConfigured()5469 void Camera3Device::RequestBufferStateMachine::onStreamsConfigured() {
5470     std::lock_guard<std::mutex> lock(mLock);
5471     mSwitchedToOffline = false;
5472     mStatus = RB_STATUS_READY;
5473     return;
5474 }
5475 
onSubmittingRequest()5476 void Camera3Device::RequestBufferStateMachine::onSubmittingRequest() {
5477     std::lock_guard<std::mutex> lock(mLock);
5478     mRequestThreadPaused = false;
5479     // inflight map register actually happens in prepareHalRequest now, but it is close enough
5480     // approximation.
5481     mInflightMapEmpty = false;
5482     if (mStatus == RB_STATUS_STOPPED) {
5483         mStatus = RB_STATUS_READY;
5484     }
5485     return;
5486 }
5487 
onRequestThreadPaused()5488 void Camera3Device::RequestBufferStateMachine::onRequestThreadPaused() {
5489     std::lock_guard<std::mutex> lock(mLock);
5490     mRequestThreadPaused = true;
5491     if (mStatus == RB_STATUS_PENDING_STOP) {
5492         checkSwitchToStopLocked();
5493     }
5494     return;
5495 }
5496 
onInflightMapEmpty()5497 void Camera3Device::RequestBufferStateMachine::onInflightMapEmpty() {
5498     std::lock_guard<std::mutex> lock(mLock);
5499     mInflightMapEmpty = true;
5500     if (mStatus == RB_STATUS_PENDING_STOP) {
5501         checkSwitchToStopLocked();
5502     }
5503     return;
5504 }
5505 
onWaitUntilIdle()5506 void Camera3Device::RequestBufferStateMachine::onWaitUntilIdle() {
5507     std::lock_guard<std::mutex> lock(mLock);
5508     if (!checkSwitchToStopLocked()) {
5509         mStatus = RB_STATUS_PENDING_STOP;
5510     }
5511     return;
5512 }
5513 
onSwitchToOfflineSuccess()5514 bool Camera3Device::RequestBufferStateMachine::onSwitchToOfflineSuccess() {
5515     std::lock_guard<std::mutex> lock(mLock);
5516     if (mRequestBufferOngoing) {
5517         ALOGE("%s: HAL must not be requesting buffer after HAL returns switchToOffline!",
5518                 __FUNCTION__);
5519         return false;
5520     }
5521     mSwitchedToOffline = true;
5522     mInflightMapEmpty = true;
5523     mRequestThreadPaused = true;
5524     mStatus = RB_STATUS_STOPPED;
5525     return true;
5526 }
5527 
notifyTrackerLocked(bool active)5528 void Camera3Device::RequestBufferStateMachine::notifyTrackerLocked(bool active) {
5529     sp<StatusTracker> statusTracker = mStatusTracker.promote();
5530     if (statusTracker != nullptr) {
5531         if (active) {
5532             statusTracker->markComponentActive(mRequestBufferStatusId);
5533         } else {
5534             statusTracker->markComponentIdle(mRequestBufferStatusId, Fence::NO_FENCE);
5535         }
5536     }
5537 }
5538 
checkSwitchToStopLocked()5539 bool Camera3Device::RequestBufferStateMachine::checkSwitchToStopLocked() {
5540     if (mInflightMapEmpty && mRequestThreadPaused && !mRequestBufferOngoing) {
5541         mStatus = RB_STATUS_STOPPED;
5542         return true;
5543     }
5544     return false;
5545 }
5546 
startRequestBuffer()5547 bool Camera3Device::startRequestBuffer() {
5548     return mRequestBufferSM.startRequestBuffer();
5549 }
5550 
endRequestBuffer()5551 void Camera3Device::endRequestBuffer() {
5552     mRequestBufferSM.endRequestBuffer();
5553 }
5554 
getWaitDuration()5555 nsecs_t Camera3Device::getWaitDuration() {
5556     return kBaseGetBufferWait + getExpectedInFlightDuration();
5557 }
5558 
getInflightBufferKeys(std::vector<std::pair<int32_t,int32_t>> * out)5559 void Camera3Device::getInflightBufferKeys(std::vector<std::pair<int32_t, int32_t>>* out) {
5560     mInterface->getInflightBufferKeys(out);
5561 }
5562 
getInflightRequestBufferKeys(std::vector<uint64_t> * out)5563 void Camera3Device::getInflightRequestBufferKeys(std::vector<uint64_t>* out) {
5564     mInterface->getInflightRequestBufferKeys(out);
5565 }
5566 
getAllStreams()5567 std::vector<sp<Camera3StreamInterface>> Camera3Device::getAllStreams() {
5568     std::vector<sp<Camera3StreamInterface>> ret;
5569     bool hasInputStream = mInputStream != nullptr;
5570     ret.reserve(mOutputStreams.size() + mDeletedStreams.size() + ((hasInputStream) ? 1 : 0));
5571     if (hasInputStream) {
5572         ret.push_back(mInputStream);
5573     }
5574     for (size_t i = 0; i < mOutputStreams.size(); i++) {
5575         ret.push_back(mOutputStreams[i]);
5576     }
5577     for (size_t i = 0; i < mDeletedStreams.size(); i++) {
5578         ret.push_back(mDeletedStreams[i]);
5579     }
5580     return ret;
5581 }
5582 
getOfflineStreamIds(std::vector<int> * offlineStreamIds)5583 void Camera3Device::getOfflineStreamIds(std::vector<int> *offlineStreamIds) {
5584     ATRACE_CALL();
5585 
5586     if (offlineStreamIds == nullptr) {
5587         return;
5588     }
5589 
5590     Mutex::Autolock il(mInterfaceLock);
5591 
5592     auto streamIds = mOutputStreams.getStreamIds();
5593     bool hasInputStream = mInputStream != nullptr;
5594     if (hasInputStream && mInputStream->getOfflineProcessingSupport()) {
5595         offlineStreamIds->push_back(mInputStream->getId());
5596     }
5597 
5598     for (const auto & streamId : streamIds) {
5599         sp<camera3::Camera3OutputStreamInterface> stream = mOutputStreams.get(streamId);
5600         // Streams that use the camera buffer manager are currently not supported in
5601         // offline mode
5602         if (stream->getOfflineProcessingSupport() &&
5603                 (stream->getStreamSetId() == CAMERA3_STREAM_SET_ID_INVALID)) {
5604             offlineStreamIds->push_back(streamId);
5605         }
5606     }
5607 }
5608 
setRotateAndCropAutoBehavior(camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropValue,bool fromHal)5609 status_t Camera3Device::setRotateAndCropAutoBehavior(
5610     camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropValue, bool fromHal) {
5611     ATRACE_CALL();
5612     // We shouldn't hold mInterfaceLock when called as an effect of a HAL
5613     // callback since this can lead to a deadlock : b/299348355.
5614     // mLock still protects state.
5615     std::optional<Mutex::Autolock> maybeMutex =
5616         fromHal ? std::nullopt : std::optional<Mutex::Autolock>(mInterfaceLock);
5617     Mutex::Autolock l(mLock);
5618     if (mRequestThread == nullptr) {
5619         return INVALID_OPERATION;
5620     }
5621     if (rotateAndCropValue == ANDROID_SCALER_ROTATE_AND_CROP_AUTO) {
5622         return BAD_VALUE;
5623     }
5624     mRotateAndCropOverride = rotateAndCropValue;
5625     return mRequestThread->setRotateAndCropAutoBehavior(rotateAndCropValue);
5626 }
5627 
setAutoframingAutoBehavior(camera_metadata_enum_android_control_autoframing_t autoframingValue)5628 status_t Camera3Device::setAutoframingAutoBehavior(
5629     camera_metadata_enum_android_control_autoframing_t autoframingValue) {
5630     ATRACE_CALL();
5631     Mutex::Autolock il(mInterfaceLock);
5632     Mutex::Autolock l(mLock);
5633     if (mRequestThread == nullptr) {
5634         return INVALID_OPERATION;
5635     }
5636     if (autoframingValue == ANDROID_CONTROL_AUTOFRAMING_AUTO) {
5637         return BAD_VALUE;
5638     }
5639     mAutoframingOverride = autoframingValue;
5640     return mRequestThread->setAutoframingAutoBehaviour(autoframingValue);
5641 }
5642 
supportsCameraMute()5643 bool Camera3Device::supportsCameraMute() {
5644     Mutex::Autolock il(mInterfaceLock);
5645     Mutex::Autolock l(mLock);
5646 
5647     return mSupportCameraMute;
5648 }
5649 
setCameraMute(bool enabled)5650 status_t Camera3Device::setCameraMute(bool enabled) {
5651     ATRACE_CALL();
5652     Mutex::Autolock il(mInterfaceLock);
5653     Mutex::Autolock l(mLock);
5654     return setCameraMuteLocked(enabled);
5655 }
5656 
setCameraMuteLocked(bool enabled)5657 status_t Camera3Device::setCameraMuteLocked(bool enabled) {
5658     if (mRequestThread == nullptr) {
5659         mCameraMuteInitial = enabled;
5660         return OK;
5661     }
5662 
5663     if (!mSupportCameraMute) {
5664         return INVALID_OPERATION;
5665     }
5666 
5667     int32_t muteMode =
5668             !enabled                      ? ANDROID_SENSOR_TEST_PATTERN_MODE_OFF :
5669             mSupportTestPatternSolidColor ? ANDROID_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR :
5670                                             ANDROID_SENSOR_TEST_PATTERN_MODE_BLACK;
5671     return mRequestThread->setCameraMute(muteMode);
5672 }
5673 
supportsZoomOverride()5674 bool Camera3Device::supportsZoomOverride() {
5675     Mutex::Autolock il(mInterfaceLock);
5676     Mutex::Autolock l(mLock);
5677 
5678     return mSupportZoomOverride;
5679 }
5680 
setZoomOverride(int32_t zoomOverride)5681 status_t Camera3Device::setZoomOverride(int32_t zoomOverride) {
5682     ATRACE_CALL();
5683     Mutex::Autolock il(mInterfaceLock);
5684     Mutex::Autolock l(mLock);
5685 
5686     if (mRequestThread == nullptr || !mSupportZoomOverride) {
5687         return INVALID_OPERATION;
5688     }
5689 
5690     return mRequestThread->setZoomOverride(zoomOverride);
5691 }
5692 
injectCamera(const std::string & injectedCamId,sp<CameraProviderManager> manager)5693 status_t Camera3Device::injectCamera(const std::string& injectedCamId,
5694                                      sp<CameraProviderManager> manager) {
5695     ALOGI("%s Injection camera: injectedCamId = %s", __FUNCTION__, injectedCamId.c_str());
5696     ATRACE_CALL();
5697     Mutex::Autolock il(mInterfaceLock);
5698     // When the camera device is active, injectCamera() and stopInjection() will call
5699     // internalPauseAndWaitLocked() and internalResumeLocked(), and then they will call
5700     // mStatusChanged.waitRelative(mLock, timeout) of waitUntilStateThenRelock(). But
5701     // mStatusChanged.waitRelative(mLock, timeout)'s parameter: mutex "mLock" must be in the locked
5702     // state, so we need to add "Mutex::Autolock l(mLock)" to lock the "mLock" before calling
5703     // waitUntilStateThenRelock().
5704     Mutex::Autolock l(mLock);
5705 
5706     status_t res = NO_ERROR;
5707     if (mInjectionMethods->isInjecting()) {
5708         if (injectedCamId == mInjectionMethods->getInjectedCamId()) {
5709             return OK;
5710         } else {
5711             res = mInjectionMethods->stopInjection();
5712             if (res != OK) {
5713                 ALOGE("%s: Failed to stop the injection camera! ret != NO_ERROR: %d",
5714                         __FUNCTION__, res);
5715                 return res;
5716             }
5717         }
5718     }
5719 
5720     res = injectionCameraInitialize(injectedCamId, manager);
5721     if (res != OK) {
5722         ALOGE("%s: Failed to initialize the injection camera! ret != NO_ERROR: %d",
5723                 __FUNCTION__, res);
5724         return res;
5725     }
5726 
5727     // When the second display of android is cast to the remote device, and the opened camera is
5728     // also cast to the second display, in this case, because the camera has configured the streams
5729     // at this time, we can directly call injectCamera() to replace the internal camera with
5730     // injection camera.
5731     if (mInjectionMethods->isStreamConfigCompleteButNotInjected()) {
5732         ALOGD("%s: The opened camera is directly cast to the remote device.", __FUNCTION__);
5733 
5734         camera3::camera_stream_configuration injectionConfig;
5735         std::vector<uint32_t> injectionBufferSizes;
5736         mInjectionMethods->getInjectionConfig(&injectionConfig, &injectionBufferSizes);
5737         if (mOperatingMode < 0 || injectionConfig.num_streams <= 0
5738                     || injectionBufferSizes.size() <= 0) {
5739             ALOGE("Failed to inject camera due to abandoned configuration! "
5740                     "mOperatingMode: %d injectionConfig.num_streams: %d "
5741                     "injectionBufferSizes.size(): %zu", mOperatingMode,
5742                     injectionConfig.num_streams, injectionBufferSizes.size());
5743             return DEAD_OBJECT;
5744         }
5745 
5746         res = mInjectionMethods->injectCamera(
5747                 injectionConfig, injectionBufferSizes);
5748         if (res != OK) {
5749             ALOGE("Can't finish inject camera process!");
5750             return res;
5751         }
5752     }
5753 
5754     return OK;
5755 }
5756 
stopInjection()5757 status_t Camera3Device::stopInjection() {
5758     ALOGI("%s: Injection camera: stopInjection", __FUNCTION__);
5759     Mutex::Autolock il(mInterfaceLock);
5760     Mutex::Autolock l(mLock);
5761     return mInjectionMethods->stopInjection();
5762 }
5763 
overrideStreamUseCaseLocked()5764 void Camera3Device::overrideStreamUseCaseLocked() {
5765     if (mStreamUseCaseOverrides.size() == 0) {
5766         return;
5767     }
5768 
5769     // Start from an array of indexes in mStreamUseCaseOverrides, and sort them
5770     // based first on size, and second on formats of [JPEG, RAW, YUV, PRIV].
5771     // Refer to CameraService::printHelp for details.
5772     std::vector<int> outputStreamsIndices(mOutputStreams.size());
5773     for (size_t i = 0; i < outputStreamsIndices.size(); i++) {
5774         outputStreamsIndices[i] = i;
5775     }
5776 
5777     std::sort(outputStreamsIndices.begin(), outputStreamsIndices.end(),
5778             [&](int a, int b) -> bool {
5779 
5780                 auto formatScore = [](int format) {
5781                     switch (format) {
5782                     case HAL_PIXEL_FORMAT_BLOB:
5783                         return 4;
5784                     case HAL_PIXEL_FORMAT_RAW16:
5785                     case HAL_PIXEL_FORMAT_RAW10:
5786                     case HAL_PIXEL_FORMAT_RAW12:
5787                         return 3;
5788                     case HAL_PIXEL_FORMAT_YCBCR_420_888:
5789                         return 2;
5790                     case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
5791                         return 1;
5792                     default:
5793                         return 0;
5794                     }
5795                 };
5796 
5797                 int sizeA = mOutputStreams[a]->getWidth() * mOutputStreams[a]->getHeight();
5798                 int sizeB = mOutputStreams[a]->getWidth() * mOutputStreams[a]->getHeight();
5799                 int formatAScore = formatScore(mOutputStreams[a]->getFormat());
5800                 int formatBScore = formatScore(mOutputStreams[b]->getFormat());
5801                 if (sizeA > sizeB ||
5802                         (sizeA == sizeB && formatAScore >= formatBScore)) {
5803                     return true;
5804                 } else {
5805                     return false;
5806                 }
5807             });
5808 
5809     size_t overlapSize = std::min(mStreamUseCaseOverrides.size(), mOutputStreams.size());
5810     for (size_t i = 0; i < mOutputStreams.size(); i++) {
5811         mOutputStreams[outputStreamsIndices[i]]->setStreamUseCase(
5812                 mStreamUseCaseOverrides[std::min(i, overlapSize-1)]);
5813     }
5814 }
5815 
deriveAndSetTransformLocked(Camera3OutputStreamInterface & stream,int mirrorMode,int surfaceId)5816 status_t Camera3Device::deriveAndSetTransformLocked(
5817         Camera3OutputStreamInterface& stream, int mirrorMode, int surfaceId) {
5818     int transform = -1;
5819     bool enableTransformInverseDisplay = true;
5820     using hardware::ICameraService::ROTATION_OVERRIDE_ROTATION_ONLY;
5821     if (wm_flags::enable_camera_compat_for_desktop_windowing()) {
5822         enableTransformInverseDisplay = (mRotationOverride != ROTATION_OVERRIDE_ROTATION_ONLY);
5823     }
5824     int res = CameraUtils::getRotationTransform(mDeviceInfo, mirrorMode,
5825             enableTransformInverseDisplay, &transform);
5826     if (res != OK) {
5827         return res;
5828     }
5829     stream.setTransform(transform, false /*mayChangeMirror*/, surfaceId);
5830     return OK;
5831 }
5832 
5833 }; // namespace android
5834