| /* |
| * Copyright (C) 2019 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "EmulatedRequestProcessor" |
| #define ATRACE_TAG ATRACE_TAG_CAMERA |
| |
| #include "EmulatedRequestProcessor.h" |
| |
| #include <HandleImporter.h> |
| #include <hardware/gralloc.h> |
| #include <log/log.h> |
| #include <sync/sync.h> |
| #include <utils/Timers.h> |
| #include <utils/Trace.h> |
| |
| #include <memory> |
| |
| #include "GrallocSensorBuffer.h" |
| |
| namespace android { |
| |
| using ::android::frameworks::sensorservice::V1_0::ISensorManager; |
| using ::android::frameworks::sensorservice::V1_0::Result; |
| using android::hardware::camera::common::V1_0::helper::HandleImporter; |
| using ::android::hardware::sensors::V1_0::SensorInfo; |
| using ::android::hardware::sensors::V1_0::SensorType; |
| using google_camera_hal::ErrorCode; |
| using google_camera_hal::HwlPipelineResult; |
| using google_camera_hal::MessageType; |
| using google_camera_hal::NotifyMessage; |
| |
| EmulatedRequestProcessor::EmulatedRequestProcessor( |
| uint32_t camera_id, sp<EmulatedSensor> sensor, |
| const HwlSessionCallback& session_callback) |
| : camera_id_(camera_id), |
| sensor_(sensor), |
| session_callback_(session_callback), |
| request_state_(std::make_unique<EmulatedLogicalRequestState>(camera_id)) { |
| ATRACE_CALL(); |
| request_thread_ = std::thread([this] { this->RequestProcessorLoop(); }); |
| importer_ = std::make_shared<HandleImporter>(); |
| } |
| |
| EmulatedRequestProcessor::~EmulatedRequestProcessor() { |
| ATRACE_CALL(); |
| processor_done_ = true; |
| request_thread_.join(); |
| |
| auto ret = sensor_->ShutDown(); |
| if (ret != OK) { |
| ALOGE("%s: Failed during sensor shutdown %s (%d)", __FUNCTION__, |
| strerror(-ret), ret); |
| } |
| |
| if (sensor_event_queue_.get() != nullptr) { |
| sensor_event_queue_->disableSensor(sensor_handle_); |
| sensor_event_queue_.clear(); |
| sensor_event_queue_ = nullptr; |
| } |
| } |
| |
| status_t EmulatedRequestProcessor::ProcessPipelineRequests( |
| uint32_t frame_number, std::vector<HwlPipelineRequest>& requests, |
| const std::vector<EmulatedPipeline>& pipelines, |
| const DynamicStreamIdMapType& dynamic_stream_id_map, |
| bool use_default_physical_camera) { |
| ATRACE_CALL(); |
| status_t res = OK; |
| |
| std::unique_lock<std::mutex> lock(process_mutex_); |
| |
| for (auto& request : requests) { |
| if (request.pipeline_id >= pipelines.size()) { |
| ALOGE("%s: Pipeline request with invalid pipeline id: %u", __FUNCTION__, |
| request.pipeline_id); |
| return BAD_VALUE; |
| } |
| |
| while (pending_requests_.size() > EmulatedSensor::kPipelineDepth) { |
| auto result = request_condition_.wait_for( |
| lock, std::chrono::nanoseconds( |
| EmulatedSensor::kSupportedFrameDurationRange[1])); |
| if (result == std::cv_status::timeout) { |
| ALOGE("%s: Timed out waiting for a pending request slot", __FUNCTION__); |
| return TIMED_OUT; |
| } |
| } |
| |
| res = request_state_->UpdateRequestForDynamicStreams( |
| &request, pipelines, dynamic_stream_id_map, use_default_physical_camera); |
| if (res != OK) { |
| ALOGE("%s: Failed to update request for dynamic streams: %s(%d)", |
| __FUNCTION__, strerror(-res), res); |
| return res; |
| } |
| |
| auto output_buffers = CreateSensorBuffers( |
| frame_number, request.output_buffers, |
| pipelines[request.pipeline_id].streams, request.pipeline_id, |
| pipelines[request.pipeline_id].cb, /*override_width*/ 0, |
| /*override_height*/ 0); |
| if (output_buffers == nullptr) { |
| return NO_MEMORY; |
| } |
| |
| auto input_buffers = CreateSensorBuffers( |
| frame_number, request.input_buffers, |
| pipelines[request.pipeline_id].streams, request.pipeline_id, |
| pipelines[request.pipeline_id].cb, request.input_width, |
| request.input_height); |
| |
| // Check if there are any settings that need to be overridden. |
| camera_metadata_ro_entry_t entry; |
| if (request.settings.get() != nullptr) { |
| auto ret = request.settings.get()->Get(ANDROID_CONTROL_SETTINGS_OVERRIDE, |
| &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| std::unique_ptr<HalCameraMetadata> override_setting = |
| HalCameraMetadata::Clone(request.settings.get()); |
| override_settings_.push({.settings = std::move(override_setting), |
| .frame_number = frame_number}); |
| } |
| } else { |
| override_settings_.push( |
| {.settings = nullptr, .frame_number = frame_number}); |
| } |
| pending_requests_.push( |
| {.frame_number = frame_number, |
| .pipeline_id = request.pipeline_id, |
| .callback = pipelines[request.pipeline_id].cb, |
| .settings = HalCameraMetadata::Clone(request.settings.get()), |
| .input_buffers = std::move(input_buffers), |
| .output_buffers = std::move(output_buffers)}); |
| } |
| |
| return OK; |
| } |
| |
| std::unique_ptr<Buffers> EmulatedRequestProcessor::CreateSensorBuffers( |
| uint32_t frame_number, const std::vector<StreamBuffer>& buffers, |
| const std::unordered_map<uint32_t, EmulatedStream>& streams, |
| uint32_t pipeline_id, HwlPipelineCallback cb, int32_t override_width, |
| int32_t override_height) { |
| if (buffers.empty()) { |
| return nullptr; |
| } |
| |
| std::vector<StreamBuffer> requested_buffers; |
| for (auto& buffer : buffers) { |
| if (buffer.buffer != nullptr) { |
| requested_buffers.push_back(buffer); |
| continue; |
| } |
| |
| if (session_callback_.request_stream_buffers != nullptr) { |
| std::vector<StreamBuffer> one_requested_buffer; |
| status_t res = session_callback_.request_stream_buffers( |
| buffer.stream_id, 1, &one_requested_buffer, frame_number); |
| if (res != OK) { |
| ALOGE("%s: request_stream_buffers failed: %s(%d)", __FUNCTION__, |
| strerror(-res), res); |
| continue; |
| } |
| if (one_requested_buffer.size() != 1 || |
| one_requested_buffer[0].buffer == nullptr) { |
| ALOGE("%s: request_stream_buffers failed to return a valid buffer", |
| __FUNCTION__); |
| continue; |
| } |
| requested_buffers.push_back(one_requested_buffer[0]); |
| } |
| } |
| |
| if (requested_buffers.size() < buffers.size()) { |
| ALOGE( |
| "%s: Failed to acquire all sensor buffers: %zu acquired, %zu requested", |
| __FUNCTION__, requested_buffers.size(), buffers.size()); |
| // This only happens for HAL buffer manager use case. |
| if (session_callback_.return_stream_buffers != nullptr) { |
| session_callback_.return_stream_buffers(requested_buffers); |
| } |
| requested_buffers.clear(); |
| } |
| |
| auto sensor_buffers = std::make_unique<Buffers>(); |
| sensor_buffers->reserve(requested_buffers.size()); |
| for (auto& buffer : requested_buffers) { |
| auto sensor_buffer = CreateSensorBuffer( |
| frame_number, streams.at(buffer.stream_id), pipeline_id, cb, buffer, |
| override_width, override_height); |
| if (sensor_buffer.get() != nullptr) { |
| sensor_buffers->push_back(std::move(sensor_buffer)); |
| } |
| } |
| |
| return sensor_buffers; |
| } |
| |
| void EmulatedRequestProcessor::NotifyFailedRequest(const PendingRequest& request) { |
| if (request.output_buffers != nullptr) { |
| // Mark all output buffers for this request in order not to send |
| // ERROR_BUFFER for them. |
| for (auto& output_buffer : *(request.output_buffers)) { |
| output_buffer->is_failed_request = true; |
| } |
| } |
| |
| NotifyMessage msg = { |
| .type = MessageType::kError, |
| .message.error = {.frame_number = request.frame_number, |
| .error_stream_id = -1, |
| .error_code = ErrorCode::kErrorRequest}}; |
| request.callback.notify(request.pipeline_id, msg); |
| } |
| |
| status_t EmulatedRequestProcessor::Flush() { |
| std::lock_guard<std::mutex> lock(process_mutex_); |
| // First flush in-flight requests |
| auto ret = sensor_->Flush(); |
| |
| // Then the rest of the pending requests |
| while (!pending_requests_.empty()) { |
| const auto& request = pending_requests_.front(); |
| NotifyFailedRequest(request); |
| pending_requests_.pop(); |
| } |
| |
| return ret; |
| } |
| |
| status_t EmulatedRequestProcessor::GetBufferSizeAndStride( |
| const EmulatedStream& stream, buffer_handle_t buffer, |
| uint32_t* size /*out*/, uint32_t* stride /*out*/) { |
| if (size == nullptr) { |
| return BAD_VALUE; |
| } |
| |
| switch (stream.override_format) { |
| case HAL_PIXEL_FORMAT_RGB_888: |
| *stride = stream.width * 3; |
| *size = (*stride) * stream.height; |
| break; |
| case HAL_PIXEL_FORMAT_RGBA_8888: |
| *stride = stream.width * 4; |
| *size = (*stride) * stream.height; |
| break; |
| case HAL_PIXEL_FORMAT_Y16: |
| if (stream.override_data_space == HAL_DATASPACE_DEPTH) { |
| *stride = AlignTo(AlignTo(stream.width, 2) * 2, 16); |
| *size = (*stride) * AlignTo(stream.height, 2); |
| } else { |
| return BAD_VALUE; |
| } |
| break; |
| case HAL_PIXEL_FORMAT_BLOB: |
| if (stream.override_data_space == HAL_DATASPACE_V0_JFIF) { |
| *size = stream.buffer_size; |
| *stride = *size; |
| } else { |
| return BAD_VALUE; |
| } |
| break; |
| case HAL_PIXEL_FORMAT_RAW16: |
| if (importer_->getMonoPlanarStrideBytes(buffer, stride) != NO_ERROR) { |
| *stride = stream.width * 2; |
| } |
| *size = (*stride) * stream.height; |
| break; |
| default: |
| return BAD_VALUE; |
| } |
| |
| return OK; |
| } |
| |
| status_t EmulatedRequestProcessor::LockSensorBuffer( |
| const EmulatedStream& stream, buffer_handle_t buffer, int32_t width, |
| int32_t height, SensorBuffer* sensor_buffer /*out*/) { |
| if (sensor_buffer == nullptr) { |
| return BAD_VALUE; |
| } |
| |
| auto usage = GRALLOC_USAGE_SW_WRITE_OFTEN; |
| bool isYUV_420_888 = stream.override_format == HAL_PIXEL_FORMAT_YCBCR_420_888; |
| bool isP010 = static_cast<android_pixel_format_v1_1_t>( |
| stream.override_format) == HAL_PIXEL_FORMAT_YCBCR_P010; |
| if ((isYUV_420_888) || (isP010)) { |
| 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)) { |
| sensor_buffer->plane.img_y_crcb.img_y = |
| static_cast<uint8_t*>(yuv_layout.y); |
| sensor_buffer->plane.img_y_crcb.img_cb = |
| 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.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: %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; |
| } else { |
| ALOGE("%s: Failed to lock output buffer!", __FUNCTION__); |
| return BAD_VALUE; |
| } |
| } else { |
| uint32_t buffer_size = 0, stride = 0; |
| auto ret = GetBufferSizeAndStride(stream, buffer, &buffer_size, &stride); |
| if (ret != OK) { |
| ALOGE("%s: Unsupported pixel format: 0x%x", __FUNCTION__, |
| stream.override_format); |
| return BAD_VALUE; |
| } |
| if (stream.override_format == HAL_PIXEL_FORMAT_BLOB) { |
| sensor_buffer->plane.img.img = |
| static_cast<uint8_t*>(importer_->lock(buffer, usage, buffer_size)); |
| } else { |
| android::Rect region{0, 0, width, height}; |
| sensor_buffer->plane.img.img = |
| static_cast<uint8_t*>(importer_->lock(buffer, usage, region)); |
| } |
| if (sensor_buffer->plane.img.img == nullptr) { |
| ALOGE("%s: Failed to lock output buffer!", __FUNCTION__); |
| return BAD_VALUE; |
| } |
| sensor_buffer->plane.img.stride_in_bytes = stride; |
| sensor_buffer->plane.img.buffer_size = buffer_size; |
| } |
| |
| return OK; |
| } |
| |
| std::unique_ptr<SensorBuffer> EmulatedRequestProcessor::CreateSensorBuffer( |
| uint32_t frame_number, const EmulatedStream& emulated_stream, |
| uint32_t pipeline_id, HwlPipelineCallback callback, |
| StreamBuffer stream_buffer, int32_t override_width, |
| int32_t override_height) { |
| auto buffer = std::make_unique<GrallocSensorBuffer>(importer_); |
| |
| auto stream = emulated_stream; |
| // Make sure input stream formats are correctly mapped here |
| if (stream.is_input) { |
| stream.override_format = EmulatedSensor::OverrideFormat( |
| stream.override_format, |
| ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD); |
| } |
| if (override_width > 0 && override_height > 0) { |
| buffer->width = override_width; |
| buffer->height = override_height; |
| } else { |
| buffer->width = stream.width; |
| buffer->height = stream.height; |
| } |
| buffer->format = static_cast<PixelFormat>(stream.override_format); |
| buffer->dataSpace = stream.override_data_space; |
| buffer->color_space = stream.color_space; |
| buffer->use_case = stream.use_case; |
| buffer->stream_buffer = stream_buffer; |
| buffer->pipeline_id = pipeline_id; |
| buffer->callback = callback; |
| buffer->frame_number = frame_number; |
| buffer->camera_id = emulated_stream.is_physical_camera_stream |
| ? emulated_stream.physical_camera_id |
| : camera_id_; |
| buffer->is_input = stream.is_input; |
| // In case buffer processing is successful, flip this flag accordingly |
| buffer->stream_buffer.status = BufferStatus::kError; |
| |
| if (buffer->stream_buffer.buffer != nullptr) { |
| auto ret = LockSensorBuffer(stream, buffer->stream_buffer.buffer, |
| buffer->width, buffer->height, buffer.get()); |
| if (ret != OK) { |
| buffer->is_failed_request = true; |
| buffer = nullptr; |
| } |
| } |
| |
| if ((buffer.get() != nullptr) && (stream_buffer.acquire_fence != nullptr)) { |
| auto fence_status = importer_->importFence(stream_buffer.acquire_fence, |
| buffer->acquire_fence_fd); |
| if (!fence_status) { |
| ALOGE("%s: Failed importing acquire fence!", __FUNCTION__); |
| buffer->is_failed_request = true; |
| buffer = nullptr; |
| } |
| } |
| |
| return buffer; |
| } |
| |
| std::unique_ptr<Buffers> EmulatedRequestProcessor::AcquireBuffers( |
| Buffers* buffers) { |
| if ((buffers == nullptr) || (buffers->empty())) { |
| return nullptr; |
| } |
| |
| auto acquired_buffers = std::make_unique<Buffers>(); |
| acquired_buffers->reserve(buffers->size()); |
| auto output_buffer = buffers->begin(); |
| while (output_buffer != buffers->end()) { |
| status_t ret = OK; |
| if ((*output_buffer)->acquire_fence_fd >= 0) { |
| ret = sync_wait((*output_buffer)->acquire_fence_fd, |
| ns2ms(EmulatedSensor::kSupportedFrameDurationRange[1])); |
| if (ret != OK) { |
| ALOGE("%s: Fence sync failed: %s, (%d)", __FUNCTION__, strerror(-ret), |
| ret); |
| } |
| } |
| |
| if (ret == OK) { |
| acquired_buffers->push_back(std::move(*output_buffer)); |
| } |
| |
| output_buffer = buffers->erase(output_buffer); |
| } |
| |
| return acquired_buffers; |
| } |
| |
| void EmulatedRequestProcessor::RequestProcessorLoop() { |
| ATRACE_CALL(); |
| |
| bool vsync_status_ = true; |
| while (!processor_done_ && vsync_status_) { |
| { |
| std::lock_guard<std::mutex> lock(process_mutex_); |
| if (!pending_requests_.empty()) { |
| status_t ret; |
| const auto& request = pending_requests_.front(); |
| auto frame_number = request.frame_number; |
| auto notify_callback = request.callback; |
| auto pipeline_id = request.pipeline_id; |
| |
| auto output_buffers = AcquireBuffers(request.output_buffers.get()); |
| auto input_buffers = AcquireBuffers(request.input_buffers.get()); |
| if ((output_buffers != nullptr) && !output_buffers->empty()) { |
| std::unique_ptr<EmulatedSensor::LogicalCameraSettings> logical_settings = |
| std::make_unique<EmulatedSensor::LogicalCameraSettings>(); |
| |
| std::unique_ptr<std::set<uint32_t>> physical_camera_output_ids = |
| std::make_unique<std::set<uint32_t>>(); |
| for (const auto& it : *output_buffers) { |
| if (it->camera_id != camera_id_) { |
| physical_camera_output_ids->emplace(it->camera_id); |
| } |
| } |
| |
| // Repeating requests usually include valid settings only during the |
| // initial call. Afterwards an invalid settings pointer means that |
| // there are no changes in the parameters and Hal should re-use the |
| // last valid values. |
| // TODO: Add support for individual physical camera requests. |
| if (request.settings.get() != nullptr) { |
| auto override_frame_number = |
| ApplyOverrideSettings(frame_number, request.settings); |
| ret = request_state_->InitializeLogicalSettings( |
| HalCameraMetadata::Clone(request.settings.get()), |
| std::move(physical_camera_output_ids), override_frame_number, |
| logical_settings.get()); |
| last_settings_ = HalCameraMetadata::Clone(request.settings.get()); |
| } else { |
| auto override_frame_number = |
| ApplyOverrideSettings(frame_number, last_settings_); |
| ret = request_state_->InitializeLogicalSettings( |
| HalCameraMetadata::Clone(last_settings_.get()), |
| std::move(physical_camera_output_ids), override_frame_number, |
| logical_settings.get()); |
| } |
| |
| if (ret == OK) { |
| 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(); |
| it != logical_settings->end(); it++) { |
| it->second.screen_rotation = screen_rotation; |
| } |
| |
| sensor_->SetCurrentRequest( |
| std::move(logical_settings), std::move(result), |
| std::move(partial_result), std::move(input_buffers), |
| std::move(output_buffers)); |
| } else { |
| NotifyMessage msg{.type = MessageType::kError, |
| .message.error = { |
| .frame_number = frame_number, |
| .error_stream_id = -1, |
| .error_code = ErrorCode::kErrorResult, |
| }}; |
| |
| notify_callback.notify(pipeline_id, msg); |
| } |
| } else { |
| // No further processing is needed, just fail the result which will |
| // complete this request. |
| NotifyMessage msg{.type = MessageType::kError, |
| .message.error = { |
| .frame_number = frame_number, |
| .error_stream_id = -1, |
| .error_code = ErrorCode::kErrorResult, |
| }}; |
| |
| notify_callback.notify(pipeline_id, msg); |
| } |
| |
| pending_requests_.pop(); |
| request_condition_.notify_one(); |
| } |
| } |
| |
| vsync_status_ = |
| sensor_->WaitForVSync(EmulatedSensor::kSupportedFrameDurationRange[1]); |
| } |
| } |
| |
| status_t EmulatedRequestProcessor::Initialize( |
| std::unique_ptr<HalCameraMetadata> static_meta, |
| PhysicalDeviceMapPtr physical_devices) { |
| std::lock_guard<std::mutex> lock(process_mutex_); |
| return request_state_->Initialize(std::move(static_meta), |
| std::move(physical_devices)); |
| } |
| |
| void EmulatedRequestProcessor::SetSessionCallback( |
| const HwlSessionCallback& hwl_session_callback) { |
| std::lock_guard<std::mutex> lock(process_mutex_); |
| session_callback_ = hwl_session_callback; |
| } |
| |
| status_t EmulatedRequestProcessor::GetDefaultRequest( |
| RequestTemplate type, std::unique_ptr<HalCameraMetadata>* default_settings) { |
| std::lock_guard<std::mutex> lock(process_mutex_); |
| return request_state_->GetDefaultRequest(type, default_settings); |
| } |
| |
| uint32_t EmulatedRequestProcessor::ApplyOverrideSettings( |
| uint32_t frame_number, |
| const std::unique_ptr<HalCameraMetadata>& request_settings) { |
| while (!override_settings_.empty() && request_settings.get() != nullptr) { |
| auto override_frame_number = override_settings_.front().frame_number; |
| bool repeatingOverride = (override_settings_.front().settings == nullptr); |
| const auto& override_setting = repeatingOverride |
| ? last_override_settings_ |
| : override_settings_.front().settings; |
| |
| camera_metadata_ro_entry_t entry; |
| status_t ret = |
| override_setting->Get(ANDROID_CONTROL_SETTINGS_OVERRIDE, &entry); |
| bool overriding = false; |
| if ((ret == OK) && (entry.count == 1) && |
| (entry.data.i32[0] == ANDROID_CONTROL_SETTINGS_OVERRIDE_ZOOM)) { |
| ApplyOverrideZoom(override_setting, request_settings, |
| ANDROID_CONTROL_SETTINGS_OVERRIDE); |
| ApplyOverrideZoom(override_setting, request_settings, |
| ANDROID_CONTROL_ZOOM_RATIO); |
| ApplyOverrideZoom(override_setting, request_settings, |
| ANDROID_SCALER_CROP_REGION); |
| ApplyOverrideZoom(override_setting, request_settings, |
| ANDROID_CONTROL_AE_REGIONS); |
| ApplyOverrideZoom(override_setting, request_settings, |
| ANDROID_CONTROL_AWB_REGIONS); |
| ApplyOverrideZoom(override_setting, request_settings, |
| ANDROID_CONTROL_AF_REGIONS); |
| overriding = true; |
| } |
| if (!repeatingOverride) { |
| last_override_settings_ = HalCameraMetadata::Clone(override_setting.get()); |
| } |
| |
| override_settings_.pop(); |
| // If there are multiple queued override settings, skip until the speed-up |
| // is at least 2 frames. |
| if (override_frame_number - frame_number >= kZoomSpeedup) { |
| // If the request's settings override isn't ON, do not return |
| // override_frame_number. Return 0 to indicate there is no |
| // override happening. |
| return overriding ? override_frame_number : 0; |
| } |
| } |
| return 0; |
| } |
| |
| void EmulatedRequestProcessor::ApplyOverrideZoom( |
| const std::unique_ptr<HalCameraMetadata>& override_setting, |
| const std::unique_ptr<HalCameraMetadata>& request_settings, |
| camera_metadata_tag tag) { |
| status_t ret; |
| camera_metadata_ro_entry_t entry; |
| ret = override_setting->Get(tag, &entry); |
| if (ret == OK) { |
| if (entry.type == TYPE_INT32) { |
| request_settings->Set(tag, entry.data.i32, entry.count); |
| } else if (entry.type == TYPE_FLOAT) { |
| request_settings->Set(tag, entry.data.f, entry.count); |
| } else { |
| ALOGE("%s: Unsupported override key %d", __FUNCTION__, tag); |
| } |
| } else { |
| auto missing_tag = get_camera_metadata_tag_name(tag); |
| ALOGE("%s: %s needs to be specified for overriding zoom", __func__, |
| missing_tag); |
| } |
| } |
| |
| Return<void> EmulatedRequestProcessor::SensorHandler::onEvent(const Event& e) { |
| auto processor = processor_.lock(); |
| if (processor.get() == nullptr) { |
| return Void(); |
| } |
| |
| if (e.sensorType == SensorType::ACCELEROMETER) { |
| // Heuristic approach for deducing the screen |
| // rotation depending on the reported |
| // accelerometer readings. We switch |
| // the screen rotation when one of the |
| // x/y axis gets close enough to the earth |
| // acceleration. |
| const uint32_t earth_accel = 9; // Switch threshold [m/s^2] |
| uint32_t x_accel = e.u.vec3.x; |
| uint32_t y_accel = e.u.vec3.y; |
| uint32_t z_accel = abs(e.u.vec3.z); |
| if (z_accel == earth_accel) { |
| return Void(); |
| } |
| |
| if (x_accel == earth_accel) { |
| processor->screen_rotation_ = 270; |
| } else if (x_accel == -earth_accel) { |
| processor->screen_rotation_ = 90; |
| } else if (y_accel == -earth_accel) { |
| processor->screen_rotation_ = 180; |
| } else { |
| processor->screen_rotation_ = 0; |
| } |
| } else { |
| ALOGE("%s: unexpected event received type: %d", __func__, e.sensorType); |
| } |
| return Void(); |
| } |
| |
| void EmulatedRequestProcessor::InitializeSensorQueue( |
| std::weak_ptr<EmulatedRequestProcessor> processor) { |
| if (sensor_event_queue_.get() != nullptr) { |
| return; |
| } |
| |
| sp<ISensorManager> manager = ISensorManager::getService(); |
| if (manager == nullptr) { |
| ALOGE("%s: Cannot get ISensorManager", __func__); |
| } else { |
| bool sensor_found = false; |
| manager->getSensorList([&](const auto& list, auto result) { |
| if (result != Result::OK) { |
| ALOGE("%s: Failed to retrieve sensor list!", __func__); |
| } else { |
| for (const SensorInfo& it : list) { |
| if (it.type == SensorType::ACCELEROMETER) { |
| sensor_found = true; |
| sensor_handle_ = it.sensorHandle; |
| } |
| } |
| } |
| }); |
| if (sensor_found) { |
| manager->createEventQueue( |
| new SensorHandler(processor), [&](const auto& q, auto result) { |
| if (result != Result::OK) { |
| ALOGE("%s: Cannot create event queue", __func__); |
| return; |
| } |
| sensor_event_queue_ = q; |
| }); |
| |
| if (sensor_event_queue_.get() != nullptr) { |
| auto res = sensor_event_queue_->enableSensor( |
| sensor_handle_, |
| ns2us(EmulatedSensor::kSupportedFrameDurationRange[0]), |
| 0 /*maxBatchReportLatencyUs*/); |
| if (res.isOk()) { |
| } else { |
| ALOGE("%s: Failed to enable sensor", __func__); |
| } |
| } else { |
| ALOGE("%s: Failed to create event queue", __func__); |
| } |
| } |
| } |
| } |
| |
| } // namespace android |
