| /* |
| * Copyright (C) 2021 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "Camera3DeviceInjectionMethods" |
| #define ATRACE_TAG ATRACE_TAG_CAMERA |
| //#define LOG_NDEBUG 0 |
| |
| #include <utils/Log.h> |
| #include <utils/Trace.h> |
| |
| #include "common/CameraProviderManager.h" |
| #include "device3/Camera3Device.h" |
| |
| namespace android { |
| |
| Camera3Device::Camera3DeviceInjectionMethods::Camera3DeviceInjectionMethods( |
| wp<Camera3Device> parent) |
| : mParent(parent) { |
| ALOGV("%s: Created injection camera methods", __FUNCTION__); |
| } |
| |
| Camera3Device::Camera3DeviceInjectionMethods::~Camera3DeviceInjectionMethods() { |
| ALOGV("%s: Removed injection camera methods", __FUNCTION__); |
| injectionDisconnectImpl(); |
| } |
| |
| status_t Camera3Device::Camera3DeviceInjectionMethods::injectCamera( |
| camera3::camera_stream_configuration& injectionConfig, |
| const std::vector<uint32_t>& injectionBufferSizes) { |
| status_t res = NO_ERROR; |
| |
| if (mInjectedCamHalInterface == nullptr) { |
| ALOGE("%s: mInjectedCamHalInterface does not exist!", __FUNCTION__); |
| return DEAD_OBJECT; |
| } |
| |
| sp<Camera3Device> parent = mParent.promote(); |
| if (parent == nullptr) { |
| ALOGE("%s: parent does not exist!", __FUNCTION__); |
| return INVALID_OPERATION; |
| } |
| |
| nsecs_t maxExpectedDuration = parent->getExpectedInFlightDuration(); |
| bool wasActive = false; |
| if (parent->mStatus == STATUS_ACTIVE) { |
| ALOGV("%s: Let the device be IDLE and the request thread is paused", |
| __FUNCTION__); |
| res = parent->internalPauseAndWaitLocked(maxExpectedDuration, |
| /*requestThreadInvocation*/false); |
| if (res != OK) { |
| ALOGE("%s: Can't pause captures to inject camera!", __FUNCTION__); |
| return res; |
| } |
| wasActive = true; |
| } |
| |
| ALOGV("%s: Injection camera: replaceHalInterface", __FUNCTION__); |
| res = replaceHalInterface(mInjectedCamHalInterface, true); |
| if (res != OK) { |
| ALOGE("%s: Failed to replace the new HalInterface!", __FUNCTION__); |
| injectionDisconnectImpl(); |
| return res; |
| } |
| |
| res = parent->mRequestThread->setHalInterface(mInjectedCamHalInterface); |
| if (res != OK) { |
| ALOGE("%s: Failed to set new HalInterface in RequestThread!", __FUNCTION__); |
| replaceHalInterface(mBackupHalInterface, false); |
| injectionDisconnectImpl(); |
| return res; |
| } |
| |
| parent->mNeedConfig = true; |
| res = injectionConfigureStreams(injectionConfig, injectionBufferSizes); |
| parent->mNeedConfig = false; |
| if (res != OK) { |
| ALOGE("Can't injectionConfigureStreams device for streams: %d: %s " |
| "(%d)", parent->mNextStreamId, strerror(-res), res); |
| replaceHalInterface(mBackupHalInterface, false); |
| injectionDisconnectImpl(); |
| return res; |
| } |
| |
| if (wasActive) { |
| ALOGV("%s: Restarting activity to inject camera", __FUNCTION__); |
| // Reuse current operating mode and session parameters for new stream |
| // config. |
| parent->internalResumeLocked(); |
| } |
| |
| return OK; |
| } |
| |
| status_t Camera3Device::Camera3DeviceInjectionMethods::stopInjection() { |
| status_t res = NO_ERROR; |
| |
| sp<Camera3Device> parent = mParent.promote(); |
| if (parent == nullptr) { |
| ALOGE("%s: parent does not exist!", __FUNCTION__); |
| return DEAD_OBJECT; |
| } |
| |
| nsecs_t maxExpectedDuration = parent->getExpectedInFlightDuration(); |
| bool wasActive = false; |
| if (parent->mStatus == STATUS_ACTIVE) { |
| ALOGV("%s: Let the device be IDLE and the request thread is paused", |
| __FUNCTION__); |
| res = parent->internalPauseAndWaitLocked(maxExpectedDuration, |
| /*requestThreadInvocation*/false); |
| if (res != OK) { |
| ALOGE("%s: Can't pause captures to stop injection!", __FUNCTION__); |
| return res; |
| } |
| wasActive = true; |
| } |
| |
| res = replaceHalInterface(mBackupHalInterface, false); |
| if (res != OK) { |
| ALOGE("%s: Failed to restore the backup HalInterface!", __FUNCTION__); |
| injectionDisconnectImpl(); |
| return res; |
| } |
| injectionDisconnectImpl(); |
| |
| if (wasActive) { |
| ALOGV("%s: Restarting activity to stop injection", __FUNCTION__); |
| // Reuse current operating mode and session parameters for new stream |
| // config. |
| parent->internalResumeLocked(); |
| } |
| |
| return OK; |
| } |
| |
| bool Camera3Device::Camera3DeviceInjectionMethods::isInjecting() { |
| if (mInjectedCamHalInterface == nullptr) { |
| return false; |
| } else { |
| return true; |
| } |
| } |
| |
| bool Camera3Device::Camera3DeviceInjectionMethods::isStreamConfigCompleteButNotInjected() { |
| return mIsStreamConfigCompleteButNotInjected; |
| } |
| |
| const std::string& Camera3Device::Camera3DeviceInjectionMethods::getInjectedCamId() |
| const { |
| return mInjectedCamId; |
| } |
| |
| void Camera3Device::Camera3DeviceInjectionMethods::getInjectionConfig( |
| /*out*/ camera3::camera_stream_configuration* injectionConfig, |
| /*out*/ std::vector<uint32_t>* injectionBufferSizes) { |
| if (injectionConfig == nullptr || injectionBufferSizes == nullptr) { |
| ALOGE("%s: Injection configuration arguments must not be null!", __FUNCTION__); |
| return; |
| } |
| |
| *injectionConfig = mInjectionConfig; |
| *injectionBufferSizes = mInjectionBufferSizes; |
| } |
| |
| void Camera3Device::Camera3DeviceInjectionMethods::storeInjectionConfig( |
| const camera3::camera_stream_configuration& injectionConfig, |
| const std::vector<uint32_t>& injectionBufferSizes) { |
| mIsStreamConfigCompleteButNotInjected = true; |
| mInjectionConfig = injectionConfig; |
| mInjectionStreams.clear(); |
| for (size_t i = 0; i < injectionConfig.num_streams; i++) { |
| mInjectionStreams.push_back(injectionConfig.streams[i]); |
| } |
| mInjectionConfig.streams = mInjectionStreams.editArray(); |
| mInjectionBufferSizes = injectionBufferSizes; |
| } |
| |
| status_t Camera3Device::Camera3DeviceInjectionMethods::injectionConfigureStreams( |
| camera3::camera_stream_configuration& injectionConfig, |
| const std::vector<uint32_t>& injectionBufferSizes) { |
| ATRACE_CALL(); |
| status_t res = NO_ERROR; |
| |
| sp<Camera3Device> parent = mParent.promote(); |
| if (parent == nullptr) { |
| ALOGE("%s: parent does not exist!", __FUNCTION__); |
| return INVALID_OPERATION; |
| } |
| |
| if (parent->mOperatingMode < 0) { |
| ALOGE("Invalid operating mode: %d", parent->mOperatingMode); |
| return BAD_VALUE; |
| } |
| |
| // Start configuring the streams |
| ALOGV("%s: Injection camera %s: Starting stream configuration", __FUNCTION__, |
| mInjectedCamId.c_str()); |
| |
| parent->mPreparerThread->pause(); |
| |
| // Do the HAL configuration; will potentially touch stream |
| // max_buffers, usage, and priv fields, as well as data_space and format |
| // fields for IMPLEMENTATION_DEFINED formats. |
| |
| const camera_metadata_t* sessionBuffer = parent->mSessionParams.getAndLock(); |
| res = mInjectedCamHalInterface->configureInjectedStreams( |
| sessionBuffer, &injectionConfig, injectionBufferSizes, |
| parent->mDeviceInfo); |
| parent->mSessionParams.unlock(sessionBuffer); |
| |
| if (res == BAD_VALUE) { |
| // HAL rejected this set of streams as unsupported, clean up config |
| // attempt and return to unconfigured state |
| ALOGE("Set of requested outputs not supported by HAL"); |
| parent->cancelStreamsConfigurationLocked(); |
| return BAD_VALUE; |
| } else if (res != OK) { |
| // Some other kind of error from configure_streams - this is not |
| // expected |
| ALOGE("Unable to configure streams with HAL: %s (%d)", strerror(-res), |
| res); |
| return res; |
| } |
| |
| for (size_t i = 0; i < parent->mOutputStreams.size(); i++) { |
| sp<camera3::Camera3OutputStreamInterface> outputStream = |
| parent->mOutputStreams[i]; |
| mInjectedCamHalInterface->onStreamReConfigured(outputStream->getId()); |
| } |
| |
| // Request thread needs to know to avoid using repeat-last-settings protocol |
| // across configure_streams() calls |
| parent->mRequestThread->configurationComplete( |
| parent->mIsConstrainedHighSpeedConfiguration, parent->mSessionParams, |
| parent->mGroupIdPhysicalCameraMap); |
| |
| parent->internalUpdateStatusLocked(STATUS_CONFIGURED); |
| |
| ALOGV("%s: Injection camera %s: Stream configuration complete", __FUNCTION__, |
| mInjectedCamId.c_str()); |
| |
| auto rc = parent->mPreparerThread->resume(); |
| if (rc != OK) { |
| ALOGE("%s: Injection camera %s: Preparer thread failed to resume!", |
| __FUNCTION__, mInjectedCamId.c_str()); |
| return rc; |
| } |
| |
| return OK; |
| } |
| |
| void Camera3Device::Camera3DeviceInjectionMethods::injectionDisconnectImpl() { |
| ATRACE_CALL(); |
| ALOGI("%s: Injection camera disconnect", __FUNCTION__); |
| mIsStreamConfigCompleteButNotInjected = false; |
| mInjectionStreams.clear(); |
| mInjectionConfig.streams = nullptr; |
| |
| mBackupHalInterface = nullptr; |
| HalInterface* interface = nullptr; |
| { |
| Mutex::Autolock lock(mInjectionLock); |
| if (mInjectedCamHalInterface != nullptr) { |
| interface = mInjectedCamHalInterface.get(); |
| // Call close without internal mutex held, as the HAL close may need |
| // to wait on assorted callbacks,etc, to complete before it can |
| // return. |
| } |
| } |
| |
| if (interface != nullptr) { |
| interface->close(); |
| } |
| |
| { |
| Mutex::Autolock lock(mInjectionLock); |
| if (mInjectedCamHalInterface != nullptr) { |
| mInjectedCamHalInterface->clear(); |
| mInjectedCamHalInterface = nullptr; |
| } |
| } |
| } |
| |
| }; // namespace android |
