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