diff options
author | Xin Li <delphij@google.com> | 2024-01-17 22:14:13 -0800 |
---|---|---|
committer | Xin Li <delphij@google.com> | 2024-01-17 22:14:13 -0800 |
commit | 5913efb05046d116bf089cc24353c68fcadbf57b (patch) | |
tree | 855a40a5913144250bf22d3cfc4c610ce82d51fc | |
parent | ce9c94d94bff436dee6153ae5ab7812330547e79 (diff) | |
parent | e0be63de6bde41af23c060ceca400c02a1782a40 (diff) | |
download | camera-temp_319669529.tar.gz |
Merge Android 24Q1 Release (ab/11220357)temp_319669529
Bug: 319669529
Merged-In: I75fddd651315b7074a5d32f13a827f8ba854e26b
Change-Id: I99d371c65b5f69270b65aa52e1ec1d112cdb6b7c
71 files changed, 1566 insertions, 525 deletions
diff --git a/common/hal/aidl_service/Android.bp b/common/hal/aidl_service/Android.bp index 722d3fd..4872360 100644 --- a/common/hal/aidl_service/Android.bp +++ b/common/hal/aidl_service/Android.bp @@ -90,12 +90,9 @@ cc_defaults { ], compile_multilib: "first", shared_libs: [ - "android.hardware.camera.device-V2-ndk", + "android.hardware.camera.device-V3-ndk", "android.hardware.camera.common-V1-ndk", - "android.hardware.camera.provider-V2-ndk", - "android.hardware.graphics.mapper@2.0", - "android.hardware.graphics.mapper@3.0", - "android.hardware.graphics.mapper@4.0", + "android.hardware.camera.provider-V3-ndk", "android.hardware.thermal-V1-ndk", "libbinder_ndk", "libbase", @@ -106,6 +103,7 @@ cc_defaults { "libgooglecamerahalutils", "libhidlbase", "liblog", + "libui", "libutils", "lib_profiler", ], diff --git a/common/hal/aidl_service/aidl_camera_device.cc b/common/hal/aidl_service/aidl_camera_device.cc index 9d6c869..a086897 100644 --- a/common/hal/aidl_service/aidl_camera_device.cc +++ b/common/hal/aidl_service/aidl_camera_device.cc @@ -162,6 +162,43 @@ ScopedAStatus AidlCameraDevice::getTorchStrengthLevel(int32_t* strength_level) { return ScopedAStatus::ok(); } +ScopedAStatus AidlCameraDevice::constructDefaultRequestSettings( + RequestTemplate /*requestTemplate*/, CameraMetadata* requestSettings) { + if (requestSettings == nullptr) { + return ScopedAStatus::fromServiceSpecificError( + static_cast<int32_t>(Status::ILLEGAL_ARGUMENT)); + } + return ScopedAStatus::fromServiceSpecificError( + static_cast<int32_t>(Status::OPERATION_NOT_SUPPORTED)); +} + +ScopedAStatus AidlCameraDevice::isStreamCombinationWithSettingsSupported( + const StreamConfiguration& /*streamConfiguration*/, bool* supported) { + if (supported == nullptr) { + return ScopedAStatus::fromServiceSpecificError( + static_cast<int32_t>(Status::ILLEGAL_ARGUMENT)); + } + return ScopedAStatus::fromServiceSpecificError( + static_cast<int32_t>(Status::OPERATION_NOT_SUPPORTED)); +} + +ScopedAStatus AidlCameraDevice::getSessionCharacteristics( + const StreamConfiguration& session_config, + CameraMetadata* characteristics_ret) { + // Temporary check to make sure session configuration is valid. + // As a mock implementation, we are just returning the camera characteristics + // for now. + google_camera_hal::StreamConfiguration stream_config; + status_t res = + aidl_utils::ConvertToHalStreamConfig(session_config, &stream_config); + if (res != OK) { + ALOGE("%s: ConvertToHalStreamConfig fail", __FUNCTION__); + return ScopedAStatus::fromServiceSpecificError( + static_cast<int32_t>(Status::INTERNAL_ERROR)); + } + return getCameraCharacteristics(characteristics_ret); +} + ScopedAStatus AidlCameraDevice::getPhysicalCameraCharacteristics( const std::string& physicalCameraId, CameraMetadata* characteristics_ret) { if (characteristics_ret == nullptr) { @@ -255,7 +292,7 @@ ScopedAStatus AidlCameraDevice::isStreamCombinationSupported( google_camera_hal::StreamConfiguration stream_config; status_t res = aidl_utils::ConvertToHalStreamConfig(streams, &stream_config); if (res != OK) { - ALOGE("%s: ConverToHalStreamConfig fail", __FUNCTION__); + ALOGE("%s: ConvertToHalStreamConfig fail", __FUNCTION__); return ScopedAStatus::fromServiceSpecificError( static_cast<int32_t>(Status::INTERNAL_ERROR)); } diff --git a/common/hal/aidl_service/aidl_camera_device.h b/common/hal/aidl_service/aidl_camera_device.h index 86b7263..ccfaea2 100644 --- a/common/hal/aidl_service/aidl_camera_device.h +++ b/common/hal/aidl_service/aidl_camera_device.h @@ -36,6 +36,7 @@ using aidl::android::hardware::camera::device::ICameraDevice; using aidl::android::hardware::camera::device::ICameraDeviceCallback; using aidl::android::hardware::camera::device::ICameraDeviceSession; using aidl::android::hardware::camera::device::ICameraInjectionSession; +using aidl::android::hardware::camera::device::RequestTemplate; using aidl::android::hardware::camera::device::StreamConfiguration; using ::android::hardware::camera::implementation::AidlProfiler; using ndk::ScopedAStatus; @@ -86,6 +87,16 @@ class AidlCameraDevice : public BnCameraDevice { ScopedAStatus getTorchStrengthLevel(int32_t* strength_level) override; + ScopedAStatus constructDefaultRequestSettings( + RequestTemplate requestTemplate, CameraMetadata* requestSettings) override; + + ScopedAStatus isStreamCombinationWithSettingsSupported( + const StreamConfiguration& streamConfiguration, bool* supported) override; + + ScopedAStatus getSessionCharacteristics( + const StreamConfiguration& session_config, + CameraMetadata* characteristics) override; + // End of override functions in ICameraDevice AidlCameraDevice() = default; diff --git a/common/hal/aidl_service/aidl_camera_device_session.cc b/common/hal/aidl_service/aidl_camera_device_session.cc index ed4978e..13cd520 100644 --- a/common/hal/aidl_service/aidl_camera_device_session.cc +++ b/common/hal/aidl_service/aidl_camera_device_session.cc @@ -26,9 +26,11 @@ #include <cutils/trace.h> #include <log/log.h> #include <malloc.h> +#include <ui/GraphicBufferMapper.h> #include <utils/Trace.h> #include "aidl_profiler.h" +#include "aidl_thermal_utils.h" #include "aidl_utils.h" namespace android { namespace hardware { @@ -46,6 +48,7 @@ using ::aidl::android::hardware::camera::device::CameraMetadata; using ::aidl::android::hardware::camera::device::CameraOfflineSessionInfo; using ::aidl::android::hardware::camera::device::CaptureRequest; using ::aidl::android::hardware::camera::device::CaptureResult; +using ::aidl::android::hardware::camera::device::ConfigureStreamsRet; using ::aidl::android::hardware::camera::device::HalStream; using ::aidl::android::hardware::camera::device::ICameraDeviceCallback; using ::aidl::android::hardware::camera::device::ICameraDeviceSession; @@ -98,20 +101,8 @@ void AidlCameraDeviceSession::ProcessCaptureResult( return; } - { - std::lock_guard<std::mutex> pending_lock(pending_first_frame_buffers_mutex_); - if (!hal_result->output_buffers.empty() && - num_pending_first_frame_buffers_ > 0 && - first_request_frame_number_ == hal_result->frame_number) { - num_pending_first_frame_buffers_ -= hal_result->output_buffers.size(); - if (num_pending_first_frame_buffers_ == 0) { - ALOGI("%s: First frame done", __FUNCTION__); - aidl_profiler_->FirstFrameEnd(); - ATRACE_ASYNC_END("first_frame", 0); - ATRACE_ASYNC_END("switch_mode", 0); - } - } - } + TryLogFirstFrameDone(*hal_result, __FUNCTION__); + for (auto& buffer : hal_result->output_buffers) { aidl_profiler_->ProfileFrameRate("Stream " + std::to_string(buffer.stream_id)); @@ -134,6 +125,44 @@ void AidlCameraDeviceSession::ProcessCaptureResult( } } +void AidlCameraDeviceSession::ProcessBatchCaptureResult( + std::vector<std::unique_ptr<google_camera_hal::CaptureResult>> hal_results) { + std::shared_lock lock(aidl_device_callback_lock_); + if (aidl_device_callback_ == nullptr) { + ALOGE("%s: aidl_device_callback_ is nullptr", __FUNCTION__); + return; + } + int batch_size = hal_results.size(); + std::vector<CaptureResult> aidl_results(batch_size); + for (size_t i = 0; i < hal_results.size(); ++i) { + std::unique_ptr<google_camera_hal::CaptureResult>& hal_result = + hal_results[i]; + auto& aidl_result = aidl_results[i]; + + TryLogFirstFrameDone(*hal_result, __FUNCTION__); + + for (auto& buffer : hal_result->output_buffers) { + aidl_profiler_->ProfileFrameRate("Stream " + + std::to_string(buffer.stream_id)); + } + + status_t res = aidl_utils::ConvertToAidlCaptureResult( + result_metadata_queue_.get(), std::move(hal_result), &aidl_result); + if (res != OK) { + ALOGE("%s: Converting to AIDL result failed: %s(%d)", __FUNCTION__, + strerror(-res), res); + return; + } + } + + auto aidl_res = aidl_device_callback_->processCaptureResult(aidl_results); + if (!aidl_res.isOk()) { + ALOGE("%s: processCaptureResult transaction failed: %s.", __FUNCTION__, + aidl_res.getMessage()); + return; + } +} + void AidlCameraDeviceSession::NotifyHalMessage( const google_camera_hal::NotifyMessage& hal_message) { std::shared_lock lock(aidl_device_callback_lock_); @@ -250,21 +279,11 @@ AidlCameraDeviceSession::RequestStreamBuffers( if (!aidl_utils::IsAidlNativeHandleNull(aidl_buffer.buffer)) { native_handle_t* aidl_buffer_native_handle = makeFromAidl(aidl_buffer.buffer); - if (buffer_mapper_v4_ != nullptr) { - hal_buffer.buffer = ImportBufferHandle< - android::hardware::graphics::mapper::V4_0::IMapper, - android::hardware::graphics::mapper::V4_0::Error>( - buffer_mapper_v4_, aidl_buffer_native_handle); - } else if (buffer_mapper_v3_ != nullptr) { - hal_buffer.buffer = ImportBufferHandle< - android::hardware::graphics::mapper::V3_0::IMapper, - android::hardware::graphics::mapper::V3_0::Error>( - buffer_mapper_v3_, aidl_buffer_native_handle); - } else { - hal_buffer.buffer = ImportBufferHandle< - android::hardware::graphics::mapper::V2_0::IMapper, - android::hardware::graphics::mapper::V2_0::Error>( - buffer_mapper_v2_, aidl_buffer_native_handle); + status_t status = GraphicBufferMapper::get().importBufferNoValidate( + aidl_buffer_native_handle, &hal_buffer.buffer); + if (status != OK) { + ALOGE("%s: Importing graphic buffer failed. Status: %s", + __FUNCTION__, ::android::statusToString(status).c_str()); } native_handle_delete(aidl_buffer_native_handle); } @@ -281,26 +300,6 @@ AidlCameraDeviceSession::RequestStreamBuffers( return hal_buffer_request_status; } -template <class T, class U> -buffer_handle_t AidlCameraDeviceSession::ImportBufferHandle( - const sp<T> buffer_mapper_, const hidl_handle& buffer_hidl_handle) { - U mapper_error; - buffer_handle_t imported_buffer_handle; - - auto hidl_res = buffer_mapper_->importBuffer( - buffer_hidl_handle, [&](const auto& error, const auto& buffer_handle) { - mapper_error = error; - imported_buffer_handle = static_cast<buffer_handle_t>(buffer_handle); - }); - if (!hidl_res.isOk() || mapper_error != U::NONE) { - ALOGE("%s: Importing buffer failed: %s, mapper error %u", __FUNCTION__, - hidl_res.description().c_str(), mapper_error); - return nullptr; - } - - return imported_buffer_handle; -} - void AidlCameraDeviceSession::ReturnStreamBuffers( const std::vector<google_camera_hal::StreamBuffer>& return_hal_buffers) { std::shared_lock lock(aidl_device_callback_lock_); @@ -331,29 +330,6 @@ void AidlCameraDeviceSession::ReturnStreamBuffers( } } -status_t AidlCameraDeviceSession::InitializeBufferMapper() { - buffer_mapper_v4_ = - android::hardware::graphics::mapper::V4_0::IMapper::getService(); - if (buffer_mapper_v4_ != nullptr) { - return OK; - } - - buffer_mapper_v3_ = - android::hardware::graphics::mapper::V3_0::IMapper::getService(); - if (buffer_mapper_v3_ != nullptr) { - return OK; - } - - buffer_mapper_v2_ = - android::hardware::graphics::mapper::V2_0::IMapper::getService(); - if (buffer_mapper_v2_ != nullptr) { - return OK; - } - - ALOGE("%s: Getting buffer mapper failed.", __FUNCTION__); - return UNKNOWN_ERROR; -} - status_t AidlCameraDeviceSession::Initialize( const std::shared_ptr<ICameraDeviceCallback>& callback, std::unique_ptr<google_camera_hal::CameraDeviceSession> device_session, @@ -388,12 +364,7 @@ status_t AidlCameraDeviceSession::Initialize( } // Initialize buffer mapper - res = InitializeBufferMapper(); - if (res != OK) { - ALOGE("%s: Initialize buffer mapper failed: %s(%d)", __FUNCTION__, - strerror(-res), res); - return res; - } + GraphicBufferMapper::preloadHal(); const std::string thermal_instance_name = std::string(aidl::android::hardware::thermal::IThermal::descriptor) + @@ -423,6 +394,13 @@ void AidlCameraDeviceSession::SetSessionCallbacks() { [this](std::unique_ptr<google_camera_hal::CaptureResult> result) { ProcessCaptureResult(std::move(result)); }), + .process_batch_capture_result = + google_camera_hal::ProcessBatchCaptureResultFunc( + [this]( + std::vector<std::unique_ptr<google_camera_hal::CaptureResult>> + results) { + ProcessBatchCaptureResult(std::move(results)); + }), .notify = google_camera_hal::NotifyFunc( [this](const google_camera_hal::NotifyMessage& message) { NotifyHalMessage(message); @@ -583,15 +561,25 @@ ndk::ScopedAStatus AidlCameraDeviceSession::constructDefaultRequestSettings( return ndk::ScopedAStatus::ok(); } -ndk::ScopedAStatus AidlCameraDeviceSession::configureStreams( +ndk::ScopedAStatus AidlCameraDeviceSession::configureStreamsV2( const StreamConfiguration& requestedConfiguration, - std::vector<HalStream>* aidl_return) { - ATRACE_NAME("AidlCameraDeviceSession::configureStreams"); + ConfigureStreamsRet* aidl_return) { if (aidl_return == nullptr) { return ndk::ScopedAStatus::fromServiceSpecificError( static_cast<int32_t>(Status::ILLEGAL_ARGUMENT)); } - aidl_return->clear(); + return configureStreamsImpl(requestedConfiguration, /*v2=*/true, aidl_return); +} + +ndk::ScopedAStatus AidlCameraDeviceSession::configureStreamsImpl( + const StreamConfiguration& requestedConfiguration, bool v2, + ConfigureStreamsRet* aidl_return) { + ATRACE_NAME("AidlCameraDeviceSession::configureStreamsV2"); + if (aidl_return == nullptr) { + return ndk::ScopedAStatus::fromServiceSpecificError( + static_cast<int32_t>(Status::ILLEGAL_ARGUMENT)); + } + aidl_return->halStreams.clear(); if (device_session_ == nullptr) { return ndk::ScopedAStatus::fromServiceSpecificError( static_cast<int32_t>(Status::ILLEGAL_ARGUMENT)); @@ -619,8 +607,8 @@ ndk::ScopedAStatus AidlCameraDeviceSession::configureStreams( static_cast<int32_t>(Status::ILLEGAL_ARGUMENT)); } - std::vector<google_camera_hal::HalStream> hal_configured_streams; - res = device_session_->ConfigureStreams(hal_stream_config, + google_camera_hal::ConfigureStreamsReturn hal_configured_streams; + res = device_session_->ConfigureStreams(hal_stream_config, v2, &hal_configured_streams); if (res != OK) { ALOGE("%s: Configuring streams failed: %s(%d)", __FUNCTION__, @@ -636,6 +624,24 @@ ndk::ScopedAStatus AidlCameraDeviceSession::configureStreams( return ndk::ScopedAStatus::ok(); } +ndk::ScopedAStatus AidlCameraDeviceSession::configureStreams( + const StreamConfiguration& requestedConfiguration, + std::vector<HalStream>* aidl_return) { + ATRACE_NAME("AidlCameraDeviceSession::configureStreams"); + if (aidl_return == nullptr) { + return ndk::ScopedAStatus::fromServiceSpecificError( + static_cast<int32_t>(Status::ILLEGAL_ARGUMENT)); + } + ConfigureStreamsRet aidl_config; + auto err = configureStreamsImpl(requestedConfiguration, + /*v2=*/false, &aidl_config); + if (!err.isOk()) { + return err; + } + *aidl_return = std::move(aidl_config.halStreams); + return ndk::ScopedAStatus::ok(); +} + ndk::ScopedAStatus AidlCameraDeviceSession::getCaptureRequestMetadataQueue( aidl::android::hardware::common::fmq::MQDescriptor< int8_t, aidl::android::hardware::common::fmq::SynchronizedReadWrite>* @@ -834,6 +840,22 @@ ndk::ScopedAStatus AidlCameraDeviceSession::isReconfigurationRequired( return binder; } +void AidlCameraDeviceSession::TryLogFirstFrameDone( + const google_camera_hal::CaptureResult& result, + const char* caller_func_name) { + std::lock_guard<std::mutex> pending_lock(pending_first_frame_buffers_mutex_); + if (!result.output_buffers.empty() && num_pending_first_frame_buffers_ > 0 && + first_request_frame_number_ == result.frame_number) { + num_pending_first_frame_buffers_ -= result.output_buffers.size(); + if (num_pending_first_frame_buffers_ == 0) { + ALOGI("%s: First frame done", caller_func_name); + aidl_profiler_->FirstFrameEnd(); + ATRACE_ASYNC_END("first_frame", 0); + ATRACE_ASYNC_END("switch_mode", 0); + } + } +} + } // namespace implementation } // namespace device } // namespace camera diff --git a/common/hal/aidl_service/aidl_camera_device_session.h b/common/hal/aidl_service/aidl_camera_device_session.h index 6480b05..1f6b609 100644 --- a/common/hal/aidl_service/aidl_camera_device_session.h +++ b/common/hal/aidl_service/aidl_camera_device_session.h @@ -26,10 +26,11 @@ #include <utils/StrongPointer.h> #include <shared_mutex> +#include <vector> #include "aidl_profiler.h" -#include "aidl_thermal_utils.h" #include "camera_device_session.h" +#include "hal_types.h" namespace android { namespace hardware { @@ -113,6 +114,9 @@ class AidlCameraDeviceSession return ndk::ScopedAStatus::ok(); }; + ndk::ScopedAStatus configureStreamsV2( + const aidl::android::hardware::camera::device::StreamConfiguration&, + aidl::android::hardware::camera::device::ConfigureStreamsRet*) override; AidlCameraDeviceSession() = default; protected: @@ -151,6 +155,19 @@ class AidlCameraDeviceSession void ProcessCaptureResult( std::unique_ptr<google_camera_hal::CaptureResult> hal_result); + // Invoked when receiving a batched result from HAL. + void ProcessBatchCaptureResult( + std::vector<std::unique_ptr<google_camera_hal::CaptureResult>> hal_results); + + // TODO b/311263114: Remove this method once the feature flag is enabled. + // This is needed since the framework has the feature support flagged. The HAL + // should not switch HAL buffer on / off is the framework doesn't support them + // (flag is off). Since aconfig flags are not shared between the framework and + // the HAL - the HAL can know about framework support through knowing whether + // configureStreamsV2 was called or not. + ndk::ScopedAStatus configureStreamsImpl( + const aidl::android::hardware::camera::device::StreamConfiguration&, + bool v2, aidl::android::hardware::camera::device::ConfigureStreamsRet*); // Invoked when receiving a message from HAL. void NotifyHalMessage(const google_camera_hal::NotifyMessage& hal_message); @@ -163,11 +180,6 @@ class AidlCameraDeviceSession void ReturnStreamBuffers( const std::vector<google_camera_hal::StreamBuffer>& return_hal_buffers); - // Import a buffer handle. - template <class T, class U> - buffer_handle_t ImportBufferHandle(const sp<T> buffer_mapper_, - const hidl_handle& buffer_hidl_handle); - // Set camera device session callbacks. void SetSessionCallbacks(); @@ -183,6 +195,10 @@ class AidlCameraDeviceSession // Unregister thermal changed callback. void UnregisterThermalChangedCallback(); + // Log when the first frame buffers are all received. + void TryLogFirstFrameDone(const google_camera_hal::CaptureResult& result, + const char* caller_func_name); + std::unique_ptr<google_camera_hal::CameraDeviceSession> device_session_; // Metadata queue to read the request metadata from. @@ -198,10 +214,6 @@ class AidlCameraDeviceSession std::shared_ptr<aidl::android::hardware::camera::device::ICameraDeviceCallback> aidl_device_callback_; - android::sp<android::hardware::graphics::mapper::V2_0::IMapper> buffer_mapper_v2_; - android::sp<android::hardware::graphics::mapper::V3_0::IMapper> buffer_mapper_v3_; - android::sp<android::hardware::graphics::mapper::V4_0::IMapper> buffer_mapper_v4_; - std::mutex aidl_thermal_mutex_; std::shared_ptr<aidl::android::hardware::thermal::IThermal> thermal_; diff --git a/common/hal/aidl_service/aidl_utils.cc b/common/hal/aidl_service/aidl_utils.cc index ed84c50..b603aea 100644 --- a/common/hal/aidl_service/aidl_utils.cc +++ b/common/hal/aidl_service/aidl_utils.cc @@ -186,44 +186,44 @@ status_t ConvertToHalTemplateType( } status_t ConvertToAidlHalStreamConfig( - const std::vector<google_camera_hal::HalStream>& hal_configured_streams, - std::vector<HalStream>* aidl_hal_streams) { - if (aidl_hal_streams == nullptr) { - ALOGE("%s: aidl_hal_streams is nullptr.", __FUNCTION__); + const google_camera_hal::ConfigureStreamsReturn& hal_config, + ConfigureStreamsRet* aidl_config) { + if (aidl_config == nullptr) { + ALOGE("%s: aidl_config is nullptr.", __FUNCTION__); return BAD_VALUE; } - aidl_hal_streams->resize(hal_configured_streams.size()); + aidl_config->halStreams.resize(hal_config.hal_streams.size()); - for (uint32_t i = 0; i < hal_configured_streams.size(); i++) { - auto& dst = (*aidl_hal_streams)[i]; + for (uint32_t i = 0; i < hal_config.hal_streams.size(); i++) { + auto& dst = aidl_config->halStreams[i]; dst.supportOffline = false; - if (hal_configured_streams[i].is_physical_camera_stream) { + if (hal_config.hal_streams[i].is_physical_camera_stream) { dst.physicalCameraId = - std::to_string(hal_configured_streams[i].physical_camera_id); + std::to_string(hal_config.hal_streams[i].physical_camera_id); } dst.overrideDataSpace = static_cast<aidl::android::hardware::graphics::common::Dataspace>( - hal_configured_streams[i].override_data_space); + hal_config.hal_streams[i].override_data_space); - dst.id = hal_configured_streams[i].id; + dst.id = hal_config.hal_streams[i].id; dst.overrideFormat = static_cast<aidl::android::hardware::graphics::common::PixelFormat>( - hal_configured_streams[i].override_format); + hal_config.hal_streams[i].override_format); dst.producerUsage = static_cast<aidl::android::hardware::graphics::common::BufferUsage>( - hal_configured_streams[i].producer_usage); + hal_config.hal_streams[i].producer_usage); dst.consumerUsage = static_cast<aidl::android::hardware::graphics::common::BufferUsage>( - hal_configured_streams[i].consumer_usage); + hal_config.hal_streams[i].consumer_usage); - dst.maxBuffers = hal_configured_streams[i].max_buffers; + dst.maxBuffers = hal_config.hal_streams[i].max_buffers; } - + aidl_config->enableHalBufferManager = hal_config.use_hal_buf_manager; return OK; } @@ -812,7 +812,8 @@ status_t ConvertToHalCaptureRequest( } google_camera_hal::StreamBuffer hal_buffer = {}; - if (!IsAidlNativeHandleNull(aidl_request.inputBuffer.buffer)) { + + if (aidl_request.inputBuffer.streamId != -1) { res = ConvertToHalStreamBuffer(aidl_request.inputBuffer, &hal_buffer, handles_to_delete); if (res != OK) { diff --git a/common/hal/aidl_service/aidl_utils.h b/common/hal/aidl_service/aidl_utils.h index be7e6a5..f8b23a0 100644 --- a/common/hal/aidl_service/aidl_utils.h +++ b/common/hal/aidl_service/aidl_utils.h @@ -51,6 +51,7 @@ using aidl::android::hardware::camera::device::BufferRequestStatus; using aidl::android::hardware::camera::device::BufferStatus; using aidl::android::hardware::camera::device::CaptureRequest; using aidl::android::hardware::camera::device::CaptureResult; +using aidl::android::hardware::camera::device::ConfigureStreamsRet; using aidl::android::hardware::camera::device::ErrorCode; using aidl::android::hardware::camera::device::ErrorMsg; using aidl::android::hardware::camera::device::HalStream; @@ -91,8 +92,8 @@ status_t ConvertToAidlResourceCost( CameraResourceCost* aidl_cost); status_t ConvertToAidlHalStreamConfig( - const std::vector<google_camera_hal::HalStream>& hal_configured_streams, - std::vector<HalStream>* aidl_hal_stream_config); + const google_camera_hal::ConfigureStreamsReturn& hal_config, + ConfigureStreamsRet* aidl_config); status_t ConverToAidlNotifyMessage( const google_camera_hal::NotifyMessage& hal_message, diff --git a/common/hal/aidl_service/android.hardware.camera.provider@2.7-service-google.xml b/common/hal/aidl_service/android.hardware.camera.provider@2.7-service-google.xml index a772f31..048c9c9 100644 --- a/common/hal/aidl_service/android.hardware.camera.provider@2.7-service-google.xml +++ b/common/hal/aidl_service/android.hardware.camera.provider@2.7-service-google.xml @@ -1,7 +1,7 @@ <manifest version="1.0" type="device"> <hal format="aidl"> <name>android.hardware.camera.provider</name> - <version>2</version> + <version>3</version> <interface> <name>ICameraProvider</name> <instance>internal/0</instance> diff --git a/common/hal/common/hal_types.h b/common/hal/common/hal_types.h index 8695418..380d2fb 100644 --- a/common/hal/common/hal_types.h +++ b/common/hal/common/hal_types.h @@ -19,6 +19,7 @@ #include <cutils/native_handle.h> #include <system/graphics-base-v1.0.h> + #include <string> #include <unordered_map> #include <vector> @@ -172,6 +173,14 @@ struct HalStream { uint32_t physical_camera_id = 0; }; +// Corresponds to the definition of ConfigureStreamsRet +// parcelable in ConfigureStreamsRet.aidl. That is used as the +// return type for ICameraDeviceSession.configureStreamsV2 +struct ConfigureStreamsReturn { + std::vector<HalStream> hal_streams; + bool use_hal_buf_manager = false; +}; + // See the definition of // ::android::hardware::camera::device::V3_2::BufferCache struct BufferCache { @@ -396,6 +405,10 @@ enum class DeviceState : uint64_t { using ProcessCaptureResultFunc = std::function<void(std::unique_ptr<CaptureResult> /*result*/)>; +// Callback function invoked to process a batched capture result. +using ProcessBatchCaptureResultFunc = + std::function<void(std::vector<std::unique_ptr<CaptureResult>> /*results*/)>; + // Callback function invoked to notify messages. using NotifyFunc = std::function<void(const NotifyMessage& /*message*/)>; diff --git a/common/hal/google_camera_hal/Android.bp b/common/hal/google_camera_hal/Android.bp index 0b35366..7910d90 100644 --- a/common/hal/google_camera_hal/Android.bp +++ b/common/hal/google_camera_hal/Android.bp @@ -80,9 +80,6 @@ cc_library_shared { "zsl_snapshot_capture_session.cc", ], shared_libs: [ - "android.hardware.graphics.mapper@2.0", - "android.hardware.graphics.mapper@3.0", - "android.hardware.graphics.mapper@4.0", "lib_profiler", "libbase", "libcamera_metadata", @@ -91,6 +88,7 @@ cc_library_shared { "libhidlbase", "liblog", "libmeminfo", + "libui", "libutils", "libsync", ], diff --git a/common/hal/google_camera_hal/basic_capture_session.cc b/common/hal/google_camera_hal/basic_capture_session.cc index 667d8df..18e8c34 100644 --- a/common/hal/google_camera_hal/basic_capture_session.cc +++ b/common/hal/google_camera_hal/basic_capture_session.cc @@ -14,13 +14,14 @@ * limitations under the License. */ -//#define LOG_NDEBUG 0 +// #define LOG_NDEBUG 0 #define LOG_TAG "GCH_BasicCaptureSession" #define ATRACE_TAG ATRACE_TAG_CAMERA +#include "basic_capture_session.h" + #include <log/log.h> #include <utils/Trace.h> -#include "basic_capture_session.h" #include "basic_request_processor.h" #include "basic_result_processor.h" #include "realtime_process_block.h" @@ -44,8 +45,9 @@ bool BasicCaptureSession::IsStreamConfigurationSupported( std::unique_ptr<CaptureSession> BasicCaptureSession::Create( CameraDeviceSessionHwl* device_session_hwl, const StreamConfiguration& stream_config, - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, - HwlSessionCallback /*session_callback*/, + ProcessCaptureResultFunc process_capture_result, + ProcessBatchCaptureResultFunc process_batch_capture_result, + NotifyFunc notify, HwlSessionCallback /*session_callback*/, std::vector<HalStream>* hal_configured_streams, CameraBufferAllocatorHwl* /*camera_allocator_hwl*/) { ATRACE_CALL(); @@ -55,9 +57,9 @@ std::unique_ptr<CaptureSession> BasicCaptureSession::Create( return nullptr; } - status_t res = session->Initialize(device_session_hwl, stream_config, - process_capture_result, notify, - hal_configured_streams); + status_t res = session->Initialize( + device_session_hwl, stream_config, process_capture_result, + process_batch_capture_result, notify, hal_configured_streams); if (res != OK) { ALOGE("%s: Initializing BasicCaptureSession failed: %s (%d).", __FUNCTION__, strerror(-res), res); @@ -185,8 +187,9 @@ status_t BasicCaptureSession::ConnectProcessChain( status_t BasicCaptureSession::Initialize( CameraDeviceSessionHwl* device_session_hwl, const StreamConfiguration& stream_config, - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, - std::vector<HalStream>* hal_configured_streams) { + ProcessCaptureResultFunc process_capture_result, + ProcessBatchCaptureResultFunc process_batch_capture_result, + NotifyFunc notify, std::vector<HalStream>* hal_configured_streams) { ATRACE_CALL(); if (!IsStreamConfigurationSupported(device_session_hwl, stream_config)) { ALOGE("%s: stream configuration is not supported.", __FUNCTION__); @@ -207,7 +210,8 @@ status_t BasicCaptureSession::Initialize( return UNKNOWN_ERROR; } - result_processor->SetResultCallback(process_capture_result, notify); + result_processor->SetResultCallback(process_capture_result, notify, + process_batch_capture_result); // Create process block. auto process_block = RealtimeProcessBlock::Create(device_session_hwl_); diff --git a/common/hal/google_camera_hal/basic_capture_session.h b/common/hal/google_camera_hal/basic_capture_session.h index c777e91..d2267d0 100644 --- a/common/hal/google_camera_hal/basic_capture_session.h +++ b/common/hal/google_camera_hal/basic_capture_session.h @@ -46,6 +46,8 @@ class BasicCaptureSession : public CaptureSession { // lifetime of BasicCaptureSession. // stream_config is the stream configuration. // process_capture_result is the callback function to notify results. + // process_batch_capture_result is the callback function to notify batched + // results. // notify is the callback function to notify messages. // hal_configured_streams will be filled with HAL configured streams. // camera_allocator_hwl is owned by the caller and must be valid during the @@ -53,8 +55,9 @@ class BasicCaptureSession : public CaptureSession { static std::unique_ptr<CaptureSession> Create( CameraDeviceSessionHwl* device_session_hwl, const StreamConfiguration& stream_config, - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, - HwlSessionCallback session_callback, + ProcessCaptureResultFunc process_capture_result, + ProcessBatchCaptureResultFunc process_batch_capture_result, + NotifyFunc notify, HwlSessionCallback session_callback, std::vector<HalStream>* hal_configured_streams, CameraBufferAllocatorHwl* camera_allocator_hwl = nullptr); @@ -73,6 +76,7 @@ class BasicCaptureSession : public CaptureSession { status_t Initialize(CameraDeviceSessionHwl* device_session_hwl, const StreamConfiguration& stream_config, ProcessCaptureResultFunc process_capture_result, + ProcessBatchCaptureResultFunc process_batch_capture_result, NotifyFunc notify, std::vector<HalStream>* hal_configured_streams); diff --git a/common/hal/google_camera_hal/basic_result_processor.cc b/common/hal/google_camera_hal/basic_result_processor.cc index 41a112b..bfd1493 100644 --- a/common/hal/google_camera_hal/basic_result_processor.cc +++ b/common/hal/google_camera_hal/basic_result_processor.cc @@ -14,15 +14,15 @@ * limitations under the License. */ -//#define LOG_NDEBUG 0 +// #define LOG_NDEBUG 0 #define LOG_TAG "GCH_BasicResultProcessor" #define ATRACE_TAG ATRACE_TAG_CAMERA -#include <log/log.h> -#include <utils/Trace.h> +#include "basic_result_processor.h" #include <inttypes.h> +#include <log/log.h> +#include <utils/Trace.h> -#include "basic_result_processor.h" #include "hal_utils.h" namespace android { @@ -54,11 +54,13 @@ std::unique_ptr<BasicResultProcessor> BasicResultProcessor::Create() { } void BasicResultProcessor::SetResultCallback( - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify) { + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc process_batch_capture_result) { ATRACE_CALL(); std::lock_guard<std::mutex> lock(callback_lock_); process_capture_result_ = process_capture_result; notify_ = notify; + process_batch_capture_result_ = process_batch_capture_result; } status_t BasicResultProcessor::AddPendingRequests( @@ -93,6 +95,29 @@ void BasicResultProcessor::ProcessResult(ProcessBlockResult block_result) { process_capture_result_(std::move(block_result.result)); } +void BasicResultProcessor::ProcessBatchResult( + std::vector<ProcessBlockResult> block_results) { + ATRACE_CALL(); + std::lock_guard<std::mutex> lock(callback_lock_); + if (process_capture_result_ == nullptr) { + ALOGE("%s: process_capture_result_ is nullptr. Dropping a result.", + __FUNCTION__); + return; + } + + std::vector<std::unique_ptr<CaptureResult>> capture_results; + capture_results.reserve(block_results.size()); + for (auto& block_result : block_results) { + if (block_result.result == nullptr) { + ALOGW("%s: Received a nullptr result.", __FUNCTION__); + continue; + } + capture_results.push_back(std::move(block_result.result)); + } + + process_batch_capture_result_(std::move(capture_results)); +} + void BasicResultProcessor::Notify(const ProcessBlockNotifyMessage& block_message) { ATRACE_CALL(); std::lock_guard<std::mutex> lock(callback_lock_); diff --git a/common/hal/google_camera_hal/basic_result_processor.h b/common/hal/google_camera_hal/basic_result_processor.h index f263807..2fa1e3b 100644 --- a/common/hal/google_camera_hal/basic_result_processor.h +++ b/common/hal/google_camera_hal/basic_result_processor.h @@ -17,6 +17,8 @@ #ifndef HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_BASIC_RESULT_PROCESSOR_H_ #define HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_BASIC_RESULT_PROCESSOR_H_ +#include <vector> + #include "result_processor.h" namespace android { @@ -31,8 +33,9 @@ class BasicResultProcessor : public ResultProcessor { virtual ~BasicResultProcessor(); // Override functions of ResultProcessor start. - void SetResultCallback(ProcessCaptureResultFunc process_capture_result, - NotifyFunc notify) override; + void SetResultCallback( + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc process_batch_capture_result) override; status_t AddPendingRequests( const std::vector<ProcessBlockRequest>& process_block_requests, @@ -40,6 +43,8 @@ class BasicResultProcessor : public ResultProcessor { void ProcessResult(ProcessBlockResult block_result) override; + void ProcessBatchResult(std::vector<ProcessBlockResult> block_results) override; + void Notify(const ProcessBlockNotifyMessage& block_message) override; status_t FlushPendingRequests() override; @@ -53,6 +58,7 @@ class BasicResultProcessor : public ResultProcessor { // The following callbacks must be protected by callback_lock_. ProcessCaptureResultFunc process_capture_result_; + ProcessBatchCaptureResultFunc process_batch_capture_result_; NotifyFunc notify_; }; diff --git a/common/hal/google_camera_hal/camera_device_session.cc b/common/hal/google_camera_hal/camera_device_session.cc index 621fd6f..8d545ed 100644 --- a/common/hal/google_camera_hal/camera_device_session.cc +++ b/common/hal/google_camera_hal/camera_device_session.cc @@ -31,6 +31,7 @@ #include "hdrplus_capture_session.h" #include "rgbird_capture_session.h" #include "system/camera_metadata.h" +#include "ui/GraphicBufferMapper.h" #include "vendor_tag_defs.h" #include "vendor_tag_types.h" #include "vendor_tags.h" @@ -186,48 +187,7 @@ status_t CameraDeviceSession::UpdatePendingRequest(CaptureResult* result) { void CameraDeviceSession::ProcessCaptureResult( std::unique_ptr<CaptureResult> result) { - if (result == nullptr) { - ALOGE("%s: result is nullptr", __FUNCTION__); - return; - } - zoom_ratio_mapper_.UpdateCaptureResult(result.get()); - - // If buffer management is not supported, simply send the result to the client. - if (!buffer_management_supported_) { - std::shared_lock lock(session_callback_lock_); - session_callback_.process_capture_result(std::move(result)); - return; - } - - status_t res = UpdatePendingRequest(result.get()); - if (res != OK) { - ALOGE("%s: Updating inflight requests/streams failed.", __FUNCTION__); - } - - for (auto& stream_buffer : result->output_buffers) { - ALOGV("%s: [sbc] <= Return result output buf[%p], bid[%" PRIu64 - "], strm[%d], frm[%u]", - __FUNCTION__, stream_buffer.buffer, stream_buffer.buffer_id, - stream_buffer.stream_id, result->frame_number); - } - for (auto& stream_buffer : result->input_buffers) { - ALOGV("%s: [sbc] <= Return result input buf[%p], bid[%" PRIu64 - "], strm[%d], frm[%u]", - __FUNCTION__, stream_buffer.buffer, stream_buffer.buffer_id, - stream_buffer.stream_id, result->frame_number); - } - - // If there is dummy buffer or a dummy buffer has been observed of this frame, - // handle the capture result specifically. - bool result_handled = false; - res = TryHandleDummyResult(result.get(), &result_handled); - if (res != OK) { - ALOGE("%s: Failed to handle dummy result.", __FUNCTION__); - return; - } - if (result_handled == true) { - return; - } + if (TryHandleCaptureResult(result)) return; // Update pending request tracker with returned buffers. std::vector<StreamBuffer> buffers; @@ -244,18 +204,40 @@ void CameraDeviceSession::ProcessCaptureResult( session_callback_.process_capture_result(std::move(result)); } - if (!buffers.empty()) { - if (pending_requests_tracker_->TrackReturnedAcquiredBuffers(buffers) != OK) { - ALOGE("%s: Tracking requested acquired buffers failed", __FUNCTION__); - } - if (pending_requests_tracker_->TrackReturnedResultBuffers(buffers) != OK) { - ALOGE("%s: Tracking requested quota buffers failed", __FUNCTION__); + TrackReturnedBuffers(buffers); +} + +void CameraDeviceSession::ProcessBatchCaptureResult( + std::vector<std::unique_ptr<CaptureResult>> results) { + std::vector<std::unique_ptr<CaptureResult>> results_to_callback; + results_to_callback.reserve(results.size()); + std::vector<StreamBuffer> buffers; + for (auto& result : results) { + if (TryHandleCaptureResult(result)) continue; + + // Update pending request tracker with returned buffers. + buffers.insert(buffers.end(), result->output_buffers.begin(), + result->output_buffers.end()); + + if (result->result_metadata) { + std::lock_guard<std::mutex> lock(request_record_lock_); + pending_results_.erase(result->frame_number); } + + results_to_callback.push_back(std::move(result)); + } + + { + std::shared_lock lock(session_callback_lock_); + session_callback_.process_batch_capture_result( + std::move(results_to_callback)); } + + TrackReturnedBuffers(buffers); } void CameraDeviceSession::Notify(const NotifyMessage& result) { - if (buffer_management_supported_) { + if (buffer_management_used_) { uint32_t frame_number = 0; if (result.type == MessageType::kError) { frame_number = result.message.error.frame_number; @@ -305,29 +287,6 @@ void CameraDeviceSession::Notify(const NotifyMessage& result) { session_callback_.notify(result); } -status_t CameraDeviceSession::InitializeBufferMapper() { - buffer_mapper_v4_ = - android::hardware::graphics::mapper::V4_0::IMapper::getService(); - if (buffer_mapper_v4_ != nullptr) { - return OK; - } - - buffer_mapper_v3_ = - android::hardware::graphics::mapper::V3_0::IMapper::getService(); - if (buffer_mapper_v3_ != nullptr) { - return OK; - } - - buffer_mapper_v2_ = - android::hardware::graphics::mapper::V2_0::IMapper::getService(); - if (buffer_mapper_v2_ != nullptr) { - return OK; - } - - ALOGE("%s: Getting buffer mapper failed.", __FUNCTION__); - return UNKNOWN_ERROR; -} - void CameraDeviceSession::InitializeCallbacks() { std::lock_guard lock(session_callback_lock_); @@ -359,6 +318,12 @@ void CameraDeviceSession::InitializeCallbacks() { ProcessCaptureResult(std::move(result)); }); + camera_device_session_callback_.process_batch_capture_result = + ProcessBatchCaptureResultFunc( + [this](std::vector<std::unique_ptr<CaptureResult>> results) { + ProcessBatchCaptureResult(std::move(results)); + }); + camera_device_session_callback_.notify = NotifyFunc([this](const NotifyMessage& result) { Notify(result); }); @@ -390,9 +355,12 @@ status_t CameraDeviceSession::InitializeBufferManagement( status_t res = characteristics->Get( ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, &entry); if (res == OK && entry.count > 0) { - buffer_management_supported_ = - (entry.data.u8[0] >= + buffer_management_used_ = + (entry.data.u8[0] == ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5); + session_buffer_management_supported_ = + (entry.data.u8[0] == + ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE); } return OK; @@ -416,17 +384,11 @@ status_t CameraDeviceSession::Initialize( device_session_hwl_ = std::move(device_session_hwl); camera_allocator_hwl_ = camera_allocator_hwl; - status_t res = InitializeBufferMapper(); - if (res != OK) { - ALOGE("%s: Initialize buffer mapper failed: %s(%d)", __FUNCTION__, - strerror(-res), res); - return res; - } - + GraphicBufferMapper::preloadHal(); InitializeCallbacks(); std::unique_ptr<google_camera_hal::HalCameraMetadata> characteristics; - res = device_session_hwl_->GetCameraCharacteristics(&characteristics); + status_t res = device_session_hwl_->GetCameraCharacteristics(&characteristics); if (res != OK) { ALOGE("%s: Get camera characteristics failed: %s(%d)", __FUNCTION__, strerror(-res), res); @@ -600,16 +562,7 @@ CameraDeviceSession::~CameraDeviceSession() { } external_capture_session_entries_.clear(); - if (buffer_mapper_v4_ != nullptr) { - FreeImportedBufferHandles<android::hardware::graphics::mapper::V4_0::IMapper>( - buffer_mapper_v4_); - } else if (buffer_mapper_v3_ != nullptr) { - FreeImportedBufferHandles<android::hardware::graphics::mapper::V3_0::IMapper>( - buffer_mapper_v3_); - } else if (buffer_mapper_v2_ != nullptr) { - FreeImportedBufferHandles<android::hardware::graphics::mapper::V2_0::IMapper>( - buffer_mapper_v2_); - } + FreeImportedBufferHandles(); } void CameraDeviceSession::UnregisterThermalCallback() { @@ -681,12 +634,17 @@ status_t CameraDeviceSession::ConstructDefaultRequestSettings( } status_t CameraDeviceSession::ConfigureStreams( - const StreamConfiguration& stream_config, - std::vector<HalStream>* hal_config) { + const StreamConfiguration& stream_config, bool v2, + ConfigureStreamsReturn* configured_streams) { ATRACE_CALL(); bool set_realtime_thread = false; int32_t schedule_policy; struct sched_param schedule_param = {0}; + if (configured_streams == nullptr) { + ALOGE("%s: configured_streams output is nullptr", __FUNCTION__); + return BAD_VALUE; + } + std::vector<HalStream>& hal_config = configured_streams->hal_streams; if (utils::SupportRealtimeThread()) { bool get_thread_schedule = false; if (pthread_getschedparam(pthread_self(), &schedule_policy, @@ -733,13 +691,14 @@ status_t CameraDeviceSession::ConfigureStreams( if (!utils::IsStreamUseCaseSupported(stream_config, stream_use_cases_)) { return BAD_VALUE; } - + device_session_hwl_->setConfigureStreamsV2(v2); capture_session_ = CreateCaptureSession( stream_config, kWrapperCaptureSessionEntries, external_capture_session_entries_, kCaptureSessionEntries, hwl_session_callback_, camera_allocator_hwl_, device_session_hwl_.get(), - hal_config, camera_device_session_callback_.process_capture_result, - camera_device_session_callback_.notify); + &hal_config, camera_device_session_callback_.process_capture_result, + camera_device_session_callback_.notify, + camera_device_session_callback_.process_batch_capture_result); if (capture_session_ == nullptr) { ALOGE("%s: Cannot find a capture session compatible with stream config", @@ -749,8 +708,19 @@ status_t CameraDeviceSession::ConfigureStreams( } return BAD_VALUE; } - - if (buffer_management_supported_) { + if (session_buffer_management_supported_ && v2) { + bool use_buffer_management = false; + auto ret = + device_session_hwl_->ShouldUseHalBufferManager(&use_buffer_management); + if (ret != OK) { + ALOGE("%s: shouldUseHalBufManager() failed", __FUNCTION__); + return ret; + } else { + buffer_management_used_ = use_buffer_management; + } + configured_streams->use_hal_buf_manager = buffer_management_used_; + } + if (buffer_management_used_) { stream_buffer_cache_manager_ = StreamBufferCacheManager::Create(); if (stream_buffer_cache_manager_ == nullptr) { ALOGE("%s: Failed to create stream buffer cache manager.", __FUNCTION__); @@ -762,7 +732,7 @@ status_t CameraDeviceSession::ConfigureStreams( } status_t res = - RegisterStreamsIntoCacheManagerLocked(stream_config, *hal_config); + RegisterStreamsIntoCacheManagerLocked(stream_config, hal_config); if (res != OK) { ALOGE("%s: Failed to register streams into stream buffer cache manager.", __FUNCTION__); @@ -775,7 +745,7 @@ status_t CameraDeviceSession::ConfigureStreams( } // (b/129561652): Framework assumes HalStream is sorted. - std::sort(hal_config->begin(), hal_config->end(), + std::sort(hal_config.begin(), hal_config.end(), [](const HalStream& a, const HalStream& b) { return a.id < b.id; }); // Backup the streams received from frameworks into configured_streams_map_, @@ -789,9 +759,9 @@ status_t CameraDeviceSession::ConfigureStreams( // If buffer management is support, create a pending request tracker for // capture request throttling. - if (buffer_management_supported_) { + if (buffer_management_used_) { pending_requests_tracker_ = - PendingRequestsTracker::Create(*hal_config, grouped_stream_id_map_); + PendingRequestsTracker::Create(hal_config, grouped_stream_id_map_); if (pending_requests_tracker_ == nullptr) { ALOGE("%s: Cannot create a pending request tracker.", __FUNCTION__); if (set_realtime_thread) { @@ -820,7 +790,6 @@ status_t CameraDeviceSession::ConfigureStreams( if (set_realtime_thread) { utils::UpdateThreadSched(pthread_self(), schedule_policy, &schedule_param); } - return OK; } @@ -914,7 +883,7 @@ status_t CameraDeviceSession::CreateCaptureRequestLocked( } // If buffer management API is supported, buffers will be requested via // RequestStreamBuffersFunc. - if (!buffer_management_supported_) { + if (!buffer_management_used_) { res = UpdateBufferHandlesLocked(&updated_request->output_buffers); if (res != OK) { ALOGE("%s: Updating output buffer handles failed: %s(%d)", __FUNCTION__, @@ -929,22 +898,16 @@ status_t CameraDeviceSession::CreateCaptureRequestLocked( return OK; } -template <class T, class U> status_t CameraDeviceSession::ImportBufferHandleLocked( - const sp<T> buffer_mapper, const StreamBuffer& buffer) { + const StreamBuffer& buffer) { ATRACE_CALL(); - U mapper_error; buffer_handle_t imported_buffer_handle; - auto hidl_res = buffer_mapper->importBuffer( - android::hardware::hidl_handle(buffer.buffer), - [&](const auto& error, const auto& buffer_handle) { - mapper_error = error; - imported_buffer_handle = static_cast<buffer_handle_t>(buffer_handle); - }); - if (!hidl_res.isOk() || mapper_error != U::NONE) { - ALOGE("%s: Importing buffer failed: %s, mapper error %u", __FUNCTION__, - hidl_res.description().c_str(), mapper_error); + status_t status = GraphicBufferMapper::get().importBufferNoValidate( + buffer.buffer, &imported_buffer_handle); + if (status != OK) { + ALOGE("%s: Importing buffer failed: %s", __FUNCTION__, + ::android::statusToString(status).c_str()); return UNKNOWN_ERROR; } @@ -960,23 +923,7 @@ status_t CameraDeviceSession::ImportBufferHandles( // Import buffers that are new to HAL. for (auto& buffer : buffers) { if (!IsBufferImportedLocked(buffer.stream_id, buffer.buffer_id)) { - status_t res = OK; - if (buffer_mapper_v4_ != nullptr) { - res = ImportBufferHandleLocked< - android::hardware::graphics::mapper::V4_0::IMapper, - android::hardware::graphics::mapper::V4_0::Error>(buffer_mapper_v4_, - buffer); - } else if (buffer_mapper_v3_ != nullptr) { - res = ImportBufferHandleLocked< - android::hardware::graphics::mapper::V3_0::IMapper, - android::hardware::graphics::mapper::V3_0::Error>(buffer_mapper_v3_, - buffer); - } else { - res = ImportBufferHandleLocked< - android::hardware::graphics::mapper::V2_0::IMapper, - android::hardware::graphics::mapper::V2_0::Error>(buffer_mapper_v2_, - buffer); - } + status_t res = ImportBufferHandleLocked(buffer); if (res != OK) { ALOGE("%s: Importing buffer %" PRIu64 " from stream %d failed: %s(%d)", @@ -1001,7 +948,7 @@ status_t CameraDeviceSession::ImportRequestBufferHandles( return res; } - if (buffer_management_supported_) { + if (buffer_management_used_) { ALOGV( "%s: Buffer management is enabled. Skip importing buffers in " "requests.", @@ -1215,7 +1162,7 @@ void CameraDeviceSession::CheckRequestForStreamBufferCacheManager( return; } - // Note: This function should only be called if buffer_management_supported_ + // Note: This function should only be called if buffer_management_used_ // is true. if (pending_request_streams_.empty()) { pending_requests_tracker_->OnBufferCacheFlushed(); @@ -1346,14 +1293,14 @@ status_t CameraDeviceSession::ProcessCaptureRequest( ErrorCode::kErrorRequest); NotifyBufferError(request); need_to_process = false; - } else if (buffer_management_supported_) { + } else if (buffer_management_used_) { CheckRequestForStreamBufferCacheManager(updated_request, &need_to_process); } if (need_to_process) { // If buffer management is supported, framework does not throttle requests // with stream's max buffers. We need to throttle on our own. - if (buffer_management_supported_) { + if (buffer_management_used_) { std::vector<int32_t> first_requested_stream_ids; res = pending_requests_tracker_->WaitAndTrackRequestBuffers( @@ -1378,7 +1325,7 @@ status_t CameraDeviceSession::ProcessCaptureRequest( // Check the flush status again to prevent flush being called while we are // waiting for the request buffers(request throttling). - if (buffer_management_supported_ && is_flushing_) { + if (buffer_management_used_ && is_flushing_) { std::vector<StreamBuffer> buffers = updated_request.output_buffers; { std::lock_guard<std::mutex> lock(request_record_lock_); @@ -1453,41 +1400,28 @@ void CameraDeviceSession::RemoveBufferCache( continue; } - auto free_buffer_mapper = [&buffer_handle_it](auto buffer_mapper) { - auto hidl_res = buffer_mapper->freeBuffer( - const_cast<native_handle_t*>(buffer_handle_it->second)); - if (!hidl_res.isOk()) { - ALOGE("%s: Freeing imported buffer failed: %s", __FUNCTION__, - hidl_res.description().c_str()); - } - }; - device_session_hwl_->RemoveCachedBuffers(buffer_handle_it->second); - if (buffer_mapper_v4_ != nullptr) { - free_buffer_mapper(buffer_mapper_v4_); - } else if (buffer_mapper_v3_ != nullptr) { - free_buffer_mapper(buffer_mapper_v3_); - } else { - free_buffer_mapper(buffer_mapper_v2_); - ; + status_t res = + GraphicBufferMapper::get().freeBuffer(buffer_handle_it->second); + if (res != OK) { + ALOGE("%s: Freeing imported buffer failed: %s", __FUNCTION__, + ::android::statusToString(res).c_str()); } imported_buffer_handle_map_.erase(buffer_handle_it); } } -template <class T> -void CameraDeviceSession::FreeBufferHandlesLocked(const sp<T> buffer_mapper, - int32_t stream_id) { +void CameraDeviceSession::FreeBufferHandlesLocked(int32_t stream_id) { for (auto buffer_handle_it = imported_buffer_handle_map_.begin(); buffer_handle_it != imported_buffer_handle_map_.end();) { if (buffer_handle_it->first.stream_id == stream_id) { - auto hidl_res = buffer_mapper->freeBuffer( - const_cast<native_handle_t*>(buffer_handle_it->second)); - if (!hidl_res.isOk()) { + status_t res = + GraphicBufferMapper::get().freeBuffer(buffer_handle_it->second); + if (res != OK) { ALOGE("%s: Freeing imported buffer failed: %s", __FUNCTION__, - hidl_res.description().c_str()); + ::android::statusToString(res).c_str()); } buffer_handle_it = imported_buffer_handle_map_.erase(buffer_handle_it); } else { @@ -1496,21 +1430,16 @@ void CameraDeviceSession::FreeBufferHandlesLocked(const sp<T> buffer_mapper, } } -template <class T> -void CameraDeviceSession::FreeImportedBufferHandles(const sp<T> buffer_mapper) { +void CameraDeviceSession::FreeImportedBufferHandles() { ATRACE_CALL(); std::lock_guard<std::mutex> lock(imported_buffer_handle_map_lock_); - if (buffer_mapper == nullptr) { - return; - } - + auto& mapper = GraphicBufferMapper::get(); for (auto buffer_handle_it : imported_buffer_handle_map_) { - auto hidl_res = buffer_mapper->freeBuffer( - const_cast<native_handle_t*>(buffer_handle_it.second)); - if (!hidl_res.isOk()) { + status_t status = mapper.freeBuffer(buffer_handle_it.second); + if (status != OK) { ALOGE("%s: Freeing imported buffer failed: %s", __FUNCTION__, - hidl_res.description().c_str()); + ::android::statusToString(status).c_str()); } } @@ -1532,16 +1461,7 @@ void CameraDeviceSession::CleanupStaleStreamsLocked( if (!found) { std::lock_guard<std::mutex> lock(imported_buffer_handle_map_lock_); stream_it = configured_streams_map_.erase(stream_it); - if (buffer_mapper_v4_ != nullptr) { - FreeBufferHandlesLocked<android::hardware::graphics::mapper::V4_0::IMapper>( - buffer_mapper_v4_, stream_id); - } else if (buffer_mapper_v3_ != nullptr) { - FreeBufferHandlesLocked<android::hardware::graphics::mapper::V3_0::IMapper>( - buffer_mapper_v3_, stream_id); - } else { - FreeBufferHandlesLocked<android::hardware::graphics::mapper::V2_0::IMapper>( - buffer_mapper_v2_, stream_id); - } + FreeBufferHandlesLocked(stream_id); } else { stream_it++; } @@ -1940,5 +1860,63 @@ CameraDeviceSession::GetProfiler(uint32_t camera_id, int option) { return device_session_hwl_->GetProfiler(camera_id, option); } +bool CameraDeviceSession::TryHandleCaptureResult( + std::unique_ptr<CaptureResult>& result) { + if (result == nullptr) { + ALOGE("%s: result is nullptr", __FUNCTION__); + return true; + } + zoom_ratio_mapper_.UpdateCaptureResult(result.get()); + + // If buffer management is not used, simply send the result to the client. + if (!buffer_management_used_) { + std::shared_lock lock(session_callback_lock_); + session_callback_.process_capture_result(std::move(result)); + return true; + } + + status_t res = UpdatePendingRequest(result.get()); + if (res != OK) { + ALOGE("%s: Updating inflight requests/streams failed: %s(%d)", __FUNCTION__, + strerror(-res), res); + return true; + } + + for (auto& stream_buffer : result->output_buffers) { + ALOGV("%s: [sbc] <= Return result output buf[%p], bid[%" PRIu64 + "], strm[%d], frm[%u]", + __FUNCTION__, stream_buffer.buffer, stream_buffer.buffer_id, + stream_buffer.stream_id, result->frame_number); + } + for (auto& stream_buffer : result->input_buffers) { + ALOGV("%s: [sbc] <= Return result input buf[%p], bid[%" PRIu64 + "], strm[%d], frm[%u]", + __FUNCTION__, stream_buffer.buffer, stream_buffer.buffer_id, + stream_buffer.stream_id, result->frame_number); + } + + // If there is placeholder buffer or a placeholder buffer has been observed of + // this frame, handle the capture result specifically. + bool result_handled = false; + res = TryHandleDummyResult(result.get(), &result_handled); + if (res != OK) { + ALOGE("%s: Failed to handle placeholder result.", __FUNCTION__); + return true; + } + return result_handled; +} + +void CameraDeviceSession::TrackReturnedBuffers( + const std::vector<StreamBuffer>& buffers) { + if (!buffers.empty()) { + if (pending_requests_tracker_->TrackReturnedAcquiredBuffers(buffers) != OK) { + ALOGE("%s: Tracking requested acquired buffers failed", __FUNCTION__); + } + if (pending_requests_tracker_->TrackReturnedResultBuffers(buffers) != OK) { + ALOGE("%s: Tracking requested quota buffers failed", __FUNCTION__); + } + } +} + } // namespace google_camera_hal } // namespace android diff --git a/common/hal/google_camera_hal/camera_device_session.h b/common/hal/google_camera_hal/camera_device_session.h index 768cf26..644a91c 100644 --- a/common/hal/google_camera_hal/camera_device_session.h +++ b/common/hal/google_camera_hal/camera_device_session.h @@ -17,10 +17,6 @@ #ifndef HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_CAMERA_DEVICE__SESSION_H_ #define HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_CAMERA_DEVICE__SESSION_H_ -#include <android/hardware/graphics/mapper/2.0/IMapper.h> -#include <android/hardware/graphics/mapper/3.0/IMapper.h> -#include <android/hardware/graphics/mapper/4.0/IMapper.h> - #include <memory> #include <set> #include <shared_mutex> @@ -46,6 +42,9 @@ struct CameraDeviceSessionCallback { // Callback to notify when a camera device produces a capture result. ProcessCaptureResultFunc process_capture_result; + // Callback to notify when a camera device produces a batched capture result. + ProcessBatchCaptureResultFunc process_batch_capture_result; + // Callback to notify shutters or errors. NotifyFunc notify; @@ -100,9 +99,11 @@ class CameraDeviceSession { // Configure streams. // stream_config is the requested stream configuration. + // v2 is whether the ConfigureStreams call is made by the configureStreamsV2 + // AIDL call or not. // hal_configured_streams is filled by this method with configured stream. - status_t ConfigureStreams(const StreamConfiguration& stream_config, - std::vector<HalStream>* hal_configured_streams); + status_t ConfigureStreams(const StreamConfiguration& stream_config, bool v2, + ConfigureStreamsReturn* configured_streams); // Process a capture request. // num_processed_requests is filled by this method with the number of @@ -147,9 +148,6 @@ class CameraDeviceSession { CameraBufferAllocatorHwl* camera_allocator_hwl, std::vector<GetCaptureSessionFactoryFunc> external_session_factory_entries); - // Initialize the latest available gralloc buffer mapper. - status_t InitializeBufferMapper(); - // Initialize callbacks from HWL and callbacks to the client. void InitializeCallbacks(); @@ -168,9 +166,7 @@ class CameraDeviceSession { // Import the buffer handle of a buffer. // Must be protected by imported_buffer_handle_map_lock_. - template <class T, class U> - status_t ImportBufferHandleLocked(const sp<T> buffer_mapper, - const StreamBuffer& buffer); + status_t ImportBufferHandleLocked(const StreamBuffer& buffer); // Create a request with updated buffer handles and modified settings. // Must be protected by session_lock_. @@ -190,11 +186,9 @@ class CameraDeviceSession { // Free all imported buffer handles belonging to the stream id. // Must be protected by imported_buffer_handle_map_lock_. - template <class T> - void FreeBufferHandlesLocked(const sp<T> buffer_mapper, int32_t stream_id); + void FreeBufferHandlesLocked(int32_t stream_id); - template <class T> - void FreeImportedBufferHandles(const sp<T> buffer_mapper); + void FreeImportedBufferHandles(); // Clean up stale streams with new stream configuration. // Must be protected by session_lock_. @@ -239,6 +233,10 @@ class CameraDeviceSession { // Process the capture result returned from the HWL void ProcessCaptureResult(std::unique_ptr<CaptureResult> result); + // Process the batched capture result returned from the HWL + void ProcessBatchCaptureResult( + std::vector<std::unique_ptr<CaptureResult>> results); + // Notify error message with error code for stream of frame[frame_number]. // Caller is responsible to make sure this function is called only once for any frame. void NotifyErrorMessage(uint32_t frame_number, int32_t stream_id, @@ -287,14 +285,18 @@ class CameraDeviceSession { // within that group to one single stream ID for easier tracking. void DeriveGroupedStreamIdMap(); + // Try handling a single capture result. Returns true when the result callback + // was sent in the function, or failed to handle it by running into an + // error. So the caller could skip sending the result callback when the + // function returned true. + bool TryHandleCaptureResult(std::unique_ptr<CaptureResult>& result); + + // Tracks the returned buffers in capture results. + void TrackReturnedBuffers(const std::vector<StreamBuffer>& buffers); + uint32_t camera_id_ = 0; std::unique_ptr<CameraDeviceSessionHwl> device_session_hwl_; - // Graphics buffer mapper used to import and free buffers. - sp<android::hardware::graphics::mapper::V2_0::IMapper> buffer_mapper_v2_; - sp<android::hardware::graphics::mapper::V3_0::IMapper> buffer_mapper_v3_; - sp<android::hardware::graphics::mapper::V4_0::IMapper> buffer_mapper_v4_; - // Assuming callbacks to framework is thread-safe, the shared mutex is only // used to protect member variable writing and reading. std::shared_mutex session_callback_lock_; @@ -365,8 +367,11 @@ class CameraDeviceSession { // hwl allocator CameraBufferAllocatorHwl* camera_allocator_hwl_ = nullptr; - // If buffer management API support. - bool buffer_management_supported_ = false; + // If buffer management API support is used for the session configured + bool buffer_management_used_ = false; + + // If session specific hal buffer manager is supported by the HAL + bool session_buffer_management_supported_ = false; // Pending requests tracker used when buffer management API is enabled. // Protected by session_lock_. diff --git a/common/hal/google_camera_hal/capture_session_utils.cc b/common/hal/google_camera_hal/capture_session_utils.cc index 3d5f34c..bdc26d4 100644 --- a/common/hal/google_camera_hal/capture_session_utils.cc +++ b/common/hal/google_camera_hal/capture_session_utils.cc @@ -32,7 +32,8 @@ std::unique_ptr<CaptureSession> CreateCaptureSession( CameraBufferAllocatorHwl* camera_buffer_allocator_hwl, CameraDeviceSessionHwl* camera_device_session_hwl, std::vector<HalStream>* hal_config, - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify) { + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc process_batch_capture_result) { // first pass: check predefined wrapper capture session for (auto sessionEntry : wrapper_capture_session_entries) { if (sessionEntry.IsStreamConfigurationSupported(camera_device_session_hwl, @@ -61,7 +62,8 @@ std::unique_ptr<CaptureSession> CreateCaptureSession( stream_config)) { return sessionEntry.CreateSession( camera_device_session_hwl, stream_config, process_capture_result, - notify, hwl_session_callback, hal_config, camera_buffer_allocator_hwl); + process_batch_capture_result, notify, hwl_session_callback, + hal_config, camera_buffer_allocator_hwl); } } return nullptr; diff --git a/common/hal/google_camera_hal/capture_session_utils.h b/common/hal/google_camera_hal/capture_session_utils.h index f77c553..e544276 100644 --- a/common/hal/google_camera_hal/capture_session_utils.h +++ b/common/hal/google_camera_hal/capture_session_utils.h @@ -37,8 +37,9 @@ using StreamConfigSupportedFunc = using CaptureSessionCreateFunc = std::function<std::unique_ptr<CaptureSession>( CameraDeviceSessionHwl* device_session_hwl, const StreamConfiguration& stream_config, - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, - HwlSessionCallback session_callback, + ProcessCaptureResultFunc process_capture_result, + ProcessBatchCaptureResultFunc process_capture_batch_result, + NotifyFunc notify, HwlSessionCallback session_callback, std::vector<HalStream>* hal_configured_streams, CameraBufferAllocatorHwl* camera_allocator_hwl)>; @@ -82,7 +83,8 @@ std::unique_ptr<CaptureSession> CreateCaptureSession( CameraBufferAllocatorHwl* camera_buffer_allocator_hwl, CameraDeviceSessionHwl* camera_device_session_hwl, std::vector<HalStream>* hal_config, - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify); + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc process_batch_capture_result = nullptr); } // namespace google_camera_hal } // namespace android diff --git a/common/hal/google_camera_hal/depth_process_block.cc b/common/hal/google_camera_hal/depth_process_block.cc index b4f8121..afd5474 100644 --- a/common/hal/google_camera_hal/depth_process_block.cc +++ b/common/hal/google_camera_hal/depth_process_block.cc @@ -87,7 +87,7 @@ std::unique_ptr<DepthProcessBlock> DepthProcessBlock::Create( // rt_request_processor and result_request_processor. block->rgb_ir_auto_cal_enabled_ = property_get_bool("vendor.camera.frontdepth.enableautocal", true); - + block->device_session_hwl_ = device_session_hwl; return block; } @@ -106,9 +106,12 @@ status_t DepthProcessBlock::InitializeBufferManagementStatus( res = characteristics->Get(ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, &entry); if (res == OK && entry.count > 0) { - buffer_management_supported_ = - (entry.data.u8[0] >= + buffer_management_used_ = + (entry.data.u8[0] == ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5); + session_buffer_management_supported_ = + (entry.data.u8[0] == + ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE); } return OK; @@ -250,7 +253,17 @@ status_t DepthProcessBlock::ConfigureStreams( depth_generator_->SetResultCallback(nullptr); } } - + if (session_buffer_management_supported_ && + device_session_hwl_->configure_streams_v2()) { + bool use_buf_manager = false; + auto ret = device_session_hwl_->ShouldUseHalBufferManager(&use_buf_manager); + if (ret != OK) { + ALOGE("%s: shouldUseHalBufManager() failed", __FUNCTION__); + return ret; + } else { + buffer_management_used_ = use_buf_manager; + } + } is_configured_ = true; return OK; } @@ -549,7 +562,7 @@ status_t DepthProcessBlock::UnmapBuffersForDepthGenerator( status_t DepthProcessBlock::RequestDepthStreamBuffer( StreamBuffer* incomplete_buffer, uint32_t frame_number) { - if (!buffer_management_supported_) { + if (!buffer_management_used_) { return OK; } @@ -693,7 +706,7 @@ status_t DepthProcessBlock::PrepareDepthRequestInfo( return BAD_VALUE; } - if (buffer_management_supported_) { + if (buffer_management_used_) { res = RequestDepthStreamBuffer( &(const_cast<CaptureRequest&>(request).output_buffers[0]), request.frame_number); diff --git a/common/hal/google_camera_hal/depth_process_block.h b/common/hal/google_camera_hal/depth_process_block.h index 15c4341..52514f8 100644 --- a/common/hal/google_camera_hal/depth_process_block.h +++ b/common/hal/google_camera_hal/depth_process_block.h @@ -177,8 +177,13 @@ class DepthProcessBlock : public ProcessBlock { int32_t ir_active_array_width_ = 640; int32_t ir_active_array_height_ = 480; - // Whether the HAL Buffer Management is supported - bool buffer_management_supported_ = false; + // Whether the HAL Buffer Management is supported for the session + // configured + bool buffer_management_used_ = false; + bool session_buffer_management_supported_ = false; + + // Owned by the client calling Create() + CameraDeviceSessionHwl* device_session_hwl_ = nullptr; // Whether the pipelined depth engine is enabled bool pipelined_depth_engine_enabled_ = false; diff --git a/common/hal/google_camera_hal/dual_ir_capture_session.cc b/common/hal/google_camera_hal/dual_ir_capture_session.cc index b1dfd00..4b52476 100644 --- a/common/hal/google_camera_hal/dual_ir_capture_session.cc +++ b/common/hal/google_camera_hal/dual_ir_capture_session.cc @@ -14,16 +14,17 @@ * limitations under the License. */ -//#define LOG_NDEBUG 0 +// #define LOG_NDEBUG 0 #define LOG_TAG "GCH_DualIrCaptureSession" #define ATRACE_TAG ATRACE_TAG_CAMERA +#include "dual_ir_capture_session.h" + #include <log/log.h> #include <utils/Trace.h> #include <set> #include <vector> -#include "dual_ir_capture_session.h" #include "dual_ir_request_processor.h" #include "dual_ir_result_request_processor.h" #include "hal_utils.h" @@ -90,8 +91,9 @@ bool DualIrCaptureSession::IsStreamConfigurationSupported( std::unique_ptr<CaptureSession> DualIrCaptureSession::Create( CameraDeviceSessionHwl* device_session_hwl, const StreamConfiguration& stream_config, - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, - HwlSessionCallback /*session_callback*/, + ProcessCaptureResultFunc process_capture_result, + ProcessBatchCaptureResultFunc /*process_batch_capture_result*/, + NotifyFunc notify, HwlSessionCallback /*session_callback*/, std::vector<HalStream>* hal_configured_streams, CameraBufferAllocatorHwl* /*camera_allocator_hwl*/) { ATRACE_CALL(); @@ -480,7 +482,9 @@ status_t DualIrCaptureSession::CreateProcessChain( // Only connect the depth segment of the realtime process chain when depth // stream is configured if (has_depth_stream_) { - depth_result_processor->SetResultCallback(process_capture_result, notify); + depth_result_processor->SetResultCallback( + process_capture_result, notify, + /*process_batch_capture_result=*/nullptr); res = ConnectProcessChain(rt_result_request_processor.get(), std::move(depth_process_block), std::move(depth_result_processor)); @@ -491,7 +495,8 @@ status_t DualIrCaptureSession::CreateProcessChain( } } - rt_result_request_processor->SetResultCallback(process_capture_result, notify); + rt_result_request_processor->SetResultCallback( + process_capture_result, notify, /*process_batch_capture_result=*/nullptr); res = ConnectProcessChain(request_processor_.get(), std::move(rt_process_block), std::move(rt_result_request_processor)); diff --git a/common/hal/google_camera_hal/dual_ir_capture_session.h b/common/hal/google_camera_hal/dual_ir_capture_session.h index 66236c9..b28820b 100644 --- a/common/hal/google_camera_hal/dual_ir_capture_session.h +++ b/common/hal/google_camera_hal/dual_ir_capture_session.h @@ -51,6 +51,8 @@ class DualIrCaptureSession : public CaptureSession { // lifetime of DualIrCaptureSession. // stream_config is the stream configuration. // process_capture_result is the callback function to notify results. + // process_batch_capture_result is the callback function to notify batched + // results. // notify is the callback function to notify messages. // hal_configured_streams will be filled with HAL configured streams. // camera_allocator_hwl is owned by the caller and must be valid during the @@ -58,8 +60,9 @@ class DualIrCaptureSession : public CaptureSession { static std::unique_ptr<CaptureSession> Create( CameraDeviceSessionHwl* device_session_hwl, const StreamConfiguration& stream_config, - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, - HwlSessionCallback session_callback, + ProcessCaptureResultFunc process_capture_result, + ProcessBatchCaptureResultFunc process_batch_capture_result, + NotifyFunc notify, HwlSessionCallback session_callback, std::vector<HalStream>* hal_configured_streams, CameraBufferAllocatorHwl* camera_allocator_hwl); diff --git a/common/hal/google_camera_hal/dual_ir_depth_result_processor.cc b/common/hal/google_camera_hal/dual_ir_depth_result_processor.cc index ee30451..a81a448 100644 --- a/common/hal/google_camera_hal/dual_ir_depth_result_processor.cc +++ b/common/hal/google_camera_hal/dual_ir_depth_result_processor.cc @@ -14,15 +14,15 @@ * limitations under the License. */ -//#define LOG_NDEBUG 0 +// #define LOG_NDEBUG 0 #define LOG_TAG "DualIrDepthResultProcessor" #define ATRACE_TAG ATRACE_TAG_CAMERA -#include <log/log.h> -#include <utils/Trace.h> +#include "dual_ir_depth_result_processor.h" #include <inttypes.h> +#include <log/log.h> +#include <utils/Trace.h> -#include "dual_ir_depth_result_processor.h" #include "hal_utils.h" namespace android { @@ -50,7 +50,8 @@ DualIrDepthResultProcessor::DualIrDepthResultProcessor( } void DualIrDepthResultProcessor::SetResultCallback( - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify) { + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc /*process_batch_capture_result*/) { std::lock_guard<std::mutex> lock(callback_lock_); process_capture_result_ = process_capture_result; notify_ = notify; diff --git a/common/hal/google_camera_hal/dual_ir_depth_result_processor.h b/common/hal/google_camera_hal/dual_ir_depth_result_processor.h index 4e9af84..6641e11 100644 --- a/common/hal/google_camera_hal/dual_ir_depth_result_processor.h +++ b/common/hal/google_camera_hal/dual_ir_depth_result_processor.h @@ -31,8 +31,9 @@ class DualIrDepthResultProcessor : public ResultProcessor { virtual ~DualIrDepthResultProcessor() = default; // Override functions of ResultProcessor start. - void SetResultCallback(ProcessCaptureResultFunc process_capture_result, - NotifyFunc notify) override; + void SetResultCallback( + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc process_batch_capture_result) override; status_t AddPendingRequests( const std::vector<ProcessBlockRequest>& process_block_requests, diff --git a/common/hal/google_camera_hal/dual_ir_result_request_processor.cc b/common/hal/google_camera_hal/dual_ir_result_request_processor.cc index 3511886..0e3819d 100644 --- a/common/hal/google_camera_hal/dual_ir_result_request_processor.cc +++ b/common/hal/google_camera_hal/dual_ir_result_request_processor.cc @@ -14,15 +14,15 @@ * limitations under the License. */ -//#define LOG_NDEBUG 0 +// #define LOG_NDEBUG 0 #define LOG_TAG "GCH_DualIrResultRequestProcessor" #define ATRACE_TAG ATRACE_TAG_CAMERA -#include <log/log.h> -#include <utils/Trace.h> +#include "dual_ir_result_request_processor.h" #include <inttypes.h> +#include <log/log.h> +#include <utils/Trace.h> -#include "dual_ir_result_request_processor.h" #include "hal_utils.h" namespace android { @@ -67,7 +67,8 @@ DualIrResultRequestProcessor::DualIrResultRequestProcessor( } void DualIrResultRequestProcessor::SetResultCallback( - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify) { + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc /*process_batch_capture_result*/) { ATRACE_CALL(); std::lock_guard<std::mutex> lock(callback_lock_); process_capture_result_ = process_capture_result; diff --git a/common/hal/google_camera_hal/dual_ir_result_request_processor.h b/common/hal/google_camera_hal/dual_ir_result_request_processor.h index 39bde53..534fa71 100644 --- a/common/hal/google_camera_hal/dual_ir_result_request_processor.h +++ b/common/hal/google_camera_hal/dual_ir_result_request_processor.h @@ -44,8 +44,9 @@ class DualIrResultRequestProcessor : public ResultProcessor, virtual ~DualIrResultRequestProcessor() = default; // Override functions of ResultProcessor start. - void SetResultCallback(ProcessCaptureResultFunc process_capture_result, - NotifyFunc notify) override; + void SetResultCallback( + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc process_batch_capture_result) override; status_t AddPendingRequests( const std::vector<ProcessBlockRequest>& process_block_requests, diff --git a/common/hal/google_camera_hal/hdrplus_capture_session.cc b/common/hal/google_camera_hal/hdrplus_capture_session.cc index 28abcce..64ba4d4 100644 --- a/common/hal/google_camera_hal/hdrplus_capture_session.cc +++ b/common/hal/google_camera_hal/hdrplus_capture_session.cc @@ -14,7 +14,7 @@ * limitations under the License. */ -//#define LOG_NDEBUG 0 +// #define LOG_NDEBUG 0 #define LOG_TAG "GCH_HdrplusCaptureSession" #define ATRACE_TAG ATRACE_TAG_CAMERA #include "hdrplus_capture_session.h" @@ -80,8 +80,9 @@ bool HdrplusCaptureSession::IsStreamConfigurationSupported( std::unique_ptr<HdrplusCaptureSession> HdrplusCaptureSession::Create( CameraDeviceSessionHwl* device_session_hwl, const StreamConfiguration& stream_config, - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, - HwlSessionCallback /*session_callback*/, + ProcessCaptureResultFunc process_capture_result, + ProcessBatchCaptureResultFunc /*process_batch_capture_result*/, + NotifyFunc notify, HwlSessionCallback /*session_callback*/, std::vector<HalStream>* hal_configured_streams, CameraBufferAllocatorHwl* /*camera_allocator_hwl*/) { ATRACE_CALL(); @@ -380,7 +381,8 @@ status_t HdrplusCaptureSession::SetupRealtimeProcessChain( ALOGE("%s: Creating RealtimeZslResultProcessor failed.", __FUNCTION__); return UNKNOWN_ERROR; } - result_processor->SetResultCallback(process_capture_result, notify); + result_processor->SetResultCallback(process_capture_result, notify, + /*process_batch_capture_result=*/nullptr); *realtime_process_block = std::move(process_block); *realtime_result_processor = std::move(result_processor); @@ -426,7 +428,8 @@ status_t HdrplusCaptureSession::SetupHdrplusProcessChain( ALOGE("%s: Creating HdrplusResultProcessor failed.", __FUNCTION__); return UNKNOWN_ERROR; } - result_processor->SetResultCallback(process_capture_result, notify); + result_processor->SetResultCallback(process_capture_result, notify, + /*process_batch_capture_result=*/nullptr); status_t res = ConfigureHdrplusStreams( stream_config, hdrplus_request_processor_.get(), process_block.get()); diff --git a/common/hal/google_camera_hal/hdrplus_capture_session.h b/common/hal/google_camera_hal/hdrplus_capture_session.h index 8369196..29d8993 100644 --- a/common/hal/google_camera_hal/hdrplus_capture_session.h +++ b/common/hal/google_camera_hal/hdrplus_capture_session.h @@ -50,6 +50,8 @@ class HdrplusCaptureSession : public CaptureSession { // lifetime of HdrplusCaptureSession. // stream_config is the stream configuration. // process_capture_result is the callback function to notify results. + // process_batch_capture_result is the callback function to notify batched + // results. // notify is the callback function to notify messages. // hal_configured_streams will be filled with HAL configured streams. // camera_allocator_hwl is owned by the caller and must be valid during the @@ -57,8 +59,9 @@ class HdrplusCaptureSession : public CaptureSession { static std::unique_ptr<HdrplusCaptureSession> Create( CameraDeviceSessionHwl* device_session_hwl, const StreamConfiguration& stream_config, - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, - HwlSessionCallback session_callback, + ProcessCaptureResultFunc process_capture_result, + ProcessBatchCaptureResultFunc process_batch_capture_result, + NotifyFunc notify, HwlSessionCallback session_callback, std::vector<HalStream>* hal_configured_streams, CameraBufferAllocatorHwl* camera_allocator_hwl = nullptr); diff --git a/common/hal/google_camera_hal/realtime_zsl_result_processor.cc b/common/hal/google_camera_hal/realtime_zsl_result_processor.cc index 6580167..2735920 100644 --- a/common/hal/google_camera_hal/realtime_zsl_result_processor.cc +++ b/common/hal/google_camera_hal/realtime_zsl_result_processor.cc @@ -59,7 +59,8 @@ RealtimeZslResultProcessor::RealtimeZslResultProcessor( } void RealtimeZslResultProcessor::SetResultCallback( - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify) { + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc /*process_batch_capture_result*/) { std::lock_guard<std::mutex> lock(callback_lock_); process_capture_result_ = process_capture_result; notify_ = notify; diff --git a/common/hal/google_camera_hal/realtime_zsl_result_processor.h b/common/hal/google_camera_hal/realtime_zsl_result_processor.h index 61106e3..7ab5490 100644 --- a/common/hal/google_camera_hal/realtime_zsl_result_processor.h +++ b/common/hal/google_camera_hal/realtime_zsl_result_processor.h @@ -36,8 +36,9 @@ class RealtimeZslResultProcessor : public ResultProcessor { virtual ~RealtimeZslResultProcessor() = default; // Override functions of ResultProcessor start. - void SetResultCallback(ProcessCaptureResultFunc process_capture_result, - NotifyFunc notify) override; + void SetResultCallback( + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc process_batch_capture_result) override; status_t AddPendingRequests( const std::vector<ProcessBlockRequest>& process_block_requests, diff --git a/common/hal/google_camera_hal/rgbird_capture_session.cc b/common/hal/google_camera_hal/rgbird_capture_session.cc index e41872b..5cd79a0 100644 --- a/common/hal/google_camera_hal/rgbird_capture_session.cc +++ b/common/hal/google_camera_hal/rgbird_capture_session.cc @@ -14,14 +14,16 @@ * limitations under the License. */ -//#define LOG_NDEBUG 0 +// #define LOG_NDEBUG 0 #define LOG_TAG "GCH_RgbirdCaptureSession" #define ATRACE_TAG ATRACE_TAG_CAMERA +#include "rgbird_capture_session.h" + #include <cutils/properties.h> +#include <inttypes.h> #include <log/log.h> #include <utils/Trace.h> -#include <inttypes.h> #include <set> #include "basic_result_processor.h" @@ -31,7 +33,6 @@ #include "hdrplus_request_processor.h" #include "hdrplus_result_processor.h" #include "multicam_realtime_process_block.h" -#include "rgbird_capture_session.h" #include "rgbird_depth_result_processor.h" #include "rgbird_result_request_processor.h" #include "rgbird_rt_request_processor.h" @@ -89,8 +90,9 @@ bool RgbirdCaptureSession::IsStreamConfigurationSupported( std::unique_ptr<CaptureSession> RgbirdCaptureSession::Create( CameraDeviceSessionHwl* device_session_hwl, const StreamConfiguration& stream_config, - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, - HwlSessionCallback session_callback, + ProcessCaptureResultFunc process_capture_result, + ProcessBatchCaptureResultFunc /*process_batch_capture_result*/, + NotifyFunc notify, HwlSessionCallback session_callback, std::vector<HalStream>* hal_configured_streams, CameraBufferAllocatorHwl* /*camera_allocator_hwl*/) { ATRACE_CALL(); @@ -573,7 +575,8 @@ status_t RgbirdCaptureSession::SetupRealtimeProcessChain( ALOGE("%s: Creating RgbirdResultRequestProcessor failed.", __FUNCTION__); return UNKNOWN_ERROR; } - rt_result_processor->SetResultCallback(process_capture_result, notify); + rt_result_processor->SetResultCallback( + process_capture_result, notify, /*process_batch_capture_result=*/nullptr); if (is_hdrplus_supported_) { res = rt_result_processor->ConfigureStreams(internal_stream_manager_.get(), @@ -652,7 +655,8 @@ status_t RgbirdCaptureSession::SetupHdrplusProcessChain( ALOGE("%s: Creating HdrplusResultProcessor failed.", __FUNCTION__); return UNKNOWN_ERROR; } - result_processor->SetResultCallback(process_capture_result, notify); + result_processor->SetResultCallback(process_capture_result, notify, + /*process_batch_capture_result=*/nullptr); StreamConfiguration process_block_stream_config; status_t res = @@ -716,7 +720,9 @@ status_t RgbirdCaptureSession::CreateProcessChain( // Connecting the depth segment of the realtime process chain. if (NeedDepthProcessBlock()) { - depth_result_processor->SetResultCallback(process_capture_result, notify); + depth_result_processor->SetResultCallback( + process_capture_result, notify, + /*process_batch_capture_result=*/nullptr); res = ConnectProcessChain(realtime_result_processor.get(), std::move(depth_process_block), diff --git a/common/hal/google_camera_hal/rgbird_capture_session.h b/common/hal/google_camera_hal/rgbird_capture_session.h index 0ba6675..a9da992 100644 --- a/common/hal/google_camera_hal/rgbird_capture_session.h +++ b/common/hal/google_camera_hal/rgbird_capture_session.h @@ -54,14 +54,18 @@ class RgbirdCaptureSession : public CaptureSession { // stream_config is the stream configuration. // process_capture_result is the callback function to notify results. // notify is the callback function to notify messages. + // process_batch_capture_result is the callback function to notify batched + // results. + // notify is the callback function to notify messages. // hal_configured_streams will be filled with HAL configured streams. // camera_allocator_hwl is owned by the caller and must be valid during the // lifetime of RgbirdCaptureSession static std::unique_ptr<CaptureSession> Create( CameraDeviceSessionHwl* device_session_hwl, const StreamConfiguration& stream_config, - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, - HwlSessionCallback session_callback, + ProcessCaptureResultFunc process_capture_result, + ProcessBatchCaptureResultFunc process_batch_capture_result, + NotifyFunc notify, HwlSessionCallback session_callback, std::vector<HalStream>* hal_configured_streams, CameraBufferAllocatorHwl* camera_allocator_hwl = nullptr); diff --git a/common/hal/google_camera_hal/rgbird_depth_result_processor.cc b/common/hal/google_camera_hal/rgbird_depth_result_processor.cc index 83d92e2..591a6a6 100644 --- a/common/hal/google_camera_hal/rgbird_depth_result_processor.cc +++ b/common/hal/google_camera_hal/rgbird_depth_result_processor.cc @@ -14,16 +14,16 @@ * limitations under the License. */ -//#define LOG_NDEBUG 0 +// #define LOG_NDEBUG 0 #define LOG_TAG "GCH_RgbirdDepthResultProcessor" #define ATRACE_TAG ATRACE_TAG_CAMERA -#include <log/log.h> -#include <utils/Trace.h> +#include "rgbird_depth_result_processor.h" #include <inttypes.h> +#include <log/log.h> +#include <utils/Trace.h> #include "hal_utils.h" -#include "rgbird_depth_result_processor.h" namespace android { namespace google_camera_hal { @@ -50,7 +50,8 @@ RgbirdDepthResultProcessor::RgbirdDepthResultProcessor( } void RgbirdDepthResultProcessor::SetResultCallback( - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify) { + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc /*process_batch_capture_result*/) { std::lock_guard<std::mutex> lock(callback_lock_); process_capture_result_ = process_capture_result; notify_ = notify; diff --git a/common/hal/google_camera_hal/rgbird_depth_result_processor.h b/common/hal/google_camera_hal/rgbird_depth_result_processor.h index 88f9fd2..e4f201c 100644 --- a/common/hal/google_camera_hal/rgbird_depth_result_processor.h +++ b/common/hal/google_camera_hal/rgbird_depth_result_processor.h @@ -39,8 +39,9 @@ class RgbirdDepthResultProcessor : public ResultProcessor { virtual ~RgbirdDepthResultProcessor() = default; // Override functions of ResultProcessor start. - void SetResultCallback(ProcessCaptureResultFunc process_capture_result, - NotifyFunc notify) override; + void SetResultCallback( + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc process_batch_capture_result) override; status_t AddPendingRequests( const std::vector<ProcessBlockRequest>& process_block_requests, diff --git a/common/hal/google_camera_hal/rgbird_result_request_processor.cc b/common/hal/google_camera_hal/rgbird_result_request_processor.cc index e48e3d1..a05384c 100644 --- a/common/hal/google_camera_hal/rgbird_result_request_processor.cc +++ b/common/hal/google_camera_hal/rgbird_result_request_processor.cc @@ -14,19 +14,19 @@ * limitations under the License. */ -//#define LOG_NDEBUG 0 +// #define LOG_NDEBUG 0 #define LOG_TAG "GCH_RgbirdResultRequestProcessor" #define ATRACE_TAG ATRACE_TAG_CAMERA +#include "rgbird_result_request_processor.h" + +#include <cutils/native_handle.h> #include <cutils/properties.h> +#include <inttypes.h> #include <log/log.h> #include <sync/sync.h> #include <utils/Trace.h> -#include <cutils/native_handle.h> -#include <inttypes.h> - #include "hal_utils.h" -#include "rgbird_result_request_processor.h" namespace android { namespace google_camera_hal { @@ -70,7 +70,8 @@ RgbirdResultRequestProcessor::RgbirdResultRequestProcessor( } void RgbirdResultRequestProcessor::SetResultCallback( - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify) { + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc /*process_batch_capture_result*/) { std::lock_guard<std::mutex> lock(callback_lock_); process_capture_result_ = process_capture_result; notify_ = notify; diff --git a/common/hal/google_camera_hal/rgbird_result_request_processor.h b/common/hal/google_camera_hal/rgbird_result_request_processor.h index 0c35d28..84ee2c1 100644 --- a/common/hal/google_camera_hal/rgbird_result_request_processor.h +++ b/common/hal/google_camera_hal/rgbird_result_request_processor.h @@ -53,8 +53,9 @@ class RgbirdResultRequestProcessor : public ResultProcessor, virtual ~RgbirdResultRequestProcessor() = default; // Override functions of ResultProcessor start. - void SetResultCallback(ProcessCaptureResultFunc process_capture_result, - NotifyFunc notify) override; + void SetResultCallback( + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc process_batch_capture_result) override; status_t AddPendingRequests( const std::vector<ProcessBlockRequest>& process_block_requests, diff --git a/common/hal/google_camera_hal/snapshot_result_processor.cc b/common/hal/google_camera_hal/snapshot_result_processor.cc index dd79daf..19dcd8e 100644 --- a/common/hal/google_camera_hal/snapshot_result_processor.cc +++ b/common/hal/google_camera_hal/snapshot_result_processor.cc @@ -14,7 +14,7 @@ * limitations under the License. */ -//#define LOG_NDEBUG 0 +// #define LOG_NDEBUG 0 #define LOG_TAG "GCH_SnapshotResultProcessor" #define ATRACE_TAG ATRACE_TAG_CAMERA #include "snapshot_result_processor.h" @@ -52,7 +52,8 @@ SnapshotResultProcessor::SnapshotResultProcessor( yuv_stream_id_ = yuv_stream_id; } void SnapshotResultProcessor::SetResultCallback( - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify) { + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc /*process_batch_capture_result*/) { ATRACE_CALL(); std::lock_guard<std::mutex> lock(callback_lock_); process_capture_result_ = process_capture_result; diff --git a/common/hal/google_camera_hal/snapshot_result_processor.h b/common/hal/google_camera_hal/snapshot_result_processor.h index 08ac23e..fbd976b 100644 --- a/common/hal/google_camera_hal/snapshot_result_processor.h +++ b/common/hal/google_camera_hal/snapshot_result_processor.h @@ -34,8 +34,9 @@ class SnapshotResultProcessor : public ResultProcessor { virtual ~SnapshotResultProcessor() = default; // Override functions of ResultProcessor start. - void SetResultCallback(ProcessCaptureResultFunc process_capture_result, - NotifyFunc notify) override; + void SetResultCallback( + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc process_batch_capture_result) override; status_t AddPendingRequests( const std::vector<ProcessBlockRequest>& process_block_requests, diff --git a/common/hal/google_camera_hal/zsl_snapshot_capture_session.cc b/common/hal/google_camera_hal/zsl_snapshot_capture_session.cc index f6e658a..d42a9e2 100644 --- a/common/hal/google_camera_hal/zsl_snapshot_capture_session.cc +++ b/common/hal/google_camera_hal/zsl_snapshot_capture_session.cc @@ -442,7 +442,8 @@ status_t ZslSnapshotCaptureSession::ConfigureStreams( __FUNCTION__); return UNKNOWN_ERROR; } - realtime_result_processor->SetResultCallback(process_capture_result, notify); + realtime_result_processor->SetResultCallback( + process_capture_result, notify, /*process_batch_capture_result=*/nullptr); res = process_block->SetResultProcessor(std::move(realtime_result_processor)); if (res != OK) { @@ -490,7 +491,9 @@ status_t ZslSnapshotCaptureSession::ConfigureStreams( return UNKNOWN_ERROR; } basic_result_processor_ = basic_result_processor.get(); - basic_result_processor->SetResultCallback(process_capture_result, notify); + basic_result_processor->SetResultCallback( + process_capture_result, notify, + /*process_batch_capture_result=*/nullptr); res = denoise_processor->SetResultProcessor(std::move(basic_result_processor)); @@ -603,7 +606,8 @@ status_t ZslSnapshotCaptureSession::SetupSnapshotProcessChain( res = snapshot_process_block_->SetResultProcessor( std::move(snapshot_result_processor)); - snapshot_result_processor_->SetResultCallback(process_capture_result, notify); + snapshot_result_processor_->SetResultCallback( + process_capture_result, notify, /*process_batch_capture_result=*/nullptr); res = ConfigureSnapshotStreams(stream_config); if (res != OK) { ALOGE("%s: Configuring snapshot stream failed: %s(%d)", __FUNCTION__, diff --git a/common/hal/hwl_interface/camera_device_session_hwl.h b/common/hal/hwl_interface/camera_device_session_hwl.h index c8094a5..ceeae59 100644 --- a/common/hal/hwl_interface/camera_device_session_hwl.h +++ b/common/hal/hwl_interface/camera_device_session_hwl.h @@ -73,6 +73,21 @@ class CameraDeviceSessionHwl { // NO_INIT. virtual status_t BuildPipelines() = 0; + // If the HAL buffer manager should be used for this session configuration. + // This should only be called after the pipelines have been configured. + // Otherwise this method will return NO_INIT. If the operation is not + // supported INVALID_OPERATION is returned. + // This is an hwl level method since the hwl layer can make the best decision + // about whether to use hal buffer manager for the session configured - since + // it has device specific context. + virtual status_t ShouldUseHalBufferManager(bool* result) { + if (result == nullptr) { + return BAD_VALUE; + } + *result = false; + return INVALID_OPERATION; + } + // Warm up pipeline to ready for taking request, this can be a NoOp for // implementation which doesn't support to put pipeline in standby mode // This call is optional for capture session before sending request. only @@ -189,6 +204,17 @@ class CameraDeviceSessionHwl { // caching of file descriptors done by the HWL. virtual void RemoveCachedBuffers(const native_handle_t* /*handle*/) { } + + void setConfigureStreamsV2(bool set) { + configure_streams_v2_ = set; + } + + bool configure_streams_v2() const { + return configure_streams_v2_; + } + + private: + bool configure_streams_v2_ = false; }; } // namespace google_camera_hal diff --git a/common/hal/hwl_interface/hwl_types.h b/common/hal/hwl_interface/hwl_types.h index 8168a7d..8017fef 100644 --- a/common/hal/hwl_interface/hwl_types.h +++ b/common/hal/hwl_interface/hwl_types.h @@ -17,6 +17,8 @@ #ifndef HARDWARE_GOOGLE_CAMERA_HAL_HWL_INTERFACE_HWL_TYPES_H_ #define HARDWARE_GOOGLE_CAMERA_HAL_HWL_INTERFACE_HWL_TYPES_H_ +#include <vector> + #include "hal_types.h" namespace android { @@ -81,6 +83,10 @@ struct HwlPipelineResult { using HwlProcessPipelineResultFunc = std::function<void(std::unique_ptr<HwlPipelineResult> /*result*/)>; +// Callback to invoke to send a batched result from HWL. +using HwlProcessPipelineBatchResultFunc = std::function<void( + std::vector<std::unique_ptr<HwlPipelineResult>> /*results*/)>; + // Callback to invoke to notify a message from HWL. using NotifyHwlPipelineMessageFunc = std::function<void( uint32_t /*pipeline_id*/, const NotifyMessage& /*message*/)>; @@ -90,6 +96,9 @@ struct HwlPipelineCallback { // Callback to notify when a HWL pipeline produces a capture result. HwlProcessPipelineResultFunc process_pipeline_result; + // Callback to notify when a HWL pipeline produces a batched capture result. + HwlProcessPipelineBatchResultFunc process_pipeline_batch_result; + // Callback to notify shutters or errors. NotifyHwlPipelineMessageFunc notify; }; diff --git a/common/hal/hwl_interface/result_processor.h b/common/hal/hwl_interface/result_processor.h index 28eef51..165f54d 100644 --- a/common/hal/hwl_interface/result_processor.h +++ b/common/hal/hwl_interface/result_processor.h @@ -36,8 +36,9 @@ class ResultProcessor { // Set the callbacks to send the finished results. Must be called before // calling ProcessResult. - virtual void SetResultCallback(ProcessCaptureResultFunc process_capture_result, - NotifyFunc notify) = 0; + virtual void SetResultCallback( + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc process_batch_capture_result) = 0; // Add pending requests to the result processor. // @@ -57,6 +58,13 @@ class ResultProcessor { // Called by a ProcessBlock to send the capture results. virtual void ProcessResult(ProcessBlockResult block_result) = 0; + // Called by a ProcessBlock to send the batched capture results. + virtual void ProcessBatchResult(std::vector<ProcessBlockResult> block_results) { + for (auto& result : block_results) { + ProcessResult(std::move(result)); + } + } + // Called by a ProcessBlock to notify a message. virtual void Notify(const ProcessBlockNotifyMessage& block_message) = 0; diff --git a/common/hal/tests/Android.bp b/common/hal/tests/Android.bp index 16c943d..79d5a36 100644 --- a/common/hal/tests/Android.bp +++ b/common/hal/tests/Android.bp @@ -55,9 +55,6 @@ cc_library { ], shared_libs: [ "android.hardware.camera.provider@2.4", - "android.hardware.graphics.mapper@2.0", - "android.hardware.graphics.mapper@3.0", - "android.hardware.graphics.mapper@4.0", "lib_profiler", "libcamera_metadata", "libcutils", @@ -95,9 +92,6 @@ cc_test { "libgooglecamerahal", "libgooglecamerahalutils", "android.hardware.camera.provider@2.4", - "android.hardware.graphics.mapper@2.0", - "android.hardware.graphics.mapper@3.0", - "android.hardware.graphics.mapper@4.0", "libcamera_metadata", "libcutils", "libhardware", diff --git a/common/hal/tests/camera_device_session_tests.cc b/common/hal/tests/camera_device_session_tests.cc index 75682a2..fba6116 100644 --- a/common/hal/tests/camera_device_session_tests.cc +++ b/common/hal/tests/camera_device_session_tests.cc @@ -359,7 +359,10 @@ TEST_F(CameraDeviceSessionTests, ConfigurePreviewStream) { for (auto& resolution : preview_resolutions) { test_utils::GetPreviewOnlyStreamConfiguration( &preview_config, resolution.first, resolution.second); - res = session->ConfigureStreams(preview_config, &hal_configured_streams); + ConfigureStreamsReturn hal_config; + res = session->ConfigureStreams(preview_config, /*interfaceV3*/ false, + &hal_config); + hal_configured_streams = std::move(hal_config.hal_streams); EXPECT_EQ(res, OK); } } @@ -408,8 +411,11 @@ TEST_F(CameraDeviceSessionTests, PreviewRequests) { test_utils::GetPreviewOnlyStreamConfiguration(&preview_config, kPreviewWidth, kPreviewHeight); - ASSERT_EQ(session->ConfigureStreams(preview_config, &hal_configured_streams), + ConfigureStreamsReturn hal_config; + ASSERT_EQ(session->ConfigureStreams(preview_config, /*interfaceV3*/ false, + &hal_config), OK); + hal_configured_streams = std::move(hal_config.hal_streams); ASSERT_EQ(hal_configured_streams.size(), static_cast<uint32_t>(1)); // Allocate buffers. diff --git a/common/hal/tests/mock_result_processor.h b/common/hal/tests/mock_result_processor.h index fdf36cf..e3ed279 100644 --- a/common/hal/tests/mock_result_processor.h +++ b/common/hal/tests/mock_result_processor.h @@ -26,9 +26,10 @@ namespace google_camera_hal { // Defines a ResultProcessor mock using gmock. class MockResultProcessor : public ResultProcessor { public: - MOCK_METHOD2(SetResultCallback, + MOCK_METHOD3(SetResultCallback, void(ProcessCaptureResultFunc process_capture_result, - NotifyFunc notify)); + NotifyFunc notify, + ProcessBatchCaptureResultFunc process_batch_capture_result)); MOCK_METHOD2( AddPendingRequests, diff --git a/common/hal/tests/result_processor_tests.cc b/common/hal/tests/result_processor_tests.cc index 51b2bd7..341b41b 100644 --- a/common/hal/tests/result_processor_tests.cc +++ b/common/hal/tests/result_processor_tests.cc @@ -15,9 +15,9 @@ */ #define LOG_TAG "ResultProcessorTest" +#include <gtest/gtest.h> #include <log/log.h> -#include <gtest/gtest.h> #include <memory> #include "basic_result_processor.h" @@ -59,7 +59,9 @@ TEST(ResultProcessorTest, SetResultCallback) { ASSERT_NE(result_processor, nullptr) << "Creating a result processor failed"; - result_processor->SetResultCallback(process_capture_result, notify); + result_processor->SetResultCallback( + process_capture_result, notify, + /*process_batch_capture_result=*/nullptr); } } @@ -116,7 +118,9 @@ TEST(ResultProcessorTest, ProcessResultAndNotify) { SendResultsAndMessages(result_processor.get()); // Test again after setting result callback. - result_processor->SetResultCallback(process_capture_result, notify); + result_processor->SetResultCallback( + process_capture_result, notify, + /*process_batch_capture_result=*/nullptr); SendResultsAndMessages(result_processor.get()); } } @@ -135,7 +139,8 @@ TEST(ResultProcessorTest, BasicResultProcessorResultAndNotify) { NotifyFunc notify = NotifyFunc( [&](const NotifyMessage& /*message*/) { message_received = true; }); - result_processor->SetResultCallback(process_capture_result, notify); + result_processor->SetResultCallback(process_capture_result, notify, + /*process_batch_capture_result=*/nullptr); ProcessBlockResult null_result; result_processor->ProcessResult(std::move(null_result)); @@ -165,7 +170,8 @@ TEST(ResultProcessorTest, BasicResultProcessorAddPendingRequest) { NotifyFunc notify = NotifyFunc([&](const NotifyMessage& /*message*/) {}); - result_processor->SetResultCallback(process_capture_result, notify); + result_processor->SetResultCallback(process_capture_result, notify, + /*process_batch_capture_result=*/nullptr); std::vector<ProcessBlockRequest> requests(1); requests[0].request.output_buffers = {StreamBuffer{}}; diff --git a/common/hal/utils/hdrplus_result_processor.cc b/common/hal/utils/hdrplus_result_processor.cc index b1747ef..ba08bb4 100644 --- a/common/hal/utils/hdrplus_result_processor.cc +++ b/common/hal/utils/hdrplus_result_processor.cc @@ -14,16 +14,16 @@ * limitations under the License. */ -//#define LOG_NDEBUG 0 +// #define LOG_NDEBUG 0 #define LOG_TAG "GCH_HdrplusResultProcessor" #define ATRACE_TAG ATRACE_TAG_CAMERA -#include <log/log.h> -#include <utils/Trace.h> +#include "hdrplus_result_processor.h" #include <inttypes.h> +#include <log/log.h> +#include <utils/Trace.h> #include "hal_utils.h" -#include "hdrplus_result_processor.h" namespace android { namespace google_camera_hal { @@ -52,7 +52,8 @@ HdrplusResultProcessor::HdrplusResultProcessor( raw_stream_id_ = raw_stream_id; } void HdrplusResultProcessor::SetResultCallback( - ProcessCaptureResultFunc process_capture_result, NotifyFunc notify) { + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc /*process_batch_capture_result*/) { ATRACE_CALL(); std::lock_guard<std::mutex> lock(callback_lock_); process_capture_result_ = process_capture_result; diff --git a/common/hal/utils/hdrplus_result_processor.h b/common/hal/utils/hdrplus_result_processor.h index e6062a5..6719eb9 100644 --- a/common/hal/utils/hdrplus_result_processor.h +++ b/common/hal/utils/hdrplus_result_processor.h @@ -34,8 +34,9 @@ class HdrplusResultProcessor : public ResultProcessor { virtual ~HdrplusResultProcessor() = default; // Override functions of ResultProcessor start. - void SetResultCallback(ProcessCaptureResultFunc process_capture_result, - NotifyFunc notify) override; + void SetResultCallback( + ProcessCaptureResultFunc process_capture_result, NotifyFunc notify, + ProcessBatchCaptureResultFunc process_batch_capture_result) override; status_t AddPendingRequests( const std::vector<ProcessBlockRequest>& process_block_requests, diff --git a/common/hal/utils/realtime_process_block.cc b/common/hal/utils/realtime_process_block.cc index d082886..d5679be 100644 --- a/common/hal/utils/realtime_process_block.cc +++ b/common/hal/utils/realtime_process_block.cc @@ -65,6 +65,12 @@ RealtimeProcessBlock::RealtimeProcessBlock( NotifyHwlPipelineResult(std::move(result)); }); + hwl_pipeline_callback_.process_pipeline_batch_result = + HwlProcessPipelineBatchResultFunc( + [this](std::vector<std::unique_ptr<HwlPipelineResult>> results) { + NotifyHwlPipelineBatchResult(std::move(results)); + }); + hwl_pipeline_callback_.notify = NotifyHwlPipelineMessageFunc( [this](uint32_t pipeline_id, const NotifyMessage& message) { NotifyHwlPipelineMessage(pipeline_id, message); @@ -203,6 +209,31 @@ void RealtimeProcessBlock::NotifyHwlPipelineResult( result_processor_->ProcessResult(std::move(result)); } +void RealtimeProcessBlock::NotifyHwlPipelineBatchResult( + std::vector<std::unique_ptr<HwlPipelineResult>> hwl_results) { + ATRACE_CALL(); + std::lock_guard<std::mutex> lock(result_processor_lock_); + if (result_processor_ == nullptr) { + ALOGE("%s: result processor is nullptr. Dropping a result", __FUNCTION__); + return; + } + + std::vector<ProcessBlockResult> block_results; + block_results.reserve(hwl_results.size()); + for (auto& hwl_result : hwl_results) { + auto capture_result = + hal_utils::ConvertToCaptureResult(std::move(hwl_result)); + if (capture_result == nullptr) { + ALOGE("%s: Converting to capture result failed.", __FUNCTION__); + return; + } + + block_results.push_back( + ProcessBlockResult{.result = std::move(capture_result)}); + } + result_processor_->ProcessBatchResult(std::move(block_results)); +} + void RealtimeProcessBlock::NotifyHwlPipelineMessage( uint32_t /*pipeline_id*/, const NotifyMessage& message) { ATRACE_CALL(); diff --git a/common/hal/utils/realtime_process_block.h b/common/hal/utils/realtime_process_block.h index b1fcf6c..e2eb90f 100644 --- a/common/hal/utils/realtime_process_block.h +++ b/common/hal/utils/realtime_process_block.h @@ -18,6 +18,7 @@ #define HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_REALTIME_PROCESS_BLOCK_H_ #include <shared_mutex> +#include <vector> #include "process_block.h" @@ -68,6 +69,10 @@ class RealtimeProcessBlock : public ProcessBlock { // Invoked when the HWL pipeline sends a result. void NotifyHwlPipelineResult(std::unique_ptr<HwlPipelineResult> hwl_result); + // Invoked when the HWL pipeline sends a batched result. + void NotifyHwlPipelineBatchResult( + std::vector<std::unique_ptr<HwlPipelineResult>> hwl_results); + // Invoked when the HWL pipeline sends a message. void NotifyHwlPipelineMessage(uint32_t pipeline_id, const NotifyMessage& message); diff --git a/common/hal/utils/utils.cc b/common/hal/utils/utils.cc index b9efc80..f2d8122 100644 --- a/common/hal/utils/utils.cc +++ b/common/hal/utils/utils.cc @@ -38,15 +38,16 @@ namespace { using FpsRange = std::pair<int32_t, int32_t>; +static const std::vector<std::pair<FpsRange, FpsRange>> kAcceptableTransitions = { + std::make_pair<FpsRange, FpsRange>({2, 2}, {12, 12}), + std::make_pair<FpsRange, FpsRange>({12, 12}, {30, 30}), + std::make_pair<FpsRange, FpsRange>({30, 30}, {60, 60}), + std::make_pair<FpsRange, FpsRange>({24, 24}, {24, 30}), + std::make_pair<FpsRange, FpsRange>({24, 24}, {30, 30}), +}; + bool IsAcceptableThrottledFpsChange(const FpsRange& old_fps, const FpsRange& new_fps) { - // We allow smooth transitions between [30,30] to [60,60] and [24,24] and [24,30]. - constexpr std::array<std::pair<FpsRange, FpsRange>, 3> kAcceptableTransitions = { - std::make_pair<FpsRange, FpsRange>({30, 30}, {60, 60}), - std::make_pair<FpsRange, FpsRange>({24, 24}, {24, 30}), - std::make_pair<FpsRange, FpsRange>({24, 24}, {30, 30}), - }; - for (const std::pair<FpsRange, FpsRange>& range : kAcceptableTransitions) { // We don't care about the direction of the transition. if ((old_fps == range.first && new_fps == range.second) || @@ -54,7 +55,6 @@ bool IsAcceptableThrottledFpsChange(const FpsRange& old_fps, return true; } } - return false; } } // namespace @@ -430,9 +430,9 @@ bool IsSessionParameterCompatible(const HalCameraMetadata* old_session, if (old_max_fps == new_max_fps || ignore_fps_range_diff) { ALOGI( "%s: Ignore fps (%d, %d) to (%d, %d). " - "video_60_to_30fps_thermal_throttle: %u", + "video_60_to_30fps_thermal_throttle: %u. video_fps_throttle: %u.", __FUNCTION__, old_min_fps, old_max_fps, new_min_fps, new_max_fps, - video_60_to_30fps_thermal_throttle); + video_60_to_30fps_thermal_throttle, video_fps_throttle); continue; } diff --git a/common/profiler/profiler.cc b/common/profiler/profiler.cc index 689ef35..c090ab2 100644 --- a/common/profiler/profiler.cc +++ b/common/profiler/profiler.cc @@ -21,7 +21,6 @@ #include <sys/stat.h> #include <fstream> -#include <list> #include <mutex> #include <unordered_map> #include <vector> @@ -95,7 +94,7 @@ class ProfilerImpl : public Profiler { void SetFpsPrintInterval(int32_t interval_seconds) override final; // Get the latency associated with the name - std::list<std::pair<std::string, float>> GetLatencyData() override final; + std::vector<LatencyEvent> GetLatencyData() override final; std::string GetUseCase() const override final { return use_case_; @@ -111,6 +110,11 @@ class ProfilerImpl : public Profiler { int32_t request_id = 0; }; + struct TimeSlotEvent { + std::string name; + TimeSlot slot; + }; + // A structure to store node's profiling result. struct TimeResult { std::string node_name; @@ -499,9 +503,9 @@ void ProfilerImpl::DumpPb(std::string_view filepath) { } // Get the latency associated with the name -std::list<std::pair<std::string, float>> ProfilerImpl::GetLatencyData() { - std::list<std::pair<std::string, TimeSlot>> time_results; - std::list<std::pair<std::string, float>> latency_data; +std::vector<Profiler::LatencyEvent> ProfilerImpl::GetLatencyData() { + std::vector<TimeSlotEvent> time_results; + std::vector<LatencyEvent> latency_data; for (const auto& [node_name, time_series] : timing_map_) { for (const auto& slot : time_series) { if (slot.count > 0 && time_results.size() < time_results.max_size()) { @@ -509,8 +513,9 @@ std::list<std::pair<std::string, float>> ProfilerImpl::GetLatencyData() { } } } - time_results.sort( - [](const auto& a, const auto& b) { return a.second.end < b.second.end; }); + std::sort( + time_results.begin(), time_results.end(), + [](const auto& a, const auto& b) { return a.slot.end < b.slot.end; }); for (const auto& [node_name, slot] : time_results) { if (slot.count > 0) { @@ -549,7 +554,7 @@ class ProfilerStopwatchImpl : public ProfilerImpl { ALOGI("Profiling Case: %s", use_case_.c_str()); // Sort by end time. - std::list<std::pair<std::string, TimeSlot>> time_results; + std::vector<TimeSlotEvent> time_results; for (const auto& [node_name, time_series] : timing_map_) { for (const auto& slot : time_series) { if (slot.count > 0 && time_results.size() < time_results.max_size()) { @@ -557,9 +562,9 @@ class ProfilerStopwatchImpl : public ProfilerImpl { } } } - time_results.sort([](const auto& a, const auto& b) { - return a.second.end < b.second.end; - }); + std::sort( + time_results.begin(), time_results.end(), + [](const auto& a, const auto& b) { return a.slot.end < b.slot.end; }); for (const auto& [node_name, slot] : time_results) { if (slot.count > 0) { @@ -598,7 +603,7 @@ class ProfilerDummy : public Profiler { void PrintResult() override final{}; void ProfileFrameRate(const std::string&) override final{}; void SetFpsPrintInterval(int32_t) override final{}; - std::list<std::pair<std::string, float>> GetLatencyData() override final { + std::vector<LatencyEvent> GetLatencyData() override final { return {}; } std::string GetUseCase() const override final { diff --git a/common/profiler/profiler.h b/common/profiler/profiler.h index 8788e59..152a116 100644 --- a/common/profiler/profiler.h +++ b/common/profiler/profiler.h @@ -20,9 +20,9 @@ #include <cutils/properties.h> #include <limits> -#include <list> #include <memory> #include <string> +#include <vector> namespace google { namespace camera_common { @@ -150,6 +150,11 @@ class Profiler { virtual ~Profiler() = default; + struct LatencyEvent { + std::string name; + float duration; + }; + // adb setprop options. enum SetPropFlag { kDisable = 0, @@ -208,7 +213,7 @@ class Profiler { // The interval unit is second and interval_seconds must >= 1 virtual void SetFpsPrintInterval(int32_t interval_seconds) = 0; - virtual std::list<std::pair<std::string, float>> GetLatencyData() = 0; + virtual std::vector<LatencyEvent> GetLatencyData() = 0; virtual std::string GetUseCase() const = 0; diff --git a/devices/EmulatedCamera/hwl/Android.bp b/devices/EmulatedCamera/hwl/Android.bp index fad5ef0..b452a70 100644 --- a/devices/EmulatedCamera/hwl/Android.bp +++ b/devices/EmulatedCamera/hwl/Android.bp @@ -46,6 +46,7 @@ cc_defaults { "libjsoncpp", "liblog", "libsync", + "libui", "libutils", "libyuv", ], diff --git a/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.cpp b/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.cpp index 93cbe57..6ad921d 100644 --- a/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.cpp +++ b/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.cpp @@ -32,7 +32,6 @@ namespace android { -using google_camera_hal::Rect; using google_camera_hal::utils::GetSensorActiveArraySize; using google_camera_hal::utils::HasCapability; @@ -106,7 +105,7 @@ EmulatedCameraDeviceSessionHwlImpl::Create( static std::pair<Dimension, Dimension> GetArrayDimensions( uint32_t camera_id, const HalCameraMetadata* metadata) { - Rect active_array_size; + google_camera_hal::Rect active_array_size; Dimension active_array_size_dimension; Dimension active_array_size_dimension_maximum_resolution; status_t ret = GetSensorActiveArraySize(metadata, &active_array_size); @@ -170,6 +169,14 @@ status_t EmulatedCameraDeviceSessionHwlImpl::Initialize( return ret; } + ret = SupportsSessionHalBufManager(static_metadata_.get(), + &supports_session_hal_buf_manager_); + if (ret != OK) { + ALOGE("%s: Unable to get sensor hal buffer manager support %s (%d)", + __FUNCTION__, strerror(-ret), ret); + return ret; + } + logical_chars_.emplace(camera_id_, sensor_chars_); for (const auto& it : *physical_device_map_) { SensorCharacteristics physical_chars; @@ -374,6 +381,27 @@ status_t EmulatedCameraDeviceSessionHwlImpl::BuildPipelines() { return OK; } +status_t EmulatedCameraDeviceSessionHwlImpl::ShouldUseHalBufferManager( + bool* result) { + if (result == nullptr) { + ALOGE("%s result is nullptr", __FUNCTION__); + return BAD_VALUE; + } + *result = false; + if (!pipelines_built_) { + ALOGE("%s: Pipelines haven't been built yet", __FUNCTION__); + return INVALID_OPERATION; + } + if (!supports_session_hal_buf_manager_) { + return OK; + } + // Heuristic which doesn't necessarily correspond to real scenarios + if (pipelines_.size() >= 1 && pipelines_[0].streams.size() >= 2) { + *result = true; + } + return OK; +} + void EmulatedCameraDeviceSessionHwlImpl::DestroyPipelines() { ATRACE_CALL(); std::lock_guard<std::mutex> lock(api_mutex_); diff --git a/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.h b/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.h index 81631cf..06c3609 100644 --- a/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.h +++ b/devices/EmulatedCamera/hwl/EmulatedCameraDeviceSessionHWLImpl.h @@ -103,6 +103,8 @@ class EmulatedCameraDeviceSessionHwlImpl : public CameraDeviceSessionHwl { status_t BuildPipelines() override; + status_t ShouldUseHalBufferManager(bool* result) override; + status_t PreparePipeline(uint32_t /*pipeline_id*/, uint32_t /*frame_number*/) override { return OK; @@ -202,6 +204,7 @@ class EmulatedCameraDeviceSessionHwlImpl : public CameraDeviceSessionHwl { bool error_state_ = false; bool pipelines_built_ = false; bool has_raw_stream_ = false; + bool supports_session_hal_buf_manager_ = false; std::unique_ptr<HalCameraMetadata> static_metadata_; std::vector<EmulatedPipeline> pipelines_; std::shared_ptr<EmulatedRequestProcessor> request_processor_; diff --git a/devices/EmulatedCamera/hwl/EmulatedCameraProviderHWLImpl.cpp b/devices/EmulatedCamera/hwl/EmulatedCameraProviderHWLImpl.cpp index d4fae3e..7eb7743 100644 --- a/devices/EmulatedCamera/hwl/EmulatedCameraProviderHWLImpl.cpp +++ b/devices/EmulatedCamera/hwl/EmulatedCameraProviderHWLImpl.cpp @@ -35,11 +35,14 @@ namespace android { // Location of the camera configuration files. -constexpr std::string_view kConfigurationFileNames[] = { - "emu_camera_back.json", - "emu_camera_front.json", - "emu_camera_depth.json", -}; +constexpr std::string_view kCameraConfigBack = "emu_camera_back.json"; +constexpr std::string_view kCameraConfigFront = "emu_camera_front.json"; +constexpr std::string_view kCameraConfigExternal = "emu_camera_external.json"; +constexpr std::string_view kCameraConfigDepth = "emu_camera_depth.json"; +constexpr std::string_view kCameraConfigFiles[] = { + kCameraConfigBack, kCameraConfigFront, kCameraConfigExternal, + kCameraConfigDepth}; + constexpr std::string_view kConfigurationFileDirVendor = "/vendor/etc/config/"; constexpr std::string_view kConfigurationFileDirApex = "/apex/com.google.emulated.camera.provider.hal/etc/config/"; @@ -711,8 +714,17 @@ status_t EmulatedCameraProviderHwlImpl::Initialize() { } char prop[PROPERTY_VALUE_MAX]; if (!property_get_bool("ro.boot.qemu", false)) { - for (const auto& iter : kConfigurationFileNames) { - config_file_locations.emplace_back(config_dir + iter.data()); + // Cuttlefish + property_get("ro.vendor.camera.config", prop, nullptr); + if (strcmp(prop, "external") == 0) { + config_file_locations.emplace_back(config_dir + + kCameraConfigExternal.data()); + logical_id = 1; + } else { + // Default phone layout. + config_file_locations.emplace_back(config_dir + kCameraConfigBack.data()); + config_file_locations.emplace_back(config_dir + kCameraConfigFront.data()); + config_file_locations.emplace_back(config_dir + kCameraConfigDepth.data()); } } else { // Android Studio Emulator @@ -721,22 +733,22 @@ status_t EmulatedCameraProviderHwlImpl::Initialize() { property_get("vendor.qemu.sf.fake_camera", prop, nullptr); if (strcmp(prop, "both") == 0) { config_file_locations.emplace_back(config_dir + - kConfigurationFileNames[0].data()); + kCameraConfigBack.data()); config_file_locations.emplace_back(config_dir + - kConfigurationFileNames[1].data()); + kCameraConfigFront.data()); } else if (strcmp(prop, "front") == 0) { config_file_locations.emplace_back(config_dir + - kConfigurationFileNames[1].data()); + kCameraConfigFront.data()); logical_id = 1; } else if (strcmp(prop, "back") == 0) { config_file_locations.emplace_back(config_dir + - kConfigurationFileNames[0].data()); + kCameraConfigBack.data()); logical_id = 1; } } } } - static_metadata_.resize(ARRAY_SIZE(kConfigurationFileNames)); + static_metadata_.resize(ARRAY_SIZE(kCameraConfigFiles)); for (const auto& config_path : config_file_locations) { if (!android::base::ReadFileToString(config_path, &config)) { diff --git a/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.cpp b/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.cpp index 0195c95..cd3c136 100644 --- a/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.cpp +++ b/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.cpp @@ -99,9 +99,15 @@ void EmulatedLogicalRequestState::UpdateActivePhysicalId( std::unique_ptr<HwlPipelineResult> EmulatedLogicalRequestState::InitializeLogicalResult(uint32_t pipeline_id, - uint32_t frame_number) { - auto ret = logical_request_state_->InitializeResult(pipeline_id, frame_number); - if (is_logical_device_) { + uint32_t frame_number, + bool is_partial_result) { + auto ret = + is_partial_result + ? logical_request_state_->InitializePartialResult(pipeline_id, + frame_number) + : logical_request_state_->InitializeResult(pipeline_id, frame_number); + + if (is_logical_device_ && !is_partial_result) { if ((physical_camera_output_ids_.get() != nullptr) && (!physical_camera_output_ids_->empty())) { ret->physical_camera_results.reserve(physical_camera_output_ids_->size()); diff --git a/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.h b/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.h index dcf1595..77f8955 100644 --- a/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.h +++ b/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.h @@ -68,7 +68,7 @@ class EmulatedLogicalRequestState { std::unique_ptr<HalCameraMetadata>* default_settings /*out*/); std::unique_ptr<HwlPipelineResult> InitializeLogicalResult( - uint32_t pipeline_id, uint32_t frame_number); + uint32_t pipeline_id, uint32_t frame_number, bool is_partial_result); status_t InitializeLogicalSettings( std::unique_ptr<HalCameraMetadata> request_settings, diff --git a/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.cpp b/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.cpp index ef57437..536b423 100644 --- a/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.cpp +++ b/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.cpp @@ -298,7 +298,7 @@ status_t EmulatedRequestProcessor::LockSensorBuffer( bool isP010 = static_cast<android_pixel_format_v1_1_t>( stream.override_format) == HAL_PIXEL_FORMAT_YCBCR_P010; if ((isYUV_420_888) || (isP010)) { - IMapper::Rect map_rect = {0, 0, width, height}; + android::Rect map_rect = {0, 0, width, height}; auto yuv_layout = importer_->lockYCbCr(buffer, usage, map_rect); if ((yuv_layout.y != nullptr) && (yuv_layout.cb != nullptr) && (yuv_layout.cr != nullptr)) { @@ -308,17 +308,18 @@ status_t EmulatedRequestProcessor::LockSensorBuffer( static_cast<uint8_t*>(yuv_layout.cb); sensor_buffer->plane.img_y_crcb.img_cr = static_cast<uint8_t*>(yuv_layout.cr); - sensor_buffer->plane.img_y_crcb.y_stride = yuv_layout.yStride; - sensor_buffer->plane.img_y_crcb.cbcr_stride = yuv_layout.cStride; - sensor_buffer->plane.img_y_crcb.cbcr_step = yuv_layout.chromaStep; - if (isYUV_420_888 && (yuv_layout.chromaStep == 2) && + sensor_buffer->plane.img_y_crcb.y_stride = yuv_layout.ystride; + sensor_buffer->plane.img_y_crcb.cbcr_stride = yuv_layout.cstride; + sensor_buffer->plane.img_y_crcb.cbcr_step = yuv_layout.chroma_step; + if (isYUV_420_888 && (yuv_layout.chroma_step == 2) && std::abs(sensor_buffer->plane.img_y_crcb.img_cb - sensor_buffer->plane.img_y_crcb.img_cr) != 1) { - ALOGE("%s: Unsupported YUV layout, chroma step: %u U/V plane delta: %u", - __FUNCTION__, yuv_layout.chromaStep, - static_cast<unsigned>( - std::abs(sensor_buffer->plane.img_y_crcb.img_cb - - sensor_buffer->plane.img_y_crcb.img_cr))); + ALOGE( + "%s: Unsupported YUV layout, chroma step: %zu U/V plane delta: %u", + __FUNCTION__, yuv_layout.chroma_step, + static_cast<unsigned>( + std::abs(sensor_buffer->plane.img_y_crcb.img_cb - + sensor_buffer->plane.img_y_crcb.img_cr))); return BAD_VALUE; } sensor_buffer->plane.img_y_crcb.bytesPerPixel = isP010 ? 2 : 1; @@ -338,7 +339,7 @@ status_t EmulatedRequestProcessor::LockSensorBuffer( sensor_buffer->plane.img.img = static_cast<uint8_t*>(importer_->lock(buffer, usage, buffer_size)); } else { - IMapper::Rect region{0, 0, width, height}; + android::Rect region{0, 0, width, height}; sensor_buffer->plane.img.img = static_cast<uint8_t*>(importer_->lock(buffer, usage, region)); } @@ -492,8 +493,12 @@ void EmulatedRequestProcessor::RequestProcessorLoop() { } if (ret == OK) { - auto result = request_state_->InitializeLogicalResult(pipeline_id, - frame_number); + auto partial_result = request_state_->InitializeLogicalResult( + pipeline_id, frame_number, + /*partial result*/ true); + auto result = request_state_->InitializeLogicalResult( + pipeline_id, frame_number, + /*partial result*/ false); // The screen rotation will be the same for all logical and physical devices uint32_t screen_rotation = screen_rotation_; for (auto it = logical_settings->begin(); @@ -503,7 +508,8 @@ void EmulatedRequestProcessor::RequestProcessorLoop() { sensor_->SetCurrentRequest( std::move(logical_settings), std::move(result), - std::move(input_buffers), std::move(output_buffers)); + std::move(partial_result), std::move(input_buffers), + std::move(output_buffers)); } else { NotifyMessage msg{.type = MessageType::kError, .message.error = { diff --git a/devices/EmulatedCamera/hwl/EmulatedRequestState.cpp b/devices/EmulatedCamera/hwl/EmulatedRequestState.cpp index b79f8fa..ff6ed12 100644 --- a/devices/EmulatedCamera/hwl/EmulatedRequestState.cpp +++ b/devices/EmulatedCamera/hwl/EmulatedRequestState.cpp @@ -735,6 +735,20 @@ status_t EmulatedRequestState::InitializeSensorSettings( } } + // Check manual flash strength level + ret = request_settings_->Get(ANDROID_FLASH_STRENGTH_LEVEL, &entry); + if ((ret == OK) && (entry.count == 1)) { + flash_strength_level_ = entry.data.i32[0]; + if (ANDROID_FLASH_SINGLE_STRENGTH_MAX_LEVEL > 1 && + ANDROID_FLASH_TORCH_STRENGTH_MAX_LEVEL > 1 && is_flash_supported_) { + ALOGI("%s: Device supports manual flash strength control", __FUNCTION__); + flash_strength_level_ = entry.data.i32[0]; + } else { + ALOGI("%s: Device does not support manual flash strength control", __FUNCTION__); + return BAD_VALUE; + } + } + // Check video stabilization parameter uint8_t edge_mode = ANDROID_EDGE_MODE_OFF; ret = request_settings_->Get(ANDROID_EDGE_MODE, &entry); @@ -849,6 +863,15 @@ status_t EmulatedRequestState::InitializeSensorSettings( } } + ret = static_metadata_->Get(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE, &entry); + if ((ret == OK) && (entry.count == 1)) { + if (entry.data.u8[0] == ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME) { + timestamp_source_ = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME; + } else if (entry.data.u8[0] != ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN) { + ALOGE("%s: Unsupported timestamp source", __FUNCTION__); + } + } + sensor_settings->exposure_time = sensor_exposure_time_; sensor_settings->frame_duration = sensor_frame_duration_; sensor_settings->gain = sensor_sensitivity_; @@ -864,12 +887,41 @@ status_t EmulatedRequestState::InitializeSensorSettings( sensor_settings->edge_mode = edge_mode; sensor_settings->sensor_pixel_mode = sensor_pixel_mode_; sensor_settings->test_pattern_mode = test_pattern_mode; + sensor_settings->timestamp_source = timestamp_source_; memcpy(sensor_settings->test_pattern_data, test_pattern_data, sizeof(sensor_settings->test_pattern_data)); return OK; } +uint32_t EmulatedRequestState::GetPartialResultCount(bool is_partial_result) { + uint32_t res = 0; + + if (is_partial_result) { + res = 1; + } else { + res = partial_result_count ? partial_result_count : 1; + } + + return res; +} + +std::unique_ptr<HwlPipelineResult> EmulatedRequestState::InitializePartialResult( + uint32_t pipeline_id, uint32_t frame_number) { + std::lock_guard<std::mutex> lock(request_state_mutex_); + auto result = std::make_unique<HwlPipelineResult>(); + + if (partial_result_count > 1) { + result->camera_id = camera_id_; + result->pipeline_id = pipeline_id; + result->frame_number = frame_number; + result->result_metadata = HalCameraMetadata::Create(0, 0); + result->partial_result = GetPartialResultCount(/*is partial result*/ true); + } + + return result; +} + std::unique_ptr<HwlPipelineResult> EmulatedRequestState::InitializeResult( uint32_t pipeline_id, uint32_t frame_number) { std::lock_guard<std::mutex> lock(request_state_mutex_); @@ -878,7 +930,7 @@ std::unique_ptr<HwlPipelineResult> EmulatedRequestState::InitializeResult( result->pipeline_id = pipeline_id; result->frame_number = frame_number; result->result_metadata = HalCameraMetadata::Clone(request_settings_.get()); - result->partial_result = partial_result_count_; + result->partial_result = GetPartialResultCount(/*is partial result*/ false); // Results supported on all emulated devices result->result_metadata->Set(ANDROID_REQUEST_PIPELINE_DEPTH, @@ -957,14 +1009,20 @@ std::unique_ptr<HwlPipelineResult> EmulatedRequestState::InitializeResult( if (report_exposure_time_) { result->result_metadata->Set(ANDROID_SENSOR_EXPOSURE_TIME, &sensor_exposure_time_, 1); + } else { + result->result_metadata->Erase(ANDROID_SENSOR_EXPOSURE_TIME); } if (report_frame_duration_) { result->result_metadata->Set(ANDROID_SENSOR_FRAME_DURATION, &sensor_frame_duration_, 1); + } else { + result->result_metadata->Erase(ANDROID_SENSOR_FRAME_DURATION); } if (report_sensitivity_) { result->result_metadata->Set(ANDROID_SENSOR_SENSITIVITY, &sensor_sensitivity_, 1); + } else { + result->result_metadata->Erase(ANDROID_SENSOR_SENSITIVITY); } if (report_rolling_shutter_skew_) { result->result_metadata->Set( @@ -1006,6 +1064,11 @@ std::unique_ptr<HwlPipelineResult> EmulatedRequestState::InitializeResult( intrinsic_calibration_, ARRAY_SIZE(intrinsic_calibration_)); } + if (report_lens_intrinsics_samples_) { + result->result_metadata->Set(ANDROID_STATISTICS_LENS_INTRINSIC_SAMPLES, + intrinsic_calibration_, + ARRAY_SIZE(intrinsic_calibration_)); + } if (report_distortion_) { result->result_metadata->Set(ANDROID_LENS_DISTORTION, distortion_, ARRAY_SIZE(distortion_)); @@ -1026,6 +1089,11 @@ std::unique_ptr<HwlPipelineResult> EmulatedRequestState::InitializeResult( } result->result_metadata->Set(ANDROID_SCALER_CROP_REGION, chosen_crop_region, ARRAY_SIZE(scaler_crop_region_default_)); + if (report_active_sensor_crop_) { + result->result_metadata->Set( + ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION, + chosen_crop_region, ARRAY_SIZE(scaler_crop_region_default_)); + } } if (report_extended_scene_mode_) { result->result_metadata->Set(ANDROID_CONTROL_EXTENDED_SCENE_MODE, @@ -1282,6 +1350,11 @@ status_t EmulatedRequestState::InitializeStatisticsDefaults() { return BAD_VALUE; } + report_lens_intrinsics_samples_ = + (available_results_.find(ANDROID_STATISTICS_LENS_INTRINSIC_SAMPLES) != + available_results_.end()) && + (available_results_.find(ANDROID_STATISTICS_LENS_INTRINSIC_TIMESTAMPS) != + available_results_.end()); report_scene_flicker_ = available_results_.find(ANDROID_STATISTICS_SCENE_FLICKER) != available_results_.end(); @@ -2374,6 +2447,12 @@ status_t EmulatedRequestState::InitializeScalerDefaults() { __FUNCTION__); return BAD_VALUE; } + + if (available_requests_.find( + ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION) != + available_results_.end()) { + report_active_sensor_crop_ = true; + } ret = static_metadata_->Get(ANDROID_SCALER_AVAILABLE_ROTATE_AND_CROP_MODES, &entry); if ((ret == OK) && (entry.count > 0)) { @@ -2849,9 +2928,11 @@ status_t EmulatedRequestState::InitializeRequestDefaults() { ret = static_metadata_->Get(ANDROID_REQUEST_PARTIAL_RESULT_COUNT, &entry); if ((ret == OK) && (entry.count == 1)) { - if (entry.data.i32[0] != 1) { - ALOGW("%s: Partial results not supported!", __FUNCTION__); + if (entry.data.i32[0] > 2) { + ALOGW("%s: Partial result count greater than 2 not supported!", + __FUNCTION__); } + partial_result_count = entry.data.i32[0]; } ret = static_metadata_->Get(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, diff --git a/devices/EmulatedCamera/hwl/EmulatedRequestState.h b/devices/EmulatedCamera/hwl/EmulatedRequestState.h index 3af793e..79ad968 100644 --- a/devices/EmulatedCamera/hwl/EmulatedRequestState.h +++ b/devices/EmulatedCamera/hwl/EmulatedRequestState.h @@ -48,12 +48,16 @@ class EmulatedRequestState { std::unique_ptr<HwlPipelineResult> InitializeResult(uint32_t pipeline_id, uint32_t frame_number); + std::unique_ptr<HwlPipelineResult> InitializePartialResult( + uint32_t pipeline_id, uint32_t frame_number); status_t InitializeSensorSettings( std::unique_ptr<HalCameraMetadata> request_settings, uint32_t override_frame_number, EmulatedSensor::SensorSettings* sensor_settings /*out*/); + uint32_t GetPartialResultCount(bool is_partial_result); + private: bool SupportsCapability(uint8_t cap); @@ -122,7 +126,6 @@ class EmulatedRequestState { std::set<int32_t> available_results_; std::set<int32_t> available_requests_; uint8_t max_pipeline_depth_ = 0; - int32_t partial_result_count_ = 1; // TODO: add support for partial results bool supports_manual_sensor_ = false; bool supports_manual_post_processing_ = false; bool is_backward_compatible_ = false; @@ -131,6 +134,7 @@ class EmulatedRequestState { bool supports_yuv_reprocessing_ = false; bool supports_remosaic_reprocessing_ = false; bool supports_stream_use_case_ = false; + uint8_t partial_result_count = 1; // android.control.* struct SceneOverride { @@ -245,6 +249,7 @@ class EmulatedRequestState { // android.flash.* bool is_flash_supported_ = false; uint8_t flash_state_ = ANDROID_FLASH_STATE_UNAVAILABLE; + int32_t flash_strength_level_ = 1; // android.sensor.* std::pair<int32_t, int32_t> sensor_sensitivity_range_; @@ -263,6 +268,7 @@ class EmulatedRequestState { bool report_green_split_ = false; bool report_noise_profile_ = false; bool report_extended_scene_mode_ = false; + uint32_t timestamp_source_ = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN; // android.scaler.* bool report_rotate_and_crop_ = false; @@ -310,6 +316,8 @@ class EmulatedRequestState { bool report_pose_translation_ = false; bool report_distortion_ = false; bool report_intrinsic_calibration_ = false; + bool report_active_sensor_crop_ = false; + bool report_lens_intrinsics_samples_ = false; int32_t shading_map_size_[2] = {0}; unsigned int rand_seed_ = 1; diff --git a/devices/EmulatedCamera/hwl/EmulatedSensor.cpp b/devices/EmulatedCamera/hwl/EmulatedSensor.cpp index 29953e6..f96a565 100644 --- a/devices/EmulatedCamera/hwl/EmulatedSensor.cpp +++ b/devices/EmulatedCamera/hwl/EmulatedSensor.cpp @@ -682,6 +682,7 @@ status_t EmulatedSensor::ShutDown() { void EmulatedSensor::SetCurrentRequest( std::unique_ptr<LogicalCameraSettings> logical_settings, std::unique_ptr<HwlPipelineResult> result, + std::unique_ptr<HwlPipelineResult> partial_result, std::unique_ptr<Buffers> input_buffers, std::unique_ptr<Buffers> output_buffers) { Mutex::Autolock lock(control_mutex_); @@ -689,6 +690,7 @@ void EmulatedSensor::SetCurrentRequest( current_result_ = std::move(result); current_input_buffers_ = std::move(input_buffers); current_output_buffers_ = std::move(output_buffers); + partial_result_ = std::move(partial_result); } bool EmulatedSensor::WaitForVSyncLocked(nsecs_t reltime) { @@ -751,6 +753,13 @@ status_t EmulatedSensor::Flush() { return ret ? OK : TIMED_OUT; } +nsecs_t EmulatedSensor::getSystemTimeWithSource(uint32_t timestamp_source) { + if (timestamp_source == ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME) { + return systemTime(SYSTEM_TIME_BOOTTIME); + } + return systemTime(SYSTEM_TIME_MONOTONIC); +} + bool EmulatedSensor::threadLoop() { ATRACE_CALL(); /** @@ -764,14 +773,20 @@ bool EmulatedSensor::threadLoop() { std::unique_ptr<Buffers> next_buffers; std::unique_ptr<Buffers> next_input_buffer; std::unique_ptr<HwlPipelineResult> next_result; + std::unique_ptr<HwlPipelineResult> partial_result; std::unique_ptr<LogicalCameraSettings> settings; - HwlPipelineCallback callback = {nullptr, nullptr}; + HwlPipelineCallback callback = { + .process_pipeline_result = nullptr, + .process_pipeline_batch_result = nullptr, + .notify = nullptr, + }; { Mutex::Autolock lock(control_mutex_); std::swap(settings, current_settings_); std::swap(next_buffers, current_output_buffers_); std::swap(next_input_buffer, current_input_buffers_); std::swap(next_result, current_result_); + std::swap(partial_result, partial_result_); // Signal VSync for start of readout ALOGVV("Sensor VSync"); @@ -781,13 +796,15 @@ bool EmulatedSensor::threadLoop() { auto frame_duration = EmulatedSensor::kSupportedFrameDurationRange[0]; auto exposure_time = EmulatedSensor::kSupportedExposureTimeRange[0]; + uint32_t timestamp_source = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN; // Frame duration must always be the same among all physical devices if ((settings.get() != nullptr) && (!settings->empty())) { frame_duration = settings->begin()->second.frame_duration; exposure_time = settings->begin()->second.exposure_time; + timestamp_source = settings->begin()->second.timestamp_source; } - nsecs_t start_real_time = systemTime(); + nsecs_t start_real_time = getSystemTimeWithSource(timestamp_source); // Stagefright cares about system time for timestamps, so base simulated // time on that. nsecs_t frame_end_real_time = start_real_time + frame_duration; @@ -1175,7 +1192,7 @@ bool EmulatedSensor::threadLoop() { next_input_buffer->clear(); } - nsecs_t work_done_real_time = systemTime(); + nsecs_t work_done_real_time = getSystemTimeWithSource(timestamp_source); // Returning the results at this point is not entirely correct from timing // perspective. Under ideal conditions where 'ReturnResults' completes // in less than 'time_accuracy' we need to return the results after the @@ -1190,10 +1207,10 @@ bool EmulatedSensor::threadLoop() { // noticeable effect. if ((work_done_real_time + kReturnResultThreshod) > frame_end_real_time) { ReturnResults(callback, std::move(settings), std::move(next_result), - reprocess_request); + reprocess_request, std::move(partial_result)); } - work_done_real_time = systemTime(); + work_done_real_time = getSystemTimeWithSource(timestamp_source); ALOGVV("Sensor vertical blanking interval"); const nsecs_t time_accuracy = 2e6; // 2 ms of imprecision is ok if (work_done_real_time < frame_end_real_time - time_accuracy) { @@ -1208,7 +1225,7 @@ bool EmulatedSensor::threadLoop() { } ReturnResults(callback, std::move(settings), std::move(next_result), - reprocess_request); + reprocess_request, std::move(partial_result)); return true; }; @@ -1216,7 +1233,8 @@ bool EmulatedSensor::threadLoop() { void EmulatedSensor::ReturnResults( HwlPipelineCallback callback, std::unique_ptr<LogicalCameraSettings> settings, - std::unique_ptr<HwlPipelineResult> result, bool reprocess_request) { + std::unique_ptr<HwlPipelineResult> result, bool reprocess_request, + std::unique_ptr<HwlPipelineResult> partial_result) { if ((callback.process_pipeline_result != nullptr) && (result.get() != nullptr) && (result->result_metadata.get() != nullptr)) { auto logical_settings = settings->find(logical_camera_id_); @@ -1233,6 +1251,15 @@ void EmulatedSensor::ReturnResults( } result->result_metadata->Set(ANDROID_SENSOR_TIMESTAMP, &next_capture_time_, 1); + + camera_metadata_ro_entry_t lensEntry; + auto lensRet = result->result_metadata->Get( + ANDROID_STATISTICS_LENS_INTRINSIC_SAMPLES, &lensEntry); + if ((lensRet == OK) && (lensEntry.count > 0)) { + result->result_metadata->Set(ANDROID_STATISTICS_LENS_INTRINSIC_TIMESTAMPS, + &next_capture_time_, 1); + } + uint8_t raw_binned_factor_used = false; if (sensor_binning_factor_info_.find(logical_camera_id_) != sensor_binning_factor_info_.end()) { @@ -1343,6 +1370,11 @@ void EmulatedSensor::ReturnResults( } } + // Partial result count for partial result is set to a value + // only when partial results are supported + if (partial_result->partial_result != 0) { + callback.process_pipeline_result(std::move(partial_result)); + } callback.process_pipeline_result(std::move(result)); } } diff --git a/devices/EmulatedCamera/hwl/EmulatedSensor.h b/devices/EmulatedCamera/hwl/EmulatedSensor.h index 192cadd..9e21364 100644 --- a/devices/EmulatedCamera/hwl/EmulatedSensor.h +++ b/devices/EmulatedCamera/hwl/EmulatedSensor.h @@ -184,6 +184,7 @@ struct SensorCharacteristics { ColorSpaceProfileMap color_space_profiles; int32_t raw_crop_region_zoomed[4] = {0}; int32_t raw_crop_region_unzoomed[4] = {0}; + int32_t timestamp_source = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN; }; // Maps logical/physical camera ids to sensor characteristics @@ -278,6 +279,7 @@ class EmulatedSensor : private Thread, public virtual RefBase { uint8_t test_pattern_mode = ANDROID_SENSOR_TEST_PATTERN_MODE_OFF; uint32_t test_pattern_data[4] = {0, 0, 0, 0}; uint32_t screen_rotation = 0; + uint32_t timestamp_source = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN; }; // Maps physical and logical camera ids to individual device settings @@ -285,6 +287,7 @@ class EmulatedSensor : private Thread, public virtual RefBase { void SetCurrentRequest(std::unique_ptr<LogicalCameraSettings> logical_settings, std::unique_ptr<HwlPipelineResult> result, + std::unique_ptr<HwlPipelineResult> partial_result, std::unique_ptr<Buffers> input_buffers, std::unique_ptr<Buffers> output_buffers); @@ -362,6 +365,7 @@ class EmulatedSensor : private Thread, public virtual RefBase { bool got_vsync_; std::unique_ptr<LogicalCameraSettings> current_settings_; std::unique_ptr<HwlPipelineResult> current_result_; + std::unique_ptr<HwlPipelineResult> partial_result_; std::unique_ptr<Buffers> current_output_buffers_; std::unique_ptr<Buffers> current_input_buffers_; std::unique_ptr<JpegCompressor> jpeg_compressor_; @@ -455,11 +459,14 @@ class EmulatedSensor : private Thread, public virtual RefBase { void ReturnResults(HwlPipelineCallback callback, std::unique_ptr<LogicalCameraSettings> settings, std::unique_ptr<HwlPipelineResult> result, - bool reprocess_request); + bool reprocess_request, + std::unique_ptr<HwlPipelineResult> partial_result); static float GetBaseGainFactor(float max_raw_value) { return max_raw_value / EmulatedSensor::kSaturationElectrons; } + + nsecs_t getSystemTimeWithSource(uint32_t timestamp_source); }; } // namespace android diff --git a/devices/EmulatedCamera/hwl/apex/Android.bp b/devices/EmulatedCamera/hwl/apex/Android.bp index 55f492b..b864d72 100644 --- a/devices/EmulatedCamera/hwl/apex/Android.bp +++ b/devices/EmulatedCamera/hwl/apex/Android.bp @@ -70,6 +70,7 @@ apex_defaults { "emu_camera_back.json", "emu_camera_depth.json", "emu_camera_front.json", + "emu_camera_external.json", ], } diff --git a/devices/EmulatedCamera/hwl/configs/Android.bp b/devices/EmulatedCamera/hwl/configs/Android.bp index 1c74d1d..ca089b8 100644 --- a/devices/EmulatedCamera/hwl/configs/Android.bp +++ b/devices/EmulatedCamera/hwl/configs/Android.bp @@ -42,4 +42,10 @@ prebuilt_etc { name: "emu_camera_front.json", src: "emu_camera_front.json", defaults: ["emu_camera_config_defaults"], -}
\ No newline at end of file +} + +prebuilt_etc { + name: "emu_camera_external.json", + src: "emu_camera_external.json", + defaults: ["emu_camera_config_defaults"], +} diff --git a/devices/EmulatedCamera/hwl/configs/emu_camera_back.json b/devices/EmulatedCamera/hwl/configs/emu_camera_back.json index a873bea..f9488dd 100644 --- a/devices/EmulatedCamera/hwl/configs/emu_camera_back.json +++ b/devices/EmulatedCamera/hwl/configs/emu_camera_back.json @@ -118,6 +118,18 @@ "2", "3" ], + "android.flash.singleStrengthMaxLevel" : [ + "10" + ], + "android.flash.singleStrengthDefaultLevel": [ + "2" + ], + "android.flash.torchStrengthDefaultLevel": [ + "5" + ], + "android.flash.torchStrengthMaxLevel" :[ + "15" + ], "android.flash.info.available": [ "TRUE" ], @@ -485,6 +497,8 @@ "917523", "917526", "851985", + "1114133", + "1114134", "-2080374783", "-2080374782" ], @@ -498,7 +512,7 @@ "1" ], "android.request.partialResultCount": [ - "1" + "2" ], "android.request.pipelineMaxDepth": [ "8" diff --git a/devices/EmulatedCamera/hwl/configs/emu_camera_external.json b/devices/EmulatedCamera/hwl/configs/emu_camera_external.json new file mode 100644 index 0000000..f2b4293 --- /dev/null +++ b/devices/EmulatedCamera/hwl/configs/emu_camera_external.json @@ -0,0 +1,498 @@ +{ + "android.colorCorrection.availableAberrationModes": [ + "0" + ], + "android.control.aeAvailableAntibandingModes": [ + "3" + ], + "android.control.aeAvailableModes": [ + "1" + ], + "android.control.aeAvailableTargetFpsRanges": [ + "10", + "20", + "24", + "24", + "30", + "30", + "15", + "30" + ], + "android.control.aeCompensationRange": [ + "0", + "0" + ], + "android.control.aeCompensationStep": [ + "0", + "1" + ], + "android.control.aeLockAvailable": [ + "FALSE" + ], + "android.control.afAvailableModes": [ + "1", + "0" + ], + "android.control.autoframingAvailable": [ + "FALSE" + ], + "android.control.availableEffects": [ + "0" + ], + "android.control.availableModes": [ + "0", + "1" + ], + "android.control.availableSceneModes": [ + "0" + ], + "android.control.availableVideoStabilizationModes": [ + "0" + ], + "android.control.awbAvailableModes": [ + "1" + ], + "android.control.awbLockAvailable": [ + "FALSE" + ], + "android.control.maxRegions": [ + "0", + "0", + "0" + ], + "android.control.zoomRatioRange": [ + "1.00000000", + "4.00000000" + ], + "android.edge.availableEdgeModes": [ + "0", + "1" + ], + "android.flash.info.available": [ + "FALSE" + ], + "android.hotPixel.availableHotPixelModes": [ + "0" + ], + "android.info.supportedHardwareLevel": [ + "EXTERNAL" + ], + "android.jpeg.availableThumbnailSizes": [ + "0", + "0", + "176", + "144", + "240", + "144", + "256", + "144", + "240", + "160", + "256", + "154", + "240", + "180" + ], + "android.jpeg.maxSize": [ + "3145728" + ], + "android.lens.facing": [ + "EXTERNAL" + ], + "android.lens.info.availableOpticalStabilization": [ + "0" + ], + "android.lens.info.focusDistanceCalibration": [ + "UNCALIBRATED" + ], + "android.noiseReduction.availableNoiseReductionModes": [ + "0" + ], + "android.noiseReduction.mode": [ + "OFF" + ], + "android.request.availableCapabilities": [ + "BACKWARD_COMPATIBLE" + ], + "android.request.availableCharacteristicsKeys": [ + "4", + "65554", + "65555", + "65556", + "65557", + "65558", + "65572", + "65559", + "65560", + "65574", + "65561", + "65562", + "65563", + "65573", + "65564", + "327680", + "1376256", + "458759", + "524293", + "589827", + "589831", + "655362", + "786444", + "786440", + "786438", + "786443", + "786442", + "851972", + "851978", + "851981", + "983040", + "983044", + "983046", + "983050", + "983048", + "917518", + "1048578", + "1179648", + "1179654", + "1179655", + "1179650", + "1507329", + "65582", + "589824", + "589826", + "589825", + "1245189" + ], + "android.request.availableRequestKeys": [ + "3", + "65536", + "65537", + "65538", + "65539", + "65542", + "65541", + "65543", + "65545", + "65546", + "65547", + "65549", + "65550", + "65551", + "65552", + "65553", + "262146", + "458755", + "458756", + "458757", + "458758", + "524292", + "655360", + "851968", + "917528", + "1114112", + "1114115", + "65583" + ], + "android.request.availableResultKeys": [ + "3", + "65536", + "65537", + "65538", + "65539", + "65542", + "65567", + "65541", + "65543", + "65568", + "65545", + "65546", + "65547", + "65570", + "65549", + "65550", + "65551", + "65552", + "65553", + "262146", + "262149", + "458755", + "458756", + "458757", + "458758", + "524292", + "655360", + "786441", + "851968", + "917520", + "1114112", + "1114115", + "1114128", + "1114126", + "65583" + ], + "android.request.maxNumInputStreams": [ + "0" + ], + "android.request.maxNumOutputStreams": [ + "0", + "2", + "1" + ], + "android.request.partialResultCount": [ + "1" + ], + "android.request.pipelineMaxDepth": [ + "4" + ], + "android.scaler.availableMaxDigitalZoom": [ + "4.00000000" + ], + "android.scaler.availableMinFrameDurations": [ + "33", + "320", + "240", + "33333333", + "35", + "320", + "240", + "33333333", + "34", + "320", + "240", + "33333333", + "33", + "640", + "480", + "33333333", + "35", + "640", + "480", + "33333333", + "34", + "640", + "480", + "33333333", + "33", + "1280", + "720", + "33333333", + "35", + "1280", + "720", + "33333333", + "34", + "1280", + "720", + "33333333", + "33", + "1920", + "1080", + "33333333", + "35", + "1920", + "1080", + "33333333", + "34", + "1920", + "1080", + "33333333", + "33", + "1920", + "1080", + "33333333", + "35", + "1920", + "1080", + "33333333", + "34", + "1920", + "1080", + "33333333" + ], + "android.scaler.availableStallDurations": [ + "33", + "320", + "240", + "1000000000", + "35", + "320", + "240", + "0", + "34", + "320", + "240", + "0", + "33", + "640", + "480", + "1000000000", + "35", + "640", + "480", + "0", + "34", + "640", + "480", + "0", + "33", + "1280", + "720", + "1000000000", + "35", + "1280", + "720", + "0", + "34", + "1280", + "720", + "0", + "33", + "1920", + "1080", + "1000000000", + "35", + "1920", + "1080", + "0", + "34", + "1920", + "1080", + "0", + "33", + "1920", + "1080", + "1000000000", + "35", + "1920", + "1080", + "0", + "34", + "1920", + "1080", + "0" + ], + "android.scaler.availableStreamConfigurations": [ + "33", + "320", + "240", + "OUTPUT", + "35", + "320", + "240", + "OUTPUT", + "34", + "320", + "240", + "OUTPUT", + "33", + "640", + "480", + "OUTPUT", + "35", + "640", + "480", + "OUTPUT", + "34", + "640", + "480", + "OUTPUT", + "33", + "1280", + "720", + "OUTPUT", + "35", + "1280", + "720", + "OUTPUT", + "34", + "1280", + "720", + "OUTPUT", + "33", + "1920", + "1080", + "OUTPUT", + "35", + "1920", + "1080", + "OUTPUT", + "34", + "1920", + "1080", + "OUTPUT", + "33", + "1920", + "1080", + "OUTPUT", + "35", + "1920", + "1080", + "OUTPUT", + "34", + "1920", + "1080", + "OUTPUT" + ], + "android.scaler.croppingType": [ + "CENTER_ONLY" + ], + "android.sensor.availableTestPatternModes": [ + "0", + "1" + ], + "android.sensor.info.activeArraySize": [ + "0", + "0", + "1920", + "1080" + ], + "android.sensor.info.maxFrameDuration": [ + "200000000" + ], + "android.sensor.info.pixelArraySize": [ + "1920", + "1080" + ], + "android.sensor.info.preCorrectionActiveArraySize": [ + "0", + "0", + "1920", + "1080" + ], + "android.sensor.info.timestampSource": [ + "REALTIME" + ], + "android.sensor.orientation": [ + "0" + ], + "android.shading.availableModes": [ + "0" + ], + "android.statistics.info.availableFaceDetectModes": [ + "0" + ], + "android.statistics.info.availableHotPixelMapModes": [ + "0" + ], + "android.statistics.info.availableLensShadingMapModes": [ + "0" + ], + "android.statistics.info.maxFaceCount": [ + "0" + ], + "android.sync.maxLatency": [ + "UNKNOWN" + ], + "android.lens.info.availableApertures": [ + "1.70000005" + ], + "android.lens.info.availableFocalLengths": [ + "3.25999999" + ], + "android.lens.info.availableFilterDensities": [ + "0.00000000" + ], + "android.tonemap.availableToneMapModes": [ + "1" + ] +} diff --git a/devices/EmulatedCamera/hwl/configs/emu_camera_front.json b/devices/EmulatedCamera/hwl/configs/emu_camera_front.json index 5c4b617..46d89ce 100644 --- a/devices/EmulatedCamera/hwl/configs/emu_camera_front.json +++ b/devices/EmulatedCamera/hwl/configs/emu_camera_front.json @@ -186,6 +186,18 @@ "0", "3" ], + "android.flash.singleStrengthMaxLevel" : [ + "10" + ], + "android.flash.singleStrengthDefaultLevel": [ + "2" + ], + "android.flash.torchStrengthDefaultLevel": [ + "5" + ], + "android.flash.torchStrengthMaxLevel" :[ + "15" + ], "android.flash.info.available": [ "TRUE" ], @@ -630,7 +642,8 @@ "1703938", "917530", "851985", - "917536" + "917536", + "1703939" ], "android.request.maxNumOutputStreams": [ "1", @@ -641,7 +654,7 @@ "0" ], "android.request.partialResultCount": [ - "1" + "2" ], "android.request.pipelineMaxDepth": [ "8" @@ -1490,7 +1503,7 @@ "10" ], "android.info.supportedBufferManagementVersion" : [ - "HIDL_DEVICE_3_5" + "SESSION_CONFIGURABLE" ], "android.sync.maxLatency": [ "PER_FRAME_CONTROL" @@ -1688,6 +1701,18 @@ "0", "3" ], + "android.flash.singleStrengthMaxLevel" : [ + "10" + ], + "android.flash.singleStrengthDefaultLevel": [ + "2" + ], + "android.flash.torchStrengthDefaultLevel": [ + "5" + ], + "android.flash.torchStrengthMaxLevel" :[ + "15" + ], "android.flash.info.available": [ "TRUE" ], @@ -2089,7 +2114,7 @@ "0" ], "android.request.partialResultCount": [ - "1" + "2" ], "android.request.pipelineMaxDepth": [ "8" @@ -2961,7 +2986,7 @@ "10" ], "android.info.supportedBufferManagementVersion" : [ - "HIDL_DEVICE_3_5" + "SESSION_CONFIGURABLE" ], "android.sync.maxLatency": [ "PER_FRAME_CONTROL" @@ -3159,6 +3184,18 @@ "0", "3" ], + "android.flash.singleStrengthMaxLevel" : [ + "10" + ], + "android.flash.singleStrengthDefaultLevel": [ + "2" + ], + "android.flash.torchStrengthDefaultLevel": [ + "5" + ], + "android.flash.torchStrengthMaxLevel" :[ + "15" + ], "android.flash.info.available": [ "TRUE" ], @@ -3561,7 +3598,7 @@ "0" ], "android.request.partialResultCount": [ - "1" + "2" ], "android.request.pipelineMaxDepth": [ "8" @@ -4477,7 +4514,7 @@ "10" ], "android.info.supportedBufferManagementVersion" : [ - "HIDL_DEVICE_3_5" + "SESSION_CONFIGURABLE" ], "android.sync.maxLatency": [ "PER_FRAME_CONTROL" diff --git a/devices/EmulatedCamera/hwl/utils/HWLUtils.cpp b/devices/EmulatedCamera/hwl/utils/HWLUtils.cpp index f034a7a..2d156ab 100644 --- a/devices/EmulatedCamera/hwl/utils/HWLUtils.cpp +++ b/devices/EmulatedCamera/hwl/utils/HWLUtils.cpp @@ -45,6 +45,29 @@ static int64_t GetLastStreamUseCase(const HalCameraMetadata* metadata) { } return video_call_use_case; } +status_t SupportsSessionHalBufManager(const HalCameraMetadata* metadata, + bool* result /*out*/) { + if ((metadata == nullptr) || (result == nullptr)) { + return BAD_VALUE; + } + + status_t ret = OK; + camera_metadata_ro_entry_t entry; + *result = false; + ret = metadata->Get(ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION, &entry); + if (ret != OK) { + return OK; + } + if ((ret == OK) && (entry.count != 1)) { + ALOGE("%s: Invalid ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION!", + __FUNCTION__); + return BAD_VALUE; + } + *result = + (entry.data.u8[0] == + ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_SESSION_CONFIGURABLE); + return OK; +} status_t GetSensorCharacteristics(const HalCameraMetadata* metadata, SensorCharacteristics* sensor_chars /*out*/) { diff --git a/devices/EmulatedCamera/hwl/utils/HWLUtils.h b/devices/EmulatedCamera/hwl/utils/HWLUtils.h index 4ee0054..5c3a281 100644 --- a/devices/EmulatedCamera/hwl/utils/HWLUtils.h +++ b/devices/EmulatedCamera/hwl/utils/HWLUtils.h @@ -43,6 +43,9 @@ typedef unordered_map<uint32_t, pair<CameraDeviceStatus, unique_ptr<HalCameraMet typedef std::unique_ptr<PhysicalDeviceMap> PhysicalDeviceMapPtr; // Metadata utility functions start + +status_t SupportsSessionHalBufManager(const HalCameraMetadata* metadata, + bool* result /*out*/); status_t GetSensorCharacteristics(const HalCameraMetadata* metadata, SensorCharacteristics* sensor_chars /*out*/); PhysicalDeviceMapPtr ClonePhysicalDeviceMap(const PhysicalDeviceMapPtr& src); |