Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1 | /* |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 2 | * Copyright (C) 2013-2018 The Android Open Source Project |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 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 | |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 28 | // Convenience macro for transient errors |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 29 | #define CLOGE(fmt, ...) ALOGE("Camera %s: %s: " fmt, mId.string(), __FUNCTION__, \ |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 30 | ##__VA_ARGS__) |
| 31 | |
| 32 | // Convenience macros for transitioning to the error state |
| 33 | #define SET_ERR(fmt, ...) setErrorState( \ |
| 34 | "%s: " fmt, __FUNCTION__, \ |
| 35 | ##__VA_ARGS__) |
| 36 | #define SET_ERR_L(fmt, ...) setErrorStateLocked( \ |
| 37 | "%s: " fmt, __FUNCTION__, \ |
| 38 | ##__VA_ARGS__) |
| 39 | |
Colin Cross | e5729fa | 2014-03-21 15:04:25 -0700 | [diff] [blame] | 40 | #include <inttypes.h> |
| 41 | |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 42 | #include <utility> |
| 43 | |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 44 | #include <utils/Log.h> |
| 45 | #include <utils/Trace.h> |
| 46 | #include <utils/Timers.h> |
Zhijun He | 90f7c37 | 2016-08-16 16:19:43 -0700 | [diff] [blame] | 47 | #include <cutils/properties.h> |
Eino-Ville Talvala | 7b82efe | 2013-07-25 17:12:35 -0700 | [diff] [blame] | 48 | |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 49 | #include <android/hardware/camera2/ICameraDeviceUser.h> |
| 50 | |
Igor Murashkin | ff3e31d | 2013-10-23 16:40:06 -0700 | [diff] [blame] | 51 | #include "utils/CameraTraces.h" |
Eino-Ville Talvala | f99498e | 2015-09-25 16:52:55 -0700 | [diff] [blame] | 52 | #include "mediautils/SchedulingPolicyService.h" |
Eino-Ville Talvala | 7b82efe | 2013-07-25 17:12:35 -0700 | [diff] [blame] | 53 | #include "device3/Camera3Device.h" |
| 54 | #include "device3/Camera3OutputStream.h" |
| 55 | #include "device3/Camera3InputStream.h" |
Eino-Ville Talvala | 16a2ada | 2014-08-27 14:41:33 -0700 | [diff] [blame] | 56 | #include "device3/Camera3DummyStream.h" |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 57 | #include "device3/Camera3SharedOutputStream.h" |
Eino-Ville Talvala | f67e23e | 2014-07-23 17:17:59 -0700 | [diff] [blame] | 58 | #include "CameraService.h" |
Jayant Chowdhary | 1236193 | 2018-08-27 14:46:13 -0700 | [diff] [blame] | 59 | #include "utils/CameraThreadState.h" |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 60 | |
| 61 | using namespace android::camera3; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 62 | using namespace android::hardware::camera; |
| 63 | using namespace android::hardware::camera::device::V3_2; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 64 | |
| 65 | namespace android { |
| 66 | |
Eino-Ville Talvala | 2f09bac | 2016-12-13 11:29:54 -0800 | [diff] [blame] | 67 | Camera3Device::Camera3Device(const String8 &id): |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 68 | mId(id), |
Eino-Ville Talvala | bbbbe84 | 2017-02-28 17:50:56 -0800 | [diff] [blame] | 69 | mOperatingMode(NO_MODE), |
Eino-Ville Talvala | 9a17941 | 2015-06-09 13:15:16 -0700 | [diff] [blame] | 70 | mIsConstrainedHighSpeedConfiguration(false), |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 71 | mStatus(STATUS_UNINITIALIZED), |
Ruben Brunk | 183f056 | 2015-08-12 12:55:02 -0700 | [diff] [blame] | 72 | mStatusWaiters(0), |
Zhijun He | 204e329 | 2014-07-14 17:09:23 -0700 | [diff] [blame] | 73 | mUsePartialResult(false), |
| 74 | mNumPartialResults(1), |
Shuzhen Wang | c28dccc | 2016-02-11 23:48:46 -0800 | [diff] [blame] | 75 | mTimestampOffset(0), |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 76 | mNextResultFrameNumber(0), |
Chien-Yu Chen | 618ff8a | 2015-03-13 11:27:17 -0700 | [diff] [blame] | 77 | mNextReprocessResultFrameNumber(0), |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 78 | mNextShutterFrameNumber(0), |
Chien-Yu Chen | 3df11ce | 2015-09-30 14:13:30 -0700 | [diff] [blame] | 79 | mNextReprocessShutterFrameNumber(0), |
Emilian Peev | 71c73a2 | 2017-03-21 16:35:51 +0000 | [diff] [blame] | 80 | mListener(NULL), |
Emilian Peev | 811d295 | 2018-05-25 11:08:40 +0100 | [diff] [blame] | 81 | mVendorTagId(CAMERA_METADATA_INVALID_VENDOR_ID), |
| 82 | mLastTemplateId(-1) |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 83 | { |
| 84 | ATRACE_CALL(); |
| 85 | camera3_callback_ops::notify = &sNotify; |
| 86 | camera3_callback_ops::process_capture_result = &sProcessCaptureResult; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 87 | ALOGV("%s: Created device for camera %s", __FUNCTION__, mId.string()); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 88 | } |
| 89 | |
| 90 | Camera3Device::~Camera3Device() |
| 91 | { |
| 92 | ATRACE_CALL(); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 93 | ALOGV("%s: Tearing down for camera id %s", __FUNCTION__, mId.string()); |
Yin-Chia Yeh | c524813 | 2018-08-15 12:19:20 -0700 | [diff] [blame] | 94 | disconnectImpl(); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 95 | } |
| 96 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 97 | const String8& Camera3Device::getId() const { |
Igor Murashkin | 7138105 | 2013-03-04 14:53:08 -0800 | [diff] [blame] | 98 | return mId; |
| 99 | } |
| 100 | |
Emilian Peev | bd8c503 | 2018-02-14 23:05:40 +0000 | [diff] [blame] | 101 | status_t Camera3Device::initialize(sp<CameraProviderManager> manager, const String8& monitorTags) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 102 | ATRACE_CALL(); |
| 103 | Mutex::Autolock il(mInterfaceLock); |
| 104 | Mutex::Autolock l(mLock); |
| 105 | |
| 106 | ALOGV("%s: Initializing HIDL device for camera %s", __FUNCTION__, mId.string()); |
| 107 | if (mStatus != STATUS_UNINITIALIZED) { |
| 108 | CLOGE("Already initialized!"); |
| 109 | return INVALID_OPERATION; |
| 110 | } |
| 111 | if (manager == nullptr) return INVALID_OPERATION; |
| 112 | |
| 113 | sp<ICameraDeviceSession> session; |
| 114 | ATRACE_BEGIN("CameraHal::openSession"); |
Steven Moreland | 5ff9c91 | 2017-03-09 23:13:00 -0800 | [diff] [blame] | 115 | status_t res = manager->openSession(mId.string(), this, |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 116 | /*out*/ &session); |
| 117 | ATRACE_END(); |
| 118 | if (res != OK) { |
| 119 | SET_ERR_L("Could not open camera session: %s (%d)", strerror(-res), res); |
| 120 | return res; |
| 121 | } |
| 122 | |
Steven Moreland | 5ff9c91 | 2017-03-09 23:13:00 -0800 | [diff] [blame] | 123 | res = manager->getCameraCharacteristics(mId.string(), &mDeviceInfo); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 124 | if (res != OK) { |
Shuzhen Wang | 2e7f58f | 2018-07-11 14:00:29 -0700 | [diff] [blame] | 125 | SET_ERR_L("Could not retrieve camera characteristics: %s (%d)", strerror(-res), res); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 126 | session->close(); |
| 127 | return res; |
| 128 | } |
Yin-Chia Yeh | 52778d4 | 2016-12-22 18:20:43 -0800 | [diff] [blame] | 129 | |
Shuzhen Wang | 2e7f58f | 2018-07-11 14:00:29 -0700 | [diff] [blame] | 130 | std::vector<std::string> physicalCameraIds; |
| 131 | bool isLogical = CameraProviderManager::isLogicalCamera(mDeviceInfo, &physicalCameraIds); |
| 132 | if (isLogical) { |
| 133 | for (auto& physicalId : physicalCameraIds) { |
| 134 | res = manager->getCameraCharacteristics(physicalId, &mPhysicalDeviceInfoMap[physicalId]); |
| 135 | if (res != OK) { |
| 136 | SET_ERR_L("Could not retrieve camera %s characteristics: %s (%d)", |
| 137 | physicalId.c_str(), strerror(-res), res); |
| 138 | session->close(); |
| 139 | return res; |
| 140 | } |
| 141 | } |
| 142 | } |
| 143 | |
Yifan Hong | f79b554 | 2017-04-11 14:44:25 -0700 | [diff] [blame] | 144 | std::shared_ptr<RequestMetadataQueue> queue; |
Yifan Hong | a640c5a | 2017-04-12 16:30:31 -0700 | [diff] [blame] | 145 | auto requestQueueRet = session->getCaptureRequestMetadataQueue( |
| 146 | [&queue](const auto& descriptor) { |
| 147 | queue = std::make_shared<RequestMetadataQueue>(descriptor); |
| 148 | if (!queue->isValid() || queue->availableToWrite() <= 0) { |
| 149 | ALOGE("HAL returns empty request metadata fmq, not use it"); |
| 150 | queue = nullptr; |
| 151 | // don't use the queue onwards. |
| 152 | } |
| 153 | }); |
| 154 | if (!requestQueueRet.isOk()) { |
| 155 | ALOGE("Transaction error when getting request metadata fmq: %s, not use it", |
| 156 | requestQueueRet.description().c_str()); |
Eino-Ville Talvala | c5cbb87 | 2017-04-27 12:48:33 -0700 | [diff] [blame] | 157 | return DEAD_OBJECT; |
Yifan Hong | f79b554 | 2017-04-11 14:44:25 -0700 | [diff] [blame] | 158 | } |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 159 | |
| 160 | std::unique_ptr<ResultMetadataQueue>& resQueue = mResultMetadataQueue; |
Yifan Hong | a640c5a | 2017-04-12 16:30:31 -0700 | [diff] [blame] | 161 | auto resultQueueRet = session->getCaptureResultMetadataQueue( |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 162 | [&resQueue](const auto& descriptor) { |
| 163 | resQueue = std::make_unique<ResultMetadataQueue>(descriptor); |
| 164 | if (!resQueue->isValid() || resQueue->availableToWrite() <= 0) { |
Yifan Hong | a640c5a | 2017-04-12 16:30:31 -0700 | [diff] [blame] | 165 | ALOGE("HAL returns empty result metadata fmq, not use it"); |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 166 | resQueue = nullptr; |
| 167 | // Don't use the resQueue onwards. |
Yifan Hong | a640c5a | 2017-04-12 16:30:31 -0700 | [diff] [blame] | 168 | } |
| 169 | }); |
| 170 | if (!resultQueueRet.isOk()) { |
| 171 | ALOGE("Transaction error when getting result metadata queue from camera session: %s", |
| 172 | resultQueueRet.description().c_str()); |
Eino-Ville Talvala | c5cbb87 | 2017-04-27 12:48:33 -0700 | [diff] [blame] | 173 | return DEAD_OBJECT; |
Yifan Hong | a640c5a | 2017-04-12 16:30:31 -0700 | [diff] [blame] | 174 | } |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 175 | IF_ALOGV() { |
| 176 | session->interfaceChain([]( |
| 177 | ::android::hardware::hidl_vec<::android::hardware::hidl_string> interfaceChain) { |
| 178 | ALOGV("Session interface chain:"); |
| 179 | for (auto iface : interfaceChain) { |
| 180 | ALOGV(" %s", iface.c_str()); |
| 181 | } |
| 182 | }); |
| 183 | } |
Yifan Hong | f79b554 | 2017-04-11 14:44:25 -0700 | [diff] [blame] | 184 | |
Yin-Chia Yeh | db1e864 | 2017-07-14 15:19:30 -0700 | [diff] [blame] | 185 | mInterface = new HalInterface(session, queue); |
Emilian Peev | 71c73a2 | 2017-03-21 16:35:51 +0000 | [diff] [blame] | 186 | std::string providerType; |
| 187 | mVendorTagId = manager->getProviderTagIdLocked(mId.string()); |
Emilian Peev | bd8c503 | 2018-02-14 23:05:40 +0000 | [diff] [blame] | 188 | mTagMonitor.initialize(mVendorTagId); |
| 189 | if (!monitorTags.isEmpty()) { |
| 190 | mTagMonitor.parseTagsToMonitor(String8(monitorTags)); |
| 191 | } |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 192 | |
| 193 | return initializeCommonLocked(); |
| 194 | } |
| 195 | |
| 196 | status_t Camera3Device::initializeCommonLocked() { |
| 197 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 198 | /** Start up status tracker thread */ |
| 199 | mStatusTracker = new StatusTracker(this); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 200 | status_t res = mStatusTracker->run(String8::format("C3Dev-%s-Status", mId.string()).string()); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 201 | if (res != OK) { |
| 202 | SET_ERR_L("Unable to start status tracking thread: %s (%d)", |
| 203 | strerror(-res), res); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 204 | mInterface->close(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 205 | mStatusTracker.clear(); |
| 206 | return res; |
| 207 | } |
| 208 | |
Eino-Ville Talvala | 24b366e | 2016-07-21 12:53:07 -0700 | [diff] [blame] | 209 | /** Register in-flight map to the status tracker */ |
| 210 | mInFlightStatusId = mStatusTracker->addComponent(); |
| 211 | |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 212 | /** Create buffer manager */ |
| 213 | mBufferManager = new Camera3BufferManager(); |
| 214 | |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 215 | Vector<int32_t> sessionParamKeys; |
| 216 | camera_metadata_entry_t sessionKeysEntry = mDeviceInfo.find( |
| 217 | ANDROID_REQUEST_AVAILABLE_SESSION_KEYS); |
| 218 | if (sessionKeysEntry.count > 0) { |
| 219 | sessionParamKeys.insertArrayAt(sessionKeysEntry.data.i32, 0, sessionKeysEntry.count); |
| 220 | } |
Chien-Yu Chen | ab5135b | 2015-06-30 11:20:58 -0700 | [diff] [blame] | 221 | /** Start up request queue thread */ |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 222 | mRequestThread = new RequestThread(this, mStatusTracker, mInterface, sessionParamKeys); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 223 | res = mRequestThread->run(String8::format("C3Dev-%s-ReqQueue", mId.string()).string()); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 224 | if (res != OK) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 225 | SET_ERR_L("Unable to start request queue thread: %s (%d)", |
| 226 | strerror(-res), res); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 227 | mInterface->close(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 228 | mRequestThread.clear(); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 229 | return res; |
| 230 | } |
| 231 | |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 232 | mPreparerThread = new PreparerThread(); |
| 233 | |
Ruben Brunk | 183f056 | 2015-08-12 12:55:02 -0700 | [diff] [blame] | 234 | internalUpdateStatusLocked(STATUS_UNCONFIGURED); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 235 | mNextStreamId = 0; |
Eino-Ville Talvala | 16a2ada | 2014-08-27 14:41:33 -0700 | [diff] [blame] | 236 | mDummyStreamId = NO_STREAM; |
Eino-Ville Talvala | ea26c77 | 2013-06-11 16:04:06 -0700 | [diff] [blame] | 237 | mNeedConfig = true; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 238 | mPauseStateNotify = false; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 239 | |
Shuzhen Wang | c28dccc | 2016-02-11 23:48:46 -0800 | [diff] [blame] | 240 | // Measure the clock domain offset between camera and video/hw_composer |
| 241 | camera_metadata_entry timestampSource = |
| 242 | mDeviceInfo.find(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE); |
| 243 | if (timestampSource.count > 0 && timestampSource.data.u8[0] == |
| 244 | ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME) { |
| 245 | mTimestampOffset = getMonoToBoottimeOffset(); |
| 246 | } |
| 247 | |
Eino-Ville Talvala | fd6ecdd | 2013-10-11 09:51:09 -0700 | [diff] [blame] | 248 | // Will the HAL be sending in early partial result metadata? |
Emilian Peev | 08dd245 | 2017-04-06 16:55:14 +0100 | [diff] [blame] | 249 | camera_metadata_entry partialResultsCount = |
| 250 | mDeviceInfo.find(ANDROID_REQUEST_PARTIAL_RESULT_COUNT); |
| 251 | if (partialResultsCount.count > 0) { |
| 252 | mNumPartialResults = partialResultsCount.data.i32[0]; |
| 253 | mUsePartialResult = (mNumPartialResults > 1); |
Eino-Ville Talvala | fd6ecdd | 2013-10-11 09:51:09 -0700 | [diff] [blame] | 254 | } |
| 255 | |
Chien-Yu Chen | 618ff8a | 2015-03-13 11:27:17 -0700 | [diff] [blame] | 256 | camera_metadata_entry configs = |
| 257 | mDeviceInfo.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS); |
| 258 | for (uint32_t i = 0; i < configs.count; i += 4) { |
| 259 | if (configs.data.i32[i] == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED && |
| 260 | configs.data.i32[i + 3] == |
| 261 | ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT) { |
| 262 | mSupportedOpaqueInputSizes.add(Size(configs.data.i32[i + 1], |
| 263 | configs.data.i32[i + 2])); |
| 264 | } |
| 265 | } |
| 266 | |
Eino-Ville Talvala | 7b8a1fd | 2018-05-22 15:30:35 -0700 | [diff] [blame] | 267 | if (DistortionMapper::isDistortionSupported(mDeviceInfo)) { |
| 268 | res = mDistortionMapper.setupStaticInfo(mDeviceInfo); |
| 269 | if (res != OK) { |
| 270 | SET_ERR_L("Unable to read necessary calibration fields for distortion correction"); |
| 271 | return res; |
| 272 | } |
| 273 | } |
| 274 | |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 275 | return OK; |
| 276 | } |
| 277 | |
| 278 | status_t Camera3Device::disconnect() { |
Yin-Chia Yeh | c524813 | 2018-08-15 12:19:20 -0700 | [diff] [blame] | 279 | return disconnectImpl(); |
| 280 | } |
| 281 | |
| 282 | status_t Camera3Device::disconnectImpl() { |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 283 | ATRACE_CALL(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 284 | Mutex::Autolock il(mInterfaceLock); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 285 | |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 286 | ALOGI("%s: E", __FUNCTION__); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 287 | |
Eino-Ville Talvala | 214a17f | 2013-06-13 12:20:02 -0700 | [diff] [blame] | 288 | status_t res = OK; |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 289 | std::vector<wp<Camera3StreamInterface>> streams; |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 290 | nsecs_t maxExpectedDuration = getExpectedInFlightDuration(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 291 | { |
| 292 | Mutex::Autolock l(mLock); |
| 293 | if (mStatus == STATUS_UNINITIALIZED) return res; |
| 294 | |
| 295 | if (mStatus == STATUS_ACTIVE || |
| 296 | (mStatus == STATUS_ERROR && mRequestThread != NULL)) { |
| 297 | res = mRequestThread->clearRepeatingRequests(); |
Eino-Ville Talvala | 214a17f | 2013-06-13 12:20:02 -0700 | [diff] [blame] | 298 | if (res != OK) { |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 299 | SET_ERR_L("Can't stop streaming"); |
Eino-Ville Talvala | 214a17f | 2013-06-13 12:20:02 -0700 | [diff] [blame] | 300 | // Continue to close device even in case of error |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 301 | } else { |
Eino-Ville Talvala | 10bd57e | 2017-06-23 16:22:44 -0700 | [diff] [blame] | 302 | res = waitUntilStateThenRelock(/*active*/ false, maxExpectedDuration); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 303 | if (res != OK) { |
Eino-Ville Talvala | 10bd57e | 2017-06-23 16:22:44 -0700 | [diff] [blame] | 304 | SET_ERR_L("Timeout waiting for HAL to drain (% " PRIi64 " ns)", |
| 305 | maxExpectedDuration); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 306 | // Continue to close device even in case of error |
| 307 | } |
Eino-Ville Talvala | 214a17f | 2013-06-13 12:20:02 -0700 | [diff] [blame] | 308 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 309 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 310 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 311 | if (mStatus == STATUS_ERROR) { |
| 312 | CLOGE("Shutting down in an error state"); |
Eino-Ville Talvala | 214a17f | 2013-06-13 12:20:02 -0700 | [diff] [blame] | 313 | } |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 314 | |
| 315 | if (mStatusTracker != NULL) { |
| 316 | mStatusTracker->requestExit(); |
| 317 | } |
| 318 | |
| 319 | if (mRequestThread != NULL) { |
| 320 | mRequestThread->requestExit(); |
| 321 | } |
| 322 | |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 323 | streams.reserve(mOutputStreams.size() + (mInputStream != nullptr ? 1 : 0)); |
| 324 | for (size_t i = 0; i < mOutputStreams.size(); i++) { |
| 325 | streams.push_back(mOutputStreams[i]); |
| 326 | } |
| 327 | if (mInputStream != nullptr) { |
| 328 | streams.push_back(mInputStream); |
| 329 | } |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 330 | } |
| 331 | |
| 332 | // Joining done without holding mLock, otherwise deadlocks may ensue |
| 333 | // as the threads try to access parent state |
| 334 | if (mRequestThread != NULL && mStatus != STATUS_ERROR) { |
| 335 | // HAL may be in a bad state, so waiting for request thread |
| 336 | // (which may be stuck in the HAL processCaptureRequest call) |
| 337 | // could be dangerous. |
| 338 | mRequestThread->join(); |
| 339 | } |
| 340 | |
| 341 | if (mStatusTracker != NULL) { |
| 342 | mStatusTracker->join(); |
| 343 | } |
| 344 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 345 | HalInterface* interface; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 346 | { |
| 347 | Mutex::Autolock l(mLock); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 348 | mRequestThread.clear(); |
Emilian Peev | 2843c36 | 2018-09-26 08:49:40 +0100 | [diff] [blame] | 349 | Mutex::Autolock stLock(mTrackerLock); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 350 | mStatusTracker.clear(); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 351 | interface = mInterface.get(); |
Eino-Ville Talvala | efff1c4 | 2015-08-28 16:27:27 -0700 | [diff] [blame] | 352 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 353 | |
Eino-Ville Talvala | efff1c4 | 2015-08-28 16:27:27 -0700 | [diff] [blame] | 354 | // Call close without internal mutex held, as the HAL close may need to |
| 355 | // wait on assorted callbacks,etc, to complete before it can return. |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 356 | interface->close(); |
Eino-Ville Talvala | efff1c4 | 2015-08-28 16:27:27 -0700 | [diff] [blame] | 357 | |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 358 | flushInflightRequests(); |
| 359 | |
Eino-Ville Talvala | efff1c4 | 2015-08-28 16:27:27 -0700 | [diff] [blame] | 360 | { |
| 361 | Mutex::Autolock l(mLock); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 362 | mInterface->clear(); |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 363 | mOutputStreams.clear(); |
| 364 | mInputStream.clear(); |
Yin-Chia Yeh | 5090c73 | 2017-07-20 16:05:29 -0700 | [diff] [blame] | 365 | mDeletedStreams.clear(); |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 366 | mBufferManager.clear(); |
Ruben Brunk | 183f056 | 2015-08-12 12:55:02 -0700 | [diff] [blame] | 367 | internalUpdateStatusLocked(STATUS_UNINITIALIZED); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 368 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 369 | |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 370 | for (auto& weakStream : streams) { |
| 371 | sp<Camera3StreamInterface> stream = weakStream.promote(); |
| 372 | if (stream != nullptr) { |
| 373 | ALOGE("%s: Stream %d leaked! strong reference (%d)!", |
| 374 | __FUNCTION__, stream->getId(), stream->getStrongCount() - 1); |
| 375 | } |
| 376 | } |
| 377 | |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 378 | ALOGI("%s: X", __FUNCTION__); |
Eino-Ville Talvala | 214a17f | 2013-06-13 12:20:02 -0700 | [diff] [blame] | 379 | return res; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 380 | } |
| 381 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 382 | // For dumping/debugging only - |
| 383 | // try to acquire a lock a few times, eventually give up to proceed with |
| 384 | // debug/dump operations |
| 385 | bool Camera3Device::tryLockSpinRightRound(Mutex& lock) { |
| 386 | bool gotLock = false; |
| 387 | for (size_t i = 0; i < kDumpLockAttempts; ++i) { |
| 388 | if (lock.tryLock() == NO_ERROR) { |
| 389 | gotLock = true; |
| 390 | break; |
| 391 | } else { |
| 392 | usleep(kDumpSleepDuration); |
| 393 | } |
| 394 | } |
| 395 | return gotLock; |
| 396 | } |
| 397 | |
Yin-Chia Yeh | cd8fce8 | 2014-06-18 10:51:34 -0700 | [diff] [blame] | 398 | Camera3Device::Size Camera3Device::getMaxJpegResolution() const { |
| 399 | int32_t maxJpegWidth = 0, maxJpegHeight = 0; |
Emilian Peev | 08dd245 | 2017-04-06 16:55:14 +0100 | [diff] [blame] | 400 | const int STREAM_CONFIGURATION_SIZE = 4; |
| 401 | const int STREAM_FORMAT_OFFSET = 0; |
| 402 | const int STREAM_WIDTH_OFFSET = 1; |
| 403 | const int STREAM_HEIGHT_OFFSET = 2; |
| 404 | const int STREAM_IS_INPUT_OFFSET = 3; |
| 405 | camera_metadata_ro_entry_t availableStreamConfigs = |
| 406 | mDeviceInfo.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS); |
| 407 | if (availableStreamConfigs.count == 0 || |
| 408 | availableStreamConfigs.count % STREAM_CONFIGURATION_SIZE != 0) { |
| 409 | return Size(0, 0); |
| 410 | } |
Yin-Chia Yeh | cd8fce8 | 2014-06-18 10:51:34 -0700 | [diff] [blame] | 411 | |
Emilian Peev | 08dd245 | 2017-04-06 16:55:14 +0100 | [diff] [blame] | 412 | // Get max jpeg size (area-wise). |
| 413 | for (size_t i=0; i < availableStreamConfigs.count; i+= STREAM_CONFIGURATION_SIZE) { |
| 414 | int32_t format = availableStreamConfigs.data.i32[i + STREAM_FORMAT_OFFSET]; |
| 415 | int32_t width = availableStreamConfigs.data.i32[i + STREAM_WIDTH_OFFSET]; |
| 416 | int32_t height = availableStreamConfigs.data.i32[i + STREAM_HEIGHT_OFFSET]; |
| 417 | int32_t isInput = availableStreamConfigs.data.i32[i + STREAM_IS_INPUT_OFFSET]; |
| 418 | if (isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT |
| 419 | && format == HAL_PIXEL_FORMAT_BLOB && |
| 420 | (width * height > maxJpegWidth * maxJpegHeight)) { |
| 421 | maxJpegWidth = width; |
| 422 | maxJpegHeight = height; |
Yin-Chia Yeh | cd8fce8 | 2014-06-18 10:51:34 -0700 | [diff] [blame] | 423 | } |
| 424 | } |
Emilian Peev | 08dd245 | 2017-04-06 16:55:14 +0100 | [diff] [blame] | 425 | |
Yin-Chia Yeh | cd8fce8 | 2014-06-18 10:51:34 -0700 | [diff] [blame] | 426 | return Size(maxJpegWidth, maxJpegHeight); |
| 427 | } |
| 428 | |
Shuzhen Wang | c28dccc | 2016-02-11 23:48:46 -0800 | [diff] [blame] | 429 | nsecs_t Camera3Device::getMonoToBoottimeOffset() { |
| 430 | // try three times to get the clock offset, choose the one |
| 431 | // with the minimum gap in measurements. |
| 432 | const int tries = 3; |
| 433 | nsecs_t bestGap, measured; |
| 434 | for (int i = 0; i < tries; ++i) { |
| 435 | const nsecs_t tmono = systemTime(SYSTEM_TIME_MONOTONIC); |
| 436 | const nsecs_t tbase = systemTime(SYSTEM_TIME_BOOTTIME); |
| 437 | const nsecs_t tmono2 = systemTime(SYSTEM_TIME_MONOTONIC); |
| 438 | const nsecs_t gap = tmono2 - tmono; |
| 439 | if (i == 0 || gap < bestGap) { |
| 440 | bestGap = gap; |
| 441 | measured = tbase - ((tmono + tmono2) >> 1); |
| 442 | } |
| 443 | } |
| 444 | return measured; |
| 445 | } |
| 446 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 447 | hardware::graphics::common::V1_0::PixelFormat Camera3Device::mapToPixelFormat( |
| 448 | int frameworkFormat) { |
| 449 | return (hardware::graphics::common::V1_0::PixelFormat) frameworkFormat; |
| 450 | } |
| 451 | |
| 452 | DataspaceFlags Camera3Device::mapToHidlDataspace( |
| 453 | android_dataspace dataSpace) { |
| 454 | return dataSpace; |
| 455 | } |
| 456 | |
Chia-I Wu | 67a0c0e | 2017-04-06 13:37:01 -0700 | [diff] [blame] | 457 | BufferUsageFlags Camera3Device::mapToConsumerUsage( |
Emilian Peev | 050f5dc | 2017-05-18 14:43:56 +0100 | [diff] [blame] | 458 | uint64_t usage) { |
Yin-Chia Yeh | 47cf8e6 | 2017-04-04 13:00:03 -0700 | [diff] [blame] | 459 | return usage; |
| 460 | } |
| 461 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 462 | StreamRotation Camera3Device::mapToStreamRotation(camera3_stream_rotation_t rotation) { |
| 463 | switch (rotation) { |
| 464 | case CAMERA3_STREAM_ROTATION_0: |
| 465 | return StreamRotation::ROTATION_0; |
| 466 | case CAMERA3_STREAM_ROTATION_90: |
| 467 | return StreamRotation::ROTATION_90; |
| 468 | case CAMERA3_STREAM_ROTATION_180: |
| 469 | return StreamRotation::ROTATION_180; |
| 470 | case CAMERA3_STREAM_ROTATION_270: |
| 471 | return StreamRotation::ROTATION_270; |
| 472 | } |
| 473 | ALOGE("%s: Unknown stream rotation %d", __FUNCTION__, rotation); |
| 474 | return StreamRotation::ROTATION_0; |
| 475 | } |
| 476 | |
Eino-Ville Talvala | bbbbe84 | 2017-02-28 17:50:56 -0800 | [diff] [blame] | 477 | status_t Camera3Device::mapToStreamConfigurationMode( |
| 478 | camera3_stream_configuration_mode_t operationMode, StreamConfigurationMode *mode) { |
| 479 | if (mode == nullptr) return BAD_VALUE; |
| 480 | if (operationMode < CAMERA3_VENDOR_STREAM_CONFIGURATION_MODE_START) { |
| 481 | switch(operationMode) { |
| 482 | case CAMERA3_STREAM_CONFIGURATION_NORMAL_MODE: |
| 483 | *mode = StreamConfigurationMode::NORMAL_MODE; |
| 484 | break; |
| 485 | case CAMERA3_STREAM_CONFIGURATION_CONSTRAINED_HIGH_SPEED_MODE: |
| 486 | *mode = StreamConfigurationMode::CONSTRAINED_HIGH_SPEED_MODE; |
| 487 | break; |
| 488 | default: |
| 489 | ALOGE("%s: Unknown stream configuration mode %d", __FUNCTION__, operationMode); |
| 490 | return BAD_VALUE; |
| 491 | } |
| 492 | } else { |
| 493 | *mode = static_cast<StreamConfigurationMode>(operationMode); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 494 | } |
Eino-Ville Talvala | bbbbe84 | 2017-02-28 17:50:56 -0800 | [diff] [blame] | 495 | return OK; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 496 | } |
| 497 | |
| 498 | camera3_buffer_status_t Camera3Device::mapHidlBufferStatus(BufferStatus status) { |
| 499 | switch (status) { |
| 500 | case BufferStatus::OK: return CAMERA3_BUFFER_STATUS_OK; |
| 501 | case BufferStatus::ERROR: return CAMERA3_BUFFER_STATUS_ERROR; |
| 502 | } |
| 503 | return CAMERA3_BUFFER_STATUS_ERROR; |
| 504 | } |
| 505 | |
| 506 | int Camera3Device::mapToFrameworkFormat( |
| 507 | hardware::graphics::common::V1_0::PixelFormat pixelFormat) { |
| 508 | return static_cast<uint32_t>(pixelFormat); |
| 509 | } |
| 510 | |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 511 | android_dataspace Camera3Device::mapToFrameworkDataspace( |
| 512 | DataspaceFlags dataSpace) { |
| 513 | return static_cast<android_dataspace>(dataSpace); |
| 514 | } |
| 515 | |
Emilian Peev | 050f5dc | 2017-05-18 14:43:56 +0100 | [diff] [blame] | 516 | uint64_t Camera3Device::mapConsumerToFrameworkUsage( |
Chia-I Wu | 67a0c0e | 2017-04-06 13:37:01 -0700 | [diff] [blame] | 517 | BufferUsageFlags usage) { |
Yin-Chia Yeh | 47cf8e6 | 2017-04-04 13:00:03 -0700 | [diff] [blame] | 518 | return usage; |
| 519 | } |
| 520 | |
Emilian Peev | 050f5dc | 2017-05-18 14:43:56 +0100 | [diff] [blame] | 521 | uint64_t Camera3Device::mapProducerToFrameworkUsage( |
Chia-I Wu | 67a0c0e | 2017-04-06 13:37:01 -0700 | [diff] [blame] | 522 | BufferUsageFlags usage) { |
Yin-Chia Yeh | 47cf8e6 | 2017-04-04 13:00:03 -0700 | [diff] [blame] | 523 | return usage; |
| 524 | } |
| 525 | |
Zhijun He | f7da096 | 2014-04-24 13:27:56 -0700 | [diff] [blame] | 526 | ssize_t Camera3Device::getJpegBufferSize(uint32_t width, uint32_t height) const { |
Yin-Chia Yeh | cd8fce8 | 2014-06-18 10:51:34 -0700 | [diff] [blame] | 527 | // Get max jpeg size (area-wise). |
| 528 | Size maxJpegResolution = getMaxJpegResolution(); |
| 529 | if (maxJpegResolution.width == 0) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 530 | ALOGE("%s: Camera %s: Can't find valid available jpeg sizes in static metadata!", |
| 531 | __FUNCTION__, mId.string()); |
Zhijun He | f7da096 | 2014-04-24 13:27:56 -0700 | [diff] [blame] | 532 | return BAD_VALUE; |
| 533 | } |
| 534 | |
Zhijun He | f7da096 | 2014-04-24 13:27:56 -0700 | [diff] [blame] | 535 | // Get max jpeg buffer size |
| 536 | ssize_t maxJpegBufferSize = 0; |
Yin-Chia Yeh | cd8fce8 | 2014-06-18 10:51:34 -0700 | [diff] [blame] | 537 | camera_metadata_ro_entry jpegBufMaxSize = mDeviceInfo.find(ANDROID_JPEG_MAX_SIZE); |
| 538 | if (jpegBufMaxSize.count == 0) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 539 | ALOGE("%s: Camera %s: Can't find maximum JPEG size in static metadata!", __FUNCTION__, |
| 540 | mId.string()); |
Zhijun He | f7da096 | 2014-04-24 13:27:56 -0700 | [diff] [blame] | 541 | return BAD_VALUE; |
| 542 | } |
Yin-Chia Yeh | cd8fce8 | 2014-06-18 10:51:34 -0700 | [diff] [blame] | 543 | maxJpegBufferSize = jpegBufMaxSize.data.i32[0]; |
Yin-Chia Yeh | 0c4e56d | 2015-01-09 15:21:27 -0800 | [diff] [blame] | 544 | assert(kMinJpegBufferSize < maxJpegBufferSize); |
Zhijun He | f7da096 | 2014-04-24 13:27:56 -0700 | [diff] [blame] | 545 | |
| 546 | // Calculate final jpeg buffer size for the given resolution. |
Yin-Chia Yeh | cd8fce8 | 2014-06-18 10:51:34 -0700 | [diff] [blame] | 547 | float scaleFactor = ((float) (width * height)) / |
| 548 | (maxJpegResolution.width * maxJpegResolution.height); |
Yin-Chia Yeh | 0c4e56d | 2015-01-09 15:21:27 -0800 | [diff] [blame] | 549 | ssize_t jpegBufferSize = scaleFactor * (maxJpegBufferSize - kMinJpegBufferSize) + |
| 550 | kMinJpegBufferSize; |
Zhijun He | f7da096 | 2014-04-24 13:27:56 -0700 | [diff] [blame] | 551 | if (jpegBufferSize > maxJpegBufferSize) { |
| 552 | jpegBufferSize = maxJpegBufferSize; |
Zhijun He | f7da096 | 2014-04-24 13:27:56 -0700 | [diff] [blame] | 553 | } |
| 554 | |
| 555 | return jpegBufferSize; |
| 556 | } |
| 557 | |
Eino-Ville Talvala | 95a1d0f | 2015-08-11 15:08:53 -0700 | [diff] [blame] | 558 | ssize_t Camera3Device::getPointCloudBufferSize() const { |
| 559 | const int FLOATS_PER_POINT=4; |
| 560 | camera_metadata_ro_entry maxPointCount = mDeviceInfo.find(ANDROID_DEPTH_MAX_DEPTH_SAMPLES); |
| 561 | if (maxPointCount.count == 0) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 562 | ALOGE("%s: Camera %s: Can't find maximum depth point cloud size in static metadata!", |
| 563 | __FUNCTION__, mId.string()); |
Eino-Ville Talvala | 95a1d0f | 2015-08-11 15:08:53 -0700 | [diff] [blame] | 564 | return BAD_VALUE; |
| 565 | } |
| 566 | ssize_t maxBytesForPointCloud = sizeof(android_depth_points) + |
| 567 | maxPointCount.data.i32[0] * sizeof(float) * FLOATS_PER_POINT; |
| 568 | return maxBytesForPointCloud; |
| 569 | } |
| 570 | |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 571 | ssize_t Camera3Device::getRawOpaqueBufferSize(int32_t width, int32_t height) const { |
Yin-Chia Yeh | e9154ce | 2015-12-07 14:38:04 -0800 | [diff] [blame] | 572 | const int PER_CONFIGURATION_SIZE = 3; |
| 573 | const int WIDTH_OFFSET = 0; |
| 574 | const int HEIGHT_OFFSET = 1; |
| 575 | const int SIZE_OFFSET = 2; |
| 576 | camera_metadata_ro_entry rawOpaqueSizes = |
| 577 | mDeviceInfo.find(ANDROID_SENSOR_OPAQUE_RAW_SIZE); |
Aurimas Liutikas | bc57b12 | 2016-02-16 09:59:16 -0800 | [diff] [blame] | 578 | size_t count = rawOpaqueSizes.count; |
Yin-Chia Yeh | e9154ce | 2015-12-07 14:38:04 -0800 | [diff] [blame] | 579 | if (count == 0 || (count % PER_CONFIGURATION_SIZE)) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 580 | ALOGE("%s: Camera %s: bad opaque RAW size static metadata length(%zu)!", |
| 581 | __FUNCTION__, mId.string(), count); |
Yin-Chia Yeh | e9154ce | 2015-12-07 14:38:04 -0800 | [diff] [blame] | 582 | return BAD_VALUE; |
| 583 | } |
Eino-Ville Talvala | 95a1d0f | 2015-08-11 15:08:53 -0700 | [diff] [blame] | 584 | |
Yin-Chia Yeh | e9154ce | 2015-12-07 14:38:04 -0800 | [diff] [blame] | 585 | for (size_t i = 0; i < count; i += PER_CONFIGURATION_SIZE) { |
| 586 | if (width == rawOpaqueSizes.data.i32[i + WIDTH_OFFSET] && |
| 587 | height == rawOpaqueSizes.data.i32[i + HEIGHT_OFFSET]) { |
| 588 | return rawOpaqueSizes.data.i32[i + SIZE_OFFSET]; |
| 589 | } |
| 590 | } |
| 591 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 592 | ALOGE("%s: Camera %s: cannot find size for %dx%d opaque RAW image!", |
| 593 | __FUNCTION__, mId.string(), width, height); |
Yin-Chia Yeh | e9154ce | 2015-12-07 14:38:04 -0800 | [diff] [blame] | 594 | return BAD_VALUE; |
| 595 | } |
Eino-Ville Talvala | 95a1d0f | 2015-08-11 15:08:53 -0700 | [diff] [blame] | 596 | |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 597 | status_t Camera3Device::dump(int fd, const Vector<String16> &args) { |
| 598 | ATRACE_CALL(); |
| 599 | (void)args; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 600 | |
| 601 | // Try to lock, but continue in case of failure (to avoid blocking in |
| 602 | // deadlocks) |
| 603 | bool gotInterfaceLock = tryLockSpinRightRound(mInterfaceLock); |
| 604 | bool gotLock = tryLockSpinRightRound(mLock); |
| 605 | |
| 606 | ALOGW_IF(!gotInterfaceLock, |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 607 | "Camera %s: %s: Unable to lock interface lock, proceeding anyway", |
| 608 | mId.string(), __FUNCTION__); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 609 | ALOGW_IF(!gotLock, |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 610 | "Camera %s: %s: Unable to lock main lock, proceeding anyway", |
| 611 | mId.string(), __FUNCTION__); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 612 | |
Eino-Ville Talvala | 7e7a62d | 2015-11-04 14:49:43 -0800 | [diff] [blame] | 613 | bool dumpTemplates = false; |
Eino-Ville Talvala | 4d45383 | 2016-07-15 11:56:53 -0700 | [diff] [blame] | 614 | |
Eino-Ville Talvala | 7e7a62d | 2015-11-04 14:49:43 -0800 | [diff] [blame] | 615 | String16 templatesOption("-t"); |
| 616 | int n = args.size(); |
| 617 | for (int i = 0; i < n; i++) { |
| 618 | if (args[i] == templatesOption) { |
| 619 | dumpTemplates = true; |
| 620 | } |
Emilian Peev | bd8c503 | 2018-02-14 23:05:40 +0000 | [diff] [blame] | 621 | if (args[i] == TagMonitor::kMonitorOption) { |
Eino-Ville Talvala | 4d45383 | 2016-07-15 11:56:53 -0700 | [diff] [blame] | 622 | if (i + 1 < n) { |
| 623 | String8 monitorTags = String8(args[i + 1]); |
| 624 | if (monitorTags == "off") { |
| 625 | mTagMonitor.disableMonitoring(); |
| 626 | } else { |
| 627 | mTagMonitor.parseTagsToMonitor(monitorTags); |
| 628 | } |
| 629 | } else { |
| 630 | mTagMonitor.disableMonitoring(); |
| 631 | } |
| 632 | } |
Eino-Ville Talvala | 7e7a62d | 2015-11-04 14:49:43 -0800 | [diff] [blame] | 633 | } |
| 634 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 635 | String8 lines; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 636 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 637 | const char *status = |
| 638 | mStatus == STATUS_ERROR ? "ERROR" : |
| 639 | mStatus == STATUS_UNINITIALIZED ? "UNINITIALIZED" : |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 640 | mStatus == STATUS_UNCONFIGURED ? "UNCONFIGURED" : |
| 641 | mStatus == STATUS_CONFIGURED ? "CONFIGURED" : |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 642 | mStatus == STATUS_ACTIVE ? "ACTIVE" : |
| 643 | "Unknown"; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 644 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 645 | lines.appendFormat(" Device status: %s\n", status); |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 646 | if (mStatus == STATUS_ERROR) { |
| 647 | lines.appendFormat(" Error cause: %s\n", mErrorCause.string()); |
| 648 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 649 | lines.appendFormat(" Stream configuration:\n"); |
Eino-Ville Talvala | bbbbe84 | 2017-02-28 17:50:56 -0800 | [diff] [blame] | 650 | const char *mode = |
| 651 | mOperatingMode == static_cast<int>(StreamConfigurationMode::NORMAL_MODE) ? "NORMAL" : |
| 652 | mOperatingMode == static_cast<int>( |
| 653 | StreamConfigurationMode::CONSTRAINED_HIGH_SPEED_MODE) ? "CONSTRAINED_HIGH_SPEED" : |
| 654 | "CUSTOM"; |
| 655 | lines.appendFormat(" Operation mode: %s (%d) \n", mode, mOperatingMode); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 656 | |
| 657 | if (mInputStream != NULL) { |
| 658 | write(fd, lines.string(), lines.size()); |
| 659 | mInputStream->dump(fd, args); |
| 660 | } else { |
| 661 | lines.appendFormat(" No input stream.\n"); |
| 662 | write(fd, lines.string(), lines.size()); |
| 663 | } |
| 664 | for (size_t i = 0; i < mOutputStreams.size(); i++) { |
| 665 | mOutputStreams[i]->dump(fd,args); |
| 666 | } |
| 667 | |
Zhijun He | 431503c | 2016-03-07 17:30:16 -0800 | [diff] [blame] | 668 | if (mBufferManager != NULL) { |
| 669 | lines = String8(" Camera3 Buffer Manager:\n"); |
| 670 | write(fd, lines.string(), lines.size()); |
| 671 | mBufferManager->dump(fd, args); |
| 672 | } |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 673 | |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 674 | lines = String8(" In-flight requests:\n"); |
| 675 | if (mInFlightMap.size() == 0) { |
| 676 | lines.append(" None\n"); |
| 677 | } else { |
| 678 | for (size_t i = 0; i < mInFlightMap.size(); i++) { |
| 679 | InFlightRequest r = mInFlightMap.valueAt(i); |
Colin Cross | e5729fa | 2014-03-21 15:04:25 -0700 | [diff] [blame] | 680 | lines.appendFormat(" Frame %d | Timestamp: %" PRId64 ", metadata" |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 681 | " arrived: %s, buffers left: %d\n", mInFlightMap.keyAt(i), |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 682 | r.shutterTimestamp, r.haveResultMetadata ? "true" : "false", |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 683 | r.numBuffersLeft); |
| 684 | } |
| 685 | } |
| 686 | write(fd, lines.string(), lines.size()); |
| 687 | |
Shuzhen Wang | 686f644 | 2017-06-20 16:16:04 -0700 | [diff] [blame] | 688 | if (mRequestThread != NULL) { |
| 689 | mRequestThread->dumpCaptureRequestLatency(fd, |
| 690 | " ProcessCaptureRequest latency histogram:"); |
| 691 | } |
| 692 | |
Igor Murashkin | 1e479c0 | 2013-09-06 16:55:14 -0700 | [diff] [blame] | 693 | { |
| 694 | lines = String8(" Last request sent:\n"); |
| 695 | write(fd, lines.string(), lines.size()); |
| 696 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 697 | CameraMetadata lastRequest = getLatestRequestLocked(); |
Igor Murashkin | 1e479c0 | 2013-09-06 16:55:14 -0700 | [diff] [blame] | 698 | lastRequest.dump(fd, /*verbosity*/2, /*indentation*/6); |
| 699 | } |
| 700 | |
Eino-Ville Talvala | 7e7a62d | 2015-11-04 14:49:43 -0800 | [diff] [blame] | 701 | if (dumpTemplates) { |
Eino-Ville Talvala | 1a86df5 | 2018-01-17 16:00:35 -0800 | [diff] [blame] | 702 | const char *templateNames[CAMERA3_TEMPLATE_COUNT] = { |
Eino-Ville Talvala | 7e7a62d | 2015-11-04 14:49:43 -0800 | [diff] [blame] | 703 | "TEMPLATE_PREVIEW", |
| 704 | "TEMPLATE_STILL_CAPTURE", |
| 705 | "TEMPLATE_VIDEO_RECORD", |
| 706 | "TEMPLATE_VIDEO_SNAPSHOT", |
| 707 | "TEMPLATE_ZERO_SHUTTER_LAG", |
Eino-Ville Talvala | 1a86df5 | 2018-01-17 16:00:35 -0800 | [diff] [blame] | 708 | "TEMPLATE_MANUAL", |
Eino-Ville Talvala | 7e7a62d | 2015-11-04 14:49:43 -0800 | [diff] [blame] | 709 | }; |
| 710 | |
| 711 | for (int i = 1; i < CAMERA3_TEMPLATE_COUNT; i++) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 712 | camera_metadata_t *templateRequest = nullptr; |
| 713 | mInterface->constructDefaultRequestSettings( |
| 714 | (camera3_request_template_t) i, &templateRequest); |
Eino-Ville Talvala | 7e7a62d | 2015-11-04 14:49:43 -0800 | [diff] [blame] | 715 | lines = String8::format(" HAL Request %s:\n", templateNames[i-1]); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 716 | if (templateRequest == nullptr) { |
Eino-Ville Talvala | 7e7a62d | 2015-11-04 14:49:43 -0800 | [diff] [blame] | 717 | lines.append(" Not supported\n"); |
| 718 | write(fd, lines.string(), lines.size()); |
| 719 | } else { |
| 720 | write(fd, lines.string(), lines.size()); |
| 721 | dump_indented_camera_metadata(templateRequest, |
| 722 | fd, /*verbosity*/2, /*indentation*/8); |
| 723 | } |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 724 | free_camera_metadata(templateRequest); |
Eino-Ville Talvala | 7e7a62d | 2015-11-04 14:49:43 -0800 | [diff] [blame] | 725 | } |
| 726 | } |
| 727 | |
Eino-Ville Talvala | 4d45383 | 2016-07-15 11:56:53 -0700 | [diff] [blame] | 728 | mTagMonitor.dumpMonitoredMetadata(fd); |
| 729 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 730 | if (mInterface->valid()) { |
Eino-Ville Talvala | d00111e | 2017-01-31 11:59:12 -0800 | [diff] [blame] | 731 | lines = String8(" HAL device dump:\n"); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 732 | write(fd, lines.string(), lines.size()); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 733 | mInterface->dump(fd); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 734 | } |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 735 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 736 | if (gotLock) mLock.unlock(); |
| 737 | if (gotInterfaceLock) mInterfaceLock.unlock(); |
| 738 | |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 739 | return OK; |
| 740 | } |
| 741 | |
Shuzhen Wang | 2e7f58f | 2018-07-11 14:00:29 -0700 | [diff] [blame] | 742 | const CameraMetadata& Camera3Device::info(const String8& physicalId) const { |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 743 | ALOGVV("%s: E", __FUNCTION__); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 744 | if (CC_UNLIKELY(mStatus == STATUS_UNINITIALIZED || |
| 745 | mStatus == STATUS_ERROR)) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 746 | ALOGW("%s: Access to static info %s!", __FUNCTION__, |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 747 | mStatus == STATUS_ERROR ? |
| 748 | "when in error state" : "before init"); |
| 749 | } |
Shuzhen Wang | 2e7f58f | 2018-07-11 14:00:29 -0700 | [diff] [blame] | 750 | if (physicalId.isEmpty()) { |
| 751 | return mDeviceInfo; |
| 752 | } else { |
| 753 | std::string id(physicalId.c_str()); |
| 754 | if (mPhysicalDeviceInfoMap.find(id) != mPhysicalDeviceInfoMap.end()) { |
| 755 | return mPhysicalDeviceInfoMap.at(id); |
| 756 | } else { |
| 757 | ALOGE("%s: Invalid physical camera id %s", __FUNCTION__, physicalId.c_str()); |
| 758 | return mDeviceInfo; |
| 759 | } |
| 760 | } |
| 761 | } |
| 762 | |
| 763 | const CameraMetadata& Camera3Device::info() const { |
| 764 | String8 emptyId; |
| 765 | return info(emptyId); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 766 | } |
| 767 | |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 768 | status_t Camera3Device::checkStatusOkToCaptureLocked() { |
| 769 | switch (mStatus) { |
| 770 | case STATUS_ERROR: |
| 771 | CLOGE("Device has encountered a serious error"); |
| 772 | return INVALID_OPERATION; |
| 773 | case STATUS_UNINITIALIZED: |
| 774 | CLOGE("Device not initialized"); |
| 775 | return INVALID_OPERATION; |
| 776 | case STATUS_UNCONFIGURED: |
| 777 | case STATUS_CONFIGURED: |
| 778 | case STATUS_ACTIVE: |
| 779 | // OK |
| 780 | break; |
| 781 | default: |
| 782 | SET_ERR_L("Unexpected status: %d", mStatus); |
| 783 | return INVALID_OPERATION; |
| 784 | } |
| 785 | return OK; |
| 786 | } |
| 787 | |
| 788 | status_t Camera3Device::convertMetadataListToRequestListLocked( |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 789 | const List<const PhysicalCameraSettingsList> &metadataList, |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 790 | const std::list<const SurfaceMap> &surfaceMaps, |
| 791 | bool repeating, |
Shuzhen Wang | 9d06601 | 2016-09-30 11:30:20 -0700 | [diff] [blame] | 792 | RequestList *requestList) { |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 793 | if (requestList == NULL) { |
| 794 | CLOGE("requestList cannot be NULL."); |
| 795 | return BAD_VALUE; |
| 796 | } |
| 797 | |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 798 | int32_t burstId = 0; |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 799 | List<const PhysicalCameraSettingsList>::const_iterator metadataIt = metadataList.begin(); |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 800 | std::list<const SurfaceMap>::const_iterator surfaceMapIt = surfaceMaps.begin(); |
| 801 | for (; metadataIt != metadataList.end() && surfaceMapIt != surfaceMaps.end(); |
| 802 | ++metadataIt, ++surfaceMapIt) { |
| 803 | sp<CaptureRequest> newRequest = setUpRequestLocked(*metadataIt, *surfaceMapIt); |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 804 | if (newRequest == 0) { |
| 805 | CLOGE("Can't create capture request"); |
| 806 | return BAD_VALUE; |
| 807 | } |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 808 | |
Shuzhen Wang | 9d06601 | 2016-09-30 11:30:20 -0700 | [diff] [blame] | 809 | newRequest->mRepeating = repeating; |
| 810 | |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 811 | // Setup burst Id and request Id |
| 812 | newRequest->mResultExtras.burstId = burstId++; |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 813 | if (metadataIt->begin()->metadata.exists(ANDROID_REQUEST_ID)) { |
| 814 | if (metadataIt->begin()->metadata.find(ANDROID_REQUEST_ID).count == 0) { |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 815 | CLOGE("RequestID entry exists; but must not be empty in metadata"); |
| 816 | return BAD_VALUE; |
| 817 | } |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 818 | newRequest->mResultExtras.requestId = metadataIt->begin()->metadata.find( |
| 819 | ANDROID_REQUEST_ID).data.i32[0]; |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 820 | } else { |
| 821 | CLOGE("RequestID does not exist in metadata"); |
| 822 | return BAD_VALUE; |
| 823 | } |
| 824 | |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 825 | requestList->push_back(newRequest); |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 826 | |
| 827 | ALOGV("%s: requestId = %" PRId32, __FUNCTION__, newRequest->mResultExtras.requestId); |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 828 | } |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 829 | if (metadataIt != metadataList.end() || surfaceMapIt != surfaceMaps.end()) { |
| 830 | ALOGE("%s: metadataList and surfaceMaps are not the same size!", __FUNCTION__); |
| 831 | return BAD_VALUE; |
| 832 | } |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 833 | |
| 834 | // Setup batch size if this is a high speed video recording request. |
| 835 | if (mIsConstrainedHighSpeedConfiguration && requestList->size() > 0) { |
| 836 | auto firstRequest = requestList->begin(); |
| 837 | for (auto& outputStream : (*firstRequest)->mOutputStreams) { |
| 838 | if (outputStream->isVideoStream()) { |
| 839 | (*firstRequest)->mBatchSize = requestList->size(); |
| 840 | break; |
| 841 | } |
| 842 | } |
| 843 | } |
| 844 | |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 845 | return OK; |
| 846 | } |
| 847 | |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 848 | status_t Camera3Device::capture(CameraMetadata &request, int64_t* /*lastFrameNumber*/) { |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 849 | ATRACE_CALL(); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 850 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 851 | List<const PhysicalCameraSettingsList> requestsList; |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 852 | std::list<const SurfaceMap> surfaceMaps; |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 853 | convertToRequestList(requestsList, surfaceMaps, request); |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 854 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 855 | return captureList(requestsList, surfaceMaps, /*lastFrameNumber*/NULL); |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 856 | } |
| 857 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 858 | void Camera3Device::convertToRequestList(List<const PhysicalCameraSettingsList>& requestsList, |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 859 | std::list<const SurfaceMap>& surfaceMaps, |
| 860 | const CameraMetadata& request) { |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 861 | PhysicalCameraSettingsList requestList; |
| 862 | requestList.push_back({std::string(getId().string()), request}); |
| 863 | requestsList.push_back(requestList); |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 864 | |
| 865 | SurfaceMap surfaceMap; |
| 866 | camera_metadata_ro_entry streams = request.find(ANDROID_REQUEST_OUTPUT_STREAMS); |
| 867 | // With no surface list passed in, stream and surface will have 1-to-1 |
| 868 | // mapping. So the surface index is 0 for each stream in the surfaceMap. |
| 869 | for (size_t i = 0; i < streams.count; i++) { |
| 870 | surfaceMap[streams.data.i32[i]].push_back(0); |
| 871 | } |
| 872 | surfaceMaps.push_back(surfaceMap); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 873 | } |
| 874 | |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 875 | status_t Camera3Device::submitRequestsHelper( |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 876 | const List<const PhysicalCameraSettingsList> &requests, |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 877 | const std::list<const SurfaceMap> &surfaceMaps, |
| 878 | bool repeating, |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 879 | /*out*/ |
| 880 | int64_t *lastFrameNumber) { |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 881 | ATRACE_CALL(); |
| 882 | Mutex::Autolock il(mInterfaceLock); |
| 883 | Mutex::Autolock l(mLock); |
| 884 | |
| 885 | status_t res = checkStatusOkToCaptureLocked(); |
| 886 | if (res != OK) { |
| 887 | // error logged by previous call |
| 888 | return res; |
| 889 | } |
| 890 | |
| 891 | RequestList requestList; |
| 892 | |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 893 | res = convertMetadataListToRequestListLocked(requests, surfaceMaps, |
| 894 | repeating, /*out*/&requestList); |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 895 | if (res != OK) { |
| 896 | // error logged by previous call |
| 897 | return res; |
| 898 | } |
| 899 | |
| 900 | if (repeating) { |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 901 | res = mRequestThread->setRepeatingRequests(requestList, lastFrameNumber); |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 902 | } else { |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 903 | res = mRequestThread->queueRequestList(requestList, lastFrameNumber); |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 904 | } |
| 905 | |
| 906 | if (res == OK) { |
| 907 | waitUntilStateThenRelock(/*active*/true, kActiveTimeout); |
| 908 | if (res != OK) { |
| 909 | SET_ERR_L("Can't transition to active in %f seconds!", |
| 910 | kActiveTimeout/1e9); |
| 911 | } |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 912 | ALOGV("Camera %s: Capture request %" PRId32 " enqueued", mId.string(), |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 913 | (*(requestList.begin()))->mResultExtras.requestId); |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 914 | } else { |
| 915 | CLOGE("Cannot queue request. Impossible."); |
| 916 | return BAD_VALUE; |
| 917 | } |
| 918 | |
| 919 | return res; |
| 920 | } |
| 921 | |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 922 | hardware::Return<void> Camera3Device::processCaptureResult_3_4( |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 923 | const hardware::hidl_vec< |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 924 | hardware::camera::device::V3_4::CaptureResult>& results) { |
Yin-Chia Yeh | 657c187 | 2017-07-18 18:09:57 -0700 | [diff] [blame] | 925 | // Ideally we should grab mLock, but that can lead to deadlock, and |
| 926 | // it's not super important to get up to date value of mStatus for this |
| 927 | // warning print, hence skipping the lock here |
| 928 | if (mStatus == STATUS_ERROR) { |
| 929 | // Per API contract, HAL should act as closed after device error |
| 930 | // But mStatus can be set to error by framework as well, so just log |
| 931 | // a warning here. |
| 932 | ALOGW("%s: received capture result in error state.", __FUNCTION__); |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 933 | } |
Yifan Hong | a640c5a | 2017-04-12 16:30:31 -0700 | [diff] [blame] | 934 | |
| 935 | if (mProcessCaptureResultLock.tryLock() != OK) { |
| 936 | // This should never happen; it indicates a wrong client implementation |
| 937 | // that doesn't follow the contract. But, we can be tolerant here. |
| 938 | ALOGE("%s: callback overlapped! waiting 1s...", |
| 939 | __FUNCTION__); |
| 940 | if (mProcessCaptureResultLock.timedLock(1000000000 /* 1s */) != OK) { |
| 941 | ALOGE("%s: cannot acquire lock in 1s, dropping results", |
| 942 | __FUNCTION__); |
| 943 | // really don't know what to do, so bail out. |
| 944 | return hardware::Void(); |
| 945 | } |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 946 | } |
Yifan Hong | a640c5a | 2017-04-12 16:30:31 -0700 | [diff] [blame] | 947 | for (const auto& result : results) { |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 948 | processOneCaptureResultLocked(result.v3_2, result.physicalCameraMetadata); |
Yifan Hong | a640c5a | 2017-04-12 16:30:31 -0700 | [diff] [blame] | 949 | } |
| 950 | mProcessCaptureResultLock.unlock(); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 951 | return hardware::Void(); |
| 952 | } |
| 953 | |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 954 | // Only one processCaptureResult should be called at a time, so |
| 955 | // the locks won't block. The locks are present here simply to enforce this. |
| 956 | hardware::Return<void> Camera3Device::processCaptureResult( |
| 957 | const hardware::hidl_vec< |
| 958 | hardware::camera::device::V3_2::CaptureResult>& results) { |
| 959 | hardware::hidl_vec<hardware::camera::device::V3_4::PhysicalCameraMetadata> noPhysMetadata; |
| 960 | |
| 961 | // Ideally we should grab mLock, but that can lead to deadlock, and |
| 962 | // it's not super important to get up to date value of mStatus for this |
| 963 | // warning print, hence skipping the lock here |
| 964 | if (mStatus == STATUS_ERROR) { |
| 965 | // Per API contract, HAL should act as closed after device error |
| 966 | // But mStatus can be set to error by framework as well, so just log |
| 967 | // a warning here. |
| 968 | ALOGW("%s: received capture result in error state.", __FUNCTION__); |
| 969 | } |
| 970 | |
| 971 | if (mProcessCaptureResultLock.tryLock() != OK) { |
| 972 | // This should never happen; it indicates a wrong client implementation |
| 973 | // that doesn't follow the contract. But, we can be tolerant here. |
| 974 | ALOGE("%s: callback overlapped! waiting 1s...", |
| 975 | __FUNCTION__); |
| 976 | if (mProcessCaptureResultLock.timedLock(1000000000 /* 1s */) != OK) { |
| 977 | ALOGE("%s: cannot acquire lock in 1s, dropping results", |
| 978 | __FUNCTION__); |
| 979 | // really don't know what to do, so bail out. |
| 980 | return hardware::Void(); |
| 981 | } |
| 982 | } |
| 983 | for (const auto& result : results) { |
| 984 | processOneCaptureResultLocked(result, noPhysMetadata); |
| 985 | } |
| 986 | mProcessCaptureResultLock.unlock(); |
| 987 | return hardware::Void(); |
| 988 | } |
| 989 | |
| 990 | status_t Camera3Device::readOneCameraMetadataLocked( |
| 991 | uint64_t fmqResultSize, hardware::camera::device::V3_2::CameraMetadata& resultMetadata, |
| 992 | const hardware::camera::device::V3_2::CameraMetadata& result) { |
| 993 | if (fmqResultSize > 0) { |
| 994 | resultMetadata.resize(fmqResultSize); |
| 995 | if (mResultMetadataQueue == nullptr) { |
| 996 | return NO_MEMORY; // logged in initialize() |
| 997 | } |
| 998 | if (!mResultMetadataQueue->read(resultMetadata.data(), fmqResultSize)) { |
| 999 | ALOGE("%s: Cannot read camera metadata from fmq, size = %" PRIu64, |
| 1000 | __FUNCTION__, fmqResultSize); |
| 1001 | return INVALID_OPERATION; |
| 1002 | } |
| 1003 | } else { |
| 1004 | resultMetadata.setToExternal(const_cast<uint8_t *>(result.data()), |
| 1005 | result.size()); |
| 1006 | } |
| 1007 | |
| 1008 | if (resultMetadata.size() != 0) { |
| 1009 | status_t res; |
| 1010 | const camera_metadata_t* metadata = |
| 1011 | reinterpret_cast<const camera_metadata_t*>(resultMetadata.data()); |
| 1012 | size_t expected_metadata_size = resultMetadata.size(); |
| 1013 | if ((res = validate_camera_metadata_structure(metadata, &expected_metadata_size)) != OK) { |
| 1014 | ALOGE("%s: Invalid camera metadata received by camera service from HAL: %s (%d)", |
| 1015 | __FUNCTION__, strerror(-res), res); |
| 1016 | return INVALID_OPERATION; |
| 1017 | } |
| 1018 | } |
| 1019 | |
| 1020 | return OK; |
| 1021 | } |
| 1022 | |
Yifan Hong | a640c5a | 2017-04-12 16:30:31 -0700 | [diff] [blame] | 1023 | void Camera3Device::processOneCaptureResultLocked( |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 1024 | const hardware::camera::device::V3_2::CaptureResult& result, |
| 1025 | const hardware::hidl_vec< |
| 1026 | hardware::camera::device::V3_4::PhysicalCameraMetadata> physicalCameraMetadatas) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1027 | camera3_capture_result r; |
| 1028 | status_t res; |
| 1029 | r.frame_number = result.frameNumber; |
Yifan Hong | a640c5a | 2017-04-12 16:30:31 -0700 | [diff] [blame] | 1030 | |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 1031 | // Read and validate the result metadata. |
Yifan Hong | a640c5a | 2017-04-12 16:30:31 -0700 | [diff] [blame] | 1032 | hardware::camera::device::V3_2::CameraMetadata resultMetadata; |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 1033 | res = readOneCameraMetadataLocked(result.fmqResultSize, resultMetadata, result.result); |
| 1034 | if (res != OK) { |
| 1035 | ALOGE("%s: Frame %d: Failed to read capture result metadata", |
| 1036 | __FUNCTION__, result.frameNumber); |
| 1037 | return; |
Yifan Hong | a640c5a | 2017-04-12 16:30:31 -0700 | [diff] [blame] | 1038 | } |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 1039 | r.result = reinterpret_cast<const camera_metadata_t*>(resultMetadata.data()); |
Yifan Hong | a640c5a | 2017-04-12 16:30:31 -0700 | [diff] [blame] | 1040 | |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 1041 | // Read and validate physical camera metadata |
| 1042 | size_t physResultCount = physicalCameraMetadatas.size(); |
| 1043 | std::vector<const char*> physCamIds(physResultCount); |
| 1044 | std::vector<const camera_metadata_t *> phyCamMetadatas(physResultCount); |
| 1045 | std::vector<hardware::camera::device::V3_2::CameraMetadata> physResultMetadata; |
| 1046 | physResultMetadata.resize(physResultCount); |
| 1047 | for (size_t i = 0; i < physicalCameraMetadatas.size(); i++) { |
| 1048 | res = readOneCameraMetadataLocked(physicalCameraMetadatas[i].fmqMetadataSize, |
| 1049 | physResultMetadata[i], physicalCameraMetadatas[i].metadata); |
| 1050 | if (res != OK) { |
| 1051 | ALOGE("%s: Frame %d: Failed to read capture result metadata for camera %s", |
| 1052 | __FUNCTION__, result.frameNumber, |
| 1053 | physicalCameraMetadatas[i].physicalCameraId.c_str()); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 1054 | return; |
Yin-Chia Yeh | 52778d4 | 2016-12-22 18:20:43 -0800 | [diff] [blame] | 1055 | } |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 1056 | physCamIds[i] = physicalCameraMetadatas[i].physicalCameraId.c_str(); |
| 1057 | phyCamMetadatas[i] = reinterpret_cast<const camera_metadata_t*>( |
| 1058 | physResultMetadata[i].data()); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1059 | } |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 1060 | r.num_physcam_metadata = physResultCount; |
| 1061 | r.physcam_ids = physCamIds.data(); |
| 1062 | r.physcam_metadata = phyCamMetadatas.data(); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1063 | |
| 1064 | std::vector<camera3_stream_buffer_t> outputBuffers(result.outputBuffers.size()); |
| 1065 | std::vector<buffer_handle_t> outputBufferHandles(result.outputBuffers.size()); |
| 1066 | for (size_t i = 0; i < result.outputBuffers.size(); i++) { |
| 1067 | auto& bDst = outputBuffers[i]; |
| 1068 | const StreamBuffer &bSrc = result.outputBuffers[i]; |
| 1069 | |
| 1070 | ssize_t idx = mOutputStreams.indexOfKey(bSrc.streamId); |
Emilian Peev | be3d40c | 2017-03-27 13:03:10 +0100 | [diff] [blame] | 1071 | if (idx == NAME_NOT_FOUND) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1072 | ALOGE("%s: Frame %d: Buffer %zu: Invalid output stream id %d", |
| 1073 | __FUNCTION__, result.frameNumber, i, bSrc.streamId); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 1074 | return; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1075 | } |
| 1076 | bDst.stream = mOutputStreams.valueAt(idx)->asHalStream(); |
| 1077 | |
| 1078 | buffer_handle_t *buffer; |
Yin-Chia Yeh | f465060 | 2017-01-10 13:13:39 -0800 | [diff] [blame] | 1079 | res = mInterface->popInflightBuffer(result.frameNumber, bSrc.streamId, &buffer); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1080 | if (res != OK) { |
| 1081 | ALOGE("%s: Frame %d: Buffer %zu: No in-flight buffer for stream %d", |
| 1082 | __FUNCTION__, result.frameNumber, i, bSrc.streamId); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 1083 | return; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1084 | } |
| 1085 | bDst.buffer = buffer; |
| 1086 | bDst.status = mapHidlBufferStatus(bSrc.status); |
| 1087 | bDst.acquire_fence = -1; |
| 1088 | if (bSrc.releaseFence == nullptr) { |
| 1089 | bDst.release_fence = -1; |
| 1090 | } else if (bSrc.releaseFence->numFds == 1) { |
| 1091 | bDst.release_fence = dup(bSrc.releaseFence->data[0]); |
| 1092 | } else { |
| 1093 | ALOGE("%s: Frame %d: Invalid release fence for buffer %zu, fd count is %d, not 1", |
| 1094 | __FUNCTION__, result.frameNumber, i, bSrc.releaseFence->numFds); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 1095 | return; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1096 | } |
| 1097 | } |
| 1098 | r.num_output_buffers = outputBuffers.size(); |
| 1099 | r.output_buffers = outputBuffers.data(); |
| 1100 | |
| 1101 | camera3_stream_buffer_t inputBuffer; |
Yin-Chia Yeh | 52778d4 | 2016-12-22 18:20:43 -0800 | [diff] [blame] | 1102 | if (result.inputBuffer.streamId == -1) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1103 | r.input_buffer = nullptr; |
| 1104 | } else { |
| 1105 | if (mInputStream->getId() != result.inputBuffer.streamId) { |
| 1106 | ALOGE("%s: Frame %d: Invalid input stream id %d", __FUNCTION__, |
| 1107 | result.frameNumber, result.inputBuffer.streamId); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 1108 | return; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1109 | } |
| 1110 | inputBuffer.stream = mInputStream->asHalStream(); |
| 1111 | buffer_handle_t *buffer; |
| 1112 | res = mInterface->popInflightBuffer(result.frameNumber, result.inputBuffer.streamId, |
| 1113 | &buffer); |
| 1114 | if (res != OK) { |
| 1115 | ALOGE("%s: Frame %d: Input buffer: No in-flight buffer for stream %d", |
| 1116 | __FUNCTION__, result.frameNumber, result.inputBuffer.streamId); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 1117 | return; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1118 | } |
| 1119 | inputBuffer.buffer = buffer; |
| 1120 | inputBuffer.status = mapHidlBufferStatus(result.inputBuffer.status); |
| 1121 | inputBuffer.acquire_fence = -1; |
| 1122 | if (result.inputBuffer.releaseFence == nullptr) { |
| 1123 | inputBuffer.release_fence = -1; |
| 1124 | } else if (result.inputBuffer.releaseFence->numFds == 1) { |
| 1125 | inputBuffer.release_fence = dup(result.inputBuffer.releaseFence->data[0]); |
| 1126 | } else { |
| 1127 | ALOGE("%s: Frame %d: Invalid release fence for input buffer, fd count is %d, not 1", |
| 1128 | __FUNCTION__, result.frameNumber, result.inputBuffer.releaseFence->numFds); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 1129 | return; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1130 | } |
| 1131 | r.input_buffer = &inputBuffer; |
| 1132 | } |
| 1133 | |
| 1134 | r.partial_result = result.partialResult; |
| 1135 | |
| 1136 | processCaptureResult(&r); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1137 | } |
| 1138 | |
| 1139 | hardware::Return<void> Camera3Device::notify( |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 1140 | const hardware::hidl_vec<hardware::camera::device::V3_2::NotifyMsg>& msgs) { |
Yin-Chia Yeh | 657c187 | 2017-07-18 18:09:57 -0700 | [diff] [blame] | 1141 | // Ideally we should grab mLock, but that can lead to deadlock, and |
| 1142 | // it's not super important to get up to date value of mStatus for this |
| 1143 | // warning print, hence skipping the lock here |
| 1144 | if (mStatus == STATUS_ERROR) { |
| 1145 | // Per API contract, HAL should act as closed after device error |
| 1146 | // But mStatus can be set to error by framework as well, so just log |
| 1147 | // a warning here. |
| 1148 | ALOGW("%s: received notify message in error state.", __FUNCTION__); |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 1149 | } |
Yin-Chia Yeh | 657c187 | 2017-07-18 18:09:57 -0700 | [diff] [blame] | 1150 | |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 1151 | for (const auto& msg : msgs) { |
| 1152 | notify(msg); |
| 1153 | } |
| 1154 | return hardware::Void(); |
| 1155 | } |
| 1156 | |
| 1157 | void Camera3Device::notify( |
| 1158 | const hardware::camera::device::V3_2::NotifyMsg& msg) { |
| 1159 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1160 | camera3_notify_msg m; |
| 1161 | switch (msg.type) { |
| 1162 | case MsgType::ERROR: |
| 1163 | m.type = CAMERA3_MSG_ERROR; |
| 1164 | m.message.error.frame_number = msg.msg.error.frameNumber; |
| 1165 | if (msg.msg.error.errorStreamId >= 0) { |
| 1166 | ssize_t idx = mOutputStreams.indexOfKey(msg.msg.error.errorStreamId); |
Emilian Peev | be3d40c | 2017-03-27 13:03:10 +0100 | [diff] [blame] | 1167 | if (idx == NAME_NOT_FOUND) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1168 | ALOGE("%s: Frame %d: Invalid error stream id %d", |
| 1169 | __FUNCTION__, m.message.error.frame_number, msg.msg.error.errorStreamId); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 1170 | return; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1171 | } |
| 1172 | m.message.error.error_stream = mOutputStreams.valueAt(idx)->asHalStream(); |
| 1173 | } else { |
| 1174 | m.message.error.error_stream = nullptr; |
| 1175 | } |
| 1176 | switch (msg.msg.error.errorCode) { |
| 1177 | case ErrorCode::ERROR_DEVICE: |
| 1178 | m.message.error.error_code = CAMERA3_MSG_ERROR_DEVICE; |
| 1179 | break; |
| 1180 | case ErrorCode::ERROR_REQUEST: |
| 1181 | m.message.error.error_code = CAMERA3_MSG_ERROR_REQUEST; |
| 1182 | break; |
| 1183 | case ErrorCode::ERROR_RESULT: |
| 1184 | m.message.error.error_code = CAMERA3_MSG_ERROR_RESULT; |
| 1185 | break; |
| 1186 | case ErrorCode::ERROR_BUFFER: |
| 1187 | m.message.error.error_code = CAMERA3_MSG_ERROR_BUFFER; |
| 1188 | break; |
| 1189 | } |
| 1190 | break; |
| 1191 | case MsgType::SHUTTER: |
| 1192 | m.type = CAMERA3_MSG_SHUTTER; |
| 1193 | m.message.shutter.frame_number = msg.msg.shutter.frameNumber; |
| 1194 | m.message.shutter.timestamp = msg.msg.shutter.timestamp; |
| 1195 | break; |
| 1196 | } |
| 1197 | notify(&m); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1198 | } |
| 1199 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 1200 | status_t Camera3Device::captureList(const List<const PhysicalCameraSettingsList> &requestsList, |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1201 | const std::list<const SurfaceMap> &surfaceMaps, |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 1202 | int64_t *lastFrameNumber) { |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 1203 | ATRACE_CALL(); |
| 1204 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 1205 | return submitRequestsHelper(requestsList, surfaceMaps, /*repeating*/false, lastFrameNumber); |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 1206 | } |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1207 | |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 1208 | status_t Camera3Device::setStreamingRequest(const CameraMetadata &request, |
| 1209 | int64_t* /*lastFrameNumber*/) { |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1210 | ATRACE_CALL(); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1211 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 1212 | List<const PhysicalCameraSettingsList> requestsList; |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1213 | std::list<const SurfaceMap> surfaceMaps; |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 1214 | convertToRequestList(requestsList, surfaceMaps, request); |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1215 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 1216 | return setStreamingRequestList(requestsList, /*surfaceMap*/surfaceMaps, |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1217 | /*lastFrameNumber*/NULL); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1218 | } |
| 1219 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 1220 | status_t Camera3Device::setStreamingRequestList( |
| 1221 | const List<const PhysicalCameraSettingsList> &requestsList, |
| 1222 | const std::list<const SurfaceMap> &surfaceMaps, int64_t *lastFrameNumber) { |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 1223 | ATRACE_CALL(); |
| 1224 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 1225 | return submitRequestsHelper(requestsList, surfaceMaps, /*repeating*/true, lastFrameNumber); |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 1226 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1227 | |
| 1228 | sp<Camera3Device::CaptureRequest> Camera3Device::setUpRequestLocked( |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 1229 | const PhysicalCameraSettingsList &request, const SurfaceMap &surfaceMap) { |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1230 | status_t res; |
| 1231 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1232 | if (mStatus == STATUS_UNCONFIGURED || mNeedConfig) { |
Eino-Ville Talvala | e7091aa | 2017-03-07 15:23:06 -0800 | [diff] [blame] | 1233 | // This point should only be reached via API1 (API2 must explicitly call configureStreams) |
| 1234 | // so unilaterally select normal operating mode. |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 1235 | res = filterParamsAndConfigureLocked(request.begin()->metadata, |
| 1236 | CAMERA3_STREAM_CONFIGURATION_NORMAL_MODE); |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 1237 | // Stream configuration failed. Client might try other configuraitons. |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1238 | if (res != OK) { |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 1239 | CLOGE("Can't set up streams: %s (%d)", strerror(-res), res); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1240 | return NULL; |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 1241 | } else if (mStatus == STATUS_UNCONFIGURED) { |
| 1242 | // Stream configuration successfully configure to empty stream configuration. |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1243 | CLOGE("No streams configured"); |
| 1244 | return NULL; |
| 1245 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1246 | } |
| 1247 | |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1248 | sp<CaptureRequest> newRequest = createCaptureRequest(request, surfaceMap); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1249 | return newRequest; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1250 | } |
| 1251 | |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 1252 | status_t Camera3Device::clearStreamingRequest(int64_t *lastFrameNumber) { |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1253 | ATRACE_CALL(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1254 | Mutex::Autolock il(mInterfaceLock); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1255 | Mutex::Autolock l(mLock); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1256 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1257 | switch (mStatus) { |
| 1258 | case STATUS_ERROR: |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1259 | CLOGE("Device has encountered a serious error"); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1260 | return INVALID_OPERATION; |
| 1261 | case STATUS_UNINITIALIZED: |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1262 | CLOGE("Device not initialized"); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1263 | return INVALID_OPERATION; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1264 | case STATUS_UNCONFIGURED: |
| 1265 | case STATUS_CONFIGURED: |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1266 | case STATUS_ACTIVE: |
| 1267 | // OK |
| 1268 | break; |
| 1269 | default: |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1270 | SET_ERR_L("Unexpected status: %d", mStatus); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1271 | return INVALID_OPERATION; |
| 1272 | } |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1273 | ALOGV("Camera %s: Clearing repeating request", mId.string()); |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 1274 | |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 1275 | return mRequestThread->clearRepeatingRequests(lastFrameNumber); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1276 | } |
| 1277 | |
| 1278 | status_t Camera3Device::waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) { |
| 1279 | ATRACE_CALL(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1280 | Mutex::Autolock il(mInterfaceLock); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1281 | |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 1282 | return mRequestThread->waitUntilRequestProcessed(requestId, timeout); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1283 | } |
| 1284 | |
Igor Murashkin | 5a269fa | 2013-04-15 14:59:22 -0700 | [diff] [blame] | 1285 | status_t Camera3Device::createInputStream( |
| 1286 | uint32_t width, uint32_t height, int format, int *id) { |
| 1287 | ATRACE_CALL(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1288 | Mutex::Autolock il(mInterfaceLock); |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 1289 | nsecs_t maxExpectedDuration = getExpectedInFlightDuration(); |
Igor Murashkin | 5a269fa | 2013-04-15 14:59:22 -0700 | [diff] [blame] | 1290 | Mutex::Autolock l(mLock); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1291 | ALOGV("Camera %s: Creating new input stream %d: %d x %d, format %d", |
| 1292 | mId.string(), mNextStreamId, width, height, format); |
Igor Murashkin | 5a269fa | 2013-04-15 14:59:22 -0700 | [diff] [blame] | 1293 | |
| 1294 | status_t res; |
| 1295 | bool wasActive = false; |
| 1296 | |
| 1297 | switch (mStatus) { |
| 1298 | case STATUS_ERROR: |
| 1299 | ALOGE("%s: Device has encountered a serious error", __FUNCTION__); |
| 1300 | return INVALID_OPERATION; |
| 1301 | case STATUS_UNINITIALIZED: |
| 1302 | ALOGE("%s: Device not initialized", __FUNCTION__); |
| 1303 | return INVALID_OPERATION; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1304 | case STATUS_UNCONFIGURED: |
| 1305 | case STATUS_CONFIGURED: |
Igor Murashkin | 5a269fa | 2013-04-15 14:59:22 -0700 | [diff] [blame] | 1306 | // OK |
| 1307 | break; |
| 1308 | case STATUS_ACTIVE: |
| 1309 | ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__); |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 1310 | res = internalPauseAndWaitLocked(maxExpectedDuration); |
Igor Murashkin | 5a269fa | 2013-04-15 14:59:22 -0700 | [diff] [blame] | 1311 | if (res != OK) { |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1312 | SET_ERR_L("Can't pause captures to reconfigure streams!"); |
Igor Murashkin | 5a269fa | 2013-04-15 14:59:22 -0700 | [diff] [blame] | 1313 | return res; |
| 1314 | } |
| 1315 | wasActive = true; |
| 1316 | break; |
| 1317 | default: |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1318 | SET_ERR_L("%s: Unexpected status: %d", mStatus); |
Igor Murashkin | 5a269fa | 2013-04-15 14:59:22 -0700 | [diff] [blame] | 1319 | return INVALID_OPERATION; |
| 1320 | } |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1321 | assert(mStatus != STATUS_ACTIVE); |
Igor Murashkin | 5a269fa | 2013-04-15 14:59:22 -0700 | [diff] [blame] | 1322 | |
| 1323 | if (mInputStream != 0) { |
| 1324 | ALOGE("%s: Cannot create more than 1 input stream", __FUNCTION__); |
| 1325 | return INVALID_OPERATION; |
| 1326 | } |
| 1327 | |
| 1328 | sp<Camera3InputStream> newStream = new Camera3InputStream(mNextStreamId, |
| 1329 | width, height, format); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1330 | newStream->setStatusTracker(mStatusTracker); |
Igor Murashkin | 5a269fa | 2013-04-15 14:59:22 -0700 | [diff] [blame] | 1331 | |
| 1332 | mInputStream = newStream; |
| 1333 | |
| 1334 | *id = mNextStreamId++; |
| 1335 | |
| 1336 | // Continue captures if active at start |
| 1337 | if (wasActive) { |
| 1338 | ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__); |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 1339 | // Reuse current operating mode and session parameters for new stream config |
| 1340 | res = configureStreamsLocked(mOperatingMode, mSessionParams); |
Igor Murashkin | 5a269fa | 2013-04-15 14:59:22 -0700 | [diff] [blame] | 1341 | if (res != OK) { |
| 1342 | ALOGE("%s: Can't reconfigure device for new stream %d: %s (%d)", |
| 1343 | __FUNCTION__, mNextStreamId, strerror(-res), res); |
| 1344 | return res; |
| 1345 | } |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1346 | internalResumeLocked(); |
Igor Murashkin | 5a269fa | 2013-04-15 14:59:22 -0700 | [diff] [blame] | 1347 | } |
| 1348 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1349 | ALOGV("Camera %s: Created input stream", mId.string()); |
Igor Murashkin | 5a269fa | 2013-04-15 14:59:22 -0700 | [diff] [blame] | 1350 | return OK; |
| 1351 | } |
| 1352 | |
Eino-Ville Talvala | 727d172 | 2015-06-09 13:44:19 -0700 | [diff] [blame] | 1353 | status_t Camera3Device::createStream(sp<Surface> consumer, |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1354 | uint32_t width, uint32_t height, int format, |
| 1355 | android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 1356 | const String8& physicalCameraId, |
Emilian Peev | 40ead60 | 2017-09-26 15:46:36 +0100 | [diff] [blame] | 1357 | std::vector<int> *surfaceIds, int streamSetId, bool isShared, uint64_t consumerUsage) { |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1358 | ATRACE_CALL(); |
| 1359 | |
| 1360 | if (consumer == nullptr) { |
| 1361 | ALOGE("%s: consumer must not be null", __FUNCTION__); |
| 1362 | return BAD_VALUE; |
| 1363 | } |
| 1364 | |
| 1365 | std::vector<sp<Surface>> consumers; |
| 1366 | consumers.push_back(consumer); |
| 1367 | |
| 1368 | return createStream(consumers, /*hasDeferredConsumer*/ false, width, height, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 1369 | format, dataSpace, rotation, id, physicalCameraId, surfaceIds, streamSetId, |
| 1370 | isShared, consumerUsage); |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1371 | } |
| 1372 | |
| 1373 | status_t Camera3Device::createStream(const std::vector<sp<Surface>>& consumers, |
| 1374 | bool hasDeferredConsumer, uint32_t width, uint32_t height, int format, |
| 1375 | android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 1376 | const String8& physicalCameraId, |
Emilian Peev | 40ead60 | 2017-09-26 15:46:36 +0100 | [diff] [blame] | 1377 | std::vector<int> *surfaceIds, int streamSetId, bool isShared, uint64_t consumerUsage) { |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1378 | ATRACE_CALL(); |
Emilian Peev | 40ead60 | 2017-09-26 15:46:36 +0100 | [diff] [blame] | 1379 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1380 | Mutex::Autolock il(mInterfaceLock); |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 1381 | nsecs_t maxExpectedDuration = getExpectedInFlightDuration(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1382 | Mutex::Autolock l(mLock); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1383 | ALOGV("Camera %s: Creating new stream %d: %d x %d, format %d, dataspace %d rotation %d" |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 1384 | " consumer usage %" PRIu64 ", isShared %d, physicalCameraId %s", mId.string(), |
| 1385 | mNextStreamId, width, height, format, dataSpace, rotation, consumerUsage, isShared, |
| 1386 | physicalCameraId.string()); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1387 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1388 | status_t res; |
| 1389 | bool wasActive = false; |
| 1390 | |
| 1391 | switch (mStatus) { |
| 1392 | case STATUS_ERROR: |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1393 | CLOGE("Device has encountered a serious error"); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1394 | return INVALID_OPERATION; |
| 1395 | case STATUS_UNINITIALIZED: |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1396 | CLOGE("Device not initialized"); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1397 | return INVALID_OPERATION; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1398 | case STATUS_UNCONFIGURED: |
| 1399 | case STATUS_CONFIGURED: |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1400 | // OK |
| 1401 | break; |
| 1402 | case STATUS_ACTIVE: |
| 1403 | ALOGV("%s: Stopping activity to reconfigure streams", __FUNCTION__); |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 1404 | res = internalPauseAndWaitLocked(maxExpectedDuration); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1405 | if (res != OK) { |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1406 | SET_ERR_L("Can't pause captures to reconfigure streams!"); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1407 | return res; |
| 1408 | } |
| 1409 | wasActive = true; |
| 1410 | break; |
| 1411 | default: |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1412 | SET_ERR_L("Unexpected status: %d", mStatus); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1413 | return INVALID_OPERATION; |
| 1414 | } |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1415 | assert(mStatus != STATUS_ACTIVE); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1416 | |
| 1417 | sp<Camera3OutputStream> newStream; |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 1418 | |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1419 | if (consumers.size() == 0 && !hasDeferredConsumer) { |
| 1420 | ALOGE("%s: Number of consumers cannot be smaller than 1", __FUNCTION__); |
| 1421 | return BAD_VALUE; |
| 1422 | } |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 1423 | |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1424 | if (hasDeferredConsumer && format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 1425 | ALOGE("Deferred consumer stream creation only support IMPLEMENTATION_DEFINED format"); |
| 1426 | return BAD_VALUE; |
| 1427 | } |
| 1428 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1429 | if (format == HAL_PIXEL_FORMAT_BLOB) { |
Eino-Ville Talvala | 95a1d0f | 2015-08-11 15:08:53 -0700 | [diff] [blame] | 1430 | ssize_t blobBufferSize; |
| 1431 | if (dataSpace != HAL_DATASPACE_DEPTH) { |
| 1432 | blobBufferSize = getJpegBufferSize(width, height); |
| 1433 | if (blobBufferSize <= 0) { |
| 1434 | SET_ERR_L("Invalid jpeg buffer size %zd", blobBufferSize); |
| 1435 | return BAD_VALUE; |
| 1436 | } |
| 1437 | } else { |
| 1438 | blobBufferSize = getPointCloudBufferSize(); |
| 1439 | if (blobBufferSize <= 0) { |
| 1440 | SET_ERR_L("Invalid point cloud buffer size %zd", blobBufferSize); |
| 1441 | return BAD_VALUE; |
| 1442 | } |
Zhijun He | f7da096 | 2014-04-24 13:27:56 -0700 | [diff] [blame] | 1443 | } |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1444 | newStream = new Camera3OutputStream(mNextStreamId, consumers[0], |
Shuzhen Wang | c28dccc | 2016-02-11 23:48:46 -0800 | [diff] [blame] | 1445 | width, height, blobBufferSize, format, dataSpace, rotation, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 1446 | mTimestampOffset, physicalCameraId, streamSetId); |
Yin-Chia Yeh | e9154ce | 2015-12-07 14:38:04 -0800 | [diff] [blame] | 1447 | } else if (format == HAL_PIXEL_FORMAT_RAW_OPAQUE) { |
| 1448 | ssize_t rawOpaqueBufferSize = getRawOpaqueBufferSize(width, height); |
| 1449 | if (rawOpaqueBufferSize <= 0) { |
| 1450 | SET_ERR_L("Invalid RAW opaque buffer size %zd", rawOpaqueBufferSize); |
| 1451 | return BAD_VALUE; |
| 1452 | } |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1453 | newStream = new Camera3OutputStream(mNextStreamId, consumers[0], |
Shuzhen Wang | c28dccc | 2016-02-11 23:48:46 -0800 | [diff] [blame] | 1454 | width, height, rawOpaqueBufferSize, format, dataSpace, rotation, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 1455 | mTimestampOffset, physicalCameraId, streamSetId); |
Shuzhen Wang | 758c215 | 2017-01-10 18:26:18 -0800 | [diff] [blame] | 1456 | } else if (isShared) { |
| 1457 | newStream = new Camera3SharedOutputStream(mNextStreamId, consumers, |
| 1458 | width, height, format, consumerUsage, dataSpace, rotation, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 1459 | mTimestampOffset, physicalCameraId, streamSetId); |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1460 | } else if (consumers.size() == 0 && hasDeferredConsumer) { |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 1461 | newStream = new Camera3OutputStream(mNextStreamId, |
| 1462 | width, height, format, consumerUsage, dataSpace, rotation, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 1463 | mTimestampOffset, physicalCameraId, streamSetId); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1464 | } else { |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 1465 | newStream = new Camera3OutputStream(mNextStreamId, consumers[0], |
Shuzhen Wang | c28dccc | 2016-02-11 23:48:46 -0800 | [diff] [blame] | 1466 | width, height, format, dataSpace, rotation, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 1467 | mTimestampOffset, physicalCameraId, streamSetId); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1468 | } |
Emilian Peev | 40ead60 | 2017-09-26 15:46:36 +0100 | [diff] [blame] | 1469 | |
| 1470 | size_t consumerCount = consumers.size(); |
| 1471 | for (size_t i = 0; i < consumerCount; i++) { |
| 1472 | int id = newStream->getSurfaceId(consumers[i]); |
| 1473 | if (id < 0) { |
| 1474 | SET_ERR_L("Invalid surface id"); |
| 1475 | return BAD_VALUE; |
| 1476 | } |
| 1477 | if (surfaceIds != nullptr) { |
| 1478 | surfaceIds->push_back(id); |
| 1479 | } |
| 1480 | } |
| 1481 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1482 | newStream->setStatusTracker(mStatusTracker); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1483 | |
Emilian Peev | 08dd245 | 2017-04-06 16:55:14 +0100 | [diff] [blame] | 1484 | newStream->setBufferManager(mBufferManager); |
Zhijun He | 125684a | 2015-12-26 15:07:30 -0800 | [diff] [blame] | 1485 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1486 | res = mOutputStreams.add(mNextStreamId, newStream); |
| 1487 | if (res < 0) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1488 | SET_ERR_L("Can't add new stream to set: %s (%d)", strerror(-res), res); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1489 | return res; |
| 1490 | } |
| 1491 | |
| 1492 | *id = mNextStreamId++; |
Eino-Ville Talvala | ea26c77 | 2013-06-11 16:04:06 -0700 | [diff] [blame] | 1493 | mNeedConfig = true; |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1494 | |
| 1495 | // Continue captures if active at start |
| 1496 | if (wasActive) { |
| 1497 | ALOGV("%s: Restarting activity to reconfigure streams", __FUNCTION__); |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 1498 | // Reuse current operating mode and session parameters for new stream config |
| 1499 | res = configureStreamsLocked(mOperatingMode, mSessionParams); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1500 | if (res != OK) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1501 | CLOGE("Can't reconfigure device for new stream %d: %s (%d)", |
| 1502 | mNextStreamId, strerror(-res), res); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1503 | return res; |
| 1504 | } |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1505 | internalResumeLocked(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1506 | } |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1507 | ALOGV("Camera %s: Created new stream", mId.string()); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1508 | return OK; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1509 | } |
| 1510 | |
Emilian Peev | 710c142 | 2017-08-30 11:19:38 +0100 | [diff] [blame] | 1511 | status_t Camera3Device::getStreamInfo(int id, StreamInfo *streamInfo) { |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1512 | ATRACE_CALL(); |
Emilian Peev | 710c142 | 2017-08-30 11:19:38 +0100 | [diff] [blame] | 1513 | if (nullptr == streamInfo) { |
| 1514 | return BAD_VALUE; |
| 1515 | } |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1516 | Mutex::Autolock il(mInterfaceLock); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1517 | Mutex::Autolock l(mLock); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1518 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1519 | switch (mStatus) { |
| 1520 | case STATUS_ERROR: |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1521 | CLOGE("Device has encountered a serious error"); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1522 | return INVALID_OPERATION; |
| 1523 | case STATUS_UNINITIALIZED: |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1524 | CLOGE("Device not initialized!"); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1525 | return INVALID_OPERATION; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1526 | case STATUS_UNCONFIGURED: |
| 1527 | case STATUS_CONFIGURED: |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1528 | case STATUS_ACTIVE: |
| 1529 | // OK |
| 1530 | break; |
| 1531 | default: |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1532 | SET_ERR_L("Unexpected status: %d", mStatus); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1533 | return INVALID_OPERATION; |
| 1534 | } |
| 1535 | |
| 1536 | ssize_t idx = mOutputStreams.indexOfKey(id); |
| 1537 | if (idx == NAME_NOT_FOUND) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1538 | CLOGE("Stream %d is unknown", id); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1539 | return idx; |
| 1540 | } |
| 1541 | |
Emilian Peev | 710c142 | 2017-08-30 11:19:38 +0100 | [diff] [blame] | 1542 | streamInfo->width = mOutputStreams[idx]->getWidth(); |
| 1543 | streamInfo->height = mOutputStreams[idx]->getHeight(); |
| 1544 | streamInfo->format = mOutputStreams[idx]->getFormat(); |
| 1545 | streamInfo->dataSpace = mOutputStreams[idx]->getDataSpace(); |
| 1546 | streamInfo->formatOverridden = mOutputStreams[idx]->isFormatOverridden(); |
| 1547 | streamInfo->originalFormat = mOutputStreams[idx]->getOriginalFormat(); |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 1548 | streamInfo->dataSpaceOverridden = mOutputStreams[idx]->isDataSpaceOverridden(); |
| 1549 | streamInfo->originalDataSpace = mOutputStreams[idx]->getOriginalDataSpace(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1550 | return OK; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1551 | } |
| 1552 | |
| 1553 | status_t Camera3Device::setStreamTransform(int id, |
| 1554 | int transform) { |
| 1555 | ATRACE_CALL(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1556 | Mutex::Autolock il(mInterfaceLock); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1557 | Mutex::Autolock l(mLock); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1558 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1559 | switch (mStatus) { |
| 1560 | case STATUS_ERROR: |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1561 | CLOGE("Device has encountered a serious error"); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1562 | return INVALID_OPERATION; |
| 1563 | case STATUS_UNINITIALIZED: |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1564 | CLOGE("Device not initialized"); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1565 | return INVALID_OPERATION; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1566 | case STATUS_UNCONFIGURED: |
| 1567 | case STATUS_CONFIGURED: |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1568 | case STATUS_ACTIVE: |
| 1569 | // OK |
| 1570 | break; |
| 1571 | default: |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1572 | SET_ERR_L("Unexpected status: %d", mStatus); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1573 | return INVALID_OPERATION; |
| 1574 | } |
| 1575 | |
| 1576 | ssize_t idx = mOutputStreams.indexOfKey(id); |
| 1577 | if (idx == NAME_NOT_FOUND) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1578 | CLOGE("Stream %d does not exist", |
| 1579 | id); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1580 | return BAD_VALUE; |
| 1581 | } |
| 1582 | |
| 1583 | return mOutputStreams.editValueAt(idx)->setTransform(transform); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1584 | } |
| 1585 | |
| 1586 | status_t Camera3Device::deleteStream(int id) { |
| 1587 | ATRACE_CALL(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1588 | Mutex::Autolock il(mInterfaceLock); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1589 | Mutex::Autolock l(mLock); |
| 1590 | status_t res; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1591 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1592 | ALOGV("%s: Camera %s: Deleting stream %d", __FUNCTION__, mId.string(), id); |
Igor Murashkin | e2172be | 2013-05-28 15:31:39 -0700 | [diff] [blame] | 1593 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1594 | // CameraDevice semantics require device to already be idle before |
| 1595 | // deleteStream is called, unlike for createStream. |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1596 | if (mStatus == STATUS_ACTIVE) { |
Yin-Chia Yeh | 693047d | 2018-03-08 12:14:19 -0800 | [diff] [blame] | 1597 | ALOGW("%s: Camera %s: Device not idle", __FUNCTION__, mId.string()); |
Igor Murashkin | 5282713 | 2013-05-13 14:53:44 -0700 | [diff] [blame] | 1598 | return -EBUSY; |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1599 | } |
| 1600 | |
Yin-Chia Yeh | 5090c73 | 2017-07-20 16:05:29 -0700 | [diff] [blame] | 1601 | if (mStatus == STATUS_ERROR) { |
| 1602 | ALOGW("%s: Camera %s: deleteStream not allowed in ERROR state", |
| 1603 | __FUNCTION__, mId.string()); |
| 1604 | return -EBUSY; |
| 1605 | } |
| 1606 | |
Igor Murashkin | 2fba584 | 2013-04-22 14:03:54 -0700 | [diff] [blame] | 1607 | sp<Camera3StreamInterface> deletedStream; |
Zhijun He | 5f44635 | 2014-01-22 09:49:33 -0800 | [diff] [blame] | 1608 | ssize_t outputStreamIdx = mOutputStreams.indexOfKey(id); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1609 | if (mInputStream != NULL && id == mInputStream->getId()) { |
| 1610 | deletedStream = mInputStream; |
| 1611 | mInputStream.clear(); |
| 1612 | } else { |
Zhijun He | 5f44635 | 2014-01-22 09:49:33 -0800 | [diff] [blame] | 1613 | if (outputStreamIdx == NAME_NOT_FOUND) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1614 | CLOGE("Stream %d does not exist", id); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1615 | return BAD_VALUE; |
| 1616 | } |
Zhijun He | 5f44635 | 2014-01-22 09:49:33 -0800 | [diff] [blame] | 1617 | } |
| 1618 | |
| 1619 | // Delete output stream or the output part of a bi-directional stream. |
| 1620 | if (outputStreamIdx != NAME_NOT_FOUND) { |
| 1621 | deletedStream = mOutputStreams.editValueAt(outputStreamIdx); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1622 | mOutputStreams.removeItem(id); |
| 1623 | } |
| 1624 | |
| 1625 | // Free up the stream endpoint so that it can be used by some other stream |
| 1626 | res = deletedStream->disconnect(); |
| 1627 | if (res != OK) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1628 | SET_ERR_L("Can't disconnect deleted stream %d", id); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1629 | // fall through since we want to still list the stream as deleted. |
| 1630 | } |
| 1631 | mDeletedStreams.add(deletedStream); |
Eino-Ville Talvala | ea26c77 | 2013-06-11 16:04:06 -0700 | [diff] [blame] | 1632 | mNeedConfig = true; |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1633 | |
| 1634 | return res; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1635 | } |
| 1636 | |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 1637 | status_t Camera3Device::configureStreams(const CameraMetadata& sessionParams, int operatingMode) { |
Igor Murashkin | e2d167e | 2014-08-19 16:19:59 -0700 | [diff] [blame] | 1638 | ATRACE_CALL(); |
| 1639 | ALOGV("%s: E", __FUNCTION__); |
| 1640 | |
| 1641 | Mutex::Autolock il(mInterfaceLock); |
| 1642 | Mutex::Autolock l(mLock); |
Chien-Yu Chen | 17338fc | 2015-06-18 16:30:12 -0700 | [diff] [blame] | 1643 | |
Emilian Peev | 811d295 | 2018-05-25 11:08:40 +0100 | [diff] [blame] | 1644 | // In case the client doesn't include any session parameter, try a |
| 1645 | // speculative configuration using the values from the last cached |
| 1646 | // default request. |
| 1647 | if (sessionParams.isEmpty() && |
| 1648 | ((mLastTemplateId > 0) && (mLastTemplateId < CAMERA3_TEMPLATE_COUNT)) && |
| 1649 | (!mRequestTemplateCache[mLastTemplateId].isEmpty())) { |
| 1650 | ALOGV("%s: Speculative session param configuration with template id: %d", __func__, |
| 1651 | mLastTemplateId); |
| 1652 | return filterParamsAndConfigureLocked(mRequestTemplateCache[mLastTemplateId], |
| 1653 | operatingMode); |
| 1654 | } |
| 1655 | |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 1656 | return filterParamsAndConfigureLocked(sessionParams, operatingMode); |
| 1657 | } |
| 1658 | |
| 1659 | status_t Camera3Device::filterParamsAndConfigureLocked(const CameraMetadata& sessionParams, |
| 1660 | int operatingMode) { |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 1661 | //Filter out any incoming session parameters |
| 1662 | const CameraMetadata params(sessionParams); |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 1663 | camera_metadata_entry_t availableSessionKeys = mDeviceInfo.find( |
| 1664 | ANDROID_REQUEST_AVAILABLE_SESSION_KEYS); |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 1665 | CameraMetadata filteredParams(availableSessionKeys.count); |
| 1666 | camera_metadata_t *meta = const_cast<camera_metadata_t *>( |
| 1667 | filteredParams.getAndLock()); |
| 1668 | set_camera_metadata_vendor_id(meta, mVendorTagId); |
| 1669 | filteredParams.unlock(meta); |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 1670 | if (availableSessionKeys.count > 0) { |
| 1671 | for (size_t i = 0; i < availableSessionKeys.count; i++) { |
| 1672 | camera_metadata_ro_entry entry = params.find( |
| 1673 | availableSessionKeys.data.i32[i]); |
| 1674 | if (entry.count > 0) { |
| 1675 | filteredParams.update(entry); |
| 1676 | } |
| 1677 | } |
| 1678 | } |
| 1679 | |
| 1680 | return configureStreamsLocked(operatingMode, filteredParams); |
Igor Murashkin | e2d167e | 2014-08-19 16:19:59 -0700 | [diff] [blame] | 1681 | } |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1682 | |
Chien-Yu Chen | 618ff8a | 2015-03-13 11:27:17 -0700 | [diff] [blame] | 1683 | status_t Camera3Device::getInputBufferProducer( |
| 1684 | sp<IGraphicBufferProducer> *producer) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 1685 | ATRACE_CALL(); |
Chien-Yu Chen | 618ff8a | 2015-03-13 11:27:17 -0700 | [diff] [blame] | 1686 | Mutex::Autolock il(mInterfaceLock); |
| 1687 | Mutex::Autolock l(mLock); |
| 1688 | |
| 1689 | if (producer == NULL) { |
| 1690 | return BAD_VALUE; |
| 1691 | } else if (mInputStream == NULL) { |
| 1692 | return INVALID_OPERATION; |
| 1693 | } |
| 1694 | |
| 1695 | return mInputStream->getInputBufferProducer(producer); |
| 1696 | } |
| 1697 | |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1698 | status_t Camera3Device::createDefaultRequest(int templateId, |
| 1699 | CameraMetadata *request) { |
| 1700 | ATRACE_CALL(); |
Alex Ray | fe7e0c6 | 2013-05-30 00:12:13 -0700 | [diff] [blame] | 1701 | ALOGV("%s: for template %d", __FUNCTION__, templateId); |
Chien-Yu Chen | 9cd1402 | 2016-03-09 12:21:01 -0800 | [diff] [blame] | 1702 | |
| 1703 | if (templateId <= 0 || templateId >= CAMERA3_TEMPLATE_COUNT) { |
| 1704 | android_errorWriteWithInfoLog(CameraService::SN_EVENT_LOG_ID, "26866110", |
Jayant Chowdhary | 1236193 | 2018-08-27 14:46:13 -0700 | [diff] [blame] | 1705 | CameraThreadState::getCallingUid(), nullptr, 0); |
Chien-Yu Chen | 9cd1402 | 2016-03-09 12:21:01 -0800 | [diff] [blame] | 1706 | return BAD_VALUE; |
| 1707 | } |
| 1708 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1709 | Mutex::Autolock il(mInterfaceLock); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1710 | |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 1711 | { |
| 1712 | Mutex::Autolock l(mLock); |
| 1713 | switch (mStatus) { |
| 1714 | case STATUS_ERROR: |
| 1715 | CLOGE("Device has encountered a serious error"); |
| 1716 | return INVALID_OPERATION; |
| 1717 | case STATUS_UNINITIALIZED: |
| 1718 | CLOGE("Device is not initialized!"); |
| 1719 | return INVALID_OPERATION; |
| 1720 | case STATUS_UNCONFIGURED: |
| 1721 | case STATUS_CONFIGURED: |
| 1722 | case STATUS_ACTIVE: |
| 1723 | // OK |
| 1724 | break; |
| 1725 | default: |
| 1726 | SET_ERR_L("Unexpected status: %d", mStatus); |
| 1727 | return INVALID_OPERATION; |
| 1728 | } |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1729 | |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 1730 | if (!mRequestTemplateCache[templateId].isEmpty()) { |
| 1731 | *request = mRequestTemplateCache[templateId]; |
Emilian Peev | 811d295 | 2018-05-25 11:08:40 +0100 | [diff] [blame] | 1732 | mLastTemplateId = templateId; |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 1733 | return OK; |
| 1734 | } |
Zhijun He | a1530f1 | 2014-09-14 12:44:20 -0700 | [diff] [blame] | 1735 | } |
| 1736 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1737 | camera_metadata_t *rawRequest; |
| 1738 | status_t res = mInterface->constructDefaultRequestSettings( |
| 1739 | (camera3_request_template_t) templateId, &rawRequest); |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 1740 | |
| 1741 | { |
| 1742 | Mutex::Autolock l(mLock); |
| 1743 | if (res == BAD_VALUE) { |
| 1744 | ALOGI("%s: template %d is not supported on this camera device", |
| 1745 | __FUNCTION__, templateId); |
| 1746 | return res; |
| 1747 | } else if (res != OK) { |
| 1748 | CLOGE("Unable to construct request template %d: %s (%d)", |
| 1749 | templateId, strerror(-res), res); |
| 1750 | return res; |
| 1751 | } |
| 1752 | |
| 1753 | set_camera_metadata_vendor_id(rawRequest, mVendorTagId); |
| 1754 | mRequestTemplateCache[templateId].acquire(rawRequest); |
| 1755 | |
| 1756 | *request = mRequestTemplateCache[templateId]; |
Emilian Peev | 811d295 | 2018-05-25 11:08:40 +0100 | [diff] [blame] | 1757 | mLastTemplateId = templateId; |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1758 | } |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1759 | return OK; |
| 1760 | } |
| 1761 | |
| 1762 | status_t Camera3Device::waitUntilDrained() { |
| 1763 | ATRACE_CALL(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1764 | Mutex::Autolock il(mInterfaceLock); |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 1765 | nsecs_t maxExpectedDuration = getExpectedInFlightDuration(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1766 | Mutex::Autolock l(mLock); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1767 | |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 1768 | return waitUntilDrainedLocked(maxExpectedDuration); |
Zhijun He | 69a3748 | 2014-03-23 18:44:49 -0700 | [diff] [blame] | 1769 | } |
| 1770 | |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 1771 | status_t Camera3Device::waitUntilDrainedLocked(nsecs_t maxExpectedDuration) { |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1772 | switch (mStatus) { |
| 1773 | case STATUS_UNINITIALIZED: |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1774 | case STATUS_UNCONFIGURED: |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1775 | ALOGV("%s: Already idle", __FUNCTION__); |
| 1776 | return OK; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1777 | case STATUS_CONFIGURED: |
| 1778 | // To avoid race conditions, check with tracker to be sure |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1779 | case STATUS_ERROR: |
| 1780 | case STATUS_ACTIVE: |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1781 | // Need to verify shut down |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1782 | break; |
| 1783 | default: |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 1784 | SET_ERR_L("Unexpected status: %d",mStatus); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1785 | return INVALID_OPERATION; |
| 1786 | } |
Eino-Ville Talvala | 10bd57e | 2017-06-23 16:22:44 -0700 | [diff] [blame] | 1787 | ALOGV("%s: Camera %s: Waiting until idle (%" PRIi64 "ns)", __FUNCTION__, mId.string(), |
| 1788 | maxExpectedDuration); |
| 1789 | status_t res = waitUntilStateThenRelock(/*active*/ false, maxExpectedDuration); |
Eino-Ville Talvala | 9c8a091 | 2014-09-14 14:52:19 -0700 | [diff] [blame] | 1790 | if (res != OK) { |
| 1791 | SET_ERR_L("Error waiting for HAL to drain: %s (%d)", strerror(-res), |
| 1792 | res); |
| 1793 | } |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1794 | return res; |
| 1795 | } |
| 1796 | |
Ruben Brunk | 183f056 | 2015-08-12 12:55:02 -0700 | [diff] [blame] | 1797 | |
| 1798 | void Camera3Device::internalUpdateStatusLocked(Status status) { |
| 1799 | mStatus = status; |
| 1800 | mRecentStatusUpdates.add(mStatus); |
| 1801 | mStatusChanged.broadcast(); |
| 1802 | } |
| 1803 | |
Eino-Ville Talvala | 002001b | 2018-01-23 16:53:50 -0800 | [diff] [blame] | 1804 | void Camera3Device::pauseStateNotify(bool enable) { |
| 1805 | Mutex::Autolock il(mInterfaceLock); |
| 1806 | Mutex::Autolock l(mLock); |
| 1807 | |
| 1808 | mPauseStateNotify = enable; |
| 1809 | } |
| 1810 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1811 | // Pause to reconfigure |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 1812 | status_t Camera3Device::internalPauseAndWaitLocked(nsecs_t maxExpectedDuration) { |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1813 | mRequestThread->setPaused(true); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1814 | |
Eino-Ville Talvala | 10bd57e | 2017-06-23 16:22:44 -0700 | [diff] [blame] | 1815 | ALOGV("%s: Camera %s: Internal wait until idle (% " PRIi64 " ns)", __FUNCTION__, mId.string(), |
| 1816 | maxExpectedDuration); |
| 1817 | status_t res = waitUntilStateThenRelock(/*active*/ false, maxExpectedDuration); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1818 | if (res != OK) { |
| 1819 | SET_ERR_L("Can't idle device in %f seconds!", |
Eino-Ville Talvala | 10bd57e | 2017-06-23 16:22:44 -0700 | [diff] [blame] | 1820 | maxExpectedDuration/1e9); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1821 | } |
| 1822 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1823 | return res; |
| 1824 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1825 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1826 | // Resume after internalPauseAndWaitLocked |
| 1827 | status_t Camera3Device::internalResumeLocked() { |
| 1828 | status_t res; |
| 1829 | |
| 1830 | mRequestThread->setPaused(false); |
| 1831 | |
Eino-Ville Talvala | 002001b | 2018-01-23 16:53:50 -0800 | [diff] [blame] | 1832 | ALOGV("%s: Camera %s: Internal wait until active (% " PRIi64 " ns)", __FUNCTION__, mId.string(), |
| 1833 | kActiveTimeout); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1834 | res = waitUntilStateThenRelock(/*active*/ true, kActiveTimeout); |
| 1835 | if (res != OK) { |
| 1836 | SET_ERR_L("Can't transition to active in %f seconds!", |
| 1837 | kActiveTimeout/1e9); |
| 1838 | } |
| 1839 | mPauseStateNotify = false; |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 1840 | return OK; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1841 | } |
| 1842 | |
Ruben Brunk | 183f056 | 2015-08-12 12:55:02 -0700 | [diff] [blame] | 1843 | status_t Camera3Device::waitUntilStateThenRelock(bool active, nsecs_t timeout) { |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1844 | status_t res = OK; |
Ruben Brunk | 183f056 | 2015-08-12 12:55:02 -0700 | [diff] [blame] | 1845 | |
| 1846 | size_t startIndex = 0; |
| 1847 | if (mStatusWaiters == 0) { |
| 1848 | // Clear the list of recent statuses if there are no existing threads waiting on updates to |
| 1849 | // this status list |
| 1850 | mRecentStatusUpdates.clear(); |
| 1851 | } else { |
| 1852 | // If other threads are waiting on updates to this status list, set the position of the |
| 1853 | // first element that this list will check rather than clearing the list. |
| 1854 | startIndex = mRecentStatusUpdates.size(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1855 | } |
| 1856 | |
Ruben Brunk | 183f056 | 2015-08-12 12:55:02 -0700 | [diff] [blame] | 1857 | mStatusWaiters++; |
| 1858 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1859 | bool stateSeen = false; |
| 1860 | do { |
Ruben Brunk | 183f056 | 2015-08-12 12:55:02 -0700 | [diff] [blame] | 1861 | if (active == (mStatus == STATUS_ACTIVE)) { |
| 1862 | // Desired state is current |
| 1863 | break; |
| 1864 | } |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1865 | |
| 1866 | res = mStatusChanged.waitRelative(mLock, timeout); |
| 1867 | if (res != OK) break; |
| 1868 | |
Ruben Brunk | 183f056 | 2015-08-12 12:55:02 -0700 | [diff] [blame] | 1869 | // This is impossible, but if not, could result in subtle deadlocks and invalid state |
| 1870 | // transitions. |
| 1871 | LOG_ALWAYS_FATAL_IF(startIndex > mRecentStatusUpdates.size(), |
| 1872 | "%s: Skipping status updates in Camera3Device, may result in deadlock.", |
| 1873 | __FUNCTION__); |
| 1874 | |
| 1875 | // Encountered desired state since we began waiting |
| 1876 | for (size_t i = startIndex; i < mRecentStatusUpdates.size(); i++) { |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1877 | if (active == (mRecentStatusUpdates[i] == STATUS_ACTIVE) ) { |
| 1878 | stateSeen = true; |
| 1879 | break; |
| 1880 | } |
| 1881 | } |
| 1882 | } while (!stateSeen); |
| 1883 | |
Ruben Brunk | 183f056 | 2015-08-12 12:55:02 -0700 | [diff] [blame] | 1884 | mStatusWaiters--; |
| 1885 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1886 | return res; |
| 1887 | } |
| 1888 | |
| 1889 | |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 1890 | status_t Camera3Device::setNotifyCallback(wp<NotificationListener> listener) { |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1891 | ATRACE_CALL(); |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 1892 | Mutex::Autolock l(mOutputLock); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1893 | |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 1894 | if (listener != NULL && mListener != NULL) { |
| 1895 | ALOGW("%s: Replacing old callback listener", __FUNCTION__); |
| 1896 | } |
| 1897 | mListener = listener; |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 1898 | mRequestThread->setNotificationListener(listener); |
| 1899 | mPreparerThread->setNotificationListener(listener); |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 1900 | |
| 1901 | return OK; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1902 | } |
| 1903 | |
Eino-Ville Talvala | 46910bd | 2013-07-18 19:15:17 -0700 | [diff] [blame] | 1904 | bool Camera3Device::willNotify3A() { |
| 1905 | return false; |
| 1906 | } |
| 1907 | |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1908 | status_t Camera3Device::waitForNextFrame(nsecs_t timeout) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 1909 | ATRACE_CALL(); |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 1910 | status_t res; |
| 1911 | Mutex::Autolock l(mOutputLock); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1912 | |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 1913 | while (mResultQueue.empty()) { |
| 1914 | res = mResultSignal.waitRelative(mOutputLock, timeout); |
| 1915 | if (res == TIMED_OUT) { |
| 1916 | return res; |
| 1917 | } else if (res != OK) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 1918 | ALOGW("%s: Camera %s: No frame in %" PRId64 " ns: %s (%d)", |
| 1919 | __FUNCTION__, mId.string(), timeout, strerror(-res), res); |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 1920 | return res; |
| 1921 | } |
| 1922 | } |
| 1923 | return OK; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1924 | } |
| 1925 | |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 1926 | status_t Camera3Device::getNextResult(CaptureResult *frame) { |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1927 | ATRACE_CALL(); |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 1928 | Mutex::Autolock l(mOutputLock); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1929 | |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 1930 | if (mResultQueue.empty()) { |
| 1931 | return NOT_ENOUGH_DATA; |
| 1932 | } |
| 1933 | |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 1934 | if (frame == NULL) { |
| 1935 | ALOGE("%s: argument cannot be NULL", __FUNCTION__); |
| 1936 | return BAD_VALUE; |
| 1937 | } |
| 1938 | |
| 1939 | CaptureResult &result = *(mResultQueue.begin()); |
| 1940 | frame->mResultExtras = result.mResultExtras; |
| 1941 | frame->mMetadata.acquire(result.mMetadata); |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 1942 | frame->mPhysicalMetadatas = std::move(result.mPhysicalMetadatas); |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 1943 | mResultQueue.erase(mResultQueue.begin()); |
| 1944 | |
| 1945 | return OK; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1946 | } |
| 1947 | |
| 1948 | status_t Camera3Device::triggerAutofocus(uint32_t id) { |
| 1949 | ATRACE_CALL(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1950 | Mutex::Autolock il(mInterfaceLock); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1951 | |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 1952 | ALOGV("%s: Triggering autofocus, id %d", __FUNCTION__, id); |
| 1953 | // Mix-in this trigger into the next request and only the next request. |
| 1954 | RequestTrigger trigger[] = { |
| 1955 | { |
| 1956 | ANDROID_CONTROL_AF_TRIGGER, |
| 1957 | ANDROID_CONTROL_AF_TRIGGER_START |
| 1958 | }, |
| 1959 | { |
| 1960 | ANDROID_CONTROL_AF_TRIGGER_ID, |
| 1961 | static_cast<int32_t>(id) |
Yin-Chia Yeh | 741ace8 | 2014-06-23 14:07:56 -0700 | [diff] [blame] | 1962 | } |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 1963 | }; |
| 1964 | |
| 1965 | return mRequestThread->queueTrigger(trigger, |
| 1966 | sizeof(trigger)/sizeof(trigger[0])); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1967 | } |
| 1968 | |
| 1969 | status_t Camera3Device::triggerCancelAutofocus(uint32_t id) { |
| 1970 | ATRACE_CALL(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1971 | Mutex::Autolock il(mInterfaceLock); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1972 | |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 1973 | ALOGV("%s: Triggering cancel autofocus, id %d", __FUNCTION__, id); |
| 1974 | // Mix-in this trigger into the next request and only the next request. |
| 1975 | RequestTrigger trigger[] = { |
| 1976 | { |
| 1977 | ANDROID_CONTROL_AF_TRIGGER, |
| 1978 | ANDROID_CONTROL_AF_TRIGGER_CANCEL |
| 1979 | }, |
| 1980 | { |
| 1981 | ANDROID_CONTROL_AF_TRIGGER_ID, |
| 1982 | static_cast<int32_t>(id) |
Yin-Chia Yeh | 741ace8 | 2014-06-23 14:07:56 -0700 | [diff] [blame] | 1983 | } |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 1984 | }; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1985 | |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 1986 | return mRequestThread->queueTrigger(trigger, |
| 1987 | sizeof(trigger)/sizeof(trigger[0])); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1988 | } |
| 1989 | |
| 1990 | status_t Camera3Device::triggerPrecaptureMetering(uint32_t id) { |
| 1991 | ATRACE_CALL(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 1992 | Mutex::Autolock il(mInterfaceLock); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 1993 | |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 1994 | ALOGV("%s: Triggering precapture metering, id %d", __FUNCTION__, id); |
| 1995 | // Mix-in this trigger into the next request and only the next request. |
| 1996 | RequestTrigger trigger[] = { |
| 1997 | { |
| 1998 | ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, |
| 1999 | ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START |
| 2000 | }, |
| 2001 | { |
| 2002 | ANDROID_CONTROL_AE_PRECAPTURE_ID, |
| 2003 | static_cast<int32_t>(id) |
Yin-Chia Yeh | 741ace8 | 2014-06-23 14:07:56 -0700 | [diff] [blame] | 2004 | } |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 2005 | }; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 2006 | |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 2007 | return mRequestThread->queueTrigger(trigger, |
| 2008 | sizeof(trigger)/sizeof(trigger[0])); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 2009 | } |
| 2010 | |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 2011 | status_t Camera3Device::flush(int64_t *frameNumber) { |
Eino-Ville Talvala | abaa51d | 2013-08-14 11:37:00 -0700 | [diff] [blame] | 2012 | ATRACE_CALL(); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2013 | ALOGV("%s: Camera %s: Flushing all requests", __FUNCTION__, mId.string()); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 2014 | Mutex::Autolock il(mInterfaceLock); |
Eino-Ville Talvala | abaa51d | 2013-08-14 11:37:00 -0700 | [diff] [blame] | 2015 | |
Zhijun He | 7ef2039 | 2014-04-21 16:04:17 -0700 | [diff] [blame] | 2016 | { |
| 2017 | Mutex::Autolock l(mLock); |
Emilian Peev | ed2ebe4 | 2018-09-25 16:59:09 +0100 | [diff] [blame] | 2018 | |
| 2019 | // b/116514106 "disconnect()" can get called twice for the same device. The |
| 2020 | // camera device will not be initialized during the second run. |
| 2021 | if (mStatus == STATUS_UNINITIALIZED) { |
| 2022 | return OK; |
| 2023 | } |
| 2024 | |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 2025 | mRequestThread->clear(/*out*/frameNumber); |
Zhijun He | 7ef2039 | 2014-04-21 16:04:17 -0700 | [diff] [blame] | 2026 | } |
| 2027 | |
Emilian Peev | 08dd245 | 2017-04-06 16:55:14 +0100 | [diff] [blame] | 2028 | return mRequestThread->flush(); |
Eino-Ville Talvala | abaa51d | 2013-08-14 11:37:00 -0700 | [diff] [blame] | 2029 | } |
| 2030 | |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 2031 | status_t Camera3Device::prepare(int streamId) { |
Ruben Brunk | c78ac26 | 2015-08-13 17:58:46 -0700 | [diff] [blame] | 2032 | return prepare(camera3::Camera3StreamInterface::ALLOCATE_PIPELINE_MAX, streamId); |
| 2033 | } |
| 2034 | |
| 2035 | status_t Camera3Device::prepare(int maxCount, int streamId) { |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 2036 | ATRACE_CALL(); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2037 | ALOGV("%s: Camera %s: Preparing stream %d", __FUNCTION__, mId.string(), streamId); |
Eino-Ville Talvala | 261394e | 2015-05-13 14:28:38 -0700 | [diff] [blame] | 2038 | Mutex::Autolock il(mInterfaceLock); |
| 2039 | Mutex::Autolock l(mLock); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 2040 | |
| 2041 | sp<Camera3StreamInterface> stream; |
| 2042 | ssize_t outputStreamIdx = mOutputStreams.indexOfKey(streamId); |
| 2043 | if (outputStreamIdx == NAME_NOT_FOUND) { |
| 2044 | CLOGE("Stream %d does not exist", streamId); |
| 2045 | return BAD_VALUE; |
| 2046 | } |
| 2047 | |
| 2048 | stream = mOutputStreams.editValueAt(outputStreamIdx); |
| 2049 | |
| 2050 | if (stream->isUnpreparable() || stream->hasOutstandingBuffers() ) { |
Eino-Ville Talvala | 261394e | 2015-05-13 14:28:38 -0700 | [diff] [blame] | 2051 | CLOGE("Stream %d has already been a request target", streamId); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 2052 | return BAD_VALUE; |
| 2053 | } |
| 2054 | |
| 2055 | if (mRequestThread->isStreamPending(stream)) { |
Eino-Ville Talvala | 261394e | 2015-05-13 14:28:38 -0700 | [diff] [blame] | 2056 | CLOGE("Stream %d is already a target in a pending request", streamId); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 2057 | return BAD_VALUE; |
| 2058 | } |
| 2059 | |
Ruben Brunk | c78ac26 | 2015-08-13 17:58:46 -0700 | [diff] [blame] | 2060 | return mPreparerThread->prepare(maxCount, stream); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 2061 | } |
| 2062 | |
Eino-Ville Talvala | b25e3c8 | 2015-07-15 16:04:27 -0700 | [diff] [blame] | 2063 | status_t Camera3Device::tearDown(int streamId) { |
| 2064 | ATRACE_CALL(); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2065 | ALOGV("%s: Camera %s: Tearing down stream %d", __FUNCTION__, mId.string(), streamId); |
Eino-Ville Talvala | b25e3c8 | 2015-07-15 16:04:27 -0700 | [diff] [blame] | 2066 | Mutex::Autolock il(mInterfaceLock); |
| 2067 | Mutex::Autolock l(mLock); |
| 2068 | |
Eino-Ville Talvala | b25e3c8 | 2015-07-15 16:04:27 -0700 | [diff] [blame] | 2069 | sp<Camera3StreamInterface> stream; |
| 2070 | ssize_t outputStreamIdx = mOutputStreams.indexOfKey(streamId); |
| 2071 | if (outputStreamIdx == NAME_NOT_FOUND) { |
| 2072 | CLOGE("Stream %d does not exist", streamId); |
| 2073 | return BAD_VALUE; |
| 2074 | } |
| 2075 | |
| 2076 | stream = mOutputStreams.editValueAt(outputStreamIdx); |
| 2077 | |
| 2078 | if (stream->hasOutstandingBuffers() || mRequestThread->isStreamPending(stream)) { |
| 2079 | CLOGE("Stream %d is a target of a in-progress request", streamId); |
| 2080 | return BAD_VALUE; |
| 2081 | } |
| 2082 | |
| 2083 | return stream->tearDown(); |
| 2084 | } |
| 2085 | |
Shuzhen Wang | b0fdc1e | 2016-03-20 23:21:39 -0700 | [diff] [blame] | 2086 | status_t Camera3Device::addBufferListenerForStream(int streamId, |
| 2087 | wp<Camera3StreamBufferListener> listener) { |
| 2088 | ATRACE_CALL(); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2089 | ALOGV("%s: Camera %s: Adding buffer listener for stream %d", __FUNCTION__, mId.string(), streamId); |
Shuzhen Wang | b0fdc1e | 2016-03-20 23:21:39 -0700 | [diff] [blame] | 2090 | Mutex::Autolock il(mInterfaceLock); |
| 2091 | Mutex::Autolock l(mLock); |
| 2092 | |
| 2093 | sp<Camera3StreamInterface> stream; |
| 2094 | ssize_t outputStreamIdx = mOutputStreams.indexOfKey(streamId); |
| 2095 | if (outputStreamIdx == NAME_NOT_FOUND) { |
| 2096 | CLOGE("Stream %d does not exist", streamId); |
| 2097 | return BAD_VALUE; |
| 2098 | } |
| 2099 | |
| 2100 | stream = mOutputStreams.editValueAt(outputStreamIdx); |
| 2101 | stream->addBufferListener(listener); |
| 2102 | |
| 2103 | return OK; |
| 2104 | } |
| 2105 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2106 | /** |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 2107 | * Methods called by subclasses |
| 2108 | */ |
| 2109 | |
| 2110 | void Camera3Device::notifyStatus(bool idle) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 2111 | ATRACE_CALL(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 2112 | { |
| 2113 | // Need mLock to safely update state and synchronize to current |
| 2114 | // state of methods in flight. |
| 2115 | Mutex::Autolock l(mLock); |
| 2116 | // We can get various system-idle notices from the status tracker |
| 2117 | // while starting up. Only care about them if we've actually sent |
| 2118 | // in some requests recently. |
| 2119 | if (mStatus != STATUS_ACTIVE && mStatus != STATUS_CONFIGURED) { |
| 2120 | return; |
| 2121 | } |
Eino-Ville Talvala | 002001b | 2018-01-23 16:53:50 -0800 | [diff] [blame] | 2122 | ALOGV("%s: Camera %s: Now %s, pauseState: %s", __FUNCTION__, mId.string(), |
| 2123 | idle ? "idle" : "active", mPauseStateNotify ? "true" : "false"); |
Ruben Brunk | 183f056 | 2015-08-12 12:55:02 -0700 | [diff] [blame] | 2124 | internalUpdateStatusLocked(idle ? STATUS_CONFIGURED : STATUS_ACTIVE); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 2125 | |
| 2126 | // Skip notifying listener if we're doing some user-transparent |
| 2127 | // state changes |
| 2128 | if (mPauseStateNotify) return; |
| 2129 | } |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 2130 | |
| 2131 | sp<NotificationListener> listener; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 2132 | { |
| 2133 | Mutex::Autolock l(mOutputLock); |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 2134 | listener = mListener.promote(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 2135 | } |
| 2136 | if (idle && listener != NULL) { |
| 2137 | listener->notifyIdle(); |
| 2138 | } |
| 2139 | } |
| 2140 | |
Shuzhen Wang | 758c215 | 2017-01-10 18:26:18 -0800 | [diff] [blame] | 2141 | status_t Camera3Device::setConsumerSurfaces(int streamId, |
Emilian Peev | 40ead60 | 2017-09-26 15:46:36 +0100 | [diff] [blame] | 2142 | const std::vector<sp<Surface>>& consumers, std::vector<int> *surfaceIds) { |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 2143 | ATRACE_CALL(); |
Shuzhen Wang | 758c215 | 2017-01-10 18:26:18 -0800 | [diff] [blame] | 2144 | ALOGV("%s: Camera %s: set consumer surface for stream %d", |
| 2145 | __FUNCTION__, mId.string(), streamId); |
Emilian Peev | 40ead60 | 2017-09-26 15:46:36 +0100 | [diff] [blame] | 2146 | |
| 2147 | if (surfaceIds == nullptr) { |
| 2148 | return BAD_VALUE; |
| 2149 | } |
| 2150 | |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 2151 | Mutex::Autolock il(mInterfaceLock); |
| 2152 | Mutex::Autolock l(mLock); |
| 2153 | |
Shuzhen Wang | 758c215 | 2017-01-10 18:26:18 -0800 | [diff] [blame] | 2154 | if (consumers.size() == 0) { |
| 2155 | CLOGE("No consumer is passed!"); |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 2156 | return BAD_VALUE; |
| 2157 | } |
| 2158 | |
| 2159 | ssize_t idx = mOutputStreams.indexOfKey(streamId); |
| 2160 | if (idx == NAME_NOT_FOUND) { |
| 2161 | CLOGE("Stream %d is unknown", streamId); |
| 2162 | return idx; |
| 2163 | } |
| 2164 | sp<Camera3OutputStreamInterface> stream = mOutputStreams[idx]; |
Shuzhen Wang | 758c215 | 2017-01-10 18:26:18 -0800 | [diff] [blame] | 2165 | status_t res = stream->setConsumers(consumers); |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 2166 | if (res != OK) { |
| 2167 | CLOGE("Stream %d set consumer failed (error %d %s) ", streamId, res, strerror(-res)); |
| 2168 | return res; |
| 2169 | } |
| 2170 | |
Emilian Peev | 40ead60 | 2017-09-26 15:46:36 +0100 | [diff] [blame] | 2171 | for (auto &consumer : consumers) { |
| 2172 | int id = stream->getSurfaceId(consumer); |
| 2173 | if (id < 0) { |
| 2174 | CLOGE("Invalid surface id!"); |
| 2175 | return BAD_VALUE; |
| 2176 | } |
| 2177 | surfaceIds->push_back(id); |
| 2178 | } |
| 2179 | |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 2180 | if (stream->isConsumerConfigurationDeferred()) { |
| 2181 | if (!stream->isConfiguring()) { |
| 2182 | CLOGE("Stream %d was already fully configured.", streamId); |
| 2183 | return INVALID_OPERATION; |
| 2184 | } |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 2185 | |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 2186 | res = stream->finishConfiguration(); |
| 2187 | if (res != OK) { |
Shuzhen Wang | 210ba5c | 2018-07-25 16:47:40 -0700 | [diff] [blame] | 2188 | // If finishConfiguration fails due to abandoned surface, do not set |
| 2189 | // device to error state. |
| 2190 | bool isSurfaceAbandoned = |
| 2191 | (res == NO_INIT || res == DEAD_OBJECT) && stream->isAbandoned(); |
| 2192 | if (!isSurfaceAbandoned) { |
| 2193 | SET_ERR_L("Can't finish configuring output stream %d: %s (%d)", |
| 2194 | stream->getId(), strerror(-res), res); |
| 2195 | } |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 2196 | return res; |
| 2197 | } |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 2198 | } |
| 2199 | |
| 2200 | return OK; |
| 2201 | } |
| 2202 | |
Emilian Peev | 40ead60 | 2017-09-26 15:46:36 +0100 | [diff] [blame] | 2203 | status_t Camera3Device::updateStream(int streamId, const std::vector<sp<Surface>> &newSurfaces, |
| 2204 | const std::vector<OutputStreamInfo> &outputInfo, |
| 2205 | const std::vector<size_t> &removedSurfaceIds, KeyedVector<sp<Surface>, size_t> *outputMap) { |
| 2206 | Mutex::Autolock il(mInterfaceLock); |
| 2207 | Mutex::Autolock l(mLock); |
| 2208 | |
| 2209 | ssize_t idx = mOutputStreams.indexOfKey(streamId); |
| 2210 | if (idx == NAME_NOT_FOUND) { |
| 2211 | CLOGE("Stream %d is unknown", streamId); |
| 2212 | return idx; |
| 2213 | } |
| 2214 | |
| 2215 | for (const auto &it : removedSurfaceIds) { |
| 2216 | if (mRequestThread->isOutputSurfacePending(streamId, it)) { |
| 2217 | CLOGE("Shared surface still part of a pending request!"); |
| 2218 | return -EBUSY; |
| 2219 | } |
| 2220 | } |
| 2221 | |
| 2222 | sp<Camera3OutputStreamInterface> stream = mOutputStreams[idx]; |
| 2223 | status_t res = stream->updateStream(newSurfaces, outputInfo, removedSurfaceIds, outputMap); |
| 2224 | if (res != OK) { |
| 2225 | CLOGE("Stream %d failed to update stream (error %d %s) ", |
| 2226 | streamId, res, strerror(-res)); |
| 2227 | if (res == UNKNOWN_ERROR) { |
| 2228 | SET_ERR_L("%s: Stream update failed to revert to previous output configuration!", |
| 2229 | __FUNCTION__); |
| 2230 | } |
| 2231 | return res; |
| 2232 | } |
| 2233 | |
| 2234 | return res; |
| 2235 | } |
| 2236 | |
Chien-Yu Chen | a936ac2 | 2017-10-23 15:59:49 -0700 | [diff] [blame] | 2237 | status_t Camera3Device::dropStreamBuffers(bool dropping, int streamId) { |
| 2238 | Mutex::Autolock il(mInterfaceLock); |
| 2239 | Mutex::Autolock l(mLock); |
| 2240 | |
| 2241 | int idx = mOutputStreams.indexOfKey(streamId); |
| 2242 | if (idx == NAME_NOT_FOUND) { |
| 2243 | ALOGE("%s: Stream %d is not found.", __FUNCTION__, streamId); |
| 2244 | return BAD_VALUE; |
| 2245 | } |
| 2246 | |
| 2247 | sp<Camera3OutputStreamInterface> stream = mOutputStreams.editValueAt(idx); |
| 2248 | return stream->dropBuffers(dropping); |
| 2249 | } |
| 2250 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 2251 | /** |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2252 | * Camera3Device private methods |
| 2253 | */ |
| 2254 | |
| 2255 | sp<Camera3Device::CaptureRequest> Camera3Device::createCaptureRequest( |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 2256 | const PhysicalCameraSettingsList &request, const SurfaceMap &surfaceMap) { |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2257 | ATRACE_CALL(); |
| 2258 | status_t res; |
| 2259 | |
| 2260 | sp<CaptureRequest> newRequest = new CaptureRequest; |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 2261 | newRequest->mSettingsList = request; |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2262 | |
| 2263 | camera_metadata_entry_t inputStreams = |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 2264 | newRequest->mSettingsList.begin()->metadata.find(ANDROID_REQUEST_INPUT_STREAMS); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2265 | if (inputStreams.count > 0) { |
| 2266 | if (mInputStream == NULL || |
Zhijun He | d1d6467 | 2013-09-06 15:00:01 -0700 | [diff] [blame] | 2267 | mInputStream->getId() != inputStreams.data.i32[0]) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 2268 | CLOGE("Request references unknown input stream %d", |
| 2269 | inputStreams.data.u8[0]); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2270 | return NULL; |
| 2271 | } |
| 2272 | // Lazy completion of stream configuration (allocation/registration) |
| 2273 | // on first use |
| 2274 | if (mInputStream->isConfiguring()) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2275 | res = mInputStream->finishConfiguration(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2276 | if (res != OK) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 2277 | SET_ERR_L("Unable to finish configuring input stream %d:" |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2278 | " %s (%d)", |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 2279 | mInputStream->getId(), strerror(-res), res); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2280 | return NULL; |
| 2281 | } |
| 2282 | } |
Shuzhen Wang | b3a0fb5 | 2018-09-13 17:24:08 -0700 | [diff] [blame] | 2283 | // Check if stream prepare is blocking requests. |
| 2284 | if (mInputStream->isBlockedByPrepare()) { |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 2285 | CLOGE("Request references an input stream that's being prepared!"); |
| 2286 | return NULL; |
| 2287 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2288 | |
| 2289 | newRequest->mInputStream = mInputStream; |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 2290 | newRequest->mSettingsList.begin()->metadata.erase(ANDROID_REQUEST_INPUT_STREAMS); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2291 | } |
| 2292 | |
| 2293 | camera_metadata_entry_t streams = |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 2294 | newRequest->mSettingsList.begin()->metadata.find(ANDROID_REQUEST_OUTPUT_STREAMS); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2295 | if (streams.count == 0) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 2296 | CLOGE("Zero output streams specified!"); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2297 | return NULL; |
| 2298 | } |
| 2299 | |
| 2300 | for (size_t i = 0; i < streams.count; i++) { |
Zhijun He | d1d6467 | 2013-09-06 15:00:01 -0700 | [diff] [blame] | 2301 | int idx = mOutputStreams.indexOfKey(streams.data.i32[i]); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2302 | if (idx == NAME_NOT_FOUND) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 2303 | CLOGE("Request references unknown stream %d", |
| 2304 | streams.data.u8[i]); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2305 | return NULL; |
| 2306 | } |
Igor Murashkin | 2fba584 | 2013-04-22 14:03:54 -0700 | [diff] [blame] | 2307 | sp<Camera3OutputStreamInterface> stream = |
| 2308 | mOutputStreams.editValueAt(idx); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2309 | |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 2310 | // It is illegal to include a deferred consumer output stream into a request |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 2311 | auto iter = surfaceMap.find(streams.data.i32[i]); |
| 2312 | if (iter != surfaceMap.end()) { |
| 2313 | const std::vector<size_t>& surfaces = iter->second; |
| 2314 | for (const auto& surface : surfaces) { |
| 2315 | if (stream->isConsumerConfigurationDeferred(surface)) { |
| 2316 | CLOGE("Stream %d surface %zu hasn't finished configuration yet " |
| 2317 | "due to deferred consumer", stream->getId(), surface); |
| 2318 | return NULL; |
| 2319 | } |
| 2320 | } |
| 2321 | newRequest->mOutputSurfaces[i] = surfaces; |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 2322 | } |
| 2323 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2324 | // Lazy completion of stream configuration (allocation/registration) |
| 2325 | // on first use |
| 2326 | if (stream->isConfiguring()) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2327 | res = stream->finishConfiguration(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2328 | if (res != OK) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 2329 | SET_ERR_L("Unable to finish configuring stream %d: %s (%d)", |
| 2330 | stream->getId(), strerror(-res), res); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2331 | return NULL; |
| 2332 | } |
| 2333 | } |
Shuzhen Wang | b3a0fb5 | 2018-09-13 17:24:08 -0700 | [diff] [blame] | 2334 | // Check if stream prepare is blocking requests. |
| 2335 | if (stream->isBlockedByPrepare()) { |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 2336 | CLOGE("Request references an output stream that's being prepared!"); |
| 2337 | return NULL; |
| 2338 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2339 | |
| 2340 | newRequest->mOutputStreams.push(stream); |
| 2341 | } |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 2342 | newRequest->mSettingsList.begin()->metadata.erase(ANDROID_REQUEST_OUTPUT_STREAMS); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 2343 | newRequest->mBatchSize = 1; |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2344 | |
| 2345 | return newRequest; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 2346 | } |
| 2347 | |
Chien-Yu Chen | 618ff8a | 2015-03-13 11:27:17 -0700 | [diff] [blame] | 2348 | bool Camera3Device::isOpaqueInputSizeSupported(uint32_t width, uint32_t height) { |
| 2349 | for (uint32_t i = 0; i < mSupportedOpaqueInputSizes.size(); i++) { |
| 2350 | Size size = mSupportedOpaqueInputSizes[i]; |
| 2351 | if (size.width == width && size.height == height) { |
| 2352 | return true; |
| 2353 | } |
| 2354 | } |
| 2355 | |
| 2356 | return false; |
| 2357 | } |
| 2358 | |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 2359 | void Camera3Device::cancelStreamsConfigurationLocked() { |
| 2360 | int res = OK; |
| 2361 | if (mInputStream != NULL && mInputStream->isConfiguring()) { |
| 2362 | res = mInputStream->cancelConfiguration(); |
| 2363 | if (res != OK) { |
| 2364 | CLOGE("Can't cancel configuring input stream %d: %s (%d)", |
| 2365 | mInputStream->getId(), strerror(-res), res); |
| 2366 | } |
| 2367 | } |
| 2368 | |
| 2369 | for (size_t i = 0; i < mOutputStreams.size(); i++) { |
| 2370 | sp<Camera3OutputStreamInterface> outputStream = mOutputStreams.editValueAt(i); |
| 2371 | if (outputStream->isConfiguring()) { |
| 2372 | res = outputStream->cancelConfiguration(); |
| 2373 | if (res != OK) { |
| 2374 | CLOGE("Can't cancel configuring output stream %d: %s (%d)", |
| 2375 | outputStream->getId(), strerror(-res), res); |
| 2376 | } |
| 2377 | } |
| 2378 | } |
| 2379 | |
| 2380 | // Return state to that at start of call, so that future configures |
| 2381 | // properly clean things up |
| 2382 | internalUpdateStatusLocked(STATUS_UNCONFIGURED); |
| 2383 | mNeedConfig = true; |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 2384 | |
| 2385 | res = mPreparerThread->resume(); |
| 2386 | if (res != OK) { |
| 2387 | ALOGE("%s: Camera %s: Preparer thread failed to resume!", __FUNCTION__, mId.string()); |
| 2388 | } |
| 2389 | } |
| 2390 | |
| 2391 | bool Camera3Device::reconfigureCamera(const CameraMetadata& sessionParams) { |
| 2392 | ATRACE_CALL(); |
| 2393 | bool ret = false; |
| 2394 | |
| 2395 | Mutex::Autolock il(mInterfaceLock); |
| 2396 | nsecs_t maxExpectedDuration = getExpectedInFlightDuration(); |
| 2397 | |
| 2398 | Mutex::Autolock l(mLock); |
| 2399 | auto rc = internalPauseAndWaitLocked(maxExpectedDuration); |
| 2400 | if (rc == NO_ERROR) { |
| 2401 | mNeedConfig = true; |
| 2402 | rc = configureStreamsLocked(mOperatingMode, sessionParams, /*notifyRequestThread*/ false); |
| 2403 | if (rc == NO_ERROR) { |
| 2404 | ret = true; |
| 2405 | mPauseStateNotify = false; |
| 2406 | //Moving to active state while holding 'mLock' is important. |
| 2407 | //There could be pending calls to 'create-/deleteStream' which |
| 2408 | //will trigger another stream configuration while the already |
| 2409 | //present streams end up with outstanding buffers that will |
| 2410 | //not get drained. |
| 2411 | internalUpdateStatusLocked(STATUS_ACTIVE); |
Shuzhen Wang | 210ba5c | 2018-07-25 16:47:40 -0700 | [diff] [blame] | 2412 | } else if (rc == DEAD_OBJECT) { |
| 2413 | // DEAD_OBJECT can be returned if either the consumer surface is |
| 2414 | // abandoned, or the HAL has died. |
| 2415 | // - If the HAL has died, configureStreamsLocked call will set |
| 2416 | // device to error state, |
| 2417 | // - If surface is abandoned, we should not set device to error |
| 2418 | // state. |
| 2419 | ALOGE("Failed to re-configure camera due to abandoned surface"); |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 2420 | } else { |
Shuzhen Wang | 210ba5c | 2018-07-25 16:47:40 -0700 | [diff] [blame] | 2421 | SET_ERR_L("Failed to re-configure camera: %d", rc); |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 2422 | } |
| 2423 | } else { |
| 2424 | ALOGE("%s: Failed to pause streaming: %d", __FUNCTION__, rc); |
| 2425 | } |
| 2426 | |
| 2427 | return ret; |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 2428 | } |
| 2429 | |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 2430 | status_t Camera3Device::configureStreamsLocked(int operatingMode, |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 2431 | const CameraMetadata& sessionParams, bool notifyRequestThread) { |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2432 | ATRACE_CALL(); |
| 2433 | status_t res; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 2434 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 2435 | if (mStatus != STATUS_UNCONFIGURED && mStatus != STATUS_CONFIGURED) { |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 2436 | CLOGE("Not idle"); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2437 | return INVALID_OPERATION; |
| 2438 | } |
| 2439 | |
Eino-Ville Talvala | e7091aa | 2017-03-07 15:23:06 -0800 | [diff] [blame] | 2440 | if (operatingMode < 0) { |
| 2441 | CLOGE("Invalid operating mode: %d", operatingMode); |
| 2442 | return BAD_VALUE; |
| 2443 | } |
| 2444 | |
| 2445 | bool isConstrainedHighSpeed = |
| 2446 | static_cast<int>(StreamConfigurationMode::CONSTRAINED_HIGH_SPEED_MODE) == |
| 2447 | operatingMode; |
| 2448 | |
| 2449 | if (mOperatingMode != operatingMode) { |
| 2450 | mNeedConfig = true; |
| 2451 | mIsConstrainedHighSpeedConfiguration = isConstrainedHighSpeed; |
| 2452 | mOperatingMode = operatingMode; |
| 2453 | } |
| 2454 | |
Eino-Ville Talvala | ea26c77 | 2013-06-11 16:04:06 -0700 | [diff] [blame] | 2455 | if (!mNeedConfig) { |
| 2456 | ALOGV("%s: Skipping config, no stream changes", __FUNCTION__); |
| 2457 | return OK; |
| 2458 | } |
| 2459 | |
Eino-Ville Talvala | 16a2ada | 2014-08-27 14:41:33 -0700 | [diff] [blame] | 2460 | // Workaround for device HALv3.2 or older spec bug - zero streams requires |
| 2461 | // adding a dummy stream instead. |
| 2462 | // TODO: Bug: 17321404 for fixing the HAL spec and removing this workaround. |
| 2463 | if (mOutputStreams.size() == 0) { |
| 2464 | addDummyStreamLocked(); |
| 2465 | } else { |
| 2466 | tryRemoveDummyStreamLocked(); |
| 2467 | } |
| 2468 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2469 | // Start configuring the streams |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2470 | ALOGV("%s: Camera %s: Starting stream configuration", __FUNCTION__, mId.string()); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2471 | |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 2472 | mPreparerThread->pause(); |
| 2473 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2474 | camera3_stream_configuration config; |
Eino-Ville Talvala | bbbbe84 | 2017-02-28 17:50:56 -0800 | [diff] [blame] | 2475 | config.operation_mode = mOperatingMode; |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2476 | config.num_streams = (mInputStream != NULL) + mOutputStreams.size(); |
| 2477 | |
| 2478 | Vector<camera3_stream_t*> streams; |
| 2479 | streams.setCapacity(config.num_streams); |
Emilian Peev | 192ee83 | 2018-01-31 14:46:47 +0000 | [diff] [blame] | 2480 | std::vector<uint32_t> bufferSizes(config.num_streams, 0); |
Yin-Chia Yeh | fb6e55b | 2018-01-25 10:50:26 -0800 | [diff] [blame] | 2481 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2482 | |
| 2483 | if (mInputStream != NULL) { |
| 2484 | camera3_stream_t *inputStream; |
| 2485 | inputStream = mInputStream->startConfiguration(); |
| 2486 | if (inputStream == NULL) { |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 2487 | CLOGE("Can't start input stream configuration"); |
| 2488 | cancelStreamsConfigurationLocked(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2489 | return INVALID_OPERATION; |
| 2490 | } |
| 2491 | streams.add(inputStream); |
| 2492 | } |
| 2493 | |
| 2494 | for (size_t i = 0; i < mOutputStreams.size(); i++) { |
Igor Murashkin | 2fba584 | 2013-04-22 14:03:54 -0700 | [diff] [blame] | 2495 | |
| 2496 | // Don't configure bidi streams twice, nor add them twice to the list |
| 2497 | if (mOutputStreams[i].get() == |
| 2498 | static_cast<Camera3StreamInterface*>(mInputStream.get())) { |
| 2499 | |
| 2500 | config.num_streams--; |
| 2501 | continue; |
| 2502 | } |
| 2503 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2504 | camera3_stream_t *outputStream; |
| 2505 | outputStream = mOutputStreams.editValueAt(i)->startConfiguration(); |
| 2506 | if (outputStream == NULL) { |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 2507 | CLOGE("Can't start output stream configuration"); |
| 2508 | cancelStreamsConfigurationLocked(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2509 | return INVALID_OPERATION; |
| 2510 | } |
| 2511 | streams.add(outputStream); |
Yin-Chia Yeh | fb6e55b | 2018-01-25 10:50:26 -0800 | [diff] [blame] | 2512 | |
| 2513 | if (outputStream->format == HAL_PIXEL_FORMAT_BLOB && |
| 2514 | outputStream->data_space == HAL_DATASPACE_V0_JFIF) { |
Emilian Peev | 192ee83 | 2018-01-31 14:46:47 +0000 | [diff] [blame] | 2515 | size_t k = i + ((mInputStream != nullptr) ? 1 : 0); // Input stream if present should |
| 2516 | // always occupy the initial entry. |
| 2517 | bufferSizes[k] = static_cast<uint32_t>( |
Yin-Chia Yeh | fb6e55b | 2018-01-25 10:50:26 -0800 | [diff] [blame] | 2518 | getJpegBufferSize(outputStream->width, outputStream->height)); |
| 2519 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2520 | } |
| 2521 | |
| 2522 | config.streams = streams.editArray(); |
| 2523 | |
| 2524 | // Do the HAL configuration; will potentially touch stream |
| 2525 | // max_buffers, usage, priv fields. |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2526 | |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 2527 | const camera_metadata_t *sessionBuffer = sessionParams.getAndLock(); |
Emilian Peev | 192ee83 | 2018-01-31 14:46:47 +0000 | [diff] [blame] | 2528 | res = mInterface->configureStreams(sessionBuffer, &config, bufferSizes); |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 2529 | sessionParams.unlock(sessionBuffer); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2530 | |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 2531 | if (res == BAD_VALUE) { |
| 2532 | // HAL rejected this set of streams as unsupported, clean up config |
| 2533 | // attempt and return to unconfigured state |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 2534 | CLOGE("Set of requested inputs/outputs not supported by HAL"); |
| 2535 | cancelStreamsConfigurationLocked(); |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 2536 | return BAD_VALUE; |
| 2537 | } else if (res != OK) { |
| 2538 | // Some other kind of error from configure_streams - this is not |
| 2539 | // expected |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 2540 | SET_ERR_L("Unable to configure streams with HAL: %s (%d)", |
| 2541 | strerror(-res), res); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2542 | return res; |
| 2543 | } |
| 2544 | |
Eino-Ville Talvala | 4c95676 | 2013-04-19 17:26:13 -0700 | [diff] [blame] | 2545 | // Finish all stream configuration immediately. |
| 2546 | // TODO: Try to relax this later back to lazy completion, which should be |
| 2547 | // faster |
| 2548 | |
Igor Murashkin | 073f857 | 2013-05-02 14:59:28 -0700 | [diff] [blame] | 2549 | if (mInputStream != NULL && mInputStream->isConfiguring()) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2550 | res = mInputStream->finishConfiguration(); |
Eino-Ville Talvala | 4c95676 | 2013-04-19 17:26:13 -0700 | [diff] [blame] | 2551 | if (res != OK) { |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 2552 | CLOGE("Can't finish configuring input stream %d: %s (%d)", |
Eino-Ville Talvala | 4c95676 | 2013-04-19 17:26:13 -0700 | [diff] [blame] | 2553 | mInputStream->getId(), strerror(-res), res); |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 2554 | cancelStreamsConfigurationLocked(); |
Shuzhen Wang | 210ba5c | 2018-07-25 16:47:40 -0700 | [diff] [blame] | 2555 | if ((res == NO_INIT || res == DEAD_OBJECT) && mInputStream->isAbandoned()) { |
| 2556 | return DEAD_OBJECT; |
| 2557 | } |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 2558 | return BAD_VALUE; |
Eino-Ville Talvala | 4c95676 | 2013-04-19 17:26:13 -0700 | [diff] [blame] | 2559 | } |
| 2560 | } |
| 2561 | |
| 2562 | for (size_t i = 0; i < mOutputStreams.size(); i++) { |
Igor Murashkin | 073f857 | 2013-05-02 14:59:28 -0700 | [diff] [blame] | 2563 | sp<Camera3OutputStreamInterface> outputStream = |
| 2564 | mOutputStreams.editValueAt(i); |
Zhijun He | 5d677d1 | 2016-05-29 16:52:39 -0700 | [diff] [blame] | 2565 | if (outputStream->isConfiguring() && !outputStream->isConsumerConfigurationDeferred()) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2566 | res = outputStream->finishConfiguration(); |
Igor Murashkin | 073f857 | 2013-05-02 14:59:28 -0700 | [diff] [blame] | 2567 | if (res != OK) { |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 2568 | CLOGE("Can't finish configuring output stream %d: %s (%d)", |
Igor Murashkin | 073f857 | 2013-05-02 14:59:28 -0700 | [diff] [blame] | 2569 | outputStream->getId(), strerror(-res), res); |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 2570 | cancelStreamsConfigurationLocked(); |
Shuzhen Wang | 210ba5c | 2018-07-25 16:47:40 -0700 | [diff] [blame] | 2571 | if ((res == NO_INIT || res == DEAD_OBJECT) && outputStream->isAbandoned()) { |
| 2572 | return DEAD_OBJECT; |
| 2573 | } |
Chien-Yu Chen | 9b5860b | 2016-06-10 13:39:09 -0700 | [diff] [blame] | 2574 | return BAD_VALUE; |
Igor Murashkin | 073f857 | 2013-05-02 14:59:28 -0700 | [diff] [blame] | 2575 | } |
Eino-Ville Talvala | 4c95676 | 2013-04-19 17:26:13 -0700 | [diff] [blame] | 2576 | } |
| 2577 | } |
| 2578 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2579 | // Request thread needs to know to avoid using repeat-last-settings protocol |
| 2580 | // across configure_streams() calls |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 2581 | if (notifyRequestThread) { |
| 2582 | mRequestThread->configurationComplete(mIsConstrainedHighSpeedConfiguration, sessionParams); |
| 2583 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2584 | |
Zhijun He | 90f7c37 | 2016-08-16 16:19:43 -0700 | [diff] [blame] | 2585 | char value[PROPERTY_VALUE_MAX]; |
| 2586 | property_get("camera.fifo.disable", value, "0"); |
| 2587 | int32_t disableFifo = atoi(value); |
| 2588 | if (disableFifo != 1) { |
| 2589 | // Boost priority of request thread to SCHED_FIFO. |
| 2590 | pid_t requestThreadTid = mRequestThread->getTid(); |
| 2591 | res = requestPriority(getpid(), requestThreadTid, |
Mikhail Naganov | 83f0427 | 2017-02-07 10:45:09 -0800 | [diff] [blame] | 2592 | kRequestThreadPriority, /*isForApp*/ false, /*asynchronous*/ false); |
Zhijun He | 90f7c37 | 2016-08-16 16:19:43 -0700 | [diff] [blame] | 2593 | if (res != OK) { |
| 2594 | ALOGW("Can't set realtime priority for request processing thread: %s (%d)", |
| 2595 | strerror(-res), res); |
| 2596 | } else { |
| 2597 | ALOGD("Set real time priority for request queue thread (tid %d)", requestThreadTid); |
| 2598 | } |
Eino-Ville Talvala | f99498e | 2015-09-25 16:52:55 -0700 | [diff] [blame] | 2599 | } |
| 2600 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 2601 | // Update device state |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 2602 | const camera_metadata_t *newSessionParams = sessionParams.getAndLock(); |
| 2603 | const camera_metadata_t *currentSessionParams = mSessionParams.getAndLock(); |
| 2604 | bool updateSessionParams = (newSessionParams != currentSessionParams) ? true : false; |
| 2605 | sessionParams.unlock(newSessionParams); |
| 2606 | mSessionParams.unlock(currentSessionParams); |
| 2607 | if (updateSessionParams) { |
| 2608 | mSessionParams = sessionParams; |
| 2609 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2610 | |
Eino-Ville Talvala | ea26c77 | 2013-06-11 16:04:06 -0700 | [diff] [blame] | 2611 | mNeedConfig = false; |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2612 | |
Ruben Brunk | 183f056 | 2015-08-12 12:55:02 -0700 | [diff] [blame] | 2613 | internalUpdateStatusLocked((mDummyStreamId == NO_STREAM) ? |
| 2614 | STATUS_CONFIGURED : STATUS_UNCONFIGURED); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 2615 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2616 | ALOGV("%s: Camera %s: Stream configuration complete", __FUNCTION__, mId.string()); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 2617 | |
Zhijun He | 0a21051 | 2014-07-24 13:45:15 -0700 | [diff] [blame] | 2618 | // tear down the deleted streams after configure streams. |
| 2619 | mDeletedStreams.clear(); |
| 2620 | |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 2621 | auto rc = mPreparerThread->resume(); |
| 2622 | if (rc != OK) { |
| 2623 | SET_ERR_L("%s: Camera %s: Preparer thread failed to resume!", __FUNCTION__, mId.string()); |
| 2624 | return rc; |
| 2625 | } |
| 2626 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2627 | return OK; |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 2628 | } |
| 2629 | |
Eino-Ville Talvala | 16a2ada | 2014-08-27 14:41:33 -0700 | [diff] [blame] | 2630 | status_t Camera3Device::addDummyStreamLocked() { |
| 2631 | ATRACE_CALL(); |
| 2632 | status_t res; |
| 2633 | |
| 2634 | if (mDummyStreamId != NO_STREAM) { |
| 2635 | // Should never be adding a second dummy stream when one is already |
| 2636 | // active |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2637 | SET_ERR_L("%s: Camera %s: A dummy stream already exists!", |
| 2638 | __FUNCTION__, mId.string()); |
Eino-Ville Talvala | 16a2ada | 2014-08-27 14:41:33 -0700 | [diff] [blame] | 2639 | return INVALID_OPERATION; |
| 2640 | } |
| 2641 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2642 | ALOGV("%s: Camera %s: Adding a dummy stream", __FUNCTION__, mId.string()); |
Eino-Ville Talvala | 16a2ada | 2014-08-27 14:41:33 -0700 | [diff] [blame] | 2643 | |
| 2644 | sp<Camera3OutputStreamInterface> dummyStream = |
| 2645 | new Camera3DummyStream(mNextStreamId); |
| 2646 | |
| 2647 | res = mOutputStreams.add(mNextStreamId, dummyStream); |
| 2648 | if (res < 0) { |
| 2649 | SET_ERR_L("Can't add dummy stream to set: %s (%d)", strerror(-res), res); |
| 2650 | return res; |
| 2651 | } |
| 2652 | |
| 2653 | mDummyStreamId = mNextStreamId; |
| 2654 | mNextStreamId++; |
| 2655 | |
| 2656 | return OK; |
| 2657 | } |
| 2658 | |
| 2659 | status_t Camera3Device::tryRemoveDummyStreamLocked() { |
| 2660 | ATRACE_CALL(); |
| 2661 | status_t res; |
| 2662 | |
| 2663 | if (mDummyStreamId == NO_STREAM) return OK; |
| 2664 | if (mOutputStreams.size() == 1) return OK; |
| 2665 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2666 | ALOGV("%s: Camera %s: Removing the dummy stream", __FUNCTION__, mId.string()); |
Eino-Ville Talvala | 16a2ada | 2014-08-27 14:41:33 -0700 | [diff] [blame] | 2667 | |
| 2668 | // Ok, have a dummy stream and there's at least one other output stream, |
| 2669 | // so remove the dummy |
| 2670 | |
| 2671 | sp<Camera3StreamInterface> deletedStream; |
| 2672 | ssize_t outputStreamIdx = mOutputStreams.indexOfKey(mDummyStreamId); |
| 2673 | if (outputStreamIdx == NAME_NOT_FOUND) { |
| 2674 | SET_ERR_L("Dummy stream %d does not appear to exist", mDummyStreamId); |
| 2675 | return INVALID_OPERATION; |
| 2676 | } |
| 2677 | |
| 2678 | deletedStream = mOutputStreams.editValueAt(outputStreamIdx); |
| 2679 | mOutputStreams.removeItemsAt(outputStreamIdx); |
| 2680 | |
| 2681 | // Free up the stream endpoint so that it can be used by some other stream |
| 2682 | res = deletedStream->disconnect(); |
| 2683 | if (res != OK) { |
| 2684 | SET_ERR_L("Can't disconnect deleted dummy stream %d", mDummyStreamId); |
| 2685 | // fall through since we want to still list the stream as deleted. |
| 2686 | } |
| 2687 | mDeletedStreams.add(deletedStream); |
| 2688 | mDummyStreamId = NO_STREAM; |
| 2689 | |
| 2690 | return res; |
| 2691 | } |
| 2692 | |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 2693 | void Camera3Device::setErrorState(const char *fmt, ...) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 2694 | ATRACE_CALL(); |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 2695 | Mutex::Autolock l(mLock); |
| 2696 | va_list args; |
| 2697 | va_start(args, fmt); |
| 2698 | |
| 2699 | setErrorStateLockedV(fmt, args); |
| 2700 | |
| 2701 | va_end(args); |
| 2702 | } |
| 2703 | |
| 2704 | void Camera3Device::setErrorStateV(const char *fmt, va_list args) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 2705 | ATRACE_CALL(); |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 2706 | Mutex::Autolock l(mLock); |
| 2707 | setErrorStateLockedV(fmt, args); |
| 2708 | } |
| 2709 | |
| 2710 | void Camera3Device::setErrorStateLocked(const char *fmt, ...) { |
| 2711 | va_list args; |
| 2712 | va_start(args, fmt); |
| 2713 | |
| 2714 | setErrorStateLockedV(fmt, args); |
| 2715 | |
| 2716 | va_end(args); |
| 2717 | } |
| 2718 | |
| 2719 | void Camera3Device::setErrorStateLockedV(const char *fmt, va_list args) { |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 2720 | // Print out all error messages to log |
| 2721 | String8 errorCause = String8::formatV(fmt, args); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 2722 | ALOGE("Camera %s: %s", mId.string(), errorCause.string()); |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 2723 | |
| 2724 | // But only do error state transition steps for the first error |
Zhijun He | b05eeae | 2013-06-06 13:51:22 -0700 | [diff] [blame] | 2725 | if (mStatus == STATUS_ERROR || mStatus == STATUS_UNINITIALIZED) return; |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 2726 | |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 2727 | mErrorCause = errorCause; |
| 2728 | |
Yin-Chia Yeh | 3d145ae | 2017-07-27 12:47:03 -0700 | [diff] [blame] | 2729 | if (mRequestThread != nullptr) { |
| 2730 | mRequestThread->setPaused(true); |
| 2731 | } |
Ruben Brunk | 183f056 | 2015-08-12 12:55:02 -0700 | [diff] [blame] | 2732 | internalUpdateStatusLocked(STATUS_ERROR); |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 2733 | |
| 2734 | // Notify upstream about a device error |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 2735 | sp<NotificationListener> listener = mListener.promote(); |
| 2736 | if (listener != NULL) { |
| 2737 | listener->notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE, |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 2738 | CaptureResultExtras()); |
| 2739 | } |
| 2740 | |
| 2741 | // Save stack trace. View by dumping it later. |
| 2742 | CameraTraces::saveTrace(); |
| 2743 | // TODO: consider adding errorCause and client pid/procname |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 2744 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 2745 | |
| 2746 | /** |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 2747 | * In-flight request management |
| 2748 | */ |
| 2749 | |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 2750 | status_t Camera3Device::registerInFlight(uint32_t frameNumber, |
Chien-Yu Chen | d196d61 | 2015-06-22 19:49:01 -0700 | [diff] [blame] | 2751 | int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput, |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 2752 | bool hasAppCallback, nsecs_t maxExpectedDuration, |
Shuzhen Wang | 26abaf4 | 2018-08-28 15:41:20 -0700 | [diff] [blame] | 2753 | std::set<String8>& physicalCameraIds, bool isStillCapture, |
| 2754 | bool isZslCapture) { |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 2755 | ATRACE_CALL(); |
| 2756 | Mutex::Autolock l(mInFlightLock); |
| 2757 | |
| 2758 | ssize_t res; |
Chien-Yu Chen | d196d61 | 2015-06-22 19:49:01 -0700 | [diff] [blame] | 2759 | res = mInFlightMap.add(frameNumber, InFlightRequest(numBuffers, resultExtras, hasInput, |
Shuzhen Wang | 26abaf4 | 2018-08-28 15:41:20 -0700 | [diff] [blame] | 2760 | hasAppCallback, maxExpectedDuration, physicalCameraIds, isStillCapture, isZslCapture)); |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 2761 | if (res < 0) return res; |
| 2762 | |
Eino-Ville Talvala | 24b366e | 2016-07-21 12:53:07 -0700 | [diff] [blame] | 2763 | if (mInFlightMap.size() == 1) { |
Emilian Peev | 26d975d | 2018-07-05 14:52:57 +0100 | [diff] [blame] | 2764 | // Hold a separate dedicated tracker lock to prevent race with disconnect and also |
| 2765 | // avoid a deadlock during reprocess requests. |
| 2766 | Mutex::Autolock l(mTrackerLock); |
Yin-Chia Yeh | 38dfde5 | 2017-06-27 17:13:33 -0700 | [diff] [blame] | 2767 | if (mStatusTracker != nullptr) { |
| 2768 | mStatusTracker->markComponentActive(mInFlightStatusId); |
| 2769 | } |
Eino-Ville Talvala | 24b366e | 2016-07-21 12:53:07 -0700 | [diff] [blame] | 2770 | } |
| 2771 | |
Eino-Ville Talvala | 10bd57e | 2017-06-23 16:22:44 -0700 | [diff] [blame] | 2772 | mExpectedInflightDuration += maxExpectedDuration; |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 2773 | return OK; |
| 2774 | } |
| 2775 | |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 2776 | void Camera3Device::returnOutputBuffers( |
| 2777 | const camera3_stream_buffer_t *outputBuffers, size_t numBuffers, |
Shuzhen Wang | 26abaf4 | 2018-08-28 15:41:20 -0700 | [diff] [blame] | 2778 | nsecs_t timestamp, bool timestampIncreasing) { |
| 2779 | |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 2780 | for (size_t i = 0; i < numBuffers; i++) |
| 2781 | { |
| 2782 | Camera3Stream *stream = Camera3Stream::cast(outputBuffers[i].stream); |
Shuzhen Wang | 26abaf4 | 2018-08-28 15:41:20 -0700 | [diff] [blame] | 2783 | status_t res = stream->returnBuffer(outputBuffers[i], timestamp, timestampIncreasing); |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 2784 | // Note: stream may be deallocated at this point, if this buffer was |
| 2785 | // the last reference to it. |
| 2786 | if (res != OK) { |
| 2787 | ALOGE("Can't return buffer to its stream: %s (%d)", |
| 2788 | strerror(-res), res); |
| 2789 | } |
| 2790 | } |
| 2791 | } |
| 2792 | |
Shuzhen Wang | cadb330 | 2016-11-04 14:17:56 -0700 | [diff] [blame] | 2793 | void Camera3Device::removeInFlightMapEntryLocked(int idx) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 2794 | ATRACE_CALL(); |
Eino-Ville Talvala | 10bd57e | 2017-06-23 16:22:44 -0700 | [diff] [blame] | 2795 | nsecs_t duration = mInFlightMap.valueAt(idx).maxExpectedDuration; |
Shuzhen Wang | cadb330 | 2016-11-04 14:17:56 -0700 | [diff] [blame] | 2796 | mInFlightMap.removeItemsAt(idx, 1); |
| 2797 | |
| 2798 | // Indicate idle inFlightMap to the status tracker |
| 2799 | if (mInFlightMap.size() == 0) { |
Emilian Peev | 26d975d | 2018-07-05 14:52:57 +0100 | [diff] [blame] | 2800 | // Hold a separate dedicated tracker lock to prevent race with disconnect and also |
| 2801 | // avoid a deadlock during reprocess requests. |
| 2802 | Mutex::Autolock l(mTrackerLock); |
Yin-Chia Yeh | 38dfde5 | 2017-06-27 17:13:33 -0700 | [diff] [blame] | 2803 | if (mStatusTracker != nullptr) { |
| 2804 | mStatusTracker->markComponentIdle(mInFlightStatusId, Fence::NO_FENCE); |
| 2805 | } |
Shuzhen Wang | cadb330 | 2016-11-04 14:17:56 -0700 | [diff] [blame] | 2806 | } |
Eino-Ville Talvala | 10bd57e | 2017-06-23 16:22:44 -0700 | [diff] [blame] | 2807 | mExpectedInflightDuration -= duration; |
Shuzhen Wang | cadb330 | 2016-11-04 14:17:56 -0700 | [diff] [blame] | 2808 | } |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 2809 | |
| 2810 | void Camera3Device::removeInFlightRequestIfReadyLocked(int idx) { |
| 2811 | |
| 2812 | const InFlightRequest &request = mInFlightMap.valueAt(idx); |
| 2813 | const uint32_t frameNumber = mInFlightMap.keyAt(idx); |
| 2814 | |
| 2815 | nsecs_t sensorTimestamp = request.sensorTimestamp; |
| 2816 | nsecs_t shutterTimestamp = request.shutterTimestamp; |
| 2817 | |
| 2818 | // Check if it's okay to remove the request from InFlightMap: |
| 2819 | // In the case of a successful request: |
| 2820 | // all input and output buffers, all result metadata, shutter callback |
| 2821 | // arrived. |
| 2822 | // In the case of a unsuccessful request: |
| 2823 | // all input and output buffers arrived. |
| 2824 | if (request.numBuffersLeft == 0 && |
Shuzhen Wang | 20f5734 | 2017-08-24 15:39:05 -0700 | [diff] [blame] | 2825 | (request.skipResultMetadata || |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 2826 | (request.haveResultMetadata && shutterTimestamp != 0))) { |
Emilian Peev | 9dd21f4 | 2018-08-03 13:39:29 +0100 | [diff] [blame] | 2827 | if (request.stillCapture) { |
| 2828 | ATRACE_ASYNC_END("still capture", frameNumber); |
| 2829 | } |
| 2830 | |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 2831 | ATRACE_ASYNC_END("frame capture", frameNumber); |
| 2832 | |
Shuzhen Wang | 403044a | 2017-02-26 23:29:04 -0800 | [diff] [blame] | 2833 | // Sanity check - if sensor timestamp matches shutter timestamp in the |
| 2834 | // case of request having callback. |
| 2835 | if (request.hasCallback && request.requestStatus == OK && |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 2836 | sensorTimestamp != shutterTimestamp) { |
| 2837 | SET_ERR("sensor timestamp (%" PRId64 |
| 2838 | ") for frame %d doesn't match shutter timestamp (%" PRId64 ")", |
| 2839 | sensorTimestamp, frameNumber, shutterTimestamp); |
| 2840 | } |
| 2841 | |
| 2842 | // for an unsuccessful request, it may have pending output buffers to |
| 2843 | // return. |
| 2844 | assert(request.requestStatus != OK || |
| 2845 | request.pendingOutputBuffers.size() == 0); |
| 2846 | returnOutputBuffers(request.pendingOutputBuffers.array(), |
| 2847 | request.pendingOutputBuffers.size(), 0); |
| 2848 | |
Shuzhen Wang | cadb330 | 2016-11-04 14:17:56 -0700 | [diff] [blame] | 2849 | removeInFlightMapEntryLocked(idx); |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 2850 | ALOGVV("%s: removed frame %d from InFlightMap", __FUNCTION__, frameNumber); |
| 2851 | } |
| 2852 | |
| 2853 | // Sanity check - if we have too many in-flight frames, something has |
| 2854 | // likely gone wrong |
Chien-Yu Chen | c96ac8d | 2015-08-12 16:46:24 -0700 | [diff] [blame] | 2855 | if (!mIsConstrainedHighSpeedConfiguration && mInFlightMap.size() > kInFlightWarnLimit) { |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 2856 | CLOGE("In-flight list too large: %zu", mInFlightMap.size()); |
Chien-Yu Chen | c96ac8d | 2015-08-12 16:46:24 -0700 | [diff] [blame] | 2857 | } else if (mIsConstrainedHighSpeedConfiguration && mInFlightMap.size() > |
| 2858 | kInFlightWarnLimitHighSpeed) { |
| 2859 | CLOGE("In-flight list too large for high speed configuration: %zu", |
| 2860 | mInFlightMap.size()); |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 2861 | } |
| 2862 | } |
| 2863 | |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 2864 | void Camera3Device::flushInflightRequests() { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 2865 | ATRACE_CALL(); |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 2866 | { // First return buffers cached in mInFlightMap |
| 2867 | Mutex::Autolock l(mInFlightLock); |
| 2868 | for (size_t idx = 0; idx < mInFlightMap.size(); idx++) { |
| 2869 | const InFlightRequest &request = mInFlightMap.valueAt(idx); |
| 2870 | returnOutputBuffers(request.pendingOutputBuffers.array(), |
| 2871 | request.pendingOutputBuffers.size(), 0); |
| 2872 | } |
| 2873 | mInFlightMap.clear(); |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 2874 | mExpectedInflightDuration = 0; |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 2875 | } |
| 2876 | |
| 2877 | // Then return all inflight buffers not returned by HAL |
| 2878 | std::vector<std::pair<int32_t, int32_t>> inflightKeys; |
| 2879 | mInterface->getInflightBufferKeys(&inflightKeys); |
| 2880 | |
| 2881 | int32_t inputStreamId = (mInputStream != nullptr) ? mInputStream->getId() : -1; |
| 2882 | for (auto& pair : inflightKeys) { |
| 2883 | int32_t frameNumber = pair.first; |
| 2884 | int32_t streamId = pair.second; |
| 2885 | buffer_handle_t* buffer; |
| 2886 | status_t res = mInterface->popInflightBuffer(frameNumber, streamId, &buffer); |
| 2887 | if (res != OK) { |
| 2888 | ALOGE("%s: Frame %d: No in-flight buffer for stream %d", |
| 2889 | __FUNCTION__, frameNumber, streamId); |
| 2890 | continue; |
| 2891 | } |
| 2892 | |
| 2893 | camera3_stream_buffer_t streamBuffer; |
| 2894 | streamBuffer.buffer = buffer; |
| 2895 | streamBuffer.status = CAMERA3_BUFFER_STATUS_ERROR; |
| 2896 | streamBuffer.acquire_fence = -1; |
| 2897 | streamBuffer.release_fence = -1; |
Yin-Chia Yeh | 5090c73 | 2017-07-20 16:05:29 -0700 | [diff] [blame] | 2898 | |
| 2899 | // First check if the buffer belongs to deleted stream |
| 2900 | bool streamDeleted = false; |
| 2901 | for (auto& stream : mDeletedStreams) { |
| 2902 | if (streamId == stream->getId()) { |
| 2903 | streamDeleted = true; |
| 2904 | // Return buffer to deleted stream |
| 2905 | camera3_stream* halStream = stream->asHalStream(); |
| 2906 | streamBuffer.stream = halStream; |
| 2907 | switch (halStream->stream_type) { |
| 2908 | case CAMERA3_STREAM_OUTPUT: |
| 2909 | res = stream->returnBuffer(streamBuffer, /*timestamp*/ 0); |
| 2910 | if (res != OK) { |
| 2911 | ALOGE("%s: Can't return output buffer for frame %d to" |
| 2912 | " stream %d: %s (%d)", __FUNCTION__, |
| 2913 | frameNumber, streamId, strerror(-res), res); |
| 2914 | } |
| 2915 | break; |
| 2916 | case CAMERA3_STREAM_INPUT: |
| 2917 | res = stream->returnInputBuffer(streamBuffer); |
| 2918 | if (res != OK) { |
| 2919 | ALOGE("%s: Can't return input buffer for frame %d to" |
| 2920 | " stream %d: %s (%d)", __FUNCTION__, |
| 2921 | frameNumber, streamId, strerror(-res), res); |
| 2922 | } |
| 2923 | break; |
| 2924 | default: // Bi-direcitonal stream is deprecated |
| 2925 | ALOGE("%s: stream %d has unknown stream type %d", |
| 2926 | __FUNCTION__, streamId, halStream->stream_type); |
| 2927 | break; |
| 2928 | } |
| 2929 | break; |
| 2930 | } |
| 2931 | } |
| 2932 | if (streamDeleted) { |
| 2933 | continue; |
| 2934 | } |
| 2935 | |
| 2936 | // Then check against configured streams |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 2937 | if (streamId == inputStreamId) { |
| 2938 | streamBuffer.stream = mInputStream->asHalStream(); |
| 2939 | res = mInputStream->returnInputBuffer(streamBuffer); |
| 2940 | if (res != OK) { |
| 2941 | ALOGE("%s: Can't return input buffer for frame %d to" |
Yin-Chia Yeh | 5090c73 | 2017-07-20 16:05:29 -0700 | [diff] [blame] | 2942 | " stream %d: %s (%d)", __FUNCTION__, |
| 2943 | frameNumber, streamId, strerror(-res), res); |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 2944 | } |
| 2945 | } else { |
Yin-Chia Yeh | 5090c73 | 2017-07-20 16:05:29 -0700 | [diff] [blame] | 2946 | ssize_t idx = mOutputStreams.indexOfKey(streamId); |
| 2947 | if (idx == NAME_NOT_FOUND) { |
| 2948 | ALOGE("%s: Output stream id %d not found!", __FUNCTION__, streamId); |
| 2949 | continue; |
| 2950 | } |
| 2951 | streamBuffer.stream = mOutputStreams.valueAt(idx)->asHalStream(); |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 2952 | returnOutputBuffers(&streamBuffer, /*size*/1, /*timestamp*/ 0); |
| 2953 | } |
| 2954 | } |
| 2955 | } |
| 2956 | |
Emilian Peev | 7e25e5e | 2017-04-07 15:48:49 +0100 | [diff] [blame] | 2957 | void Camera3Device::insertResultLocked(CaptureResult *result, |
| 2958 | uint32_t frameNumber) { |
Chien-Yu Chen | 5cd8d64 | 2016-03-08 14:46:58 -0800 | [diff] [blame] | 2959 | if (result == nullptr) return; |
| 2960 | |
Emilian Peev | 71c73a2 | 2017-03-21 16:35:51 +0000 | [diff] [blame] | 2961 | camera_metadata_t *meta = const_cast<camera_metadata_t *>( |
| 2962 | result->mMetadata.getAndLock()); |
| 2963 | set_camera_metadata_vendor_id(meta, mVendorTagId); |
| 2964 | result->mMetadata.unlock(meta); |
| 2965 | |
Chien-Yu Chen | 5cd8d64 | 2016-03-08 14:46:58 -0800 | [diff] [blame] | 2966 | if (result->mMetadata.update(ANDROID_REQUEST_FRAME_COUNT, |
| 2967 | (int32_t*)&frameNumber, 1) != OK) { |
| 2968 | SET_ERR("Failed to set frame number %d in metadata", frameNumber); |
| 2969 | return; |
| 2970 | } |
| 2971 | |
| 2972 | if (result->mMetadata.update(ANDROID_REQUEST_ID, &result->mResultExtras.requestId, 1) != OK) { |
| 2973 | SET_ERR("Failed to set request ID in metadata for frame %d", frameNumber); |
| 2974 | return; |
| 2975 | } |
| 2976 | |
Chien-Yu Chen | 5cd8d64 | 2016-03-08 14:46:58 -0800 | [diff] [blame] | 2977 | // Valid result, insert into queue |
| 2978 | List<CaptureResult>::iterator queuedResult = |
| 2979 | mResultQueue.insert(mResultQueue.end(), CaptureResult(*result)); |
| 2980 | ALOGVV("%s: result requestId = %" PRId32 ", frameNumber = %" PRId64 |
| 2981 | ", burstId = %" PRId32, __FUNCTION__, |
| 2982 | queuedResult->mResultExtras.requestId, |
| 2983 | queuedResult->mResultExtras.frameNumber, |
| 2984 | queuedResult->mResultExtras.burstId); |
| 2985 | |
| 2986 | mResultSignal.signal(); |
| 2987 | } |
| 2988 | |
| 2989 | |
| 2990 | void Camera3Device::sendPartialCaptureResult(const camera_metadata_t * partialResult, |
Emilian Peev | 7e25e5e | 2017-04-07 15:48:49 +0100 | [diff] [blame] | 2991 | const CaptureResultExtras &resultExtras, uint32_t frameNumber) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 2992 | ATRACE_CALL(); |
Chien-Yu Chen | 5cd8d64 | 2016-03-08 14:46:58 -0800 | [diff] [blame] | 2993 | Mutex::Autolock l(mOutputLock); |
| 2994 | |
| 2995 | CaptureResult captureResult; |
| 2996 | captureResult.mResultExtras = resultExtras; |
| 2997 | captureResult.mMetadata = partialResult; |
| 2998 | |
Emilian Peev | 7e25e5e | 2017-04-07 15:48:49 +0100 | [diff] [blame] | 2999 | insertResultLocked(&captureResult, frameNumber); |
Chien-Yu Chen | 5cd8d64 | 2016-03-08 14:46:58 -0800 | [diff] [blame] | 3000 | } |
| 3001 | |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3002 | |
| 3003 | void Camera3Device::sendCaptureResult(CameraMetadata &pendingMetadata, |
| 3004 | CaptureResultExtras &resultExtras, |
| 3005 | CameraMetadata &collectedPartialResult, |
Chien-Yu Chen | 618ff8a | 2015-03-13 11:27:17 -0700 | [diff] [blame] | 3006 | uint32_t frameNumber, |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 3007 | bool reprocess, |
| 3008 | const std::vector<PhysicalCaptureResultInfo>& physicalMetadatas) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 3009 | ATRACE_CALL(); |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3010 | if (pendingMetadata.isEmpty()) |
| 3011 | return; |
| 3012 | |
| 3013 | Mutex::Autolock l(mOutputLock); |
| 3014 | |
| 3015 | // TODO: need to track errors for tighter bounds on expected frame number |
Chien-Yu Chen | 618ff8a | 2015-03-13 11:27:17 -0700 | [diff] [blame] | 3016 | if (reprocess) { |
| 3017 | if (frameNumber < mNextReprocessResultFrameNumber) { |
| 3018 | SET_ERR("Out-of-order reprocess capture result metadata submitted! " |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3019 | "(got frame number %d, expecting %d)", |
Chien-Yu Chen | 618ff8a | 2015-03-13 11:27:17 -0700 | [diff] [blame] | 3020 | frameNumber, mNextReprocessResultFrameNumber); |
| 3021 | return; |
| 3022 | } |
| 3023 | mNextReprocessResultFrameNumber = frameNumber + 1; |
| 3024 | } else { |
| 3025 | if (frameNumber < mNextResultFrameNumber) { |
| 3026 | SET_ERR("Out-of-order capture result metadata submitted! " |
| 3027 | "(got frame number %d, expecting %d)", |
| 3028 | frameNumber, mNextResultFrameNumber); |
| 3029 | return; |
| 3030 | } |
| 3031 | mNextResultFrameNumber = frameNumber + 1; |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3032 | } |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3033 | |
| 3034 | CaptureResult captureResult; |
| 3035 | captureResult.mResultExtras = resultExtras; |
| 3036 | captureResult.mMetadata = pendingMetadata; |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 3037 | captureResult.mPhysicalMetadatas = physicalMetadatas; |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3038 | |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3039 | // Append any previous partials to form a complete result |
| 3040 | if (mUsePartialResult && !collectedPartialResult.isEmpty()) { |
| 3041 | captureResult.mMetadata.append(collectedPartialResult); |
| 3042 | } |
| 3043 | |
| 3044 | captureResult.mMetadata.sort(); |
| 3045 | |
| 3046 | // Check that there's a timestamp in the result metadata |
Eino-Ville Talvala | 4d45383 | 2016-07-15 11:56:53 -0700 | [diff] [blame] | 3047 | camera_metadata_entry timestamp = captureResult.mMetadata.find(ANDROID_SENSOR_TIMESTAMP); |
| 3048 | if (timestamp.count == 0) { |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3049 | SET_ERR("No timestamp provided by HAL for frame %d!", |
| 3050 | frameNumber); |
| 3051 | return; |
| 3052 | } |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 3053 | for (auto& physicalMetadata : captureResult.mPhysicalMetadatas) { |
| 3054 | camera_metadata_entry timestamp = |
| 3055 | physicalMetadata.mPhysicalCameraMetadata.find(ANDROID_SENSOR_TIMESTAMP); |
| 3056 | if (timestamp.count == 0) { |
| 3057 | SET_ERR("No timestamp provided by HAL for physical camera %s frame %d!", |
| 3058 | String8(physicalMetadata.mPhysicalCameraId).c_str(), frameNumber); |
| 3059 | return; |
| 3060 | } |
| 3061 | } |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3062 | |
Eino-Ville Talvala | 7b8a1fd | 2018-05-22 15:30:35 -0700 | [diff] [blame] | 3063 | // Fix up some result metadata to account for HAL-level distortion correction |
| 3064 | status_t res = mDistortionMapper.correctCaptureResult(&captureResult.mMetadata); |
| 3065 | if (res != OK) { |
| 3066 | SET_ERR("Unable to correct capture result metadata for frame %d: %s (%d)", |
| 3067 | frameNumber, strerror(res), res); |
| 3068 | return; |
| 3069 | } |
| 3070 | |
Eino-Ville Talvala | 4d45383 | 2016-07-15 11:56:53 -0700 | [diff] [blame] | 3071 | mTagMonitor.monitorMetadata(TagMonitor::RESULT, |
| 3072 | frameNumber, timestamp.data.i64[0], captureResult.mMetadata); |
| 3073 | |
Emilian Peev | 7e25e5e | 2017-04-07 15:48:49 +0100 | [diff] [blame] | 3074 | insertResultLocked(&captureResult, frameNumber); |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3075 | } |
| 3076 | |
Eino-Ville Talvala | fd6ecdd | 2013-10-11 09:51:09 -0700 | [diff] [blame] | 3077 | /** |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 3078 | * Camera HAL device callback methods |
| 3079 | */ |
| 3080 | |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 3081 | void Camera3Device::processCaptureResult(const camera3_capture_result *result) { |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 3082 | ATRACE_CALL(); |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 3083 | |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 3084 | status_t res; |
| 3085 | |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 3086 | uint32_t frameNumber = result->frame_number; |
Zhijun He | f0d962a | 2014-06-30 10:24:11 -0700 | [diff] [blame] | 3087 | if (result->result == NULL && result->num_output_buffers == 0 && |
| 3088 | result->input_buffer == NULL) { |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 3089 | SET_ERR("No result data provided by HAL for frame %d", |
| 3090 | frameNumber); |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 3091 | return; |
| 3092 | } |
Zhijun He | 204e329 | 2014-07-14 17:09:23 -0700 | [diff] [blame] | 3093 | |
Zhijun He | 204e329 | 2014-07-14 17:09:23 -0700 | [diff] [blame] | 3094 | if (!mUsePartialResult && |
Zhijun He | 204e329 | 2014-07-14 17:09:23 -0700 | [diff] [blame] | 3095 | result->result != NULL && |
| 3096 | result->partial_result != 1) { |
| 3097 | SET_ERR("Result is malformed for frame %d: partial_result %u must be 1" |
| 3098 | " if partial result is not supported", |
| 3099 | frameNumber, result->partial_result); |
| 3100 | return; |
| 3101 | } |
| 3102 | |
| 3103 | bool isPartialResult = false; |
| 3104 | CameraMetadata collectedPartialResult; |
Zhijun He | c98bd8d | 2014-07-07 12:44:10 -0700 | [diff] [blame] | 3105 | bool hasInputBufferInRequest = false; |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 3106 | |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3107 | // Get shutter timestamp and resultExtras from list of in-flight requests, |
| 3108 | // where it was added by the shutter notification for this frame. If the |
| 3109 | // shutter timestamp isn't received yet, append the output buffers to the |
| 3110 | // in-flight request and they will be returned when the shutter timestamp |
| 3111 | // arrives. Update the in-flight status and remove the in-flight entry if |
| 3112 | // all result data and shutter timestamp have been received. |
| 3113 | nsecs_t shutterTimestamp = 0; |
| 3114 | |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 3115 | { |
| 3116 | Mutex::Autolock l(mInFlightLock); |
| 3117 | ssize_t idx = mInFlightMap.indexOfKey(frameNumber); |
| 3118 | if (idx == NAME_NOT_FOUND) { |
| 3119 | SET_ERR("Unknown frame number for capture result: %d", |
| 3120 | frameNumber); |
| 3121 | return; |
| 3122 | } |
| 3123 | InFlightRequest &request = mInFlightMap.editValueAt(idx); |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3124 | ALOGVV("%s: got InFlightRequest requestId = %" PRId32 |
| 3125 | ", frameNumber = %" PRId64 ", burstId = %" PRId32 |
Shuzhen Wang | 4a47266 | 2017-02-26 23:29:04 -0800 | [diff] [blame] | 3126 | ", partialResultCount = %d, hasCallback = %d", |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3127 | __FUNCTION__, request.resultExtras.requestId, |
| 3128 | request.resultExtras.frameNumber, request.resultExtras.burstId, |
Shuzhen Wang | 4a47266 | 2017-02-26 23:29:04 -0800 | [diff] [blame] | 3129 | result->partial_result, request.hasCallback); |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3130 | // Always update the partial count to the latest one if it's not 0 |
| 3131 | // (buffers only). When framework aggregates adjacent partial results |
| 3132 | // into one, the latest partial count will be used. |
| 3133 | if (result->partial_result != 0) |
| 3134 | request.resultExtras.partialResultCount = result->partial_result; |
Eino-Ville Talvala | fd6ecdd | 2013-10-11 09:51:09 -0700 | [diff] [blame] | 3135 | |
| 3136 | // Check if this result carries only partial metadata |
Zhijun He | 204e329 | 2014-07-14 17:09:23 -0700 | [diff] [blame] | 3137 | if (mUsePartialResult && result->result != NULL) { |
Emilian Peev | 08dd245 | 2017-04-06 16:55:14 +0100 | [diff] [blame] | 3138 | if (result->partial_result > mNumPartialResults || result->partial_result < 1) { |
| 3139 | SET_ERR("Result is malformed for frame %d: partial_result %u must be in" |
| 3140 | " the range of [1, %d] when metadata is included in the result", |
| 3141 | frameNumber, result->partial_result, mNumPartialResults); |
| 3142 | return; |
| 3143 | } |
| 3144 | isPartialResult = (result->partial_result < mNumPartialResults); |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 3145 | if (isPartialResult && result->num_physcam_metadata) { |
| 3146 | SET_ERR("Result is malformed for frame %d: partial_result not allowed for" |
| 3147 | " physical camera result", frameNumber); |
| 3148 | return; |
| 3149 | } |
Emilian Peev | 08dd245 | 2017-04-06 16:55:14 +0100 | [diff] [blame] | 3150 | if (isPartialResult) { |
| 3151 | request.collectedPartialResult.append(result->result); |
Zhijun He | 204e329 | 2014-07-14 17:09:23 -0700 | [diff] [blame] | 3152 | } |
| 3153 | |
Shuzhen Wang | 4a47266 | 2017-02-26 23:29:04 -0800 | [diff] [blame] | 3154 | if (isPartialResult && request.hasCallback) { |
Chien-Yu Chen | 5cd8d64 | 2016-03-08 14:46:58 -0800 | [diff] [blame] | 3155 | // Send partial capture result |
Emilian Peev | 7e25e5e | 2017-04-07 15:48:49 +0100 | [diff] [blame] | 3156 | sendPartialCaptureResult(result->result, request.resultExtras, |
| 3157 | frameNumber); |
Eino-Ville Talvala | fd6ecdd | 2013-10-11 09:51:09 -0700 | [diff] [blame] | 3158 | } |
| 3159 | } |
| 3160 | |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3161 | shutterTimestamp = request.shutterTimestamp; |
Zhijun He | c98bd8d | 2014-07-07 12:44:10 -0700 | [diff] [blame] | 3162 | hasInputBufferInRequest = request.hasInputBuffer; |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 3163 | |
Eino-Ville Talvala | fd6ecdd | 2013-10-11 09:51:09 -0700 | [diff] [blame] | 3164 | // Did we get the (final) result metadata for this capture? |
Zhijun He | 204e329 | 2014-07-14 17:09:23 -0700 | [diff] [blame] | 3165 | if (result->result != NULL && !isPartialResult) { |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 3166 | if (request.physicalCameraIds.size() != result->num_physcam_metadata) { |
| 3167 | SET_ERR("Requested physical Camera Ids %d not equal to number of metadata %d", |
| 3168 | request.physicalCameraIds.size(), result->num_physcam_metadata); |
| 3169 | return; |
| 3170 | } |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 3171 | if (request.haveResultMetadata) { |
| 3172 | SET_ERR("Called multiple times with metadata for frame %d", |
| 3173 | frameNumber); |
| 3174 | return; |
| 3175 | } |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 3176 | for (uint32_t i = 0; i < result->num_physcam_metadata; i++) { |
| 3177 | String8 physicalId(result->physcam_ids[i]); |
| 3178 | std::set<String8>::iterator cameraIdIter = |
| 3179 | request.physicalCameraIds.find(physicalId); |
| 3180 | if (cameraIdIter != request.physicalCameraIds.end()) { |
| 3181 | request.physicalCameraIds.erase(cameraIdIter); |
| 3182 | } else { |
| 3183 | SET_ERR("Total result for frame %d has already returned for camera %s", |
| 3184 | frameNumber, physicalId.c_str()); |
| 3185 | return; |
| 3186 | } |
| 3187 | } |
Zhijun He | 204e329 | 2014-07-14 17:09:23 -0700 | [diff] [blame] | 3188 | if (mUsePartialResult && |
Chien-Yu Chen | 5cd8d64 | 2016-03-08 14:46:58 -0800 | [diff] [blame] | 3189 | !request.collectedPartialResult.isEmpty()) { |
Zhijun He | 204e329 | 2014-07-14 17:09:23 -0700 | [diff] [blame] | 3190 | collectedPartialResult.acquire( |
Chien-Yu Chen | 5cd8d64 | 2016-03-08 14:46:58 -0800 | [diff] [blame] | 3191 | request.collectedPartialResult); |
Eino-Ville Talvala | fd6ecdd | 2013-10-11 09:51:09 -0700 | [diff] [blame] | 3192 | } |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 3193 | request.haveResultMetadata = true; |
| 3194 | } |
| 3195 | |
Zhijun He | c98bd8d | 2014-07-07 12:44:10 -0700 | [diff] [blame] | 3196 | uint32_t numBuffersReturned = result->num_output_buffers; |
| 3197 | if (result->input_buffer != NULL) { |
| 3198 | if (hasInputBufferInRequest) { |
| 3199 | numBuffersReturned += 1; |
| 3200 | } else { |
| 3201 | ALOGW("%s: Input buffer should be NULL if there is no input" |
| 3202 | " buffer sent in the request", |
| 3203 | __FUNCTION__); |
| 3204 | } |
| 3205 | } |
| 3206 | request.numBuffersLeft -= numBuffersReturned; |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 3207 | if (request.numBuffersLeft < 0) { |
| 3208 | SET_ERR("Too many buffers returned for frame %d", |
| 3209 | frameNumber); |
| 3210 | return; |
| 3211 | } |
| 3212 | |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3213 | camera_metadata_ro_entry_t entry; |
| 3214 | res = find_camera_metadata_ro_entry(result->result, |
| 3215 | ANDROID_SENSOR_TIMESTAMP, &entry); |
| 3216 | if (res == OK && entry.count == 1) { |
| 3217 | request.sensorTimestamp = entry.data.i64[0]; |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 3218 | } |
| 3219 | |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3220 | // If shutter event isn't received yet, append the output buffers to |
| 3221 | // the in-flight request. Otherwise, return the output buffers to |
| 3222 | // streams. |
| 3223 | if (shutterTimestamp == 0) { |
| 3224 | request.pendingOutputBuffers.appendArray(result->output_buffers, |
| 3225 | result->num_output_buffers); |
Igor Murashkin | d2c9069 | 2013-04-02 12:32:32 -0700 | [diff] [blame] | 3226 | } else { |
Shuzhen Wang | 26abaf4 | 2018-08-28 15:41:20 -0700 | [diff] [blame] | 3227 | bool timestampIncreasing = !(request.zslCapture || request.hasInputBuffer); |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3228 | returnOutputBuffers(result->output_buffers, |
Shuzhen Wang | 26abaf4 | 2018-08-28 15:41:20 -0700 | [diff] [blame] | 3229 | result->num_output_buffers, shutterTimestamp, timestampIncreasing); |
Igor Murashkin | d2c9069 | 2013-04-02 12:32:32 -0700 | [diff] [blame] | 3230 | } |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 3231 | |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3232 | if (result->result != NULL && !isPartialResult) { |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 3233 | for (uint32_t i = 0; i < result->num_physcam_metadata; i++) { |
| 3234 | CameraMetadata physicalMetadata; |
| 3235 | physicalMetadata.append(result->physcam_metadata[i]); |
| 3236 | request.physicalMetadatas.push_back({String16(result->physcam_ids[i]), |
| 3237 | physicalMetadata}); |
| 3238 | } |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3239 | if (shutterTimestamp == 0) { |
| 3240 | request.pendingMetadata = result->result; |
Chien-Yu Chen | 5cd8d64 | 2016-03-08 14:46:58 -0800 | [diff] [blame] | 3241 | request.collectedPartialResult = collectedPartialResult; |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 3242 | } else if (request.hasCallback) { |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3243 | CameraMetadata metadata; |
| 3244 | metadata = result->result; |
| 3245 | sendCaptureResult(metadata, request.resultExtras, |
Emilian Peev | 7e25e5e | 2017-04-07 15:48:49 +0100 | [diff] [blame] | 3246 | collectedPartialResult, frameNumber, |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 3247 | hasInputBufferInRequest, request.physicalMetadatas); |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3248 | } |
Eino-Ville Talvala | fd6ecdd | 2013-10-11 09:51:09 -0700 | [diff] [blame] | 3249 | } |
| 3250 | |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3251 | removeInFlightRequestIfReadyLocked(idx); |
| 3252 | } // scope for mInFlightLock |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 3253 | |
Zhijun He | f0d962a | 2014-06-30 10:24:11 -0700 | [diff] [blame] | 3254 | if (result->input_buffer != NULL) { |
Zhijun He | c98bd8d | 2014-07-07 12:44:10 -0700 | [diff] [blame] | 3255 | if (hasInputBufferInRequest) { |
| 3256 | Camera3Stream *stream = |
| 3257 | Camera3Stream::cast(result->input_buffer->stream); |
| 3258 | res = stream->returnInputBuffer(*(result->input_buffer)); |
| 3259 | // Note: stream may be deallocated at this point, if this buffer was the |
| 3260 | // last reference to it. |
| 3261 | if (res != OK) { |
| 3262 | ALOGE("%s: RequestThread: Can't return input buffer for frame %d to" |
| 3263 | " its stream:%s (%d)", __FUNCTION__, |
| 3264 | frameNumber, strerror(-res), res); |
Zhijun He | 0ea8fa4 | 2014-07-07 17:05:38 -0700 | [diff] [blame] | 3265 | } |
| 3266 | } else { |
| 3267 | ALOGW("%s: Input buffer should be NULL if there is no input" |
| 3268 | " buffer sent in the request, skipping input buffer return.", |
| 3269 | __FUNCTION__); |
Zhijun He | f0d962a | 2014-06-30 10:24:11 -0700 | [diff] [blame] | 3270 | } |
| 3271 | } |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 3272 | } |
| 3273 | |
| 3274 | void Camera3Device::notify(const camera3_notify_msg *msg) { |
Eino-Ville Talvala | 17a61ad | 2013-06-03 16:53:32 -0700 | [diff] [blame] | 3275 | ATRACE_CALL(); |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 3276 | sp<NotificationListener> listener; |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 3277 | { |
| 3278 | Mutex::Autolock l(mOutputLock); |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 3279 | listener = mListener.promote(); |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 3280 | } |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 3281 | |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 3282 | if (msg == NULL) { |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 3283 | SET_ERR("HAL sent NULL notify message!"); |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 3284 | return; |
| 3285 | } |
| 3286 | |
| 3287 | switch (msg->type) { |
| 3288 | case CAMERA3_MSG_ERROR: { |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3289 | notifyError(msg->message.error, listener); |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 3290 | break; |
| 3291 | } |
| 3292 | case CAMERA3_MSG_SHUTTER: { |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3293 | notifyShutter(msg->message.shutter, listener); |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 3294 | break; |
| 3295 | } |
| 3296 | default: |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 3297 | SET_ERR("Unknown notify message from HAL: %d", |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 3298 | msg->type); |
Eino-Ville Talvala | 7d346fa | 2013-03-11 14:13:50 -0700 | [diff] [blame] | 3299 | } |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 3300 | } |
| 3301 | |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3302 | void Camera3Device::notifyError(const camera3_error_msg_t &msg, |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 3303 | sp<NotificationListener> listener) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 3304 | ATRACE_CALL(); |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3305 | // Map camera HAL error codes to ICameraDeviceCallback error codes |
| 3306 | // Index into this with the HAL error code |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 3307 | static const int32_t halErrorMap[CAMERA3_MSG_NUM_ERRORS] = { |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3308 | // 0 = Unused error code |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 3309 | hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_INVALID_ERROR, |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3310 | // 1 = CAMERA3_MSG_ERROR_DEVICE |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 3311 | hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE, |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3312 | // 2 = CAMERA3_MSG_ERROR_REQUEST |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 3313 | hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST, |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3314 | // 3 = CAMERA3_MSG_ERROR_RESULT |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 3315 | hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT, |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3316 | // 4 = CAMERA3_MSG_ERROR_BUFFER |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 3317 | hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3318 | }; |
| 3319 | |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 3320 | int32_t errorCode = |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3321 | ((msg.error_code >= 0) && |
| 3322 | (msg.error_code < CAMERA3_MSG_NUM_ERRORS)) ? |
| 3323 | halErrorMap[msg.error_code] : |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 3324 | hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_INVALID_ERROR; |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3325 | |
| 3326 | int streamId = 0; |
| 3327 | if (msg.error_stream != NULL) { |
| 3328 | Camera3Stream *stream = |
| 3329 | Camera3Stream::cast(msg.error_stream); |
| 3330 | streamId = stream->getId(); |
| 3331 | } |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3332 | ALOGV("Camera %s: %s: HAL error, frame %d, stream %d: %d", |
| 3333 | mId.string(), __FUNCTION__, msg.frame_number, |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3334 | streamId, msg.error_code); |
| 3335 | |
| 3336 | CaptureResultExtras resultExtras; |
| 3337 | switch (errorCode) { |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 3338 | case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE: |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3339 | // SET_ERR calls notifyError |
| 3340 | SET_ERR("Camera HAL reported serious device error"); |
| 3341 | break; |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 3342 | case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST: |
| 3343 | case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT: |
| 3344 | case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER: |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3345 | { |
| 3346 | Mutex::Autolock l(mInFlightLock); |
| 3347 | ssize_t idx = mInFlightMap.indexOfKey(msg.frame_number); |
| 3348 | if (idx >= 0) { |
| 3349 | InFlightRequest &r = mInFlightMap.editValueAt(idx); |
| 3350 | r.requestStatus = msg.error_code; |
| 3351 | resultExtras = r.resultExtras; |
Shuzhen Wang | 20f5734 | 2017-08-24 15:39:05 -0700 | [diff] [blame] | 3352 | if (hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT == errorCode |
| 3353 | || hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST == |
| 3354 | errorCode) { |
| 3355 | r.skipResultMetadata = true; |
| 3356 | } |
Emilian Peev | ba0fac3 | 2017-03-30 09:05:34 +0100 | [diff] [blame] | 3357 | if (hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT == |
| 3358 | errorCode) { |
| 3359 | // In case of missing result check whether the buffers |
| 3360 | // returned. If they returned, then remove inflight |
| 3361 | // request. |
| 3362 | removeInFlightRequestIfReadyLocked(idx); |
| 3363 | } |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3364 | } else { |
| 3365 | resultExtras.frameNumber = msg.frame_number; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3366 | ALOGE("Camera %s: %s: cannot find in-flight request on " |
| 3367 | "frame %" PRId64 " error", mId.string(), __FUNCTION__, |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3368 | resultExtras.frameNumber); |
| 3369 | } |
| 3370 | } |
Eino-Ville Talvala | e95bb63 | 2016-03-06 19:55:44 -0800 | [diff] [blame] | 3371 | resultExtras.errorStreamId = streamId; |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3372 | if (listener != NULL) { |
| 3373 | listener->notifyError(errorCode, resultExtras); |
| 3374 | } else { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3375 | ALOGE("Camera %s: %s: no listener available", mId.string(), __FUNCTION__); |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3376 | } |
| 3377 | break; |
| 3378 | default: |
| 3379 | // SET_ERR calls notifyError |
| 3380 | SET_ERR("Unknown error message from HAL: %d", msg.error_code); |
| 3381 | break; |
| 3382 | } |
| 3383 | } |
| 3384 | |
| 3385 | void Camera3Device::notifyShutter(const camera3_shutter_msg_t &msg, |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 3386 | sp<NotificationListener> listener) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 3387 | ATRACE_CALL(); |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3388 | ssize_t idx; |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3389 | |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3390 | // Set timestamp for the request in the in-flight tracking |
| 3391 | // and get the request ID to send upstream |
| 3392 | { |
| 3393 | Mutex::Autolock l(mInFlightLock); |
| 3394 | idx = mInFlightMap.indexOfKey(msg.frame_number); |
| 3395 | if (idx >= 0) { |
| 3396 | InFlightRequest &r = mInFlightMap.editValueAt(idx); |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3397 | |
Chien-Yu Chen | 3df11ce | 2015-09-30 14:13:30 -0700 | [diff] [blame] | 3398 | // Verify ordering of shutter notifications |
| 3399 | { |
| 3400 | Mutex::Autolock l(mOutputLock); |
| 3401 | // TODO: need to track errors for tighter bounds on expected frame number. |
| 3402 | if (r.hasInputBuffer) { |
| 3403 | if (msg.frame_number < mNextReprocessShutterFrameNumber) { |
| 3404 | SET_ERR("Shutter notification out-of-order. Expected " |
| 3405 | "notification for frame %d, got frame %d", |
| 3406 | mNextReprocessShutterFrameNumber, msg.frame_number); |
| 3407 | return; |
| 3408 | } |
| 3409 | mNextReprocessShutterFrameNumber = msg.frame_number + 1; |
| 3410 | } else { |
| 3411 | if (msg.frame_number < mNextShutterFrameNumber) { |
| 3412 | SET_ERR("Shutter notification out-of-order. Expected " |
| 3413 | "notification for frame %d, got frame %d", |
| 3414 | mNextShutterFrameNumber, msg.frame_number); |
| 3415 | return; |
| 3416 | } |
| 3417 | mNextShutterFrameNumber = msg.frame_number + 1; |
| 3418 | } |
| 3419 | } |
| 3420 | |
Shuzhen Wang | 4a47266 | 2017-02-26 23:29:04 -0800 | [diff] [blame] | 3421 | r.shutterTimestamp = msg.timestamp; |
| 3422 | if (r.hasCallback) { |
| 3423 | ALOGVV("Camera %s: %s: Shutter fired for frame %d (id %d) at %" PRId64, |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3424 | mId.string(), __FUNCTION__, |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3425 | msg.frame_number, r.resultExtras.requestId, msg.timestamp); |
Shuzhen Wang | 4a47266 | 2017-02-26 23:29:04 -0800 | [diff] [blame] | 3426 | // Call listener, if any |
| 3427 | if (listener != NULL) { |
| 3428 | listener->notifyShutter(r.resultExtras, msg.timestamp); |
| 3429 | } |
| 3430 | // send pending result and buffers |
| 3431 | sendCaptureResult(r.pendingMetadata, r.resultExtras, |
| 3432 | r.collectedPartialResult, msg.frame_number, |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 3433 | r.hasInputBuffer, r.physicalMetadatas); |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3434 | } |
Shuzhen Wang | 26abaf4 | 2018-08-28 15:41:20 -0700 | [diff] [blame] | 3435 | bool timestampIncreasing = !(r.zslCapture || r.hasInputBuffer); |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3436 | returnOutputBuffers(r.pendingOutputBuffers.array(), |
Shuzhen Wang | 26abaf4 | 2018-08-28 15:41:20 -0700 | [diff] [blame] | 3437 | r.pendingOutputBuffers.size(), r.shutterTimestamp, timestampIncreasing); |
Chien-Yu Chen | 43e69a6 | 2014-11-25 16:38:33 -0800 | [diff] [blame] | 3438 | r.pendingOutputBuffers.clear(); |
| 3439 | |
| 3440 | removeInFlightRequestIfReadyLocked(idx); |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3441 | } |
| 3442 | } |
| 3443 | if (idx < 0) { |
| 3444 | SET_ERR("Shutter notification for non-existent frame number %d", |
| 3445 | msg.frame_number); |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 3446 | } |
| 3447 | } |
| 3448 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 3449 | CameraMetadata Camera3Device::getLatestRequestLocked() { |
Igor Murashkin | 1e479c0 | 2013-09-06 16:55:14 -0700 | [diff] [blame] | 3450 | ALOGV("%s", __FUNCTION__); |
| 3451 | |
Igor Murashkin | 1e479c0 | 2013-09-06 16:55:14 -0700 | [diff] [blame] | 3452 | CameraMetadata retVal; |
| 3453 | |
| 3454 | if (mRequestThread != NULL) { |
| 3455 | retVal = mRequestThread->getLatestRequest(); |
| 3456 | } |
| 3457 | |
Igor Murashkin | 1e479c0 | 2013-09-06 16:55:14 -0700 | [diff] [blame] | 3458 | return retVal; |
| 3459 | } |
| 3460 | |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 3461 | |
Eino-Ville Talvala | 4d45383 | 2016-07-15 11:56:53 -0700 | [diff] [blame] | 3462 | void Camera3Device::monitorMetadata(TagMonitor::eventSource source, |
| 3463 | int64_t frameNumber, nsecs_t timestamp, const CameraMetadata& metadata) { |
| 3464 | mTagMonitor.monitorMetadata(source, frameNumber, timestamp, metadata); |
| 3465 | } |
| 3466 | |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 3467 | /** |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3468 | * HalInterface inner class methods |
| 3469 | */ |
| 3470 | |
Yifan Hong | f79b554 | 2017-04-11 14:44:25 -0700 | [diff] [blame] | 3471 | Camera3Device::HalInterface::HalInterface( |
| 3472 | sp<ICameraDeviceSession> &session, |
| 3473 | std::shared_ptr<RequestMetadataQueue> queue) : |
Yifan Hong | f79b554 | 2017-04-11 14:44:25 -0700 | [diff] [blame] | 3474 | mHidlSession(session), |
Eino-Ville Talvala | 1a86df5 | 2018-01-17 16:00:35 -0800 | [diff] [blame] | 3475 | mRequestMetadataQueue(queue) { |
| 3476 | // Check with hardware service manager if we can downcast these interfaces |
| 3477 | // Somewhat expensive, so cache the results at startup |
| 3478 | auto castResult_3_4 = device::V3_4::ICameraDeviceSession::castFrom(mHidlSession); |
| 3479 | if (castResult_3_4.isOk()) { |
| 3480 | mHidlSession_3_4 = castResult_3_4; |
| 3481 | } |
| 3482 | auto castResult_3_3 = device::V3_3::ICameraDeviceSession::castFrom(mHidlSession); |
| 3483 | if (castResult_3_3.isOk()) { |
| 3484 | mHidlSession_3_3 = castResult_3_3; |
| 3485 | } |
| 3486 | } |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3487 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3488 | Camera3Device::HalInterface::HalInterface() {} |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3489 | |
| 3490 | Camera3Device::HalInterface::HalInterface(const HalInterface& other) : |
Yifan Hong | f79b554 | 2017-04-11 14:44:25 -0700 | [diff] [blame] | 3491 | mHidlSession(other.mHidlSession), |
| 3492 | mRequestMetadataQueue(other.mRequestMetadataQueue) {} |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3493 | |
| 3494 | bool Camera3Device::HalInterface::valid() { |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3495 | return (mHidlSession != nullptr); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3496 | } |
| 3497 | |
| 3498 | void Camera3Device::HalInterface::clear() { |
Emilian Peev | 9e740b0 | 2018-01-30 18:28:03 +0000 | [diff] [blame] | 3499 | mHidlSession_3_4.clear(); |
| 3500 | mHidlSession_3_3.clear(); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3501 | mHidlSession.clear(); |
| 3502 | } |
| 3503 | |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 3504 | bool Camera3Device::HalInterface::supportBatchRequest() { |
| 3505 | return mHidlSession != nullptr; |
| 3506 | } |
| 3507 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3508 | status_t Camera3Device::HalInterface::constructDefaultRequestSettings( |
| 3509 | camera3_request_template_t templateId, |
| 3510 | /*out*/ camera_metadata_t **requestTemplate) { |
| 3511 | ATRACE_NAME("CameraHal::constructDefaultRequestSettings"); |
| 3512 | if (!valid()) return INVALID_OPERATION; |
| 3513 | status_t res = OK; |
| 3514 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3515 | common::V1_0::Status status; |
Eino-Ville Talvala | 1a86df5 | 2018-01-17 16:00:35 -0800 | [diff] [blame] | 3516 | |
| 3517 | auto requestCallback = [&status, &requestTemplate] |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3518 | (common::V1_0::Status s, const device::V3_2::CameraMetadata& request) { |
Eino-Ville Talvala | 1a86df5 | 2018-01-17 16:00:35 -0800 | [diff] [blame] | 3519 | status = s; |
| 3520 | if (status == common::V1_0::Status::OK) { |
| 3521 | const camera_metadata *r = |
| 3522 | reinterpret_cast<const camera_metadata_t*>(request.data()); |
| 3523 | size_t expectedSize = request.size(); |
| 3524 | int ret = validate_camera_metadata_structure(r, &expectedSize); |
| 3525 | if (ret == OK || ret == CAMERA_METADATA_VALIDATION_SHIFTED) { |
| 3526 | *requestTemplate = clone_camera_metadata(r); |
| 3527 | if (*requestTemplate == nullptr) { |
| 3528 | ALOGE("%s: Unable to clone camera metadata received from HAL", |
| 3529 | __FUNCTION__); |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3530 | status = common::V1_0::Status::INTERNAL_ERROR; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3531 | } |
Eino-Ville Talvala | 1a86df5 | 2018-01-17 16:00:35 -0800 | [diff] [blame] | 3532 | } else { |
| 3533 | ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__); |
| 3534 | status = common::V1_0::Status::INTERNAL_ERROR; |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3535 | } |
Eino-Ville Talvala | 1a86df5 | 2018-01-17 16:00:35 -0800 | [diff] [blame] | 3536 | } |
| 3537 | }; |
| 3538 | hardware::Return<void> err; |
Eino-Ville Talvala | 9644146 | 2018-02-06 11:41:55 -0800 | [diff] [blame] | 3539 | RequestTemplate id; |
| 3540 | switch (templateId) { |
| 3541 | case CAMERA3_TEMPLATE_PREVIEW: |
| 3542 | id = RequestTemplate::PREVIEW; |
| 3543 | break; |
| 3544 | case CAMERA3_TEMPLATE_STILL_CAPTURE: |
| 3545 | id = RequestTemplate::STILL_CAPTURE; |
| 3546 | break; |
| 3547 | case CAMERA3_TEMPLATE_VIDEO_RECORD: |
| 3548 | id = RequestTemplate::VIDEO_RECORD; |
| 3549 | break; |
| 3550 | case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT: |
| 3551 | id = RequestTemplate::VIDEO_SNAPSHOT; |
| 3552 | break; |
| 3553 | case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG: |
| 3554 | id = RequestTemplate::ZERO_SHUTTER_LAG; |
| 3555 | break; |
| 3556 | case CAMERA3_TEMPLATE_MANUAL: |
| 3557 | id = RequestTemplate::MANUAL; |
| 3558 | break; |
| 3559 | default: |
| 3560 | // Unknown template ID, or this HAL is too old to support it |
| 3561 | return BAD_VALUE; |
Eino-Ville Talvala | 1a86df5 | 2018-01-17 16:00:35 -0800 | [diff] [blame] | 3562 | } |
Eino-Ville Talvala | 9644146 | 2018-02-06 11:41:55 -0800 | [diff] [blame] | 3563 | err = mHidlSession->constructDefaultRequestSettings(id, requestCallback); |
Eino-Ville Talvala | 1a86df5 | 2018-01-17 16:00:35 -0800 | [diff] [blame] | 3564 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3565 | if (!err.isOk()) { |
| 3566 | ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str()); |
| 3567 | res = DEAD_OBJECT; |
| 3568 | } else { |
| 3569 | res = CameraProviderManager::mapToStatusT(status); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3570 | } |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3571 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3572 | return res; |
| 3573 | } |
| 3574 | |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 3575 | status_t Camera3Device::HalInterface::configureStreams(const camera_metadata_t *sessionParams, |
Emilian Peev | 192ee83 | 2018-01-31 14:46:47 +0000 | [diff] [blame] | 3576 | camera3_stream_configuration *config, const std::vector<uint32_t>& bufferSizes) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3577 | ATRACE_NAME("CameraHal::configureStreams"); |
| 3578 | if (!valid()) return INVALID_OPERATION; |
| 3579 | status_t res = OK; |
| 3580 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3581 | // Convert stream config to HIDL |
| 3582 | std::set<int> activeStreams; |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 3583 | device::V3_2::StreamConfiguration requestedConfiguration3_2; |
| 3584 | device::V3_4::StreamConfiguration requestedConfiguration3_4; |
| 3585 | requestedConfiguration3_2.streams.resize(config->num_streams); |
| 3586 | requestedConfiguration3_4.streams.resize(config->num_streams); |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3587 | for (size_t i = 0; i < config->num_streams; i++) { |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 3588 | device::V3_2::Stream &dst3_2 = requestedConfiguration3_2.streams[i]; |
| 3589 | device::V3_4::Stream &dst3_4 = requestedConfiguration3_4.streams[i]; |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3590 | camera3_stream_t *src = config->streams[i]; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3591 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3592 | Camera3Stream* cam3stream = Camera3Stream::cast(src); |
| 3593 | cam3stream->setBufferFreedListener(this); |
| 3594 | int streamId = cam3stream->getId(); |
| 3595 | StreamType streamType; |
| 3596 | switch (src->stream_type) { |
| 3597 | case CAMERA3_STREAM_OUTPUT: |
| 3598 | streamType = StreamType::OUTPUT; |
| 3599 | break; |
| 3600 | case CAMERA3_STREAM_INPUT: |
| 3601 | streamType = StreamType::INPUT; |
| 3602 | break; |
| 3603 | default: |
| 3604 | ALOGE("%s: Stream %d: Unsupported stream type %d", |
| 3605 | __FUNCTION__, streamId, config->streams[i]->stream_type); |
| 3606 | return BAD_VALUE; |
| 3607 | } |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 3608 | dst3_2.id = streamId; |
| 3609 | dst3_2.streamType = streamType; |
| 3610 | dst3_2.width = src->width; |
| 3611 | dst3_2.height = src->height; |
| 3612 | dst3_2.format = mapToPixelFormat(src->format); |
| 3613 | dst3_2.usage = mapToConsumerUsage(cam3stream->getUsage()); |
| 3614 | dst3_2.dataSpace = mapToHidlDataspace(src->data_space); |
| 3615 | dst3_2.rotation = mapToStreamRotation((camera3_stream_rotation_t) src->rotation); |
| 3616 | dst3_4.v3_2 = dst3_2; |
Emilian Peev | 192ee83 | 2018-01-31 14:46:47 +0000 | [diff] [blame] | 3617 | dst3_4.bufferSize = bufferSizes[i]; |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 3618 | if (src->physical_camera_id != nullptr) { |
| 3619 | dst3_4.physicalCameraId = src->physical_camera_id; |
| 3620 | } |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3621 | |
| 3622 | activeStreams.insert(streamId); |
| 3623 | // Create Buffer ID map if necessary |
| 3624 | if (mBufferIdMaps.count(streamId) == 0) { |
| 3625 | mBufferIdMaps.emplace(streamId, BufferIdMap{}); |
| 3626 | } |
| 3627 | } |
| 3628 | // remove BufferIdMap for deleted streams |
| 3629 | for(auto it = mBufferIdMaps.begin(); it != mBufferIdMaps.end();) { |
| 3630 | int streamId = it->first; |
| 3631 | bool active = activeStreams.count(streamId) > 0; |
| 3632 | if (!active) { |
| 3633 | it = mBufferIdMaps.erase(it); |
| 3634 | } else { |
| 3635 | ++it; |
| 3636 | } |
| 3637 | } |
| 3638 | |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 3639 | StreamConfigurationMode operationMode; |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3640 | res = mapToStreamConfigurationMode( |
| 3641 | (camera3_stream_configuration_mode_t) config->operation_mode, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 3642 | /*out*/ &operationMode); |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3643 | if (res != OK) { |
| 3644 | return res; |
| 3645 | } |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 3646 | requestedConfiguration3_2.operationMode = operationMode; |
| 3647 | requestedConfiguration3_4.operationMode = operationMode; |
| 3648 | requestedConfiguration3_4.sessionParams.setToExternal( |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 3649 | reinterpret_cast<uint8_t*>(const_cast<camera_metadata_t*>(sessionParams)), |
| 3650 | get_camera_metadata_size(sessionParams)); |
| 3651 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3652 | // Invoke configureStreams |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3653 | device::V3_3::HalStreamConfiguration finalConfiguration; |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3654 | common::V1_0::Status status; |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3655 | |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 3656 | // See if we have v3.4 or v3.3 HAL |
Eino-Ville Talvala | 1a86df5 | 2018-01-17 16:00:35 -0800 | [diff] [blame] | 3657 | if (mHidlSession_3_4 != nullptr) { |
| 3658 | // We do; use v3.4 for the call |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 3659 | ALOGV("%s: v3.4 device found", __FUNCTION__); |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 3660 | device::V3_4::HalStreamConfiguration finalConfiguration3_4; |
Eino-Ville Talvala | 1a86df5 | 2018-01-17 16:00:35 -0800 | [diff] [blame] | 3661 | auto err = mHidlSession_3_4->configureStreams_3_4(requestedConfiguration3_4, |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 3662 | [&status, &finalConfiguration3_4] |
| 3663 | (common::V1_0::Status s, const device::V3_4::HalStreamConfiguration& halConfiguration) { |
| 3664 | finalConfiguration3_4 = halConfiguration; |
Emilian Peev | 5fbe0ba | 2017-10-20 15:45:45 +0100 | [diff] [blame] | 3665 | status = s; |
| 3666 | }); |
| 3667 | if (!err.isOk()) { |
| 3668 | ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str()); |
| 3669 | return DEAD_OBJECT; |
| 3670 | } |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 3671 | finalConfiguration.streams.resize(finalConfiguration3_4.streams.size()); |
| 3672 | for (size_t i = 0; i < finalConfiguration3_4.streams.size(); i++) { |
| 3673 | finalConfiguration.streams[i] = finalConfiguration3_4.streams[i].v3_3; |
| 3674 | } |
Eino-Ville Talvala | 1a86df5 | 2018-01-17 16:00:35 -0800 | [diff] [blame] | 3675 | } else if (mHidlSession_3_3 != nullptr) { |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3676 | // We do; use v3.3 for the call |
| 3677 | ALOGV("%s: v3.3 device found", __FUNCTION__); |
Eino-Ville Talvala | 1a86df5 | 2018-01-17 16:00:35 -0800 | [diff] [blame] | 3678 | auto err = mHidlSession_3_3->configureStreams_3_3(requestedConfiguration3_2, |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3679 | [&status, &finalConfiguration] |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3680 | (common::V1_0::Status s, const device::V3_3::HalStreamConfiguration& halConfiguration) { |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3681 | finalConfiguration = halConfiguration; |
| 3682 | status = s; |
| 3683 | }); |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3684 | if (!err.isOk()) { |
| 3685 | ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str()); |
| 3686 | return DEAD_OBJECT; |
| 3687 | } |
| 3688 | } else { |
| 3689 | // We don't; use v3.2 call and construct a v3.3 HalStreamConfiguration |
| 3690 | ALOGV("%s: v3.2 device found", __FUNCTION__); |
| 3691 | HalStreamConfiguration finalConfiguration_3_2; |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 3692 | auto err = mHidlSession->configureStreams(requestedConfiguration3_2, |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3693 | [&status, &finalConfiguration_3_2] |
| 3694 | (common::V1_0::Status s, const HalStreamConfiguration& halConfiguration) { |
| 3695 | finalConfiguration_3_2 = halConfiguration; |
| 3696 | status = s; |
| 3697 | }); |
| 3698 | if (!err.isOk()) { |
| 3699 | ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str()); |
| 3700 | return DEAD_OBJECT; |
| 3701 | } |
| 3702 | finalConfiguration.streams.resize(finalConfiguration_3_2.streams.size()); |
| 3703 | for (size_t i = 0; i < finalConfiguration_3_2.streams.size(); i++) { |
| 3704 | finalConfiguration.streams[i].v3_2 = finalConfiguration_3_2.streams[i]; |
| 3705 | finalConfiguration.streams[i].overrideDataSpace = |
Shuzhen Wang | c28189a | 2017-11-27 23:05:10 -0800 | [diff] [blame] | 3706 | requestedConfiguration3_2.streams[i].dataSpace; |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3707 | } |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3708 | } |
| 3709 | |
| 3710 | if (status != common::V1_0::Status::OK ) { |
| 3711 | return CameraProviderManager::mapToStatusT(status); |
| 3712 | } |
| 3713 | |
| 3714 | // And convert output stream configuration from HIDL |
| 3715 | |
| 3716 | for (size_t i = 0; i < config->num_streams; i++) { |
| 3717 | camera3_stream_t *dst = config->streams[i]; |
| 3718 | int streamId = Camera3Stream::cast(dst)->getId(); |
| 3719 | |
| 3720 | // Start scan at i, with the assumption that the stream order matches |
| 3721 | size_t realIdx = i; |
| 3722 | bool found = false; |
| 3723 | for (size_t idx = 0; idx < finalConfiguration.streams.size(); idx++) { |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3724 | if (finalConfiguration.streams[realIdx].v3_2.id == streamId) { |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3725 | found = true; |
| 3726 | break; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3727 | } |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3728 | realIdx = (realIdx >= finalConfiguration.streams.size()) ? 0 : realIdx + 1; |
| 3729 | } |
| 3730 | if (!found) { |
| 3731 | ALOGE("%s: Stream %d not found in stream configuration response from HAL", |
| 3732 | __FUNCTION__, streamId); |
| 3733 | return INVALID_OPERATION; |
| 3734 | } |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3735 | device::V3_3::HalStream &src = finalConfiguration.streams[realIdx]; |
Yin-Chia Yeh | 7732705 | 2017-01-09 18:23:07 -0800 | [diff] [blame] | 3736 | |
Emilian Peev | 710c142 | 2017-08-30 11:19:38 +0100 | [diff] [blame] | 3737 | Camera3Stream* dstStream = Camera3Stream::cast(dst); |
| 3738 | dstStream->setFormatOverride(false); |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3739 | dstStream->setDataSpaceOverride(false); |
| 3740 | int overrideFormat = mapToFrameworkFormat(src.v3_2.overrideFormat); |
| 3741 | android_dataspace overrideDataSpace = mapToFrameworkDataspace(src.overrideDataSpace); |
| 3742 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3743 | if (dst->format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { |
| 3744 | if (dst->format != overrideFormat) { |
| 3745 | ALOGE("%s: Stream %d: Format override not allowed for format 0x%x", __FUNCTION__, |
| 3746 | streamId, dst->format); |
Yin-Chia Yeh | 7732705 | 2017-01-09 18:23:07 -0800 | [diff] [blame] | 3747 | } |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3748 | if (dst->data_space != overrideDataSpace) { |
| 3749 | ALOGE("%s: Stream %d: DataSpace override not allowed for format 0x%x", __FUNCTION__, |
| 3750 | streamId, dst->format); |
| 3751 | } |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3752 | } else { |
Emilian Peev | 710c142 | 2017-08-30 11:19:38 +0100 | [diff] [blame] | 3753 | dstStream->setFormatOverride((dst->format != overrideFormat) ? true : false); |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3754 | dstStream->setDataSpaceOverride((dst->data_space != overrideDataSpace) ? true : false); |
| 3755 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3756 | // Override allowed with IMPLEMENTATION_DEFINED |
| 3757 | dst->format = overrideFormat; |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3758 | dst->data_space = overrideDataSpace; |
Yin-Chia Yeh | 7732705 | 2017-01-09 18:23:07 -0800 | [diff] [blame] | 3759 | } |
| 3760 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3761 | if (dst->stream_type == CAMERA3_STREAM_INPUT) { |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3762 | if (src.v3_2.producerUsage != 0) { |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3763 | ALOGE("%s: Stream %d: INPUT streams must have 0 for producer usage", |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3764 | __FUNCTION__, streamId); |
| 3765 | return INVALID_OPERATION; |
| 3766 | } |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3767 | dstStream->setUsage( |
| 3768 | mapConsumerToFrameworkUsage(src.v3_2.consumerUsage)); |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3769 | } else { |
| 3770 | // OUTPUT |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3771 | if (src.v3_2.consumerUsage != 0) { |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3772 | ALOGE("%s: Stream %d: OUTPUT streams must have 0 for consumer usage", |
| 3773 | __FUNCTION__, streamId); |
| 3774 | return INVALID_OPERATION; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3775 | } |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3776 | dstStream->setUsage( |
| 3777 | mapProducerToFrameworkUsage(src.v3_2.producerUsage)); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3778 | } |
Eino-Ville Talvala | 91cd3f8 | 2017-08-21 16:12:50 -0700 | [diff] [blame] | 3779 | dst->max_buffers = src.v3_2.maxBuffers; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3780 | } |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3781 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3782 | return res; |
| 3783 | } |
| 3784 | |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 3785 | void Camera3Device::HalInterface::wrapAsHidlRequest(camera3_capture_request_t* request, |
| 3786 | /*out*/device::V3_2::CaptureRequest* captureRequest, |
| 3787 | /*out*/std::vector<native_handle_t*>* handlesCreated) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 3788 | ATRACE_CALL(); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 3789 | if (captureRequest == nullptr || handlesCreated == nullptr) { |
| 3790 | ALOGE("%s: captureRequest (%p) and handlesCreated (%p) must not be null", |
| 3791 | __FUNCTION__, captureRequest, handlesCreated); |
| 3792 | return; |
| 3793 | } |
| 3794 | |
| 3795 | captureRequest->frameNumber = request->frame_number; |
Yifan Hong | f79b554 | 2017-04-11 14:44:25 -0700 | [diff] [blame] | 3796 | |
| 3797 | captureRequest->fmqSettingsSize = 0; |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 3798 | |
| 3799 | { |
| 3800 | std::lock_guard<std::mutex> lock(mInflightLock); |
| 3801 | if (request->input_buffer != nullptr) { |
| 3802 | int32_t streamId = Camera3Stream::cast(request->input_buffer->stream)->getId(); |
| 3803 | buffer_handle_t buf = *(request->input_buffer->buffer); |
| 3804 | auto pair = getBufferId(buf, streamId); |
| 3805 | bool isNewBuffer = pair.first; |
| 3806 | uint64_t bufferId = pair.second; |
| 3807 | captureRequest->inputBuffer.streamId = streamId; |
| 3808 | captureRequest->inputBuffer.bufferId = bufferId; |
| 3809 | captureRequest->inputBuffer.buffer = (isNewBuffer) ? buf : nullptr; |
| 3810 | captureRequest->inputBuffer.status = BufferStatus::OK; |
| 3811 | native_handle_t *acquireFence = nullptr; |
| 3812 | if (request->input_buffer->acquire_fence != -1) { |
| 3813 | acquireFence = native_handle_create(1,0); |
| 3814 | acquireFence->data[0] = request->input_buffer->acquire_fence; |
| 3815 | handlesCreated->push_back(acquireFence); |
| 3816 | } |
| 3817 | captureRequest->inputBuffer.acquireFence = acquireFence; |
| 3818 | captureRequest->inputBuffer.releaseFence = nullptr; |
| 3819 | |
| 3820 | pushInflightBufferLocked(captureRequest->frameNumber, streamId, |
| 3821 | request->input_buffer->buffer, |
| 3822 | request->input_buffer->acquire_fence); |
| 3823 | } else { |
| 3824 | captureRequest->inputBuffer.streamId = -1; |
| 3825 | captureRequest->inputBuffer.bufferId = BUFFER_ID_NO_BUFFER; |
| 3826 | } |
| 3827 | |
| 3828 | captureRequest->outputBuffers.resize(request->num_output_buffers); |
| 3829 | for (size_t i = 0; i < request->num_output_buffers; i++) { |
| 3830 | const camera3_stream_buffer_t *src = request->output_buffers + i; |
| 3831 | StreamBuffer &dst = captureRequest->outputBuffers[i]; |
| 3832 | int32_t streamId = Camera3Stream::cast(src->stream)->getId(); |
| 3833 | buffer_handle_t buf = *(src->buffer); |
| 3834 | auto pair = getBufferId(buf, streamId); |
| 3835 | bool isNewBuffer = pair.first; |
| 3836 | dst.streamId = streamId; |
| 3837 | dst.bufferId = pair.second; |
| 3838 | dst.buffer = isNewBuffer ? buf : nullptr; |
| 3839 | dst.status = BufferStatus::OK; |
| 3840 | native_handle_t *acquireFence = nullptr; |
| 3841 | if (src->acquire_fence != -1) { |
| 3842 | acquireFence = native_handle_create(1,0); |
| 3843 | acquireFence->data[0] = src->acquire_fence; |
| 3844 | handlesCreated->push_back(acquireFence); |
| 3845 | } |
| 3846 | dst.acquireFence = acquireFence; |
| 3847 | dst.releaseFence = nullptr; |
| 3848 | |
| 3849 | pushInflightBufferLocked(captureRequest->frameNumber, streamId, |
| 3850 | src->buffer, src->acquire_fence); |
| 3851 | } |
| 3852 | } |
| 3853 | } |
| 3854 | |
| 3855 | status_t Camera3Device::HalInterface::processBatchCaptureRequests( |
| 3856 | std::vector<camera3_capture_request_t*>& requests,/*out*/uint32_t* numRequestProcessed) { |
| 3857 | ATRACE_NAME("CameraHal::processBatchCaptureRequests"); |
| 3858 | if (!valid()) return INVALID_OPERATION; |
| 3859 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 3860 | sp<device::V3_4::ICameraDeviceSession> hidlSession_3_4; |
| 3861 | auto castResult_3_4 = device::V3_4::ICameraDeviceSession::castFrom(mHidlSession); |
| 3862 | if (castResult_3_4.isOk()) { |
| 3863 | hidlSession_3_4 = castResult_3_4; |
| 3864 | } |
| 3865 | |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 3866 | hardware::hidl_vec<device::V3_2::CaptureRequest> captureRequests; |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 3867 | hardware::hidl_vec<device::V3_4::CaptureRequest> captureRequests_3_4; |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 3868 | size_t batchSize = requests.size(); |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 3869 | if (hidlSession_3_4 != nullptr) { |
| 3870 | captureRequests_3_4.resize(batchSize); |
| 3871 | } else { |
| 3872 | captureRequests.resize(batchSize); |
| 3873 | } |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 3874 | std::vector<native_handle_t*> handlesCreated; |
| 3875 | |
| 3876 | for (size_t i = 0; i < batchSize; i++) { |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 3877 | if (hidlSession_3_4 != nullptr) { |
| 3878 | wrapAsHidlRequest(requests[i], /*out*/&captureRequests_3_4[i].v3_2, |
| 3879 | /*out*/&handlesCreated); |
| 3880 | } else { |
| 3881 | wrapAsHidlRequest(requests[i], /*out*/&captureRequests[i], /*out*/&handlesCreated); |
| 3882 | } |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 3883 | } |
| 3884 | |
Yin-Chia Yeh | be83fa7 | 2017-03-30 13:35:36 -0700 | [diff] [blame] | 3885 | std::vector<device::V3_2::BufferCache> cachesToRemove; |
| 3886 | { |
| 3887 | std::lock_guard<std::mutex> lock(mBufferIdMapLock); |
| 3888 | for (auto& pair : mFreedBuffers) { |
| 3889 | // The stream might have been removed since onBufferFreed |
| 3890 | if (mBufferIdMaps.find(pair.first) != mBufferIdMaps.end()) { |
| 3891 | cachesToRemove.push_back({pair.first, pair.second}); |
| 3892 | } |
| 3893 | } |
| 3894 | mFreedBuffers.clear(); |
| 3895 | } |
| 3896 | |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 3897 | common::V1_0::Status status = common::V1_0::Status::INTERNAL_ERROR; |
| 3898 | *numRequestProcessed = 0; |
Yifan Hong | f79b554 | 2017-04-11 14:44:25 -0700 | [diff] [blame] | 3899 | |
| 3900 | // Write metadata to FMQ. |
| 3901 | for (size_t i = 0; i < batchSize; i++) { |
| 3902 | camera3_capture_request_t* request = requests[i]; |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 3903 | device::V3_2::CaptureRequest* captureRequest; |
| 3904 | if (hidlSession_3_4 != nullptr) { |
| 3905 | captureRequest = &captureRequests_3_4[i].v3_2; |
| 3906 | } else { |
| 3907 | captureRequest = &captureRequests[i]; |
| 3908 | } |
Yifan Hong | f79b554 | 2017-04-11 14:44:25 -0700 | [diff] [blame] | 3909 | |
| 3910 | if (request->settings != nullptr) { |
| 3911 | size_t settingsSize = get_camera_metadata_size(request->settings); |
| 3912 | if (mRequestMetadataQueue != nullptr && mRequestMetadataQueue->write( |
| 3913 | reinterpret_cast<const uint8_t*>(request->settings), settingsSize)) { |
| 3914 | captureRequest->settings.resize(0); |
| 3915 | captureRequest->fmqSettingsSize = settingsSize; |
| 3916 | } else { |
| 3917 | if (mRequestMetadataQueue != nullptr) { |
| 3918 | ALOGW("%s: couldn't utilize fmq, fallback to hwbinder", __FUNCTION__); |
| 3919 | } |
| 3920 | captureRequest->settings.setToExternal( |
| 3921 | reinterpret_cast<uint8_t*>(const_cast<camera_metadata_t*>(request->settings)), |
| 3922 | get_camera_metadata_size(request->settings)); |
| 3923 | captureRequest->fmqSettingsSize = 0u; |
| 3924 | } |
| 3925 | } else { |
| 3926 | // A null request settings maps to a size-0 CameraMetadata |
| 3927 | captureRequest->settings.resize(0); |
| 3928 | captureRequest->fmqSettingsSize = 0u; |
| 3929 | } |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 3930 | |
| 3931 | if (hidlSession_3_4 != nullptr) { |
| 3932 | captureRequests_3_4[i].physicalCameraSettings.resize(request->num_physcam_settings); |
| 3933 | for (size_t j = 0; j < request->num_physcam_settings; j++) { |
Emilian Peev | 00420d2 | 2018-02-05 21:33:13 +0000 | [diff] [blame] | 3934 | if (request->physcam_settings != nullptr) { |
| 3935 | size_t settingsSize = get_camera_metadata_size(request->physcam_settings[j]); |
| 3936 | if (mRequestMetadataQueue != nullptr && mRequestMetadataQueue->write( |
| 3937 | reinterpret_cast<const uint8_t*>(request->physcam_settings[j]), |
| 3938 | settingsSize)) { |
| 3939 | captureRequests_3_4[i].physicalCameraSettings[j].settings.resize(0); |
| 3940 | captureRequests_3_4[i].physicalCameraSettings[j].fmqSettingsSize = |
| 3941 | settingsSize; |
| 3942 | } else { |
| 3943 | if (mRequestMetadataQueue != nullptr) { |
| 3944 | ALOGW("%s: couldn't utilize fmq, fallback to hwbinder", __FUNCTION__); |
| 3945 | } |
| 3946 | captureRequests_3_4[i].physicalCameraSettings[j].settings.setToExternal( |
| 3947 | reinterpret_cast<uint8_t*>(const_cast<camera_metadata_t*>( |
| 3948 | request->physcam_settings[j])), |
| 3949 | get_camera_metadata_size(request->physcam_settings[j])); |
| 3950 | captureRequests_3_4[i].physicalCameraSettings[j].fmqSettingsSize = 0u; |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 3951 | } |
Emilian Peev | 00420d2 | 2018-02-05 21:33:13 +0000 | [diff] [blame] | 3952 | } else { |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 3953 | captureRequests_3_4[i].physicalCameraSettings[j].fmqSettingsSize = 0u; |
Emilian Peev | 00420d2 | 2018-02-05 21:33:13 +0000 | [diff] [blame] | 3954 | captureRequests_3_4[i].physicalCameraSettings[j].settings.resize(0); |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 3955 | } |
| 3956 | captureRequests_3_4[i].physicalCameraSettings[j].physicalCameraId = |
| 3957 | request->physcam_id[j]; |
| 3958 | } |
| 3959 | } |
Yifan Hong | f79b554 | 2017-04-11 14:44:25 -0700 | [diff] [blame] | 3960 | } |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 3961 | |
| 3962 | hardware::details::return_status err; |
Jayant Chowdhary | c8d581e | 2018-07-16 14:46:23 -0700 | [diff] [blame] | 3963 | auto resultCallback = |
| 3964 | [&status, &numRequestProcessed] (auto s, uint32_t n) { |
| 3965 | status = s; |
| 3966 | *numRequestProcessed = n; |
| 3967 | }; |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 3968 | if (hidlSession_3_4 != nullptr) { |
| 3969 | err = hidlSession_3_4->processCaptureRequest_3_4(captureRequests_3_4, cachesToRemove, |
Jayant Chowdhary | c8d581e | 2018-07-16 14:46:23 -0700 | [diff] [blame] | 3970 | resultCallback); |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 3971 | } else { |
| 3972 | err = mHidlSession->processCaptureRequest(captureRequests, cachesToRemove, |
Jayant Chowdhary | c8d581e | 2018-07-16 14:46:23 -0700 | [diff] [blame] | 3973 | resultCallback); |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 3974 | } |
Eino-Ville Talvala | c5cbb87 | 2017-04-27 12:48:33 -0700 | [diff] [blame] | 3975 | if (!err.isOk()) { |
| 3976 | ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str()); |
| 3977 | return DEAD_OBJECT; |
| 3978 | } |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 3979 | if (status == common::V1_0::Status::OK && *numRequestProcessed != batchSize) { |
| 3980 | ALOGE("%s: processCaptureRequest returns OK but processed %d/%zu requests", |
| 3981 | __FUNCTION__, *numRequestProcessed, batchSize); |
| 3982 | status = common::V1_0::Status::INTERNAL_ERROR; |
| 3983 | } |
| 3984 | |
| 3985 | for (auto& handle : handlesCreated) { |
| 3986 | native_handle_delete(handle); |
| 3987 | } |
| 3988 | return CameraProviderManager::mapToStatusT(status); |
| 3989 | } |
| 3990 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3991 | status_t Camera3Device::HalInterface::processCaptureRequest( |
| 3992 | camera3_capture_request_t *request) { |
| 3993 | ATRACE_NAME("CameraHal::processCaptureRequest"); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 3994 | if (!valid()) return INVALID_OPERATION; |
| 3995 | status_t res = OK; |
| 3996 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 3997 | uint32_t numRequestProcessed = 0; |
| 3998 | std::vector<camera3_capture_request_t*> requests(1); |
| 3999 | requests[0] = request; |
| 4000 | res = processBatchCaptureRequests(requests, &numRequestProcessed); |
| 4001 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4002 | return res; |
| 4003 | } |
| 4004 | |
| 4005 | status_t Camera3Device::HalInterface::flush() { |
| 4006 | ATRACE_NAME("CameraHal::flush"); |
| 4007 | if (!valid()) return INVALID_OPERATION; |
| 4008 | status_t res = OK; |
| 4009 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 4010 | auto err = mHidlSession->flush(); |
| 4011 | if (!err.isOk()) { |
| 4012 | ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str()); |
| 4013 | res = DEAD_OBJECT; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4014 | } else { |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 4015 | res = CameraProviderManager::mapToStatusT(err); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4016 | } |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 4017 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4018 | return res; |
| 4019 | } |
| 4020 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 4021 | status_t Camera3Device::HalInterface::dump(int /*fd*/) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4022 | ATRACE_NAME("CameraHal::dump"); |
| 4023 | if (!valid()) return INVALID_OPERATION; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4024 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 4025 | // Handled by CameraProviderManager::dump |
| 4026 | |
| 4027 | return OK; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4028 | } |
| 4029 | |
| 4030 | status_t Camera3Device::HalInterface::close() { |
| 4031 | ATRACE_NAME("CameraHal::close()"); |
| 4032 | if (!valid()) return INVALID_OPERATION; |
| 4033 | status_t res = OK; |
| 4034 | |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 4035 | auto err = mHidlSession->close(); |
| 4036 | // Interface will be dead shortly anyway, so don't log errors |
| 4037 | if (!err.isOk()) { |
| 4038 | res = DEAD_OBJECT; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4039 | } |
Emilian Peev | 31abd0a | 2017-05-11 18:37:46 +0100 | [diff] [blame] | 4040 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4041 | return res; |
| 4042 | } |
| 4043 | |
Yin-Chia Yeh | f3fe36f | 2017-07-07 18:23:18 -0700 | [diff] [blame] | 4044 | void Camera3Device::HalInterface::getInflightBufferKeys( |
| 4045 | std::vector<std::pair<int32_t, int32_t>>* out) { |
| 4046 | std::lock_guard<std::mutex> lock(mInflightLock); |
| 4047 | out->clear(); |
| 4048 | out->reserve(mInflightBufferMap.size()); |
| 4049 | for (auto& pair : mInflightBufferMap) { |
| 4050 | uint64_t key = pair.first; |
| 4051 | int32_t streamId = key & 0xFFFFFFFF; |
| 4052 | int32_t frameNumber = (key >> 32) & 0xFFFFFFFF; |
| 4053 | out->push_back(std::make_pair(frameNumber, streamId)); |
| 4054 | } |
| 4055 | return; |
| 4056 | } |
| 4057 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4058 | status_t Camera3Device::HalInterface::pushInflightBufferLocked( |
Yin-Chia Yeh | f465060 | 2017-01-10 13:13:39 -0800 | [diff] [blame] | 4059 | int32_t frameNumber, int32_t streamId, buffer_handle_t *buffer, int acquireFence) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4060 | uint64_t key = static_cast<uint64_t>(frameNumber) << 32 | static_cast<uint64_t>(streamId); |
Yin-Chia Yeh | f465060 | 2017-01-10 13:13:39 -0800 | [diff] [blame] | 4061 | auto pair = std::make_pair(buffer, acquireFence); |
| 4062 | mInflightBufferMap[key] = pair; |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4063 | return OK; |
| 4064 | } |
| 4065 | |
| 4066 | status_t Camera3Device::HalInterface::popInflightBuffer( |
Yin-Chia Yeh | f465060 | 2017-01-10 13:13:39 -0800 | [diff] [blame] | 4067 | int32_t frameNumber, int32_t streamId, |
| 4068 | /*out*/ buffer_handle_t **buffer) { |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4069 | std::lock_guard<std::mutex> lock(mInflightLock); |
| 4070 | |
| 4071 | uint64_t key = static_cast<uint64_t>(frameNumber) << 32 | static_cast<uint64_t>(streamId); |
| 4072 | auto it = mInflightBufferMap.find(key); |
| 4073 | if (it == mInflightBufferMap.end()) return NAME_NOT_FOUND; |
Yin-Chia Yeh | f465060 | 2017-01-10 13:13:39 -0800 | [diff] [blame] | 4074 | auto pair = it->second; |
| 4075 | *buffer = pair.first; |
| 4076 | int acquireFence = pair.second; |
| 4077 | if (acquireFence > 0) { |
| 4078 | ::close(acquireFence); |
| 4079 | } |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4080 | mInflightBufferMap.erase(it); |
| 4081 | return OK; |
| 4082 | } |
| 4083 | |
Yin-Chia Yeh | 7732705 | 2017-01-09 18:23:07 -0800 | [diff] [blame] | 4084 | std::pair<bool, uint64_t> Camera3Device::HalInterface::getBufferId( |
| 4085 | const buffer_handle_t& buf, int streamId) { |
| 4086 | std::lock_guard<std::mutex> lock(mBufferIdMapLock); |
| 4087 | |
| 4088 | BufferIdMap& bIdMap = mBufferIdMaps.at(streamId); |
| 4089 | auto it = bIdMap.find(buf); |
| 4090 | if (it == bIdMap.end()) { |
| 4091 | bIdMap[buf] = mNextBufferId++; |
Yin-Chia Yeh | be83fa7 | 2017-03-30 13:35:36 -0700 | [diff] [blame] | 4092 | ALOGV("stream %d now have %zu buffer caches, buf %p", |
| 4093 | streamId, bIdMap.size(), buf); |
Yin-Chia Yeh | 7732705 | 2017-01-09 18:23:07 -0800 | [diff] [blame] | 4094 | return std::make_pair(true, mNextBufferId - 1); |
| 4095 | } else { |
| 4096 | return std::make_pair(false, it->second); |
| 4097 | } |
| 4098 | } |
| 4099 | |
Yin-Chia Yeh | be83fa7 | 2017-03-30 13:35:36 -0700 | [diff] [blame] | 4100 | void Camera3Device::HalInterface::onBufferFreed( |
| 4101 | int streamId, const native_handle_t* handle) { |
| 4102 | std::lock_guard<std::mutex> lock(mBufferIdMapLock); |
| 4103 | uint64_t bufferId = BUFFER_ID_NO_BUFFER; |
| 4104 | auto mapIt = mBufferIdMaps.find(streamId); |
| 4105 | if (mapIt == mBufferIdMaps.end()) { |
| 4106 | // streamId might be from a deleted stream here |
| 4107 | ALOGI("%s: stream %d has been removed", |
| 4108 | __FUNCTION__, streamId); |
| 4109 | return; |
| 4110 | } |
| 4111 | BufferIdMap& bIdMap = mapIt->second; |
| 4112 | auto it = bIdMap.find(handle); |
| 4113 | if (it == bIdMap.end()) { |
| 4114 | ALOGW("%s: cannot find buffer %p in stream %d", |
| 4115 | __FUNCTION__, handle, streamId); |
| 4116 | return; |
| 4117 | } else { |
| 4118 | bufferId = it->second; |
| 4119 | bIdMap.erase(it); |
| 4120 | ALOGV("%s: stream %d now have %zu buffer caches after removing buf %p", |
| 4121 | __FUNCTION__, streamId, bIdMap.size(), handle); |
| 4122 | } |
| 4123 | mFreedBuffers.push_back(std::make_pair(streamId, bufferId)); |
| 4124 | } |
| 4125 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4126 | /** |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4127 | * RequestThread inner class methods |
| 4128 | */ |
| 4129 | |
| 4130 | Camera3Device::RequestThread::RequestThread(wp<Camera3Device> parent, |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 4131 | sp<StatusTracker> statusTracker, |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 4132 | sp<HalInterface> interface, const Vector<int32_t>& sessionParamKeys) : |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 4133 | Thread(/*canCallJava*/false), |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4134 | mParent(parent), |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 4135 | mStatusTracker(statusTracker), |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4136 | mInterface(interface), |
Eino-Ville Talvala | 77c1a35 | 2016-06-13 12:32:43 -0700 | [diff] [blame] | 4137 | mListener(nullptr), |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 4138 | mId(getId(parent)), |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4139 | mReconfigured(false), |
| 4140 | mDoPause(false), |
| 4141 | mPaused(true), |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 4142 | mFrameNumber(0), |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 4143 | mLatestRequestId(NAME_NOT_FOUND), |
Yin-Chia Yeh | c00a25c | 2014-08-21 14:27:44 -0700 | [diff] [blame] | 4144 | mCurrentAfTriggerId(0), |
| 4145 | mCurrentPreCaptureTriggerId(0), |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 4146 | mRepeatingLastFrameNumber( |
| 4147 | hardware::camera2::ICameraDeviceUser::NO_IN_FLIGHT_REPEATING_FRAMES), |
Shuzhen Wang | 686f644 | 2017-06-20 16:16:04 -0700 | [diff] [blame] | 4148 | mPrepareVideoStream(false), |
Emilian Peev | a14b4dd | 2018-05-15 11:00:31 +0100 | [diff] [blame] | 4149 | mConstrainedMode(false), |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 4150 | mRequestLatency(kRequestLatencyBinSize), |
| 4151 | mSessionParamKeys(sessionParamKeys), |
| 4152 | mLatestSessionParams(sessionParamKeys.size()) { |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 4153 | mStatusId = statusTracker->addComponent(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4154 | } |
| 4155 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4156 | Camera3Device::RequestThread::~RequestThread() {} |
| 4157 | |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 4158 | void Camera3Device::RequestThread::setNotificationListener( |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 4159 | wp<NotificationListener> listener) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 4160 | ATRACE_CALL(); |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 4161 | Mutex::Autolock l(mRequestLock); |
| 4162 | mListener = listener; |
| 4163 | } |
| 4164 | |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 4165 | void Camera3Device::RequestThread::configurationComplete(bool isConstrainedHighSpeed, |
| 4166 | const CameraMetadata& sessionParams) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 4167 | ATRACE_CALL(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4168 | Mutex::Autolock l(mRequestLock); |
| 4169 | mReconfigured = true; |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 4170 | mLatestSessionParams = sessionParams; |
Chien-Yu Chen | c66969b | 2016-05-19 16:37:51 -0700 | [diff] [blame] | 4171 | // Prepare video stream for high speed recording. |
| 4172 | mPrepareVideoStream = isConstrainedHighSpeed; |
Emilian Peev | a14b4dd | 2018-05-15 11:00:31 +0100 | [diff] [blame] | 4173 | mConstrainedMode = isConstrainedHighSpeed; |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4174 | } |
| 4175 | |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 4176 | status_t Camera3Device::RequestThread::queueRequestList( |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 4177 | List<sp<CaptureRequest> > &requests, |
| 4178 | /*out*/ |
| 4179 | int64_t *lastFrameNumber) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 4180 | ATRACE_CALL(); |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 4181 | Mutex::Autolock l(mRequestLock); |
| 4182 | for (List<sp<CaptureRequest> >::iterator it = requests.begin(); it != requests.end(); |
| 4183 | ++it) { |
| 4184 | mRequestQueue.push_back(*it); |
| 4185 | } |
| 4186 | |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 4187 | if (lastFrameNumber != NULL) { |
| 4188 | *lastFrameNumber = mFrameNumber + mRequestQueue.size() - 1; |
| 4189 | ALOGV("%s: requestId %d, mFrameNumber %" PRId32 ", lastFrameNumber %" PRId64 ".", |
| 4190 | __FUNCTION__, (*(requests.begin()))->mResultExtras.requestId, mFrameNumber, |
| 4191 | *lastFrameNumber); |
| 4192 | } |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 4193 | |
Jianing Wei | 90e59c9 | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 4194 | unpauseForNewRequests(); |
| 4195 | |
| 4196 | return OK; |
| 4197 | } |
| 4198 | |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 4199 | |
| 4200 | status_t Camera3Device::RequestThread::queueTrigger( |
| 4201 | RequestTrigger trigger[], |
| 4202 | size_t count) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 4203 | ATRACE_CALL(); |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 4204 | Mutex::Autolock l(mTriggerMutex); |
| 4205 | status_t ret; |
| 4206 | |
| 4207 | for (size_t i = 0; i < count; ++i) { |
| 4208 | ret = queueTriggerLocked(trigger[i]); |
| 4209 | |
| 4210 | if (ret != OK) { |
| 4211 | return ret; |
| 4212 | } |
| 4213 | } |
| 4214 | |
| 4215 | return OK; |
| 4216 | } |
| 4217 | |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4218 | const String8& Camera3Device::RequestThread::getId(const wp<Camera3Device> &device) { |
| 4219 | static String8 deadId("<DeadDevice>"); |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 4220 | sp<Camera3Device> d = device.promote(); |
Eino-Ville Talvala | 0b1cb14 | 2016-12-19 16:29:17 -0800 | [diff] [blame] | 4221 | if (d != nullptr) return d->mId; |
| 4222 | return deadId; |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 4223 | } |
| 4224 | |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 4225 | status_t Camera3Device::RequestThread::queueTriggerLocked( |
| 4226 | RequestTrigger trigger) { |
| 4227 | |
| 4228 | uint32_t tag = trigger.metadataTag; |
| 4229 | ssize_t index = mTriggerMap.indexOfKey(tag); |
| 4230 | |
| 4231 | switch (trigger.getTagType()) { |
| 4232 | case TYPE_BYTE: |
| 4233 | // fall-through |
| 4234 | case TYPE_INT32: |
| 4235 | break; |
| 4236 | default: |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 4237 | ALOGE("%s: Type not supported: 0x%x", __FUNCTION__, |
| 4238 | trigger.getTagType()); |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 4239 | return INVALID_OPERATION; |
| 4240 | } |
| 4241 | |
| 4242 | /** |
| 4243 | * Collect only the latest trigger, since we only have 1 field |
| 4244 | * in the request settings per trigger tag, and can't send more than 1 |
| 4245 | * trigger per request. |
| 4246 | */ |
| 4247 | if (index != NAME_NOT_FOUND) { |
| 4248 | mTriggerMap.editValueAt(index) = trigger; |
| 4249 | } else { |
| 4250 | mTriggerMap.add(tag, trigger); |
| 4251 | } |
| 4252 | |
| 4253 | return OK; |
| 4254 | } |
| 4255 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4256 | status_t Camera3Device::RequestThread::setRepeatingRequests( |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 4257 | const RequestList &requests, |
| 4258 | /*out*/ |
| 4259 | int64_t *lastFrameNumber) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 4260 | ATRACE_CALL(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4261 | Mutex::Autolock l(mRequestLock); |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 4262 | if (lastFrameNumber != NULL) { |
| 4263 | *lastFrameNumber = mRepeatingLastFrameNumber; |
| 4264 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4265 | mRepeatingRequests.clear(); |
| 4266 | mRepeatingRequests.insert(mRepeatingRequests.begin(), |
| 4267 | requests.begin(), requests.end()); |
Eino-Ville Talvala | 26fe6c7 | 2013-08-29 12:46:18 -0700 | [diff] [blame] | 4268 | |
| 4269 | unpauseForNewRequests(); |
| 4270 | |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 4271 | mRepeatingLastFrameNumber = hardware::camera2::ICameraDeviceUser::NO_IN_FLIGHT_REPEATING_FRAMES; |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4272 | return OK; |
| 4273 | } |
| 4274 | |
Chih-Hung Hsieh | 8b0b971 | 2016-08-09 14:25:53 -0700 | [diff] [blame] | 4275 | bool Camera3Device::RequestThread::isRepeatingRequestLocked(const sp<CaptureRequest>& requestIn) { |
Yin-Chia Yeh | 8684b7f | 2014-06-13 14:53:05 -0700 | [diff] [blame] | 4276 | if (mRepeatingRequests.empty()) { |
| 4277 | return false; |
| 4278 | } |
| 4279 | int32_t requestId = requestIn->mResultExtras.requestId; |
| 4280 | const RequestList &repeatRequests = mRepeatingRequests; |
| 4281 | // All repeating requests are guaranteed to have same id so only check first quest |
| 4282 | const sp<CaptureRequest> firstRequest = *repeatRequests.begin(); |
| 4283 | return (firstRequest->mResultExtras.requestId == requestId); |
| 4284 | } |
| 4285 | |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 4286 | status_t Camera3Device::RequestThread::clearRepeatingRequests(/*out*/int64_t *lastFrameNumber) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 4287 | ATRACE_CALL(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4288 | Mutex::Autolock l(mRequestLock); |
Chien-Yu Chen | e8c535e | 2016-04-14 12:18:26 -0700 | [diff] [blame] | 4289 | return clearRepeatingRequestsLocked(lastFrameNumber); |
| 4290 | |
| 4291 | } |
| 4292 | |
| 4293 | status_t Camera3Device::RequestThread::clearRepeatingRequestsLocked(/*out*/int64_t *lastFrameNumber) { |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4294 | mRepeatingRequests.clear(); |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 4295 | if (lastFrameNumber != NULL) { |
| 4296 | *lastFrameNumber = mRepeatingLastFrameNumber; |
| 4297 | } |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 4298 | mRepeatingLastFrameNumber = hardware::camera2::ICameraDeviceUser::NO_IN_FLIGHT_REPEATING_FRAMES; |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4299 | return OK; |
| 4300 | } |
| 4301 | |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 4302 | status_t Camera3Device::RequestThread::clear( |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 4303 | /*out*/int64_t *lastFrameNumber) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 4304 | ATRACE_CALL(); |
Eino-Ville Talvala | abaa51d | 2013-08-14 11:37:00 -0700 | [diff] [blame] | 4305 | Mutex::Autolock l(mRequestLock); |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 4306 | ALOGV("RequestThread::%s:", __FUNCTION__); |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 4307 | |
Eino-Ville Talvala | abaa51d | 2013-08-14 11:37:00 -0700 | [diff] [blame] | 4308 | mRepeatingRequests.clear(); |
Yin-Chia Yeh | 8684b7f | 2014-06-13 14:53:05 -0700 | [diff] [blame] | 4309 | |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 4310 | // Send errors for all requests pending in the request queue, including |
| 4311 | // pending repeating requests |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 4312 | sp<NotificationListener> listener = mListener.promote(); |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 4313 | if (listener != NULL) { |
| 4314 | for (RequestList::iterator it = mRequestQueue.begin(); |
| 4315 | it != mRequestQueue.end(); ++it) { |
Chien-Yu Chen | c2adf48 | 2015-05-27 14:27:49 -0700 | [diff] [blame] | 4316 | // Abort the input buffers for reprocess requests. |
| 4317 | if ((*it)->mInputStream != NULL) { |
| 4318 | camera3_stream_buffer_t inputBuffer; |
Eino-Ville Talvala | ba43525 | 2017-06-21 16:07:25 -0700 | [diff] [blame] | 4319 | status_t res = (*it)->mInputStream->getInputBuffer(&inputBuffer, |
| 4320 | /*respectHalLimit*/ false); |
Chien-Yu Chen | c2adf48 | 2015-05-27 14:27:49 -0700 | [diff] [blame] | 4321 | if (res != OK) { |
| 4322 | ALOGW("%s: %d: couldn't get input buffer while clearing the request " |
| 4323 | "list: %s (%d)", __FUNCTION__, __LINE__, strerror(-res), res); |
| 4324 | } else { |
| 4325 | res = (*it)->mInputStream->returnInputBuffer(inputBuffer); |
| 4326 | if (res != OK) { |
| 4327 | ALOGE("%s: %d: couldn't return input buffer while clearing the request " |
| 4328 | "list: %s (%d)", __FUNCTION__, __LINE__, strerror(-res), res); |
| 4329 | } |
| 4330 | } |
| 4331 | } |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 4332 | // Set the frame number this request would have had, if it |
| 4333 | // had been submitted; this frame number will not be reused. |
| 4334 | // The requestId and burstId fields were set when the request was |
| 4335 | // submitted originally (in convertMetadataListToRequestListLocked) |
| 4336 | (*it)->mResultExtras.frameNumber = mFrameNumber++; |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 4337 | listener->notifyError(hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST, |
Eino-Ville Talvala | 1754351 | 2014-08-06 14:32:02 -0700 | [diff] [blame] | 4338 | (*it)->mResultExtras); |
Yin-Chia Yeh | 8684b7f | 2014-06-13 14:53:05 -0700 | [diff] [blame] | 4339 | } |
| 4340 | } |
Eino-Ville Talvala | abaa51d | 2013-08-14 11:37:00 -0700 | [diff] [blame] | 4341 | mRequestQueue.clear(); |
Jinguang Dong | b26e7a0 | 2016-11-14 16:04:02 +0800 | [diff] [blame] | 4342 | |
| 4343 | Mutex::Autolock al(mTriggerMutex); |
Eino-Ville Talvala | abaa51d | 2013-08-14 11:37:00 -0700 | [diff] [blame] | 4344 | mTriggerMap.clear(); |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 4345 | if (lastFrameNumber != NULL) { |
| 4346 | *lastFrameNumber = mRepeatingLastFrameNumber; |
| 4347 | } |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 4348 | mRepeatingLastFrameNumber = hardware::camera2::ICameraDeviceUser::NO_IN_FLIGHT_REPEATING_FRAMES; |
Eino-Ville Talvala | abaa51d | 2013-08-14 11:37:00 -0700 | [diff] [blame] | 4349 | return OK; |
| 4350 | } |
| 4351 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4352 | status_t Camera3Device::RequestThread::flush() { |
| 4353 | ATRACE_CALL(); |
| 4354 | Mutex::Autolock l(mFlushLock); |
| 4355 | |
Emilian Peev | 08dd245 | 2017-04-06 16:55:14 +0100 | [diff] [blame] | 4356 | return mInterface->flush(); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4357 | } |
| 4358 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4359 | void Camera3Device::RequestThread::setPaused(bool paused) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 4360 | ATRACE_CALL(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4361 | Mutex::Autolock l(mPauseLock); |
| 4362 | mDoPause = paused; |
| 4363 | mDoPauseSignal.signal(); |
| 4364 | } |
| 4365 | |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 4366 | status_t Camera3Device::RequestThread::waitUntilRequestProcessed( |
| 4367 | int32_t requestId, nsecs_t timeout) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 4368 | ATRACE_CALL(); |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 4369 | Mutex::Autolock l(mLatestRequestMutex); |
| 4370 | status_t res; |
| 4371 | while (mLatestRequestId != requestId) { |
| 4372 | nsecs_t startTime = systemTime(); |
| 4373 | |
| 4374 | res = mLatestRequestSignal.waitRelative(mLatestRequestMutex, timeout); |
| 4375 | if (res != OK) return res; |
| 4376 | |
| 4377 | timeout -= (systemTime() - startTime); |
| 4378 | } |
| 4379 | |
| 4380 | return OK; |
| 4381 | } |
| 4382 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 4383 | void Camera3Device::RequestThread::requestExit() { |
| 4384 | // Call parent to set up shutdown |
| 4385 | Thread::requestExit(); |
| 4386 | // The exit from any possible waits |
| 4387 | mDoPauseSignal.signal(); |
| 4388 | mRequestSignal.signal(); |
Shuzhen Wang | 686f644 | 2017-06-20 16:16:04 -0700 | [diff] [blame] | 4389 | |
| 4390 | mRequestLatency.log("ProcessCaptureRequest latency histogram"); |
| 4391 | mRequestLatency.reset(); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 4392 | } |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 4393 | |
Chien-Yu Chen | e8c535e | 2016-04-14 12:18:26 -0700 | [diff] [blame] | 4394 | void Camera3Device::RequestThread::checkAndStopRepeatingRequest() { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 4395 | ATRACE_CALL(); |
Yin-Chia Yeh | 473fad9 | 2016-05-23 15:54:41 -0700 | [diff] [blame] | 4396 | bool surfaceAbandoned = false; |
| 4397 | int64_t lastFrameNumber = 0; |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 4398 | sp<NotificationListener> listener; |
Yin-Chia Yeh | 473fad9 | 2016-05-23 15:54:41 -0700 | [diff] [blame] | 4399 | { |
| 4400 | Mutex::Autolock l(mRequestLock); |
| 4401 | // Check all streams needed by repeating requests are still valid. Otherwise, stop |
| 4402 | // repeating requests. |
| 4403 | for (const auto& request : mRepeatingRequests) { |
| 4404 | for (const auto& s : request->mOutputStreams) { |
| 4405 | if (s->isAbandoned()) { |
| 4406 | surfaceAbandoned = true; |
| 4407 | clearRepeatingRequestsLocked(&lastFrameNumber); |
| 4408 | break; |
| 4409 | } |
| 4410 | } |
| 4411 | if (surfaceAbandoned) { |
| 4412 | break; |
Chien-Yu Chen | e8c535e | 2016-04-14 12:18:26 -0700 | [diff] [blame] | 4413 | } |
| 4414 | } |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 4415 | listener = mListener.promote(); |
Chien-Yu Chen | e8c535e | 2016-04-14 12:18:26 -0700 | [diff] [blame] | 4416 | } |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 4417 | |
| 4418 | if (listener != NULL && surfaceAbandoned) { |
| 4419 | listener->notifyRepeatingRequestError(lastFrameNumber); |
Yin-Chia Yeh | 473fad9 | 2016-05-23 15:54:41 -0700 | [diff] [blame] | 4420 | } |
Chien-Yu Chen | e8c535e | 2016-04-14 12:18:26 -0700 | [diff] [blame] | 4421 | } |
| 4422 | |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 4423 | bool Camera3Device::RequestThread::sendRequestsBatch() { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 4424 | ATRACE_CALL(); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 4425 | status_t res; |
| 4426 | size_t batchSize = mNextRequests.size(); |
| 4427 | std::vector<camera3_capture_request_t*> requests(batchSize); |
| 4428 | uint32_t numRequestProcessed = 0; |
| 4429 | for (size_t i = 0; i < batchSize; i++) { |
| 4430 | requests[i] = &mNextRequests.editItemAt(i).halRequest; |
Yin-Chia Yeh | 885691c | 2018-05-01 15:54:24 -0700 | [diff] [blame] | 4431 | ATRACE_ASYNC_BEGIN("frame capture", mNextRequests[i].halRequest.frame_number); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 4432 | } |
| 4433 | |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 4434 | res = mInterface->processBatchCaptureRequests(requests, &numRequestProcessed); |
| 4435 | |
| 4436 | bool triggerRemoveFailed = false; |
| 4437 | NextRequest& triggerFailedRequest = mNextRequests.editItemAt(0); |
| 4438 | for (size_t i = 0; i < numRequestProcessed; i++) { |
| 4439 | NextRequest& nextRequest = mNextRequests.editItemAt(i); |
| 4440 | nextRequest.submitted = true; |
| 4441 | |
| 4442 | |
| 4443 | // Update the latest request sent to HAL |
| 4444 | if (nextRequest.halRequest.settings != NULL) { // Don't update if they were unchanged |
| 4445 | Mutex::Autolock al(mLatestRequestMutex); |
| 4446 | |
| 4447 | camera_metadata_t* cloned = clone_camera_metadata(nextRequest.halRequest.settings); |
| 4448 | mLatestRequest.acquire(cloned); |
| 4449 | |
| 4450 | sp<Camera3Device> parent = mParent.promote(); |
| 4451 | if (parent != NULL) { |
| 4452 | parent->monitorMetadata(TagMonitor::REQUEST, |
| 4453 | nextRequest.halRequest.frame_number, |
| 4454 | 0, mLatestRequest); |
| 4455 | } |
| 4456 | } |
| 4457 | |
| 4458 | if (nextRequest.halRequest.settings != NULL) { |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 4459 | nextRequest.captureRequest->mSettingsList.begin()->metadata.unlock( |
| 4460 | nextRequest.halRequest.settings); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 4461 | } |
| 4462 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 4463 | cleanupPhysicalSettings(nextRequest.captureRequest, &nextRequest.halRequest); |
| 4464 | |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 4465 | if (!triggerRemoveFailed) { |
| 4466 | // Remove any previously queued triggers (after unlock) |
| 4467 | status_t removeTriggerRes = removeTriggers(mPrevRequest); |
| 4468 | if (removeTriggerRes != OK) { |
| 4469 | triggerRemoveFailed = true; |
| 4470 | triggerFailedRequest = nextRequest; |
| 4471 | } |
| 4472 | } |
| 4473 | } |
| 4474 | |
| 4475 | if (triggerRemoveFailed) { |
| 4476 | SET_ERR("RequestThread: Unable to remove triggers " |
| 4477 | "(capture request %d, HAL device: %s (%d)", |
| 4478 | triggerFailedRequest.halRequest.frame_number, strerror(-res), res); |
| 4479 | cleanUpFailedRequests(/*sendRequestError*/ false); |
| 4480 | return false; |
| 4481 | } |
| 4482 | |
| 4483 | if (res != OK) { |
| 4484 | // Should only get a failure here for malformed requests or device-level |
| 4485 | // errors, so consider all errors fatal. Bad metadata failures should |
| 4486 | // come through notify. |
| 4487 | SET_ERR("RequestThread: Unable to submit capture request %d to HAL device: %s (%d)", |
| 4488 | mNextRequests[numRequestProcessed].halRequest.frame_number, |
| 4489 | strerror(-res), res); |
| 4490 | cleanUpFailedRequests(/*sendRequestError*/ false); |
| 4491 | return false; |
| 4492 | } |
| 4493 | return true; |
| 4494 | } |
| 4495 | |
| 4496 | bool Camera3Device::RequestThread::sendRequestsOneByOne() { |
| 4497 | status_t res; |
| 4498 | |
| 4499 | for (auto& nextRequest : mNextRequests) { |
| 4500 | // Submit request and block until ready for next one |
| 4501 | ATRACE_ASYNC_BEGIN("frame capture", nextRequest.halRequest.frame_number); |
| 4502 | res = mInterface->processCaptureRequest(&nextRequest.halRequest); |
| 4503 | |
| 4504 | if (res != OK) { |
| 4505 | // Should only get a failure here for malformed requests or device-level |
| 4506 | // errors, so consider all errors fatal. Bad metadata failures should |
| 4507 | // come through notify. |
| 4508 | SET_ERR("RequestThread: Unable to submit capture request %d to HAL" |
| 4509 | " device: %s (%d)", nextRequest.halRequest.frame_number, strerror(-res), |
| 4510 | res); |
| 4511 | cleanUpFailedRequests(/*sendRequestError*/ false); |
| 4512 | return false; |
| 4513 | } |
| 4514 | |
| 4515 | // Mark that the request has be submitted successfully. |
| 4516 | nextRequest.submitted = true; |
| 4517 | |
| 4518 | // Update the latest request sent to HAL |
| 4519 | if (nextRequest.halRequest.settings != NULL) { // Don't update if they were unchanged |
| 4520 | Mutex::Autolock al(mLatestRequestMutex); |
| 4521 | |
| 4522 | camera_metadata_t* cloned = clone_camera_metadata(nextRequest.halRequest.settings); |
| 4523 | mLatestRequest.acquire(cloned); |
| 4524 | |
| 4525 | sp<Camera3Device> parent = mParent.promote(); |
| 4526 | if (parent != NULL) { |
| 4527 | parent->monitorMetadata(TagMonitor::REQUEST, nextRequest.halRequest.frame_number, |
| 4528 | 0, mLatestRequest); |
| 4529 | } |
| 4530 | } |
| 4531 | |
| 4532 | if (nextRequest.halRequest.settings != NULL) { |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 4533 | nextRequest.captureRequest->mSettingsList.begin()->metadata.unlock( |
| 4534 | nextRequest.halRequest.settings); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 4535 | } |
| 4536 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 4537 | cleanupPhysicalSettings(nextRequest.captureRequest, &nextRequest.halRequest); |
| 4538 | |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 4539 | // Remove any previously queued triggers (after unlock) |
| 4540 | res = removeTriggers(mPrevRequest); |
| 4541 | if (res != OK) { |
| 4542 | SET_ERR("RequestThread: Unable to remove triggers " |
| 4543 | "(capture request %d, HAL device: %s (%d)", |
| 4544 | nextRequest.halRequest.frame_number, strerror(-res), res); |
| 4545 | cleanUpFailedRequests(/*sendRequestError*/ false); |
| 4546 | return false; |
| 4547 | } |
| 4548 | } |
| 4549 | return true; |
| 4550 | } |
| 4551 | |
Eino-Ville Talvala | 10bd57e | 2017-06-23 16:22:44 -0700 | [diff] [blame] | 4552 | nsecs_t Camera3Device::RequestThread::calculateMaxExpectedDuration(const camera_metadata_t *request) { |
| 4553 | nsecs_t maxExpectedDuration = kDefaultExpectedDuration; |
| 4554 | camera_metadata_ro_entry_t e = camera_metadata_ro_entry_t(); |
| 4555 | find_camera_metadata_ro_entry(request, |
| 4556 | ANDROID_CONTROL_AE_MODE, |
| 4557 | &e); |
| 4558 | if (e.count == 0) return maxExpectedDuration; |
| 4559 | |
| 4560 | switch (e.data.u8[0]) { |
| 4561 | case ANDROID_CONTROL_AE_MODE_OFF: |
| 4562 | find_camera_metadata_ro_entry(request, |
| 4563 | ANDROID_SENSOR_EXPOSURE_TIME, |
| 4564 | &e); |
| 4565 | if (e.count > 0) { |
| 4566 | maxExpectedDuration = e.data.i64[0]; |
| 4567 | } |
| 4568 | find_camera_metadata_ro_entry(request, |
| 4569 | ANDROID_SENSOR_FRAME_DURATION, |
| 4570 | &e); |
| 4571 | if (e.count > 0) { |
| 4572 | maxExpectedDuration = std::max(e.data.i64[0], maxExpectedDuration); |
| 4573 | } |
| 4574 | break; |
| 4575 | default: |
| 4576 | find_camera_metadata_ro_entry(request, |
| 4577 | ANDROID_CONTROL_AE_TARGET_FPS_RANGE, |
| 4578 | &e); |
| 4579 | if (e.count > 1) { |
| 4580 | maxExpectedDuration = 1e9 / e.data.u8[0]; |
| 4581 | } |
| 4582 | break; |
| 4583 | } |
| 4584 | |
| 4585 | return maxExpectedDuration; |
| 4586 | } |
| 4587 | |
Emilian Peev | a14b4dd | 2018-05-15 11:00:31 +0100 | [diff] [blame] | 4588 | bool Camera3Device::RequestThread::skipHFRTargetFPSUpdate(int32_t tag, |
| 4589 | const camera_metadata_ro_entry_t& newEntry, const camera_metadata_entry_t& currentEntry) { |
| 4590 | if (mConstrainedMode && (ANDROID_CONTROL_AE_TARGET_FPS_RANGE == tag) && |
| 4591 | (newEntry.count == currentEntry.count) && (currentEntry.count == 2) && |
| 4592 | (currentEntry.data.i32[1] == newEntry.data.i32[1])) { |
| 4593 | return true; |
| 4594 | } |
| 4595 | |
| 4596 | return false; |
| 4597 | } |
| 4598 | |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 4599 | bool Camera3Device::RequestThread::updateSessionParameters(const CameraMetadata& settings) { |
| 4600 | ATRACE_CALL(); |
| 4601 | bool updatesDetected = false; |
| 4602 | |
| 4603 | for (auto tag : mSessionParamKeys) { |
| 4604 | camera_metadata_ro_entry entry = settings.find(tag); |
| 4605 | camera_metadata_entry lastEntry = mLatestSessionParams.find(tag); |
| 4606 | |
| 4607 | if (entry.count > 0) { |
| 4608 | bool isDifferent = false; |
| 4609 | if (lastEntry.count > 0) { |
| 4610 | // Have a last value, compare to see if changed |
| 4611 | if (lastEntry.type == entry.type && |
| 4612 | lastEntry.count == entry.count) { |
| 4613 | // Same type and count, compare values |
| 4614 | size_t bytesPerValue = camera_metadata_type_size[lastEntry.type]; |
| 4615 | size_t entryBytes = bytesPerValue * lastEntry.count; |
| 4616 | int cmp = memcmp(entry.data.u8, lastEntry.data.u8, entryBytes); |
| 4617 | if (cmp != 0) { |
| 4618 | isDifferent = true; |
| 4619 | } |
| 4620 | } else { |
| 4621 | // Count or type has changed |
| 4622 | isDifferent = true; |
| 4623 | } |
| 4624 | } else { |
| 4625 | // No last entry, so always consider to be different |
| 4626 | isDifferent = true; |
| 4627 | } |
| 4628 | |
| 4629 | if (isDifferent) { |
| 4630 | ALOGV("%s: Session parameter tag id %d changed", __FUNCTION__, tag); |
Emilian Peev | a14b4dd | 2018-05-15 11:00:31 +0100 | [diff] [blame] | 4631 | if (!skipHFRTargetFPSUpdate(tag, entry, lastEntry)) { |
| 4632 | updatesDetected = true; |
| 4633 | } |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 4634 | mLatestSessionParams.update(entry); |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 4635 | } |
| 4636 | } else if (lastEntry.count > 0) { |
| 4637 | // Value has been removed |
| 4638 | ALOGV("%s: Session parameter tag id %d removed", __FUNCTION__, tag); |
| 4639 | mLatestSessionParams.erase(tag); |
| 4640 | updatesDetected = true; |
| 4641 | } |
| 4642 | } |
| 4643 | |
| 4644 | return updatesDetected; |
| 4645 | } |
| 4646 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4647 | bool Camera3Device::RequestThread::threadLoop() { |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4648 | ATRACE_CALL(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4649 | status_t res; |
| 4650 | |
| 4651 | // Handle paused state. |
| 4652 | if (waitIfPaused()) { |
| 4653 | return true; |
| 4654 | } |
| 4655 | |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 4656 | // Wait for the next batch of requests. |
| 4657 | waitForNextRequestBatch(); |
| 4658 | if (mNextRequests.size() == 0) { |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4659 | return true; |
| 4660 | } |
| 4661 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4662 | // Get the latest request ID, if any |
| 4663 | int latestRequestId; |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 4664 | camera_metadata_entry_t requestIdEntry = mNextRequests[mNextRequests.size() - 1]. |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 4665 | captureRequest->mSettingsList.begin()->metadata.find(ANDROID_REQUEST_ID); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 4666 | if (requestIdEntry.count > 0) { |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4667 | latestRequestId = requestIdEntry.data.i32[0]; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 4668 | } else { |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4669 | ALOGW("%s: Did not have android.request.id set in the request.", __FUNCTION__); |
| 4670 | latestRequestId = NAME_NOT_FOUND; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 4671 | } |
| 4672 | |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 4673 | // 'mNextRequests' will at this point contain either a set of HFR batched requests |
| 4674 | // or a single request from streaming or burst. In either case the first element |
| 4675 | // should contain the latest camera settings that we need to check for any session |
| 4676 | // parameter updates. |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 4677 | if (updateSessionParameters(mNextRequests[0].captureRequest->mSettingsList.begin()->metadata)) { |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 4678 | res = OK; |
| 4679 | |
| 4680 | //Input stream buffers are already acquired at this point so an input stream |
| 4681 | //will not be able to move to idle state unless we force it. |
| 4682 | if (mNextRequests[0].captureRequest->mInputStream != nullptr) { |
| 4683 | res = mNextRequests[0].captureRequest->mInputStream->forceToIdle(); |
| 4684 | if (res != OK) { |
| 4685 | ALOGE("%s: Failed to force idle input stream: %d", __FUNCTION__, res); |
| 4686 | cleanUpFailedRequests(/*sendRequestError*/ false); |
| 4687 | return false; |
| 4688 | } |
| 4689 | } |
| 4690 | |
| 4691 | if (res == OK) { |
| 4692 | sp<StatusTracker> statusTracker = mStatusTracker.promote(); |
| 4693 | if (statusTracker != 0) { |
Eino-Ville Talvala | 002001b | 2018-01-23 16:53:50 -0800 | [diff] [blame] | 4694 | sp<Camera3Device> parent = mParent.promote(); |
| 4695 | if (parent != nullptr) { |
| 4696 | parent->pauseStateNotify(true); |
| 4697 | } |
| 4698 | |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 4699 | statusTracker->markComponentIdle(mStatusId, Fence::NO_FENCE); |
| 4700 | |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 4701 | if (parent != nullptr) { |
| 4702 | mReconfigured |= parent->reconfigureCamera(mLatestSessionParams); |
| 4703 | } |
| 4704 | |
| 4705 | statusTracker->markComponentActive(mStatusId); |
| 4706 | setPaused(false); |
| 4707 | } |
| 4708 | |
| 4709 | if (mNextRequests[0].captureRequest->mInputStream != nullptr) { |
| 4710 | mNextRequests[0].captureRequest->mInputStream->restoreConfiguredState(); |
| 4711 | if (res != OK) { |
| 4712 | ALOGE("%s: Failed to restore configured input stream: %d", __FUNCTION__, res); |
| 4713 | cleanUpFailedRequests(/*sendRequestError*/ false); |
| 4714 | return false; |
| 4715 | } |
| 4716 | } |
| 4717 | } |
| 4718 | } |
| 4719 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4720 | // Prepare a batch of HAL requests and output buffers. |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 4721 | res = prepareHalRequests(); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4722 | if (res == TIMED_OUT) { |
| 4723 | // Not a fatal error if getting output buffers time out. |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 4724 | cleanUpFailedRequests(/*sendRequestError*/ true); |
Chien-Yu Chen | e8c535e | 2016-04-14 12:18:26 -0700 | [diff] [blame] | 4725 | // Check if any stream is abandoned. |
| 4726 | checkAndStopRepeatingRequest(); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4727 | return true; |
| 4728 | } else if (res != OK) { |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 4729 | cleanUpFailedRequests(/*sendRequestError*/ false); |
Eino-Ville Talvala | 42368d9 | 2013-04-09 14:13:50 -0700 | [diff] [blame] | 4730 | return false; |
| 4731 | } |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 4732 | |
Zhijun He | cc27e11 | 2013-10-03 16:12:43 -0700 | [diff] [blame] | 4733 | // Inform waitUntilRequestProcessed thread of a new request ID |
| 4734 | { |
| 4735 | Mutex::Autolock al(mLatestRequestMutex); |
| 4736 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4737 | mLatestRequestId = latestRequestId; |
Zhijun He | cc27e11 | 2013-10-03 16:12:43 -0700 | [diff] [blame] | 4738 | mLatestRequestSignal.signal(); |
| 4739 | } |
| 4740 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4741 | // Submit a batch of requests to HAL. |
| 4742 | // Use flush lock only when submitting multilple requests in a batch. |
| 4743 | // TODO: The problem with flush lock is flush() will be blocked by process_capture_request() |
| 4744 | // which may take a long time to finish so synchronizing flush() and |
| 4745 | // process_capture_request() defeats the purpose of cancelling requests ASAP with flush(). |
| 4746 | // For now, only synchronize for high speed recording and we should figure something out for |
| 4747 | // removing the synchronization. |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 4748 | bool useFlushLock = mNextRequests.size() > 1; |
Eino-Ville Talvala | 17a61ad | 2013-06-03 16:53:32 -0700 | [diff] [blame] | 4749 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4750 | if (useFlushLock) { |
| 4751 | mFlushLock.lock(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4752 | } |
| 4753 | |
Zhijun He | f0645c1 | 2016-08-02 00:58:11 -0700 | [diff] [blame] | 4754 | ALOGVV("%s: %d: submitting %zu requests in a batch.", __FUNCTION__, __LINE__, |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 4755 | mNextRequests.size()); |
Igor Murashkin | 1e479c0 | 2013-09-06 16:55:14 -0700 | [diff] [blame] | 4756 | |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 4757 | bool submitRequestSuccess = false; |
Shuzhen Wang | 686f644 | 2017-06-20 16:16:04 -0700 | [diff] [blame] | 4758 | nsecs_t tRequestStart = systemTime(SYSTEM_TIME_MONOTONIC); |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 4759 | if (mInterface->supportBatchRequest()) { |
| 4760 | submitRequestSuccess = sendRequestsBatch(); |
| 4761 | } else { |
| 4762 | submitRequestSuccess = sendRequestsOneByOne(); |
Igor Murashkin | 1e479c0 | 2013-09-06 16:55:14 -0700 | [diff] [blame] | 4763 | } |
Shuzhen Wang | 686f644 | 2017-06-20 16:16:04 -0700 | [diff] [blame] | 4764 | nsecs_t tRequestEnd = systemTime(SYSTEM_TIME_MONOTONIC); |
| 4765 | mRequestLatency.add(tRequestStart, tRequestEnd); |
Igor Murashkin | 1e479c0 | 2013-09-06 16:55:14 -0700 | [diff] [blame] | 4766 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4767 | if (useFlushLock) { |
| 4768 | mFlushLock.unlock(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4769 | } |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 4770 | |
Eino-Ville Talvala | e74c228 | 2015-05-27 14:46:23 -0700 | [diff] [blame] | 4771 | // Unset as current request |
| 4772 | { |
| 4773 | Mutex::Autolock l(mRequestLock); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4774 | mNextRequests.clear(); |
Eino-Ville Talvala | e74c228 | 2015-05-27 14:46:23 -0700 | [diff] [blame] | 4775 | } |
| 4776 | |
Yin-Chia Yeh | 94c68e0 | 2017-03-06 14:09:44 -0800 | [diff] [blame] | 4777 | return submitRequestSuccess; |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 4778 | } |
| 4779 | |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 4780 | status_t Camera3Device::RequestThread::prepareHalRequests() { |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4781 | ATRACE_CALL(); |
| 4782 | |
Yin-Chia Yeh | d07b11e | 2018-06-01 12:50:02 -0700 | [diff] [blame] | 4783 | bool batchedRequest = mNextRequests[0].captureRequest->mBatchSize > 1; |
Shuzhen Wang | 4a47266 | 2017-02-26 23:29:04 -0800 | [diff] [blame] | 4784 | for (size_t i = 0; i < mNextRequests.size(); i++) { |
| 4785 | auto& nextRequest = mNextRequests.editItemAt(i); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4786 | sp<CaptureRequest> captureRequest = nextRequest.captureRequest; |
| 4787 | camera3_capture_request_t* halRequest = &nextRequest.halRequest; |
| 4788 | Vector<camera3_stream_buffer_t>* outputBuffers = &nextRequest.outputBuffers; |
| 4789 | |
| 4790 | // Prepare a request to HAL |
| 4791 | halRequest->frame_number = captureRequest->mResultExtras.frameNumber; |
| 4792 | |
| 4793 | // Insert any queued triggers (before metadata is locked) |
| 4794 | status_t res = insertTriggers(captureRequest); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4795 | if (res < 0) { |
| 4796 | SET_ERR("RequestThread: Unable to insert triggers " |
| 4797 | "(capture request %d, HAL device: %s (%d)", |
| 4798 | halRequest->frame_number, strerror(-res), res); |
| 4799 | return INVALID_OPERATION; |
| 4800 | } |
Eino-Ville Talvala | 7b8a1fd | 2018-05-22 15:30:35 -0700 | [diff] [blame] | 4801 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4802 | int triggerCount = res; |
| 4803 | bool triggersMixedIn = (triggerCount > 0 || mPrevTriggers > 0); |
| 4804 | mPrevTriggers = triggerCount; |
| 4805 | |
| 4806 | // If the request is the same as last, or we had triggers last time |
Yin-Chia Yeh | d07b11e | 2018-06-01 12:50:02 -0700 | [diff] [blame] | 4807 | bool newRequest = (mPrevRequest != captureRequest || triggersMixedIn) && |
| 4808 | // Request settings are all the same within one batch, so only treat the first |
| 4809 | // request in a batch as new |
Zhijun He | 54c3682 | 2018-07-18 09:33:39 -0700 | [diff] [blame] | 4810 | !(batchedRequest && i > 0); |
Emilian Peev | 00420d2 | 2018-02-05 21:33:13 +0000 | [diff] [blame] | 4811 | if (newRequest) { |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4812 | /** |
| 4813 | * HAL workaround: |
| 4814 | * Insert a dummy trigger ID if a trigger is set but no trigger ID is |
| 4815 | */ |
| 4816 | res = addDummyTriggerIds(captureRequest); |
| 4817 | if (res != OK) { |
| 4818 | SET_ERR("RequestThread: Unable to insert dummy trigger IDs " |
| 4819 | "(capture request %d, HAL device: %s (%d)", |
| 4820 | halRequest->frame_number, strerror(-res), res); |
| 4821 | return INVALID_OPERATION; |
| 4822 | } |
| 4823 | |
Eino-Ville Talvala | 7b8a1fd | 2018-05-22 15:30:35 -0700 | [diff] [blame] | 4824 | { |
| 4825 | // Correct metadata regions for distortion correction if enabled |
| 4826 | sp<Camera3Device> parent = mParent.promote(); |
| 4827 | if (parent != nullptr) { |
| 4828 | res = parent->mDistortionMapper.correctCaptureRequest( |
| 4829 | &(captureRequest->mSettingsList.begin()->metadata)); |
| 4830 | if (res != OK) { |
| 4831 | SET_ERR("RequestThread: Unable to correct capture requests " |
| 4832 | "for lens distortion for request %d: %s (%d)", |
| 4833 | halRequest->frame_number, strerror(-res), res); |
| 4834 | return INVALID_OPERATION; |
| 4835 | } |
| 4836 | } |
| 4837 | } |
| 4838 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4839 | /** |
| 4840 | * The request should be presorted so accesses in HAL |
| 4841 | * are O(logn). Sidenote, sorting a sorted metadata is nop. |
| 4842 | */ |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 4843 | captureRequest->mSettingsList.begin()->metadata.sort(); |
| 4844 | halRequest->settings = captureRequest->mSettingsList.begin()->metadata.getAndLock(); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4845 | mPrevRequest = captureRequest; |
| 4846 | ALOGVV("%s: Request settings are NEW", __FUNCTION__); |
| 4847 | |
| 4848 | IF_ALOGV() { |
| 4849 | camera_metadata_ro_entry_t e = camera_metadata_ro_entry_t(); |
| 4850 | find_camera_metadata_ro_entry( |
| 4851 | halRequest->settings, |
| 4852 | ANDROID_CONTROL_AF_TRIGGER, |
| 4853 | &e |
| 4854 | ); |
| 4855 | if (e.count > 0) { |
| 4856 | ALOGV("%s: Request (frame num %d) had AF trigger 0x%x", |
| 4857 | __FUNCTION__, |
| 4858 | halRequest->frame_number, |
| 4859 | e.data.u8[0]); |
| 4860 | } |
| 4861 | } |
| 4862 | } else { |
| 4863 | // leave request.settings NULL to indicate 'reuse latest given' |
| 4864 | ALOGVV("%s: Request settings are REUSED", |
| 4865 | __FUNCTION__); |
| 4866 | } |
| 4867 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 4868 | if (captureRequest->mSettingsList.size() > 1) { |
| 4869 | halRequest->num_physcam_settings = captureRequest->mSettingsList.size() - 1; |
| 4870 | halRequest->physcam_id = new const char* [halRequest->num_physcam_settings]; |
Emilian Peev | 00420d2 | 2018-02-05 21:33:13 +0000 | [diff] [blame] | 4871 | if (newRequest) { |
| 4872 | halRequest->physcam_settings = |
| 4873 | new const camera_metadata* [halRequest->num_physcam_settings]; |
| 4874 | } else { |
| 4875 | halRequest->physcam_settings = nullptr; |
| 4876 | } |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 4877 | auto it = ++captureRequest->mSettingsList.begin(); |
| 4878 | size_t i = 0; |
| 4879 | for (; it != captureRequest->mSettingsList.end(); it++, i++) { |
| 4880 | halRequest->physcam_id[i] = it->cameraId.c_str(); |
Emilian Peev | 00420d2 | 2018-02-05 21:33:13 +0000 | [diff] [blame] | 4881 | if (newRequest) { |
| 4882 | it->metadata.sort(); |
| 4883 | halRequest->physcam_settings[i] = it->metadata.getAndLock(); |
| 4884 | } |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 4885 | } |
| 4886 | } |
| 4887 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4888 | uint32_t totalNumBuffers = 0; |
| 4889 | |
| 4890 | // Fill in buffers |
| 4891 | if (captureRequest->mInputStream != NULL) { |
| 4892 | halRequest->input_buffer = &captureRequest->mInputBuffer; |
| 4893 | totalNumBuffers += 1; |
| 4894 | } else { |
| 4895 | halRequest->input_buffer = NULL; |
| 4896 | } |
| 4897 | |
| 4898 | outputBuffers->insertAt(camera3_stream_buffer_t(), 0, |
| 4899 | captureRequest->mOutputStreams.size()); |
| 4900 | halRequest->output_buffers = outputBuffers->array(); |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 4901 | std::set<String8> requestedPhysicalCameras; |
Yin-Chia Yeh | b3a80b1 | 2018-09-04 12:13:05 -0700 | [diff] [blame] | 4902 | |
| 4903 | sp<Camera3Device> parent = mParent.promote(); |
| 4904 | if (parent == NULL) { |
| 4905 | // Should not happen, and nowhere to send errors to, so just log it |
| 4906 | CLOGE("RequestThread: Parent is gone"); |
| 4907 | return INVALID_OPERATION; |
| 4908 | } |
| 4909 | nsecs_t waitDuration = kBaseGetBufferWait + parent->getExpectedInFlightDuration(); |
| 4910 | |
Shuzhen Wang | 4a47266 | 2017-02-26 23:29:04 -0800 | [diff] [blame] | 4911 | for (size_t j = 0; j < captureRequest->mOutputStreams.size(); j++) { |
| 4912 | sp<Camera3OutputStreamInterface> outputStream = captureRequest->mOutputStreams.editItemAt(j); |
Chien-Yu Chen | c66969b | 2016-05-19 16:37:51 -0700 | [diff] [blame] | 4913 | |
| 4914 | // Prepare video buffers for high speed recording on the first video request. |
| 4915 | if (mPrepareVideoStream && outputStream->isVideoStream()) { |
| 4916 | // Only try to prepare video stream on the first video request. |
| 4917 | mPrepareVideoStream = false; |
| 4918 | |
Shuzhen Wang | b3a0fb5 | 2018-09-13 17:24:08 -0700 | [diff] [blame] | 4919 | res = outputStream->startPrepare(Camera3StreamInterface::ALLOCATE_PIPELINE_MAX, |
| 4920 | false /*blockRequest*/); |
Chien-Yu Chen | c66969b | 2016-05-19 16:37:51 -0700 | [diff] [blame] | 4921 | while (res == NOT_ENOUGH_DATA) { |
| 4922 | res = outputStream->prepareNextBuffer(); |
| 4923 | } |
| 4924 | if (res != OK) { |
| 4925 | ALOGW("%s: Preparing video buffers for high speed failed: %s (%d)", |
| 4926 | __FUNCTION__, strerror(-res), res); |
| 4927 | outputStream->cancelPrepare(); |
| 4928 | } |
| 4929 | } |
| 4930 | |
Shuzhen Wang | 4a47266 | 2017-02-26 23:29:04 -0800 | [diff] [blame] | 4931 | res = outputStream->getBuffer(&outputBuffers->editItemAt(j), |
Yin-Chia Yeh | b3a80b1 | 2018-09-04 12:13:05 -0700 | [diff] [blame] | 4932 | waitDuration, |
Shuzhen Wang | 4a47266 | 2017-02-26 23:29:04 -0800 | [diff] [blame] | 4933 | captureRequest->mOutputSurfaces[j]); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4934 | if (res != OK) { |
| 4935 | // Can't get output buffer from gralloc queue - this could be due to |
| 4936 | // abandoned queue or other consumer misbehavior, so not a fatal |
| 4937 | // error |
| 4938 | ALOGE("RequestThread: Can't get output buffer, skipping request:" |
| 4939 | " %s (%d)", strerror(-res), res); |
| 4940 | |
| 4941 | return TIMED_OUT; |
| 4942 | } |
Shuzhen Wang | 0129d52 | 2016-10-30 22:43:41 -0700 | [diff] [blame] | 4943 | |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 4944 | String8 physicalCameraId = outputStream->getPhysicalCameraId(); |
| 4945 | |
| 4946 | if (!physicalCameraId.isEmpty()) { |
| 4947 | // Physical stream isn't supported for input request. |
| 4948 | if (halRequest->input_buffer) { |
| 4949 | CLOGE("Physical stream is not supported for input request"); |
| 4950 | return INVALID_OPERATION; |
| 4951 | } |
| 4952 | requestedPhysicalCameras.insert(physicalCameraId); |
| 4953 | } |
| 4954 | halRequest->num_output_buffers++; |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4955 | } |
| 4956 | totalNumBuffers += halRequest->num_output_buffers; |
| 4957 | |
| 4958 | // Log request in the in-flight queue |
Shuzhen Wang | 4a47266 | 2017-02-26 23:29:04 -0800 | [diff] [blame] | 4959 | // If this request list is for constrained high speed recording (not |
| 4960 | // preview), and the current request is not the last one in the batch, |
| 4961 | // do not send callback to the app. |
| 4962 | bool hasCallback = true; |
Yin-Chia Yeh | d07b11e | 2018-06-01 12:50:02 -0700 | [diff] [blame] | 4963 | if (batchedRequest && i != mNextRequests.size()-1) { |
Shuzhen Wang | 4a47266 | 2017-02-26 23:29:04 -0800 | [diff] [blame] | 4964 | hasCallback = false; |
| 4965 | } |
Emilian Peev | 9dd21f4 | 2018-08-03 13:39:29 +0100 | [diff] [blame] | 4966 | bool isStillCapture = false; |
Shuzhen Wang | 26abaf4 | 2018-08-28 15:41:20 -0700 | [diff] [blame] | 4967 | bool isZslCapture = false; |
Emilian Peev | 9dd21f4 | 2018-08-03 13:39:29 +0100 | [diff] [blame] | 4968 | if (!mNextRequests[0].captureRequest->mSettingsList.begin()->metadata.isEmpty()) { |
| 4969 | camera_metadata_ro_entry_t e = camera_metadata_ro_entry_t(); |
| 4970 | find_camera_metadata_ro_entry(halRequest->settings, ANDROID_CONTROL_CAPTURE_INTENT, &e); |
| 4971 | if ((e.count > 0) && (e.data.u8[0] == ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE)) { |
| 4972 | isStillCapture = true; |
| 4973 | ATRACE_ASYNC_BEGIN("still capture", mNextRequests[i].halRequest.frame_number); |
| 4974 | } |
Shuzhen Wang | 26abaf4 | 2018-08-28 15:41:20 -0700 | [diff] [blame] | 4975 | |
| 4976 | find_camera_metadata_ro_entry(halRequest->settings, ANDROID_CONTROL_ENABLE_ZSL, &e); |
| 4977 | if ((e.count > 0) && (e.data.u8[0] == ANDROID_CONTROL_ENABLE_ZSL_TRUE)) { |
| 4978 | isZslCapture = true; |
| 4979 | } |
Emilian Peev | 9dd21f4 | 2018-08-03 13:39:29 +0100 | [diff] [blame] | 4980 | } |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4981 | res = parent->registerInFlight(halRequest->frame_number, |
| 4982 | totalNumBuffers, captureRequest->mResultExtras, |
| 4983 | /*hasInput*/halRequest->input_buffer != NULL, |
Eino-Ville Talvala | 10bd57e | 2017-06-23 16:22:44 -0700 | [diff] [blame] | 4984 | hasCallback, |
Shuzhen Wang | 5c22c15 | 2017-12-31 17:12:25 -0800 | [diff] [blame] | 4985 | calculateMaxExpectedDuration(halRequest->settings), |
Shuzhen Wang | 26abaf4 | 2018-08-28 15:41:20 -0700 | [diff] [blame] | 4986 | requestedPhysicalCameras, isStillCapture, isZslCapture); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 4987 | ALOGVV("%s: registered in flight requestId = %" PRId32 ", frameNumber = %" PRId64 |
| 4988 | ", burstId = %" PRId32 ".", |
| 4989 | __FUNCTION__, |
| 4990 | captureRequest->mResultExtras.requestId, captureRequest->mResultExtras.frameNumber, |
| 4991 | captureRequest->mResultExtras.burstId); |
| 4992 | if (res != OK) { |
| 4993 | SET_ERR("RequestThread: Unable to register new in-flight request:" |
| 4994 | " %s (%d)", strerror(-res), res); |
| 4995 | return INVALID_OPERATION; |
| 4996 | } |
| 4997 | } |
| 4998 | |
| 4999 | return OK; |
| 5000 | } |
| 5001 | |
Igor Murashkin | 1e479c0 | 2013-09-06 16:55:14 -0700 | [diff] [blame] | 5002 | CameraMetadata Camera3Device::RequestThread::getLatestRequest() const { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 5003 | ATRACE_CALL(); |
Igor Murashkin | 1e479c0 | 2013-09-06 16:55:14 -0700 | [diff] [blame] | 5004 | Mutex::Autolock al(mLatestRequestMutex); |
| 5005 | |
| 5006 | ALOGV("RequestThread::%s", __FUNCTION__); |
| 5007 | |
| 5008 | return mLatestRequest; |
| 5009 | } |
| 5010 | |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5011 | bool Camera3Device::RequestThread::isStreamPending( |
| 5012 | sp<Camera3StreamInterface>& stream) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 5013 | ATRACE_CALL(); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5014 | Mutex::Autolock l(mRequestLock); |
| 5015 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 5016 | for (const auto& nextRequest : mNextRequests) { |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 5017 | if (!nextRequest.submitted) { |
| 5018 | for (const auto& s : nextRequest.captureRequest->mOutputStreams) { |
| 5019 | if (stream == s) return true; |
| 5020 | } |
| 5021 | if (stream == nextRequest.captureRequest->mInputStream) return true; |
Eino-Ville Talvala | e74c228 | 2015-05-27 14:46:23 -0700 | [diff] [blame] | 5022 | } |
Eino-Ville Talvala | e74c228 | 2015-05-27 14:46:23 -0700 | [diff] [blame] | 5023 | } |
| 5024 | |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5025 | for (const auto& request : mRequestQueue) { |
| 5026 | for (const auto& s : request->mOutputStreams) { |
| 5027 | if (stream == s) return true; |
| 5028 | } |
| 5029 | if (stream == request->mInputStream) return true; |
| 5030 | } |
| 5031 | |
| 5032 | for (const auto& request : mRepeatingRequests) { |
| 5033 | for (const auto& s : request->mOutputStreams) { |
| 5034 | if (stream == s) return true; |
| 5035 | } |
| 5036 | if (stream == request->mInputStream) return true; |
| 5037 | } |
| 5038 | |
| 5039 | return false; |
| 5040 | } |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 5041 | |
Emilian Peev | 40ead60 | 2017-09-26 15:46:36 +0100 | [diff] [blame] | 5042 | bool Camera3Device::RequestThread::isOutputSurfacePending(int streamId, size_t surfaceId) { |
| 5043 | ATRACE_CALL(); |
| 5044 | Mutex::Autolock l(mRequestLock); |
| 5045 | |
| 5046 | for (const auto& nextRequest : mNextRequests) { |
| 5047 | for (const auto& s : nextRequest.captureRequest->mOutputSurfaces) { |
| 5048 | if (s.first == streamId) { |
| 5049 | const auto &it = std::find(s.second.begin(), s.second.end(), surfaceId); |
| 5050 | if (it != s.second.end()) { |
| 5051 | return true; |
| 5052 | } |
| 5053 | } |
| 5054 | } |
| 5055 | } |
| 5056 | |
| 5057 | for (const auto& request : mRequestQueue) { |
| 5058 | for (const auto& s : request->mOutputSurfaces) { |
| 5059 | if (s.first == streamId) { |
| 5060 | const auto &it = std::find(s.second.begin(), s.second.end(), surfaceId); |
| 5061 | if (it != s.second.end()) { |
| 5062 | return true; |
| 5063 | } |
| 5064 | } |
| 5065 | } |
| 5066 | } |
| 5067 | |
| 5068 | for (const auto& request : mRepeatingRequests) { |
| 5069 | for (const auto& s : request->mOutputSurfaces) { |
| 5070 | if (s.first == streamId) { |
| 5071 | const auto &it = std::find(s.second.begin(), s.second.end(), surfaceId); |
| 5072 | if (it != s.second.end()) { |
| 5073 | return true; |
| 5074 | } |
| 5075 | } |
| 5076 | } |
| 5077 | } |
| 5078 | |
| 5079 | return false; |
| 5080 | } |
| 5081 | |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 5082 | nsecs_t Camera3Device::getExpectedInFlightDuration() { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 5083 | ATRACE_CALL(); |
Yin-Chia Yeh | 598fc60 | 2017-07-24 11:37:23 -0700 | [diff] [blame] | 5084 | Mutex::Autolock al(mInFlightLock); |
Eino-Ville Talvala | 10bd57e | 2017-06-23 16:22:44 -0700 | [diff] [blame] | 5085 | return mExpectedInflightDuration > kMinInflightDuration ? |
| 5086 | mExpectedInflightDuration : kMinInflightDuration; |
| 5087 | } |
| 5088 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 5089 | void Camera3Device::RequestThread::cleanupPhysicalSettings(sp<CaptureRequest> request, |
| 5090 | camera3_capture_request_t *halRequest) { |
| 5091 | if ((request == nullptr) || (halRequest == nullptr)) { |
| 5092 | ALOGE("%s: Invalid request!", __FUNCTION__); |
| 5093 | return; |
| 5094 | } |
| 5095 | |
| 5096 | if (halRequest->num_physcam_settings > 0) { |
| 5097 | if (halRequest->physcam_id != nullptr) { |
| 5098 | delete [] halRequest->physcam_id; |
| 5099 | halRequest->physcam_id = nullptr; |
| 5100 | } |
| 5101 | if (halRequest->physcam_settings != nullptr) { |
| 5102 | auto it = ++(request->mSettingsList.begin()); |
| 5103 | size_t i = 0; |
| 5104 | for (; it != request->mSettingsList.end(); it++, i++) { |
| 5105 | it->metadata.unlock(halRequest->physcam_settings[i]); |
| 5106 | } |
| 5107 | delete [] halRequest->physcam_settings; |
| 5108 | halRequest->physcam_settings = nullptr; |
| 5109 | } |
| 5110 | } |
| 5111 | } |
| 5112 | |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 5113 | void Camera3Device::RequestThread::cleanUpFailedRequests(bool sendRequestError) { |
| 5114 | if (mNextRequests.empty()) { |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 5115 | return; |
| 5116 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5117 | |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 5118 | for (auto& nextRequest : mNextRequests) { |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 5119 | // Skip the ones that have been submitted successfully. |
| 5120 | if (nextRequest.submitted) { |
| 5121 | continue; |
| 5122 | } |
| 5123 | |
| 5124 | sp<CaptureRequest> captureRequest = nextRequest.captureRequest; |
| 5125 | camera3_capture_request_t* halRequest = &nextRequest.halRequest; |
| 5126 | Vector<camera3_stream_buffer_t>* outputBuffers = &nextRequest.outputBuffers; |
| 5127 | |
| 5128 | if (halRequest->settings != NULL) { |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 5129 | captureRequest->mSettingsList.begin()->metadata.unlock(halRequest->settings); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 5130 | } |
| 5131 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 5132 | cleanupPhysicalSettings(captureRequest, halRequest); |
| 5133 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 5134 | if (captureRequest->mInputStream != NULL) { |
| 5135 | captureRequest->mInputBuffer.status = CAMERA3_BUFFER_STATUS_ERROR; |
| 5136 | captureRequest->mInputStream->returnInputBuffer(captureRequest->mInputBuffer); |
| 5137 | } |
| 5138 | |
| 5139 | for (size_t i = 0; i < halRequest->num_output_buffers; i++) { |
Emilian Peev | c58cf4c | 2017-05-11 17:23:41 +0100 | [diff] [blame] | 5140 | //Buffers that failed processing could still have |
| 5141 | //valid acquire fence. |
| 5142 | int acquireFence = (*outputBuffers)[i].acquire_fence; |
| 5143 | if (0 <= acquireFence) { |
| 5144 | close(acquireFence); |
| 5145 | outputBuffers->editItemAt(i).acquire_fence = -1; |
| 5146 | } |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 5147 | outputBuffers->editItemAt(i).status = CAMERA3_BUFFER_STATUS_ERROR; |
| 5148 | captureRequest->mOutputStreams.editItemAt(i)->returnBuffer((*outputBuffers)[i], 0); |
| 5149 | } |
| 5150 | |
| 5151 | if (sendRequestError) { |
| 5152 | Mutex::Autolock l(mRequestLock); |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 5153 | sp<NotificationListener> listener = mListener.promote(); |
| 5154 | if (listener != NULL) { |
| 5155 | listener->notifyError( |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 5156 | hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST, |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 5157 | captureRequest->mResultExtras); |
| 5158 | } |
| 5159 | } |
Shuzhen Wang | cadb330 | 2016-11-04 14:17:56 -0700 | [diff] [blame] | 5160 | |
| 5161 | // Remove yet-to-be submitted inflight request from inflightMap |
| 5162 | { |
| 5163 | sp<Camera3Device> parent = mParent.promote(); |
| 5164 | if (parent != NULL) { |
| 5165 | Mutex::Autolock l(parent->mInFlightLock); |
| 5166 | ssize_t idx = parent->mInFlightMap.indexOfKey(captureRequest->mResultExtras.frameNumber); |
| 5167 | if (idx >= 0) { |
| 5168 | ALOGV("%s: Remove inflight request from queue: frameNumber %" PRId64, |
| 5169 | __FUNCTION__, captureRequest->mResultExtras.frameNumber); |
| 5170 | parent->removeInFlightMapEntryLocked(idx); |
| 5171 | } |
| 5172 | } |
| 5173 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5174 | } |
Eino-Ville Talvala | e74c228 | 2015-05-27 14:46:23 -0700 | [diff] [blame] | 5175 | |
| 5176 | Mutex::Autolock l(mRequestLock); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 5177 | mNextRequests.clear(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5178 | } |
| 5179 | |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 5180 | void Camera3Device::RequestThread::waitForNextRequestBatch() { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 5181 | ATRACE_CALL(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5182 | // Optimized a bit for the simple steady-state case (single repeating |
| 5183 | // request), to avoid putting that request in the queue temporarily. |
| 5184 | Mutex::Autolock l(mRequestLock); |
| 5185 | |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 5186 | assert(mNextRequests.empty()); |
| 5187 | |
| 5188 | NextRequest nextRequest; |
| 5189 | nextRequest.captureRequest = waitForNextRequestLocked(); |
| 5190 | if (nextRequest.captureRequest == nullptr) { |
| 5191 | return; |
| 5192 | } |
| 5193 | |
| 5194 | nextRequest.halRequest = camera3_capture_request_t(); |
| 5195 | nextRequest.submitted = false; |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 5196 | mNextRequests.add(nextRequest); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 5197 | |
| 5198 | // Wait for additional requests |
| 5199 | const size_t batchSize = nextRequest.captureRequest->mBatchSize; |
| 5200 | |
| 5201 | for (size_t i = 1; i < batchSize; i++) { |
| 5202 | NextRequest additionalRequest; |
| 5203 | additionalRequest.captureRequest = waitForNextRequestLocked(); |
| 5204 | if (additionalRequest.captureRequest == nullptr) { |
| 5205 | break; |
| 5206 | } |
| 5207 | |
| 5208 | additionalRequest.halRequest = camera3_capture_request_t(); |
| 5209 | additionalRequest.submitted = false; |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 5210 | mNextRequests.add(additionalRequest); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 5211 | } |
| 5212 | |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 5213 | if (mNextRequests.size() < batchSize) { |
Eino-Ville Talvala | d309fb9 | 2015-11-25 12:12:45 -0800 | [diff] [blame] | 5214 | ALOGE("RequestThread: only get %zu out of %zu requests. Skipping requests.", |
Chien-Yu Chen | 57ea292 | 2015-09-04 12:58:56 -0700 | [diff] [blame] | 5215 | mNextRequests.size(), batchSize); |
| 5216 | cleanUpFailedRequests(/*sendRequestError*/true); |
Chien-Yu Chen | 85a6455 | 2015-08-28 15:46:12 -0700 | [diff] [blame] | 5217 | } |
| 5218 | |
| 5219 | return; |
| 5220 | } |
| 5221 | |
| 5222 | sp<Camera3Device::CaptureRequest> |
| 5223 | Camera3Device::RequestThread::waitForNextRequestLocked() { |
| 5224 | status_t res; |
| 5225 | sp<CaptureRequest> nextRequest; |
| 5226 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5227 | while (mRequestQueue.empty()) { |
| 5228 | if (!mRepeatingRequests.empty()) { |
| 5229 | // Always atomically enqueue all requests in a repeating request |
| 5230 | // list. Guarantees a complete in-sequence set of captures to |
| 5231 | // application. |
| 5232 | const RequestList &requests = mRepeatingRequests; |
| 5233 | RequestList::const_iterator firstRequest = |
| 5234 | requests.begin(); |
| 5235 | nextRequest = *firstRequest; |
| 5236 | mRequestQueue.insert(mRequestQueue.end(), |
| 5237 | ++firstRequest, |
| 5238 | requests.end()); |
| 5239 | // No need to wait any longer |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 5240 | |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 5241 | mRepeatingLastFrameNumber = mFrameNumber + requests.size() - 1; |
Jianing Wei | cb0652e | 2014-03-12 18:29:36 -0700 | [diff] [blame] | 5242 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5243 | break; |
| 5244 | } |
| 5245 | |
| 5246 | res = mRequestSignal.waitRelative(mRequestLock, kRequestTimeout); |
| 5247 | |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 5248 | if ((mRequestQueue.empty() && mRepeatingRequests.empty()) || |
| 5249 | exitPending()) { |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5250 | Mutex::Autolock pl(mPauseLock); |
| 5251 | if (mPaused == false) { |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 5252 | ALOGV("%s: RequestThread: Going idle", __FUNCTION__); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5253 | mPaused = true; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 5254 | // Let the tracker know |
| 5255 | sp<StatusTracker> statusTracker = mStatusTracker.promote(); |
| 5256 | if (statusTracker != 0) { |
| 5257 | statusTracker->markComponentIdle(mStatusId, Fence::NO_FENCE); |
| 5258 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5259 | } |
| 5260 | // Stop waiting for now and let thread management happen |
| 5261 | return NULL; |
| 5262 | } |
| 5263 | } |
| 5264 | |
| 5265 | if (nextRequest == NULL) { |
| 5266 | // Don't have a repeating request already in hand, so queue |
| 5267 | // must have an entry now. |
| 5268 | RequestList::iterator firstRequest = |
| 5269 | mRequestQueue.begin(); |
| 5270 | nextRequest = *firstRequest; |
| 5271 | mRequestQueue.erase(firstRequest); |
Shuzhen Wang | 9d06601 | 2016-09-30 11:30:20 -0700 | [diff] [blame] | 5272 | if (mRequestQueue.empty() && !nextRequest->mRepeating) { |
| 5273 | sp<NotificationListener> listener = mListener.promote(); |
| 5274 | if (listener != NULL) { |
| 5275 | listener->notifyRequestQueueEmpty(); |
| 5276 | } |
| 5277 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5278 | } |
| 5279 | |
Eino-Ville Talvala | 26fe6c7 | 2013-08-29 12:46:18 -0700 | [diff] [blame] | 5280 | // In case we've been unpaused by setPaused clearing mDoPause, need to |
| 5281 | // update internal pause state (capture/setRepeatingRequest unpause |
| 5282 | // directly). |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5283 | Mutex::Autolock pl(mPauseLock); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 5284 | if (mPaused) { |
| 5285 | ALOGV("%s: RequestThread: Unpaused", __FUNCTION__); |
| 5286 | sp<StatusTracker> statusTracker = mStatusTracker.promote(); |
| 5287 | if (statusTracker != 0) { |
| 5288 | statusTracker->markComponentActive(mStatusId); |
| 5289 | } |
| 5290 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5291 | mPaused = false; |
| 5292 | |
| 5293 | // Check if we've reconfigured since last time, and reset the preview |
| 5294 | // request if so. Can't use 'NULL request == repeat' across configure calls. |
| 5295 | if (mReconfigured) { |
| 5296 | mPrevRequest.clear(); |
| 5297 | mReconfigured = false; |
| 5298 | } |
| 5299 | |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 5300 | if (nextRequest != NULL) { |
| 5301 | nextRequest->mResultExtras.frameNumber = mFrameNumber++; |
Yin-Chia Yeh | c00a25c | 2014-08-21 14:27:44 -0700 | [diff] [blame] | 5302 | nextRequest->mResultExtras.afTriggerId = mCurrentAfTriggerId; |
| 5303 | nextRequest->mResultExtras.precaptureTriggerId = mCurrentPreCaptureTriggerId; |
Chien-Yu Chen | c2adf48 | 2015-05-27 14:27:49 -0700 | [diff] [blame] | 5304 | |
| 5305 | // Since RequestThread::clear() removes buffers from the input stream, |
| 5306 | // get the right buffer here before unlocking mRequestLock |
| 5307 | if (nextRequest->mInputStream != NULL) { |
| 5308 | res = nextRequest->mInputStream->getInputBuffer(&nextRequest->mInputBuffer); |
| 5309 | if (res != OK) { |
| 5310 | // Can't get input buffer from gralloc queue - this could be due to |
| 5311 | // disconnected queue or other producer misbehavior, so not a fatal |
| 5312 | // error |
| 5313 | ALOGE("%s: Can't get input buffer, skipping request:" |
| 5314 | " %s (%d)", __FUNCTION__, strerror(-res), res); |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 5315 | |
| 5316 | sp<NotificationListener> listener = mListener.promote(); |
| 5317 | if (listener != NULL) { |
| 5318 | listener->notifyError( |
Eino-Ville Talvala | d56db1d | 2015-12-17 16:50:35 -0800 | [diff] [blame] | 5319 | hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST, |
Chien-Yu Chen | c2adf48 | 2015-05-27 14:27:49 -0700 | [diff] [blame] | 5320 | nextRequest->mResultExtras); |
| 5321 | } |
| 5322 | return NULL; |
| 5323 | } |
| 5324 | } |
Jianing Wei | 2d6bb3f | 2014-04-11 10:00:31 -0700 | [diff] [blame] | 5325 | } |
Chien-Yu Chen | d196d61 | 2015-06-22 19:49:01 -0700 | [diff] [blame] | 5326 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5327 | return nextRequest; |
| 5328 | } |
| 5329 | |
| 5330 | bool Camera3Device::RequestThread::waitIfPaused() { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 5331 | ATRACE_CALL(); |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5332 | status_t res; |
| 5333 | Mutex::Autolock l(mPauseLock); |
| 5334 | while (mDoPause) { |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5335 | if (mPaused == false) { |
| 5336 | mPaused = true; |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 5337 | ALOGV("%s: RequestThread: Paused", __FUNCTION__); |
| 5338 | // Let the tracker know |
| 5339 | sp<StatusTracker> statusTracker = mStatusTracker.promote(); |
| 5340 | if (statusTracker != 0) { |
| 5341 | statusTracker->markComponentIdle(mStatusId, Fence::NO_FENCE); |
| 5342 | } |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5343 | } |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 5344 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5345 | res = mDoPauseSignal.waitRelative(mPauseLock, kRequestTimeout); |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 5346 | if (res == TIMED_OUT || exitPending()) { |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5347 | return true; |
| 5348 | } |
| 5349 | } |
| 5350 | // We don't set mPaused to false here, because waitForNextRequest needs |
| 5351 | // to further manage the paused state in case of starvation. |
| 5352 | return false; |
| 5353 | } |
| 5354 | |
Eino-Ville Talvala | 26fe6c7 | 2013-08-29 12:46:18 -0700 | [diff] [blame] | 5355 | void Camera3Device::RequestThread::unpauseForNewRequests() { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 5356 | ATRACE_CALL(); |
Eino-Ville Talvala | 26fe6c7 | 2013-08-29 12:46:18 -0700 | [diff] [blame] | 5357 | // With work to do, mark thread as unpaused. |
| 5358 | // If paused by request (setPaused), don't resume, to avoid |
| 5359 | // extra signaling/waiting overhead to waitUntilPaused |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 5360 | mRequestSignal.signal(); |
Eino-Ville Talvala | 26fe6c7 | 2013-08-29 12:46:18 -0700 | [diff] [blame] | 5361 | Mutex::Autolock p(mPauseLock); |
| 5362 | if (!mDoPause) { |
Eino-Ville Talvala | f1e98d8 | 2013-09-06 09:32:43 -0700 | [diff] [blame] | 5363 | ALOGV("%s: RequestThread: Going active", __FUNCTION__); |
| 5364 | if (mPaused) { |
| 5365 | sp<StatusTracker> statusTracker = mStatusTracker.promote(); |
| 5366 | if (statusTracker != 0) { |
| 5367 | statusTracker->markComponentActive(mStatusId); |
| 5368 | } |
| 5369 | } |
Eino-Ville Talvala | 26fe6c7 | 2013-08-29 12:46:18 -0700 | [diff] [blame] | 5370 | mPaused = false; |
| 5371 | } |
| 5372 | } |
| 5373 | |
Eino-Ville Talvala | b2058d1 | 2013-04-09 13:49:56 -0700 | [diff] [blame] | 5374 | void Camera3Device::RequestThread::setErrorState(const char *fmt, ...) { |
| 5375 | sp<Camera3Device> parent = mParent.promote(); |
| 5376 | if (parent != NULL) { |
| 5377 | va_list args; |
| 5378 | va_start(args, fmt); |
| 5379 | |
| 5380 | parent->setErrorStateV(fmt, args); |
| 5381 | |
| 5382 | va_end(args); |
| 5383 | } |
| 5384 | } |
| 5385 | |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 5386 | status_t Camera3Device::RequestThread::insertTriggers( |
| 5387 | const sp<CaptureRequest> &request) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 5388 | ATRACE_CALL(); |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 5389 | Mutex::Autolock al(mTriggerMutex); |
| 5390 | |
Yin-Chia Yeh | 741ace8 | 2014-06-23 14:07:56 -0700 | [diff] [blame] | 5391 | sp<Camera3Device> parent = mParent.promote(); |
| 5392 | if (parent == NULL) { |
| 5393 | CLOGE("RequestThread: Parent is gone"); |
| 5394 | return DEAD_OBJECT; |
| 5395 | } |
| 5396 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 5397 | CameraMetadata &metadata = request->mSettingsList.begin()->metadata; |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 5398 | size_t count = mTriggerMap.size(); |
| 5399 | |
| 5400 | for (size_t i = 0; i < count; ++i) { |
| 5401 | RequestTrigger trigger = mTriggerMap.valueAt(i); |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 5402 | uint32_t tag = trigger.metadataTag; |
Yin-Chia Yeh | 741ace8 | 2014-06-23 14:07:56 -0700 | [diff] [blame] | 5403 | |
| 5404 | if (tag == ANDROID_CONTROL_AF_TRIGGER_ID || tag == ANDROID_CONTROL_AE_PRECAPTURE_ID) { |
| 5405 | bool isAeTrigger = (trigger.metadataTag == ANDROID_CONTROL_AE_PRECAPTURE_ID); |
| 5406 | uint32_t triggerId = static_cast<uint32_t>(trigger.entryValue); |
Yin-Chia Yeh | c00a25c | 2014-08-21 14:27:44 -0700 | [diff] [blame] | 5407 | if (isAeTrigger) { |
| 5408 | request->mResultExtras.precaptureTriggerId = triggerId; |
| 5409 | mCurrentPreCaptureTriggerId = triggerId; |
| 5410 | } else { |
| 5411 | request->mResultExtras.afTriggerId = triggerId; |
| 5412 | mCurrentAfTriggerId = triggerId; |
| 5413 | } |
Emilian Peev | 7e25e5e | 2017-04-07 15:48:49 +0100 | [diff] [blame] | 5414 | continue; |
Yin-Chia Yeh | 741ace8 | 2014-06-23 14:07:56 -0700 | [diff] [blame] | 5415 | } |
| 5416 | |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 5417 | camera_metadata_entry entry = metadata.find(tag); |
| 5418 | |
| 5419 | if (entry.count > 0) { |
| 5420 | /** |
| 5421 | * Already has an entry for this trigger in the request. |
| 5422 | * Rewrite it with our requested trigger value. |
| 5423 | */ |
| 5424 | RequestTrigger oldTrigger = trigger; |
| 5425 | |
| 5426 | oldTrigger.entryValue = entry.data.u8[0]; |
| 5427 | |
| 5428 | mTriggerReplacedMap.add(tag, oldTrigger); |
| 5429 | } else { |
| 5430 | /** |
| 5431 | * More typical, no trigger entry, so we just add it |
| 5432 | */ |
| 5433 | mTriggerRemovedMap.add(tag, trigger); |
| 5434 | } |
| 5435 | |
| 5436 | status_t res; |
| 5437 | |
| 5438 | switch (trigger.getTagType()) { |
| 5439 | case TYPE_BYTE: { |
| 5440 | uint8_t entryValue = static_cast<uint8_t>(trigger.entryValue); |
| 5441 | res = metadata.update(tag, |
| 5442 | &entryValue, |
| 5443 | /*count*/1); |
| 5444 | break; |
| 5445 | } |
| 5446 | case TYPE_INT32: |
| 5447 | res = metadata.update(tag, |
| 5448 | &trigger.entryValue, |
| 5449 | /*count*/1); |
| 5450 | break; |
| 5451 | default: |
| 5452 | ALOGE("%s: Type not supported: 0x%x", |
| 5453 | __FUNCTION__, |
| 5454 | trigger.getTagType()); |
| 5455 | return INVALID_OPERATION; |
| 5456 | } |
| 5457 | |
| 5458 | if (res != OK) { |
| 5459 | ALOGE("%s: Failed to update request metadata with trigger tag %s" |
| 5460 | ", value %d", __FUNCTION__, trigger.getTagName(), |
| 5461 | trigger.entryValue); |
| 5462 | return res; |
| 5463 | } |
| 5464 | |
| 5465 | ALOGV("%s: Mixed in trigger %s, value %d", __FUNCTION__, |
| 5466 | trigger.getTagName(), |
| 5467 | trigger.entryValue); |
| 5468 | } |
| 5469 | |
| 5470 | mTriggerMap.clear(); |
| 5471 | |
| 5472 | return count; |
| 5473 | } |
| 5474 | |
| 5475 | status_t Camera3Device::RequestThread::removeTriggers( |
| 5476 | const sp<CaptureRequest> &request) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 5477 | ATRACE_CALL(); |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 5478 | Mutex::Autolock al(mTriggerMutex); |
| 5479 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 5480 | CameraMetadata &metadata = request->mSettingsList.begin()->metadata; |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 5481 | |
| 5482 | /** |
| 5483 | * Replace all old entries with their old values. |
| 5484 | */ |
| 5485 | for (size_t i = 0; i < mTriggerReplacedMap.size(); ++i) { |
| 5486 | RequestTrigger trigger = mTriggerReplacedMap.valueAt(i); |
| 5487 | |
| 5488 | status_t res; |
| 5489 | |
| 5490 | uint32_t tag = trigger.metadataTag; |
| 5491 | switch (trigger.getTagType()) { |
| 5492 | case TYPE_BYTE: { |
| 5493 | uint8_t entryValue = static_cast<uint8_t>(trigger.entryValue); |
| 5494 | res = metadata.update(tag, |
| 5495 | &entryValue, |
| 5496 | /*count*/1); |
| 5497 | break; |
| 5498 | } |
| 5499 | case TYPE_INT32: |
| 5500 | res = metadata.update(tag, |
| 5501 | &trigger.entryValue, |
| 5502 | /*count*/1); |
| 5503 | break; |
| 5504 | default: |
| 5505 | ALOGE("%s: Type not supported: 0x%x", |
| 5506 | __FUNCTION__, |
| 5507 | trigger.getTagType()); |
| 5508 | return INVALID_OPERATION; |
| 5509 | } |
| 5510 | |
| 5511 | if (res != OK) { |
| 5512 | ALOGE("%s: Failed to restore request metadata with trigger tag %s" |
| 5513 | ", trigger value %d", __FUNCTION__, |
| 5514 | trigger.getTagName(), trigger.entryValue); |
| 5515 | return res; |
| 5516 | } |
| 5517 | } |
| 5518 | mTriggerReplacedMap.clear(); |
| 5519 | |
| 5520 | /** |
| 5521 | * Remove all new entries. |
| 5522 | */ |
| 5523 | for (size_t i = 0; i < mTriggerRemovedMap.size(); ++i) { |
| 5524 | RequestTrigger trigger = mTriggerRemovedMap.valueAt(i); |
| 5525 | status_t res = metadata.erase(trigger.metadataTag); |
| 5526 | |
| 5527 | if (res != OK) { |
| 5528 | ALOGE("%s: Failed to erase metadata with trigger tag %s" |
| 5529 | ", trigger value %d", __FUNCTION__, |
| 5530 | trigger.getTagName(), trigger.entryValue); |
| 5531 | return res; |
| 5532 | } |
| 5533 | } |
| 5534 | mTriggerRemovedMap.clear(); |
| 5535 | |
| 5536 | return OK; |
| 5537 | } |
| 5538 | |
Eino-Ville Talvala | 2f876f9 | 2013-09-13 11:39:24 -0700 | [diff] [blame] | 5539 | status_t Camera3Device::RequestThread::addDummyTriggerIds( |
| 5540 | const sp<CaptureRequest> &request) { |
Eino-Ville Talvala | d309fb9 | 2015-11-25 12:12:45 -0800 | [diff] [blame] | 5541 | // Trigger ID 0 had special meaning in the HAL2 spec, so avoid it here |
Eino-Ville Talvala | 2f876f9 | 2013-09-13 11:39:24 -0700 | [diff] [blame] | 5542 | static const int32_t dummyTriggerId = 1; |
| 5543 | status_t res; |
| 5544 | |
Emilian Peev | aebbe41 | 2018-01-15 13:53:24 +0000 | [diff] [blame] | 5545 | CameraMetadata &metadata = request->mSettingsList.begin()->metadata; |
Eino-Ville Talvala | 2f876f9 | 2013-09-13 11:39:24 -0700 | [diff] [blame] | 5546 | |
| 5547 | // If AF trigger is active, insert a dummy AF trigger ID if none already |
| 5548 | // exists |
| 5549 | camera_metadata_entry afTrigger = metadata.find(ANDROID_CONTROL_AF_TRIGGER); |
| 5550 | camera_metadata_entry afId = metadata.find(ANDROID_CONTROL_AF_TRIGGER_ID); |
| 5551 | if (afTrigger.count > 0 && |
| 5552 | afTrigger.data.u8[0] != ANDROID_CONTROL_AF_TRIGGER_IDLE && |
| 5553 | afId.count == 0) { |
| 5554 | res = metadata.update(ANDROID_CONTROL_AF_TRIGGER_ID, &dummyTriggerId, 1); |
| 5555 | if (res != OK) return res; |
| 5556 | } |
| 5557 | |
| 5558 | // If AE precapture trigger is active, insert a dummy precapture trigger ID |
| 5559 | // if none already exists |
| 5560 | camera_metadata_entry pcTrigger = |
| 5561 | metadata.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER); |
| 5562 | camera_metadata_entry pcId = metadata.find(ANDROID_CONTROL_AE_PRECAPTURE_ID); |
| 5563 | if (pcTrigger.count > 0 && |
| 5564 | pcTrigger.data.u8[0] != ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE && |
| 5565 | pcId.count == 0) { |
| 5566 | res = metadata.update(ANDROID_CONTROL_AE_PRECAPTURE_ID, |
| 5567 | &dummyTriggerId, 1); |
| 5568 | if (res != OK) return res; |
| 5569 | } |
| 5570 | |
| 5571 | return OK; |
| 5572 | } |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 5573 | |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5574 | /** |
| 5575 | * PreparerThread inner class methods |
| 5576 | */ |
| 5577 | |
| 5578 | Camera3Device::PreparerThread::PreparerThread() : |
Eino-Ville Talvala | 77c1a35 | 2016-06-13 12:32:43 -0700 | [diff] [blame] | 5579 | Thread(/*canCallJava*/false), mListener(nullptr), |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 5580 | mActive(false), mCancelNow(false), mCurrentMaxCount(0), mCurrentPrepareComplete(false) { |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5581 | } |
| 5582 | |
| 5583 | Camera3Device::PreparerThread::~PreparerThread() { |
| 5584 | Thread::requestExitAndWait(); |
| 5585 | if (mCurrentStream != nullptr) { |
| 5586 | mCurrentStream->cancelPrepare(); |
| 5587 | ATRACE_ASYNC_END("stream prepare", mCurrentStream->getId()); |
| 5588 | mCurrentStream.clear(); |
| 5589 | } |
| 5590 | clear(); |
| 5591 | } |
| 5592 | |
Ruben Brunk | c78ac26 | 2015-08-13 17:58:46 -0700 | [diff] [blame] | 5593 | status_t Camera3Device::PreparerThread::prepare(int maxCount, sp<Camera3StreamInterface>& stream) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 5594 | ATRACE_CALL(); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5595 | status_t res; |
| 5596 | |
| 5597 | Mutex::Autolock l(mLock); |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 5598 | sp<NotificationListener> listener = mListener.promote(); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5599 | |
Shuzhen Wang | b3a0fb5 | 2018-09-13 17:24:08 -0700 | [diff] [blame] | 5600 | res = stream->startPrepare(maxCount, true /*blockRequest*/); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5601 | if (res == OK) { |
| 5602 | // No preparation needed, fire listener right off |
| 5603 | ALOGV("%s: Stream %d already prepared", __FUNCTION__, stream->getId()); |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 5604 | if (listener != NULL) { |
| 5605 | listener->notifyPrepared(stream->getId()); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5606 | } |
| 5607 | return OK; |
| 5608 | } else if (res != NOT_ENOUGH_DATA) { |
| 5609 | return res; |
| 5610 | } |
| 5611 | |
| 5612 | // Need to prepare, start up thread if necessary |
| 5613 | if (!mActive) { |
| 5614 | // mRunning will change to false before the thread fully shuts down, so wait to be sure it |
| 5615 | // isn't running |
| 5616 | Thread::requestExitAndWait(); |
| 5617 | res = Thread::run("C3PrepThread", PRIORITY_BACKGROUND); |
| 5618 | if (res != OK) { |
| 5619 | ALOGE("%s: Unable to start preparer stream: %d (%s)", __FUNCTION__, res, strerror(-res)); |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 5620 | if (listener != NULL) { |
| 5621 | listener->notifyPrepared(stream->getId()); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5622 | } |
| 5623 | return res; |
| 5624 | } |
| 5625 | mCancelNow = false; |
| 5626 | mActive = true; |
| 5627 | ALOGV("%s: Preparer stream started", __FUNCTION__); |
| 5628 | } |
| 5629 | |
| 5630 | // queue up the work |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 5631 | mPendingStreams.emplace(maxCount, stream); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5632 | ALOGV("%s: Stream %d queued for preparing", __FUNCTION__, stream->getId()); |
| 5633 | |
| 5634 | return OK; |
| 5635 | } |
| 5636 | |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 5637 | void Camera3Device::PreparerThread::pause() { |
| 5638 | ATRACE_CALL(); |
| 5639 | |
| 5640 | Mutex::Autolock l(mLock); |
| 5641 | |
| 5642 | std::unordered_map<int, sp<camera3::Camera3StreamInterface> > pendingStreams; |
| 5643 | pendingStreams.insert(mPendingStreams.begin(), mPendingStreams.end()); |
| 5644 | sp<camera3::Camera3StreamInterface> currentStream = mCurrentStream; |
| 5645 | int currentMaxCount = mCurrentMaxCount; |
| 5646 | mPendingStreams.clear(); |
| 5647 | mCancelNow = true; |
| 5648 | while (mActive) { |
| 5649 | auto res = mThreadActiveSignal.waitRelative(mLock, kActiveTimeout); |
| 5650 | if (res == TIMED_OUT) { |
| 5651 | ALOGE("%s: Timed out waiting on prepare thread!", __FUNCTION__); |
| 5652 | return; |
| 5653 | } else if (res != OK) { |
| 5654 | ALOGE("%s: Encountered an error: %d waiting on prepare thread!", __FUNCTION__, res); |
| 5655 | return; |
| 5656 | } |
| 5657 | } |
| 5658 | |
| 5659 | //Check whether the prepare thread was able to complete the current |
| 5660 | //stream. In case work is still pending emplace it along with the rest |
| 5661 | //of the streams in the pending list. |
| 5662 | if (currentStream != nullptr) { |
| 5663 | if (!mCurrentPrepareComplete) { |
| 5664 | pendingStreams.emplace(currentMaxCount, currentStream); |
| 5665 | } |
| 5666 | } |
| 5667 | |
| 5668 | mPendingStreams.insert(pendingStreams.begin(), pendingStreams.end()); |
| 5669 | for (const auto& it : mPendingStreams) { |
| 5670 | it.second->cancelPrepare(); |
| 5671 | } |
| 5672 | } |
| 5673 | |
| 5674 | status_t Camera3Device::PreparerThread::resume() { |
| 5675 | ATRACE_CALL(); |
| 5676 | status_t res; |
| 5677 | |
| 5678 | Mutex::Autolock l(mLock); |
| 5679 | sp<NotificationListener> listener = mListener.promote(); |
| 5680 | |
| 5681 | if (mActive) { |
| 5682 | ALOGE("%s: Trying to resume an already active prepare thread!", __FUNCTION__); |
| 5683 | return NO_INIT; |
| 5684 | } |
| 5685 | |
| 5686 | auto it = mPendingStreams.begin(); |
| 5687 | for (; it != mPendingStreams.end();) { |
Shuzhen Wang | b3a0fb5 | 2018-09-13 17:24:08 -0700 | [diff] [blame] | 5688 | res = it->second->startPrepare(it->first, true /*blockRequest*/); |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 5689 | if (res == OK) { |
| 5690 | if (listener != NULL) { |
| 5691 | listener->notifyPrepared(it->second->getId()); |
| 5692 | } |
| 5693 | it = mPendingStreams.erase(it); |
| 5694 | } else if (res != NOT_ENOUGH_DATA) { |
| 5695 | ALOGE("%s: Unable to start preparer stream: %d (%s)", __FUNCTION__, |
| 5696 | res, strerror(-res)); |
| 5697 | it = mPendingStreams.erase(it); |
| 5698 | } else { |
| 5699 | it++; |
| 5700 | } |
| 5701 | } |
| 5702 | |
| 5703 | if (mPendingStreams.empty()) { |
| 5704 | return OK; |
| 5705 | } |
| 5706 | |
| 5707 | res = Thread::run("C3PrepThread", PRIORITY_BACKGROUND); |
| 5708 | if (res != OK) { |
| 5709 | ALOGE("%s: Unable to start preparer stream: %d (%s)", |
| 5710 | __FUNCTION__, res, strerror(-res)); |
| 5711 | return res; |
| 5712 | } |
| 5713 | mCancelNow = false; |
| 5714 | mActive = true; |
| 5715 | ALOGV("%s: Preparer stream started", __FUNCTION__); |
| 5716 | |
| 5717 | return OK; |
| 5718 | } |
| 5719 | |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5720 | status_t Camera3Device::PreparerThread::clear() { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 5721 | ATRACE_CALL(); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5722 | Mutex::Autolock l(mLock); |
| 5723 | |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 5724 | for (const auto& it : mPendingStreams) { |
| 5725 | it.second->cancelPrepare(); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5726 | } |
| 5727 | mPendingStreams.clear(); |
| 5728 | mCancelNow = true; |
| 5729 | |
| 5730 | return OK; |
| 5731 | } |
| 5732 | |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 5733 | void Camera3Device::PreparerThread::setNotificationListener(wp<NotificationListener> listener) { |
Eino-Ville Talvala | 6aeb888 | 2017-08-07 17:40:49 -0700 | [diff] [blame] | 5734 | ATRACE_CALL(); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5735 | Mutex::Autolock l(mLock); |
| 5736 | mListener = listener; |
| 5737 | } |
| 5738 | |
| 5739 | bool Camera3Device::PreparerThread::threadLoop() { |
| 5740 | status_t res; |
| 5741 | { |
| 5742 | Mutex::Autolock l(mLock); |
| 5743 | if (mCurrentStream == nullptr) { |
| 5744 | // End thread if done with work |
| 5745 | if (mPendingStreams.empty()) { |
| 5746 | ALOGV("%s: Preparer stream out of work", __FUNCTION__); |
| 5747 | // threadLoop _must not_ re-acquire mLock after it sets mActive to false; would |
| 5748 | // cause deadlock with prepare()'s requestExitAndWait triggered by !mActive. |
| 5749 | mActive = false; |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 5750 | mThreadActiveSignal.signal(); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5751 | return false; |
| 5752 | } |
| 5753 | |
| 5754 | // Get next stream to prepare |
| 5755 | auto it = mPendingStreams.begin(); |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 5756 | mCurrentStream = it->second; |
| 5757 | mCurrentMaxCount = it->first; |
| 5758 | mCurrentPrepareComplete = false; |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5759 | mPendingStreams.erase(it); |
| 5760 | ATRACE_ASYNC_BEGIN("stream prepare", mCurrentStream->getId()); |
| 5761 | ALOGV("%s: Preparing stream %d", __FUNCTION__, mCurrentStream->getId()); |
| 5762 | } else if (mCancelNow) { |
| 5763 | mCurrentStream->cancelPrepare(); |
| 5764 | ATRACE_ASYNC_END("stream prepare", mCurrentStream->getId()); |
| 5765 | ALOGV("%s: Cancelling stream %d prepare", __FUNCTION__, mCurrentStream->getId()); |
| 5766 | mCurrentStream.clear(); |
| 5767 | mCancelNow = false; |
| 5768 | return true; |
| 5769 | } |
| 5770 | } |
| 5771 | |
| 5772 | res = mCurrentStream->prepareNextBuffer(); |
| 5773 | if (res == NOT_ENOUGH_DATA) return true; |
| 5774 | if (res != OK) { |
| 5775 | // Something bad happened; try to recover by cancelling prepare and |
| 5776 | // signalling listener anyway |
| 5777 | ALOGE("%s: Stream %d returned error %d (%s) during prepare", __FUNCTION__, |
| 5778 | mCurrentStream->getId(), res, strerror(-res)); |
| 5779 | mCurrentStream->cancelPrepare(); |
| 5780 | } |
| 5781 | |
| 5782 | // This stream has finished, notify listener |
| 5783 | Mutex::Autolock l(mLock); |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 5784 | sp<NotificationListener> listener = mListener.promote(); |
| 5785 | if (listener != NULL) { |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5786 | ALOGV("%s: Stream %d prepare done, signaling listener", __FUNCTION__, |
| 5787 | mCurrentStream->getId()); |
Yin-Chia Yeh | e1c8063 | 2016-08-08 14:48:05 -0700 | [diff] [blame] | 5788 | listener->notifyPrepared(mCurrentStream->getId()); |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5789 | } |
| 5790 | |
| 5791 | ATRACE_ASYNC_END("stream prepare", mCurrentStream->getId()); |
| 5792 | mCurrentStream.clear(); |
Emilian Peev | ac3ce6c | 2017-12-12 15:27:02 +0000 | [diff] [blame] | 5793 | mCurrentPrepareComplete = true; |
Eino-Ville Talvala | 4d44cad | 2015-04-11 13:15:45 -0700 | [diff] [blame] | 5794 | |
| 5795 | return true; |
| 5796 | } |
Igor Murashkin | 4d2f2e8 | 2013-04-01 17:29:07 -0700 | [diff] [blame] | 5797 | |
Eino-Ville Talvala | f76e027 | 2013-02-27 18:02:26 -0800 | [diff] [blame] | 5798 | /** |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 5799 | * Static callback forwarding methods from HAL to instance |
| 5800 | */ |
| 5801 | |
| 5802 | void Camera3Device::sProcessCaptureResult(const camera3_callback_ops *cb, |
| 5803 | const camera3_capture_result *result) { |
| 5804 | Camera3Device *d = |
| 5805 | const_cast<Camera3Device*>(static_cast<const Camera3Device*>(cb)); |
Chien-Yu Chen | d196d61 | 2015-06-22 19:49:01 -0700 | [diff] [blame] | 5806 | |
Eino-Ville Talvala | 7fa43f3 | 2013-02-06 17:20:07 -0800 | [diff] [blame] | 5807 | d->processCaptureResult(result); |
| 5808 | } |
| 5809 | |
| 5810 | void Camera3Device::sNotify(const camera3_callback_ops *cb, |
| 5811 | const camera3_notify_msg *msg) { |
| 5812 | Camera3Device *d = |
| 5813 | const_cast<Camera3Device*>(static_cast<const Camera3Device*>(cb)); |
| 5814 | d->notify(msg); |
| 5815 | } |
| 5816 | |
| 5817 | }; // namespace android |