| /* |
| * 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 "EmulatedRequestState" |
| #define ATRACE_TAG ATRACE_TAG_CAMERA |
| |
| #include "EmulatedRequestState.h" |
| |
| #include <inttypes.h> |
| #include <log/log.h> |
| #include <utils/HWLUtils.h> |
| |
| #include "EmulatedRequestProcessor.h" |
| |
| namespace android { |
| |
| using google_camera_hal::HwlPipelineResult; |
| |
| status_t EmulatedRequestState::Update3AMeteringRegion( |
| uint32_t tag, const HalCameraMetadata& settings, int32_t* region /*out*/) { |
| if ((region == nullptr) || ((tag != ANDROID_CONTROL_AE_REGIONS) && |
| (tag != ANDROID_CONTROL_AF_REGIONS) && |
| (tag != ANDROID_CONTROL_AWB_REGIONS))) { |
| return BAD_VALUE; |
| } |
| |
| camera_metadata_ro_entry_t entry; |
| auto ret = settings.Get(ANDROID_SCALER_CROP_REGION, &entry); |
| if ((ret == OK) && (entry.count > 0)) { |
| int32_t crop_region[4]; |
| crop_region[0] = entry.data.i32[0]; |
| crop_region[1] = entry.data.i32[1]; |
| crop_region[2] = entry.data.i32[2] + crop_region[0]; |
| crop_region[3] = entry.data.i32[3] + crop_region[1]; |
| ret = settings.Get(tag, &entry); |
| if ((ret == OK) && (entry.count > 0)) { |
| const int32_t* a_region = entry.data.i32; |
| // calculate the intersection of 3A and CROP regions |
| if (a_region[0] < crop_region[2] && crop_region[0] < a_region[2] && |
| a_region[1] < crop_region[3] && crop_region[1] < a_region[3]) { |
| region[0] = std::max(a_region[0], crop_region[0]); |
| region[1] = std::max(a_region[1], crop_region[1]); |
| region[2] = std::min(a_region[2], crop_region[2]); |
| region[3] = std::min(a_region[3], crop_region[3]); |
| region[4] = entry.data.i32[4]; |
| } |
| } |
| } |
| |
| return OK; |
| } |
| |
| status_t EmulatedRequestState::CompensateAE() { |
| auto& info = *device_info_; |
| |
| if (!info.exposure_compensation_supported_) { |
| info.sensor_exposure_time_ = current_exposure_time_; |
| return OK; |
| } |
| |
| camera_metadata_ro_entry_t entry; |
| auto ret = |
| request_settings_->Get(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| info.exposure_compensation_ = entry.data.i32[0]; |
| } else { |
| ALOGW("%s: AE compensation absent from request, re-using previous value!", |
| __FUNCTION__); |
| } |
| |
| float ae_compensation = ::powf( |
| 2, info.exposure_compensation_ * |
| ((static_cast<float>(info.exposure_compensation_step_.numerator) / |
| info.exposure_compensation_step_.denominator))); |
| |
| info.sensor_exposure_time_ = GetClosestValue( |
| static_cast<nsecs_t>(ae_compensation * current_exposure_time_), |
| info.sensor_exposure_time_range_.first, |
| info.sensor_exposure_time_range_.second); |
| |
| return OK; |
| } |
| |
| status_t EmulatedRequestState::DoFakeAE() { |
| auto& info = *device_info_; |
| |
| camera_metadata_ro_entry_t entry; |
| auto ret = request_settings_->Get(ANDROID_CONTROL_AE_LOCK, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| info.ae_lock_ = entry.data.u8[0]; |
| } else { |
| info.ae_lock_ = ANDROID_CONTROL_AE_LOCK_OFF; |
| } |
| |
| if (info.ae_lock_ == ANDROID_CONTROL_AE_LOCK_ON) { |
| info.ae_state_ = ANDROID_CONTROL_AE_STATE_LOCKED; |
| return OK; |
| } |
| |
| EmulatedCameraDeviceInfo::FPSRange fps_range; |
| ret = request_settings_->Get(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, &entry); |
| if ((ret == OK) && (entry.count == 2)) { |
| for (const auto& it : info.available_fps_ranges_) { |
| if ((it.min_fps == entry.data.i32[0]) && |
| (it.max_fps == entry.data.i32[1])) { |
| fps_range = {entry.data.i32[0], entry.data.i32[1]}; |
| break; |
| } |
| } |
| if (fps_range.max_fps == 0) { |
| ALOGE("%s: Unsupported framerate range [%d, %d]", __FUNCTION__, |
| entry.data.i32[0], entry.data.i32[1]); |
| return BAD_VALUE; |
| } |
| } else { |
| fps_range = *info.available_fps_ranges_.begin(); |
| } |
| |
| ret = request_settings_->Get(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| info.ae_trigger_ = entry.data.u8[0]; |
| } else { |
| info.ae_trigger_ = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE; |
| } |
| |
| nsecs_t min_frame_duration = |
| GetClosestValue(ms2ns(1000 / fps_range.max_fps), |
| EmulatedSensor::kSupportedFrameDurationRange[0], |
| info.sensor_max_frame_duration_); |
| nsecs_t max_frame_duration = |
| GetClosestValue(ms2ns(1000 / fps_range.min_fps), |
| EmulatedSensor::kSupportedFrameDurationRange[0], |
| info.sensor_max_frame_duration_); |
| info.sensor_frame_duration_ = (max_frame_duration + min_frame_duration) / 2; |
| |
| // Face priority mode usually changes the AE algorithm behavior by |
| // using the regions of interest associated with detected faces. |
| // Try to emulate this behavior by slightly increasing the target exposure |
| // time compared to normal operation. |
| if (info.exposure_compensation_supported_) { |
| float max_ae_compensation = ::powf( |
| 2, info.exposure_compensation_range_[1] * |
| ((static_cast<float>(info.exposure_compensation_step_.numerator) / |
| info.exposure_compensation_step_.denominator))); |
| ae_target_exposure_time_ = GetClosestValue( |
| static_cast<nsecs_t>(info.sensor_frame_duration_ / max_ae_compensation), |
| info.sensor_exposure_time_range_.first, |
| info.sensor_exposure_time_range_.second); |
| } else if (info.scene_mode_ == ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY) { |
| ae_target_exposure_time_ = GetClosestValue( |
| info.sensor_frame_duration_ / 4, info.sensor_exposure_time_range_.first, |
| info.sensor_exposure_time_range_.second); |
| } else { |
| ae_target_exposure_time_ = GetClosestValue( |
| info.sensor_frame_duration_ / 5, info.sensor_exposure_time_range_.first, |
| info.sensor_exposure_time_range_.second); |
| } |
| |
| if ((info.ae_trigger_ == ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START) || |
| (info.ae_state_ == ANDROID_CONTROL_AE_STATE_PRECAPTURE)) { |
| if (info.ae_state_ != ANDROID_CONTROL_AE_STATE_PRECAPTURE) { |
| ae_frame_counter_ = 0; |
| } |
| |
| if (info.ae_trigger_ == ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL) { |
| // Done with precapture |
| ae_frame_counter_ = 0; |
| info.ae_state_ = ANDROID_CONTROL_AE_STATE_CONVERGED; |
| info.ae_trigger_ = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL; |
| } else if ((ae_frame_counter_ > kAEPrecaptureMinFrames) && |
| (abs(ae_target_exposure_time_ - current_exposure_time_) < |
| ae_target_exposure_time_ / kAETargetThreshold)) { |
| // Done with precapture |
| ae_frame_counter_ = 0; |
| info.ae_state_ = ANDROID_CONTROL_AE_STATE_CONVERGED; |
| info.ae_trigger_ = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE; |
| } else { |
| // Converge some more |
| current_exposure_time_ += |
| (ae_target_exposure_time_ - current_exposure_time_) * |
| kExposureTrackRate; |
| ae_frame_counter_++; |
| info.ae_state_ = ANDROID_CONTROL_AE_STATE_PRECAPTURE; |
| } |
| } else { |
| switch (info.ae_state_) { |
| case ANDROID_CONTROL_AE_STATE_INACTIVE: |
| info.ae_state_ = ANDROID_CONTROL_AE_STATE_SEARCHING; |
| break; |
| case ANDROID_CONTROL_AE_STATE_CONVERGED: |
| ae_frame_counter_++; |
| if (ae_frame_counter_ > kStableAeMaxFrames) { |
| float exposure_step = ((double)rand_r(&rand_seed_) / RAND_MAX) * |
| (kExposureWanderMax - kExposureWanderMin) + |
| kExposureWanderMin; |
| ae_target_exposure_time_ = |
| GetClosestValue(static_cast<nsecs_t>(ae_target_exposure_time_ * |
| std::pow(2, exposure_step)), |
| info.sensor_exposure_time_range_.first, |
| info.sensor_exposure_time_range_.second); |
| info.ae_state_ = ANDROID_CONTROL_AE_STATE_SEARCHING; |
| } |
| break; |
| case ANDROID_CONTROL_AE_STATE_SEARCHING: |
| current_exposure_time_ += |
| (ae_target_exposure_time_ - current_exposure_time_) * |
| kExposureTrackRate; |
| if (abs(ae_target_exposure_time_ - current_exposure_time_) < |
| ae_target_exposure_time_ / kAETargetThreshold) { |
| // Close enough |
| info.ae_state_ = ANDROID_CONTROL_AE_STATE_CONVERGED; |
| ae_frame_counter_ = 0; |
| } |
| break; |
| case ANDROID_CONTROL_AE_STATE_LOCKED: |
| info.ae_state_ = ANDROID_CONTROL_AE_STATE_CONVERGED; |
| ae_frame_counter_ = 0; |
| break; |
| default: |
| ALOGE("%s: Unexpected AE state %d!", __FUNCTION__, info.ae_state_); |
| return INVALID_OPERATION; |
| } |
| } |
| |
| return OK; |
| } |
| |
| status_t EmulatedRequestState::ProcessAWB() { |
| auto& info = *device_info_; |
| |
| if (info.max_awb_regions_ > 0) { |
| auto ret = |
| Update3AMeteringRegion(ANDROID_CONTROL_AWB_REGIONS, *request_settings_, |
| info.awb_metering_region_); |
| if (ret != OK) { |
| return ret; |
| } |
| } |
| if (((info.awb_mode_ == ANDROID_CONTROL_AWB_MODE_OFF) || |
| (info.control_mode_ == ANDROID_CONTROL_MODE_OFF)) && |
| info.supports_manual_post_processing_) { |
| // TODO: Add actual manual support |
| } else if (info.is_backward_compatible_) { |
| camera_metadata_ro_entry_t entry; |
| auto ret = request_settings_->Get(ANDROID_CONTROL_AWB_LOCK, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| info.awb_lock_ = entry.data.u8[0]; |
| } else { |
| info.awb_lock_ = ANDROID_CONTROL_AWB_LOCK_OFF; |
| } |
| |
| if (info.awb_lock_ == ANDROID_CONTROL_AWB_LOCK_ON) { |
| info.awb_state_ = ANDROID_CONTROL_AWB_STATE_LOCKED; |
| } else { |
| info.awb_state_ = ANDROID_CONTROL_AWB_STATE_CONVERGED; |
| } |
| } else { |
| // No color output support no need for AWB |
| } |
| |
| return OK; |
| } |
| |
| status_t EmulatedRequestState::ProcessAF() { |
| auto& info = *device_info_; |
| camera_metadata_ro_entry entry; |
| |
| if (info.max_af_regions_ > 0) { |
| auto ret = |
| Update3AMeteringRegion(ANDROID_CONTROL_AF_REGIONS, *request_settings_, |
| info.af_metering_region_); |
| if (ret != OK) { |
| return ret; |
| } |
| } |
| if (info.af_mode_ == ANDROID_CONTROL_AF_MODE_OFF) { |
| camera_metadata_ro_entry_t entry; |
| auto ret = request_settings_->Get(ANDROID_LENS_FOCUS_DISTANCE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if ((entry.data.f[0] >= 0.f) && |
| (entry.data.f[0] <= info.minimum_focus_distance_)) { |
| info.focus_distance_ = entry.data.f[0]; |
| } else { |
| ALOGE( |
| "%s: Unsupported focus distance, It should be within " |
| "[%5.2f, %5.2f]", |
| __FUNCTION__, 0.f, info.minimum_focus_distance_); |
| } |
| } |
| |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_INACTIVE; |
| return OK; |
| } |
| |
| auto ret = request_settings_->Get(ANDROID_CONTROL_AF_TRIGGER, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| info.af_trigger_ = entry.data.u8[0]; |
| } else { |
| info.af_trigger_ = ANDROID_CONTROL_AF_TRIGGER_IDLE; |
| } |
| |
| /** |
| * Simulate AF triggers. Transition at most 1 state per frame. |
| * - Focusing always succeeds (goes into locked, or PASSIVE_SCAN). |
| */ |
| |
| bool af_trigger_start = false; |
| switch (info.af_trigger_) { |
| case ANDROID_CONTROL_AF_TRIGGER_IDLE: |
| break; |
| case ANDROID_CONTROL_AF_TRIGGER_START: |
| af_trigger_start = true; |
| break; |
| case ANDROID_CONTROL_AF_TRIGGER_CANCEL: |
| // Cancel trigger always transitions into INACTIVE |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_INACTIVE; |
| |
| // Stay in 'inactive' until at least next frame |
| return OK; |
| default: |
| ALOGE("%s: Unknown AF trigger value", __FUNCTION__); |
| return BAD_VALUE; |
| } |
| |
| // If we get down here, we're either in ANDROID_CONTROL_AF_MODE_AUTO, |
| // ANDROID_CONTROL_AF_MODE_MACRO, ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO, |
| // ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE and no other modes like |
| // ANDROID_CONTROL_AF_MODE_OFF or ANDROID_CONTROL_AF_MODE_EDOF |
| switch (info.af_state_) { |
| case ANDROID_CONTROL_AF_STATE_INACTIVE: |
| if (af_trigger_start) { |
| switch (info.af_mode_) { |
| case ANDROID_CONTROL_AF_MODE_AUTO: |
| // fall-through |
| case ANDROID_CONTROL_AF_MODE_MACRO: |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; |
| break; |
| case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: |
| // fall-through |
| case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; |
| break; |
| } |
| } else { |
| // At least one frame stays in INACTIVE |
| if (!af_mode_changed_) { |
| switch (info.af_mode_) { |
| case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: |
| // fall-through |
| case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN; |
| break; |
| } |
| } |
| } |
| break; |
| case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: |
| /** |
| * When the AF trigger is activated, the algorithm should finish |
| * its PASSIVE_SCAN if active, and then transition into AF_FOCUSED |
| * or AF_NOT_FOCUSED as appropriate |
| */ |
| if (af_trigger_start) { |
| // Randomly transition to focused or not focused |
| if (rand_r(&rand_seed_) % 3) { |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; |
| } else { |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; |
| } |
| } |
| /** |
| * When the AF trigger is not involved, the AF algorithm should |
| * start in INACTIVE state, and then transition into PASSIVE_SCAN |
| * and PASSIVE_FOCUSED states |
| */ |
| else { |
| // Randomly transition to passive focus |
| if (rand_r(&rand_seed_) % 3 == 0) { |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED; |
| } |
| } |
| |
| break; |
| case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: |
| if (af_trigger_start) { |
| // Randomly transition to focused or not focused |
| if (rand_r(&rand_seed_) % 3) { |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; |
| } else { |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; |
| } |
| } |
| // TODO: initiate passive scan (PASSIVE_SCAN) |
| break; |
| case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN: |
| // Simulate AF sweep completing instantaneously |
| |
| // Randomly transition to focused or not focused |
| if (rand_r(&rand_seed_) % 3) { |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; |
| } else { |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; |
| } |
| break; |
| case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: |
| if (af_trigger_start) { |
| switch (info.af_mode_) { |
| case ANDROID_CONTROL_AF_MODE_AUTO: |
| // fall-through |
| case ANDROID_CONTROL_AF_MODE_MACRO: |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; |
| break; |
| case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: |
| // fall-through |
| case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: |
| // continuous autofocus => trigger start has no effect |
| break; |
| } |
| } |
| break; |
| case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: |
| if (af_trigger_start) { |
| switch (info.af_mode_) { |
| case ANDROID_CONTROL_AF_MODE_AUTO: |
| // fall-through |
| case ANDROID_CONTROL_AF_MODE_MACRO: |
| info.af_state_ = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; |
| break; |
| case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: |
| // fall-through |
| case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: |
| // continuous autofocus => trigger start has no effect |
| break; |
| } |
| } |
| break; |
| default: |
| ALOGE("%s: Bad af state %d", __FUNCTION__, info.af_state_); |
| } |
| |
| return OK; |
| } |
| |
| status_t EmulatedRequestState::ProcessAE() { |
| auto& info = *device_info_; |
| if (info.max_ae_regions_ > 0) { |
| auto ret = |
| Update3AMeteringRegion(ANDROID_CONTROL_AE_REGIONS, *request_settings_, |
| info.ae_metering_region_); |
| if (ret != OK) { |
| ALOGE("%s: Failed updating the 3A metering regions: %d, (%s)", |
| __FUNCTION__, ret, strerror(-ret)); |
| } |
| } |
| |
| camera_metadata_ro_entry_t entry; |
| bool auto_ae_mode = false; |
| bool auto_ae_flash_mode = false; |
| switch (info.ae_mode_) { |
| case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH: |
| case ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH: |
| case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE: |
| auto_ae_flash_mode = true; |
| [[fallthrough]]; |
| case ANDROID_CONTROL_AE_MODE_ON: |
| auto_ae_mode = true; |
| }; |
| if (((info.ae_mode_ == ANDROID_CONTROL_AE_MODE_OFF) || |
| (info.control_mode_ == ANDROID_CONTROL_MODE_OFF)) && |
| info.supports_manual_sensor_) { |
| auto ret = request_settings_->Get(ANDROID_SENSOR_EXPOSURE_TIME, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if ((entry.data.i64[0] >= info.sensor_exposure_time_range_.first) && |
| (entry.data.i64[0] <= info.sensor_exposure_time_range_.second)) { |
| info.sensor_exposure_time_ = entry.data.i64[0]; |
| } else { |
| ALOGE("%s: Sensor exposure time %" PRId64 |
| " not within supported range[%" PRId64 ", %" PRId64 "]", |
| __FUNCTION__, entry.data.i64[0], |
| info.sensor_exposure_time_range_.first, |
| info.sensor_exposure_time_range_.second); |
| // Use last valid value |
| } |
| } |
| |
| ret = request_settings_->Get(ANDROID_SENSOR_FRAME_DURATION, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if ((entry.data.i64[0] >= |
| EmulatedSensor::kSupportedFrameDurationRange[0]) && |
| (entry.data.i64[0] <= info.sensor_max_frame_duration_)) { |
| info.sensor_frame_duration_ = entry.data.i64[0]; |
| } else { |
| ALOGE("%s: Sensor frame duration %" PRId64 |
| " not within supported range[%" PRId64 ", %" PRId64 "]", |
| __FUNCTION__, entry.data.i64[0], |
| EmulatedSensor::kSupportedFrameDurationRange[0], |
| info.sensor_max_frame_duration_); |
| // Use last valid value |
| } |
| } |
| |
| if (info.sensor_frame_duration_ < info.sensor_exposure_time_) { |
| info.sensor_frame_duration_ = info.sensor_exposure_time_; |
| } |
| |
| ret = request_settings_->Get(ANDROID_SENSOR_SENSITIVITY, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if ((entry.data.i32[0] >= info.sensor_sensitivity_range_.first) && |
| (entry.data.i32[0] <= info.sensor_sensitivity_range_.second)) { |
| info.sensor_sensitivity_ = entry.data.i32[0]; |
| } else { |
| ALOGE("%s: Sensor sensitivity %d not within supported range[%d, %d]", |
| __FUNCTION__, entry.data.i32[0], |
| info.sensor_sensitivity_range_.first, |
| info.sensor_sensitivity_range_.second); |
| // Use last valid value |
| } |
| } |
| info.ae_state_ = ANDROID_CONTROL_AE_STATE_INACTIVE; |
| } else if (info.is_backward_compatible_ && auto_ae_mode) { |
| auto ret = DoFakeAE(); |
| if (ret != OK) { |
| ALOGE("%s: Failed fake AE: %d, (%s)", __FUNCTION__, ret, strerror(-ret)); |
| } |
| |
| // Do AE compensation on the results of the AE |
| ret = CompensateAE(); |
| if (ret != OK) { |
| ALOGE("%s: Failed during AE compensation: %d, (%s)", __FUNCTION__, ret, |
| strerror(-ret)); |
| } |
| if (info.ae_priority_mode_ == ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_EXPOSURE_TIME_PRIORITY) { |
| auto ret = request_settings_->Get(ANDROID_SENSOR_EXPOSURE_TIME, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| info.sensor_exposure_time_ = GetExposureTimeClampToRange(entry.data.i64[0]); |
| } |
| } |
| |
| if (info.ae_priority_mode_ == ANDROID_CONTROL_AE_PRIORITY_MODE_SENSOR_SENSITIVITY_PRIORITY) { |
| auto ret = request_settings_->Get(ANDROID_SENSOR_SENSITIVITY, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| info.sensor_sensitivity_ = GetSensitivityClampToRange(entry.data.i32[0]); |
| } |
| } |
| } else { |
| ALOGI( |
| "%s: No emulation for current AE mode using previous sensor settings!", |
| __FUNCTION__); |
| } |
| |
| if (info.is_flash_supported_) { |
| info.flash_state_ = ANDROID_FLASH_STATE_READY; |
| // Flash fires only if the request manually enables it (SINGLE/TORCH) |
| // and the appropriate AE mode is set or during still capture with auto |
| // flash AE modes. |
| bool manual_flash_mode = false; |
| auto ret = request_settings_->Get(ANDROID_FLASH_MODE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if ((entry.data.u8[0] == ANDROID_FLASH_MODE_SINGLE) || |
| (entry.data.u8[0] == ANDROID_FLASH_MODE_TORCH)) { |
| manual_flash_mode = true; |
| } |
| } |
| if (manual_flash_mode && !auto_ae_flash_mode) { |
| info.flash_state_ = ANDROID_FLASH_STATE_FIRED; |
| } else { |
| bool is_still_capture = false; |
| ret = request_settings_->Get(ANDROID_CONTROL_CAPTURE_INTENT, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if (entry.data.u8[0] == ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE) { |
| is_still_capture = true; |
| } |
| } |
| if (is_still_capture && auto_ae_flash_mode) { |
| info.flash_state_ = ANDROID_FLASH_STATE_FIRED; |
| } |
| } |
| } else { |
| info.flash_state_ = ANDROID_FLASH_STATE_UNAVAILABLE; |
| } |
| |
| return OK; |
| } |
| |
| int EmulatedRequestState::GetSensitivityClampToRange(uint32_t sensitivity) { |
| auto& info = *device_info_; |
| uint32_t min_sensitivity = info.sensor_sensitivity_range_.first; |
| uint32_t max_sensitivity = info.sensor_sensitivity_range_.second; |
| |
| if ((sensitivity < min_sensitivity) || |
| (sensitivity > max_sensitivity)) { |
| ALOGW("%s: Sensor sensitivity %d not within supported range[%d, %d]", |
| __FUNCTION__, sensitivity, min_sensitivity, max_sensitivity); |
| } |
| |
| return std::max(min_sensitivity, std::min(max_sensitivity, sensitivity)); |
| } |
| |
| int EmulatedRequestState::GetExposureTimeClampToRange(uint32_t exposure) { |
| auto& info = *device_info_; |
| uint32_t min_exposure = info.sensor_exposure_time_range_.first; |
| uint32_t max_exposure = info.sensor_exposure_time_range_.second; |
| |
| if ((exposure < min_exposure) || |
| (exposure > max_exposure)) { |
| ALOGW("%s: Sensor exposure time %d not within supported range[%d, %d]", |
| __FUNCTION__, exposure, min_exposure, max_exposure); |
| } |
| |
| return std::max(min_exposure, std::min(max_exposure, exposure)); |
| } |
| |
| status_t EmulatedRequestState::InitializeSensorSettings( |
| std::unique_ptr<HalCameraMetadata> request_settings, |
| uint32_t override_frame_number, |
| EmulatedSensor::SensorSettings* sensor_settings /*out*/) { |
| auto& info = *device_info_; |
| if ((sensor_settings == nullptr) || (request_settings.get() == nullptr)) { |
| return BAD_VALUE; |
| } |
| |
| std::lock_guard<std::mutex> lock(request_state_mutex_); |
| request_settings_ = std::move(request_settings); |
| camera_metadata_ro_entry_t entry; |
| auto ret = request_settings_->Get(ANDROID_CONTROL_MODE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if (info.available_control_modes_.find(entry.data.u8[0]) != |
| info.available_control_modes_.end()) { |
| info.control_mode_ = entry.data.u8[0]; |
| } else { |
| ALOGE("%s: Unsupported control mode!", __FUNCTION__); |
| return BAD_VALUE; |
| } |
| } |
| |
| ret = request_settings_->Get(ANDROID_SENSOR_PIXEL_MODE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if (info.available_sensor_pixel_modes_.find(entry.data.u8[0]) != |
| info.available_sensor_pixel_modes_.end()) { |
| info.sensor_pixel_mode_ = entry.data.u8[0]; |
| } else { |
| ALOGE("%s: Unsupported control sensor pixel mode!", __FUNCTION__); |
| return BAD_VALUE; |
| } |
| } |
| |
| ret = request_settings_->Get(ANDROID_CONTROL_SCENE_MODE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| // Disabled scene is not expected to be among the available scene list |
| if ((entry.data.u8[0] == ANDROID_CONTROL_SCENE_MODE_DISABLED) || |
| (info.available_scenes_.find(entry.data.u8[0]) != |
| info.available_scenes_.end())) { |
| info.scene_mode_ = entry.data.u8[0]; |
| } else { |
| ALOGE("%s: Unsupported scene mode!", __FUNCTION__); |
| return BAD_VALUE; |
| } |
| } |
| |
| float min_zoom = info.min_zoom_, max_zoom = info.max_zoom_; |
| ret = request_settings_->Get(ANDROID_CONTROL_EXTENDED_SCENE_MODE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| bool extended_scene_mode_valid = false; |
| for (const auto& cap : info.available_extended_scene_mode_caps_) { |
| if (cap.mode == entry.data.u8[0]) { |
| info.extended_scene_mode_ = entry.data.u8[0]; |
| min_zoom = cap.min_zoom; |
| max_zoom = cap.max_zoom; |
| extended_scene_mode_valid = true; |
| break; |
| } |
| } |
| if (!extended_scene_mode_valid) { |
| ALOGE("%s: Unsupported extended scene mode %d!", __FUNCTION__, |
| entry.data.u8[0]); |
| return BAD_VALUE; |
| } |
| if (info.extended_scene_mode_ != |
| ANDROID_CONTROL_EXTENDED_SCENE_MODE_DISABLED) { |
| info.scene_mode_ = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; |
| } |
| } |
| |
| // Check zoom ratio range and override to supported range |
| ret = request_settings_->Get(ANDROID_CONTROL_ZOOM_RATIO, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| info.zoom_ratio_ = std::min(std::max(entry.data.f[0], min_zoom), max_zoom); |
| } |
| |
| // Check settings override |
| ret = request_settings_->Get(ANDROID_CONTROL_SETTINGS_OVERRIDE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| info.settings_override_ = entry.data.i32[0]; |
| } |
| |
| // Store settings override frame number |
| if (override_frame_number != 0) { |
| settings_overriding_frame_number_ = override_frame_number; |
| } |
| |
| // Check rotate_and_crop setting |
| ret = request_settings_->Get(ANDROID_SCALER_ROTATE_AND_CROP, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if (info.available_rotate_crop_modes_.find(entry.data.u8[0]) != |
| info.available_rotate_crop_modes_.end()) { |
| info.rotate_and_crop_ = entry.data.u8[0]; |
| } else { |
| ALOGE("%s: Unsupported rotate and crop mode: %u", __FUNCTION__, entry.data.u8[0]); |
| return BAD_VALUE; |
| } |
| } |
| |
| // Check video stabilization parameter |
| uint8_t vstab_mode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF; |
| ret = request_settings_->Get(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if (info.available_vstab_modes_.find(entry.data.u8[0]) != |
| info.available_vstab_modes_.end()) { |
| vstab_mode = entry.data.u8[0]; |
| } else { |
| ALOGE("%s: Unsupported video stabilization mode: %u! Video stabilization will be disabled!", |
| __FUNCTION__, entry.data.u8[0]); |
| } |
| } |
| |
| // Check autoframing |
| ret = request_settings_->Get(ANDROID_CONTROL_AUTOFRAMING, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| info.autoframing_ = entry.data.i32[0]; |
| if (info.autoframing_ == ANDROID_CONTROL_AUTOFRAMING_ON) { |
| // Set zoom_ratio to be a hard-coded value to test autoframing. |
| info.zoom_ratio_ = 1.7f; |
| vstab_mode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF; |
| } |
| } |
| |
| // Check manual flash strength level |
| ret = request_settings_->Get(ANDROID_FLASH_STRENGTH_LEVEL, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| info.flash_strength_level_ = entry.data.i32[0]; |
| if (ANDROID_FLASH_SINGLE_STRENGTH_MAX_LEVEL > 1 && |
| ANDROID_FLASH_TORCH_STRENGTH_MAX_LEVEL > 1 && info.is_flash_supported_) { |
| ALOGI("%s: Device supports manual flash strength control", __FUNCTION__); |
| info.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); |
| if ((ret == OK) && (entry.count == 1)) { |
| if (info.available_edge_modes_.find(entry.data.u8[0]) != |
| info.available_edge_modes_.end()) { |
| edge_mode = entry.data.u8[0]; |
| } else { |
| ALOGE("%s: Unsupported edge mode: %u", __FUNCTION__, entry.data.u8[0]); |
| return BAD_VALUE; |
| } |
| } |
| |
| // Check test pattern parameter |
| uint8_t test_pattern_mode = ANDROID_SENSOR_TEST_PATTERN_MODE_OFF; |
| ret = request_settings_->Get(ANDROID_SENSOR_TEST_PATTERN_MODE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if (info.available_test_pattern_modes_.find(entry.data.u8[0]) != |
| info.available_test_pattern_modes_.end()) { |
| test_pattern_mode = entry.data.u8[0]; |
| } else { |
| ALOGE("%s: Unsupported test pattern mode: %u", __FUNCTION__, |
| entry.data.u8[0]); |
| return BAD_VALUE; |
| } |
| } |
| uint32_t test_pattern_data[4] = {0, 0, 0, 0}; |
| if (test_pattern_mode == ANDROID_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR) { |
| ret = request_settings_->Get(ANDROID_SENSOR_TEST_PATTERN_DATA, &entry); |
| if ((ret == OK) && (entry.count == 4)) { |
| // 'Convert' from i32 to u32 here |
| memcpy(test_pattern_data, entry.data.i32, sizeof(test_pattern_data)); |
| } |
| } |
| // BLACK is just SOLID_COLOR with all-zero data |
| if (test_pattern_mode == ANDROID_SENSOR_TEST_PATTERN_MODE_BLACK) { |
| test_pattern_mode = ANDROID_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR; |
| } |
| |
| // 3A modes are active in case the scene is disabled or set to face priority |
| // or the control mode is not using scenes |
| if ((info.scene_mode_ == ANDROID_CONTROL_SCENE_MODE_DISABLED) || |
| (info.scene_mode_ == ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY) || |
| (info.control_mode_ != ANDROID_CONTROL_MODE_USE_SCENE_MODE)) { |
| ret = request_settings_->Get(ANDROID_CONTROL_AE_MODE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if (info.available_ae_modes_.find(entry.data.u8[0]) != |
| info.available_ae_modes_.end()) { |
| info.ae_mode_ = entry.data.u8[0]; |
| } else { |
| ALOGE("%s: Unsupported AE mode! Using last valid mode!", __FUNCTION__); |
| } |
| } |
| |
| ret = request_settings_->Get(ANDROID_CONTROL_AE_PRIORITY_MODE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if (info.available_ae_priority_modes_.find(entry.data.u8[0]) != |
| info.available_ae_priority_modes_.end()) { |
| info.ae_priority_mode_ = entry.data.u8[0]; |
| } else { |
| ALOGE("%s: Unsupported AE priority mode! Using last valid mode!", __FUNCTION__); |
| } |
| } |
| |
| ret = request_settings_->Get(ANDROID_CONTROL_AWB_MODE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if (info.available_awb_modes_.find(entry.data.u8[0]) != |
| info.available_awb_modes_.end()) { |
| info.awb_mode_ = entry.data.u8[0]; |
| } else { |
| ALOGE("%s: Unsupported AWB mode! Using last valid mode!", __FUNCTION__); |
| } |
| } |
| |
| ret = request_settings_->Get(ANDROID_CONTROL_AF_MODE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if (info.available_af_modes_.find(entry.data.u8[0]) != |
| info.available_af_modes_.end()) { |
| af_mode_changed_ = info.af_mode_ != entry.data.u8[0]; |
| info.af_mode_ = entry.data.u8[0]; |
| } else { |
| ALOGE("%s: Unsupported AF mode! Using last valid mode!", __FUNCTION__); |
| } |
| } |
| } else { |
| auto it = info.scene_overrides_.find(info.scene_mode_); |
| if (it != info.scene_overrides_.end()) { |
| info.ae_mode_ = it->second.ae_mode; |
| info.awb_mode_ = it->second.awb_mode; |
| af_mode_changed_ = info.af_mode_ != entry.data.u8[0]; |
| info.af_mode_ = it->second.af_mode; |
| } else { |
| ALOGW( |
| "%s: Current scene has no overrides! Using the currently active 3A " |
| "modes!", |
| __FUNCTION__); |
| } |
| } |
| |
| ret = ProcessAE(); |
| if (ret != OK) { |
| return ret; |
| } |
| |
| ret = ProcessAWB(); |
| if (ret != OK) { |
| return ret; |
| } |
| |
| ret = ProcessAF(); |
| if (ret != OK) { |
| return ret; |
| } |
| |
| ret = request_settings_->Get(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE, &entry); |
| if ((ret == OK) && (entry.count == 1)) { |
| if (info.available_lens_shading_map_modes_.find(entry.data.u8[0]) != |
| info.available_lens_shading_map_modes_.end()) { |
| sensor_settings->lens_shading_map_mode = entry.data.u8[0]; |
| } else { |
| ALOGE("%s: Unsupported lens shading map mode!", __FUNCTION__); |
| } |
| } |
| |
| ret = info.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) { |
| info.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 = info.sensor_exposure_time_; |
| sensor_settings->frame_duration = info.sensor_frame_duration_; |
| sensor_settings->gain = info.sensor_sensitivity_; |
| sensor_settings->report_neutral_color_point = info.report_neutral_color_point_; |
| sensor_settings->report_green_split = info.report_green_split_; |
| sensor_settings->report_noise_profile = info.report_noise_profile_; |
| sensor_settings->zoom_ratio = info.zoom_ratio_; |
| sensor_settings->report_rotate_and_crop = info.report_rotate_and_crop_; |
| sensor_settings->rotate_and_crop = info.rotate_and_crop_; |
| sensor_settings->report_video_stab = !info.available_vstab_modes_.empty(); |
| sensor_settings->video_stab = vstab_mode; |
| sensor_settings->report_edge_mode = info.report_edge_mode_; |
| sensor_settings->edge_mode = edge_mode; |
| sensor_settings->sensor_pixel_mode = info.sensor_pixel_mode_; |
| sensor_settings->test_pattern_mode = test_pattern_mode; |
| sensor_settings->timestamp_source = info.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; |
| auto& info = *device_info_; |
| |
| if (is_partial_result) { |
| res = 1; |
| } else { |
| res = info.partial_result_count_ ? info.partial_result_count_ : 1; |
| } |
| |
| return res; |
| } |
| |
| std::unique_ptr<HwlPipelineResult> EmulatedRequestState::InitializePartialResult( |
| uint32_t pipeline_id, uint32_t frame_number) { |
| auto& info = *device_info_; |
| std::lock_guard<std::mutex> lock(request_state_mutex_); |
| auto result = std::make_unique<HwlPipelineResult>(); |
| |
| if (info.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) { |
| auto& info = *device_info_; |
| std::lock_guard<std::mutex> lock(request_state_mutex_); |
| auto result = std::make_unique<HwlPipelineResult>(); |
| result->camera_id = camera_id_; |
| result->pipeline_id = pipeline_id; |
| result->frame_number = frame_number; |
| result->result_metadata = HalCameraMetadata::Clone(request_settings_.get()); |
| result->partial_result = GetPartialResultCount(/*is partial result*/ false); |
| |
| // Results supported on all emulated devices |
| result->result_metadata->Set(ANDROID_REQUEST_PIPELINE_DEPTH, |
| &info.max_pipeline_depth_, 1); |
| result->result_metadata->Set(ANDROID_CONTROL_MODE, &info.control_mode_, 1); |
| result->result_metadata->Set(ANDROID_SENSOR_PIXEL_MODE, |
| &info.sensor_pixel_mode_, 1); |
| |
| result->result_metadata->Set(ANDROID_CONTROL_AF_MODE, &info.af_mode_, 1); |
| result->result_metadata->Set(ANDROID_CONTROL_AF_STATE, &info.af_state_, 1); |
| result->result_metadata->Set(ANDROID_CONTROL_AWB_MODE, &info.awb_mode_, 1); |
| result->result_metadata->Set(ANDROID_CONTROL_AWB_STATE, &info.awb_state_, 1); |
| result->result_metadata->Set(ANDROID_CONTROL_AE_MODE, &info.ae_mode_, 1); |
| |
| if (info.ae_mode_ == ANDROID_CONTROL_AE_MODE_OFF) { |
| // AE Priority mode should not work with AE mode OFF |
| uint8_t ae_priority_mode_off = ANDROID_CONTROL_AE_PRIORITY_MODE_OFF; |
| result->result_metadata->Set(ANDROID_CONTROL_AE_PRIORITY_MODE, |
| &ae_priority_mode_off, 1); |
| } else { |
| result->result_metadata->Set(ANDROID_CONTROL_AE_PRIORITY_MODE, |
| &info.ae_priority_mode_, 1); |
| } |
| |
| result->result_metadata->Set(ANDROID_CONTROL_AE_STATE, &info.ae_state_, 1); |
| // If the overriding frame number isn't larger than current frame number, |
| // use 0. |
| int32_t settings_override = info.settings_override_; |
| uint32_t overriding_frame_number = settings_overriding_frame_number_; |
| if (overriding_frame_number <= frame_number) { |
| overriding_frame_number = frame_number; |
| settings_override = ANDROID_CONTROL_SETTINGS_OVERRIDE_OFF; |
| } |
| result->result_metadata->Set(ANDROID_CONTROL_SETTINGS_OVERRIDE, |
| &settings_override, 1); |
| result->result_metadata->Set(ANDROID_CONTROL_SETTINGS_OVERRIDING_FRAME_NUMBER, |
| (int32_t*)&overriding_frame_number, 1); |
| result->result_metadata->Set(ANDROID_CONTROL_AUTOFRAMING, &info.autoframing_, |
| 1); |
| uint8_t autoframing_state = ANDROID_CONTROL_AUTOFRAMING_STATE_INACTIVE; |
| if (info.autoframing_ == ANDROID_CONTROL_AUTOFRAMING_ON) { |
| autoframing_state = ANDROID_CONTROL_AUTOFRAMING_STATE_CONVERGED; |
| } |
| result->result_metadata->Set(ANDROID_CONTROL_AUTOFRAMING_STATE, |
| &autoframing_state, 1); |
| |
| int32_t fps_range[] = {info.ae_target_fps_.min_fps, |
| info.ae_target_fps_.max_fps}; |
| result->result_metadata->Set(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, fps_range, |
| ARRAY_SIZE(fps_range)); |
| result->result_metadata->Set(ANDROID_FLASH_STATE, &info.flash_state_, 1); |
| result->result_metadata->Set(ANDROID_LENS_STATE, &info.lens_state_, 1); |
| |
| // Results depending on device capability and features |
| if (info.is_backward_compatible_) { |
| result->result_metadata->Set(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, |
| &info.ae_trigger_, 1); |
| result->result_metadata->Set(ANDROID_CONTROL_AF_TRIGGER, &info.af_trigger_, |
| 1); |
| uint8_t vstab_mode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF; |
| result->result_metadata->Set(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, |
| &vstab_mode, 1); |
| if (info.exposure_compensation_supported_) { |
| result->result_metadata->Set(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, |
| &info.exposure_compensation_, 1); |
| } |
| } |
| if (info.ae_lock_available_ && info.report_ae_lock_) { |
| result->result_metadata->Set(ANDROID_CONTROL_AE_LOCK, &info.ae_lock_, 1); |
| } |
| if (info.awb_lock_available_ && info.report_awb_lock_) { |
| result->result_metadata->Set(ANDROID_CONTROL_AWB_LOCK, &info.awb_lock_, 1); |
| } |
| if (info.scenes_supported_) { |
| result->result_metadata->Set(ANDROID_CONTROL_SCENE_MODE, &info.scene_mode_, |
| 1); |
| } |
| if (info.max_ae_regions_ > 0) { |
| result->result_metadata->Set(ANDROID_CONTROL_AE_REGIONS, |
| info.ae_metering_region_, |
| ARRAY_SIZE(info.ae_metering_region_)); |
| } |
| if (info.max_awb_regions_ > 0) { |
| result->result_metadata->Set(ANDROID_CONTROL_AWB_REGIONS, |
| info.awb_metering_region_, |
| ARRAY_SIZE(info.awb_metering_region_)); |
| } |
| if (info.max_af_regions_ > 0) { |
| result->result_metadata->Set(ANDROID_CONTROL_AF_REGIONS, |
| info.af_metering_region_, |
| ARRAY_SIZE(info.af_metering_region_)); |
| } |
| if (info.report_exposure_time_) { |
| result->result_metadata->Set(ANDROID_SENSOR_EXPOSURE_TIME, |
| &info.sensor_exposure_time_, 1); |
| } else { |
| result->result_metadata->Erase(ANDROID_SENSOR_EXPOSURE_TIME); |
| } |
| if (info.report_frame_duration_) { |
| result->result_metadata->Set(ANDROID_SENSOR_FRAME_DURATION, |
| &info.sensor_frame_duration_, 1); |
| } else { |
| result->result_metadata->Erase(ANDROID_SENSOR_FRAME_DURATION); |
| } |
| if (info.report_sensitivity_) { |
| result->result_metadata->Set(ANDROID_SENSOR_SENSITIVITY, |
| &info.sensor_sensitivity_, 1); |
| } else { |
| result->result_metadata->Erase(ANDROID_SENSOR_SENSITIVITY); |
| } |
| if (info.report_rolling_shutter_skew_) { |
| result->result_metadata->Set( |
| ANDROID_SENSOR_ROLLING_SHUTTER_SKEW, |
| &EmulatedSensor::kSupportedFrameDurationRange[0], 1); |
| } |
| if (info.report_post_raw_boost_) { |
| result->result_metadata->Set(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST, |
| &info.post_raw_boost_, 1); |
| } |
| if (info.report_focus_distance_) { |
| result->result_metadata->Set(ANDROID_LENS_FOCUS_DISTANCE, |
| &info.focus_distance_, 1); |
| } |
| if (info.report_focus_range_) { |
| float focus_range[2] = {}; |
| focus_range[0] = info.focus_distance_; |
| result->result_metadata->Set(ANDROID_LENS_FOCUS_RANGE, focus_range, ARRAY_SIZE(focus_range)); |
| } |
| if (info.report_filter_density_) { |
| result->result_metadata->Set(ANDROID_LENS_FILTER_DENSITY, |
| &info.filter_density_, 1); |
| } |
| if (info.report_ois_mode_) { |
| result->result_metadata->Set(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, |
| &info.ois_mode_, 1); |
| } |
| if (info.report_pose_rotation_) { |
| result->result_metadata->Set(ANDROID_LENS_POSE_ROTATION, info.pose_rotation_, |
| ARRAY_SIZE(info.pose_rotation_)); |
| } |
| if (info.report_pose_translation_) { |
| result->result_metadata->Set(ANDROID_LENS_POSE_TRANSLATION, |
| info.pose_translation_, |
| ARRAY_SIZE(info.pose_translation_)); |
| } |
| if (info.report_intrinsic_calibration_) { |
| result->result_metadata->Set(ANDROID_LENS_INTRINSIC_CALIBRATION, |
| info.intrinsic_calibration_, |
| ARRAY_SIZE(info.intrinsic_calibration_)); |
| } |
| if (info.report_lens_intrinsics_samples_) { |
| result->result_metadata->Set(ANDROID_STATISTICS_LENS_INTRINSIC_SAMPLES, |
| info.intrinsic_calibration_, |
| ARRAY_SIZE(info.intrinsic_calibration_)); |
| } |
| if (info.report_distortion_) { |
| result->result_metadata->Set(ANDROID_LENS_DISTORTION, info.distortion_, |
| ARRAY_SIZE(info.distortion_)); |
| } |
| if (info.report_black_level_lock_) { |
| result->result_metadata->Set(ANDROID_BLACK_LEVEL_LOCK, |
| &info.black_level_lock_, 1); |
| } |
| if (info.report_scene_flicker_) { |
| result->result_metadata->Set(ANDROID_STATISTICS_SCENE_FLICKER, |
| &info.current_scene_flicker_, 1); |
| } |
| if (info.zoom_ratio_supported_) { |
| result->result_metadata->Set(ANDROID_CONTROL_ZOOM_RATIO, &info.zoom_ratio_, |
| 1); |
| int32_t* chosen_crop_region = info.scaler_crop_region_default_; |
| if (info.sensor_pixel_mode_ == ANDROID_SENSOR_PIXEL_MODE_MAXIMUM_RESOLUTION) { |
| chosen_crop_region = info.scaler_crop_region_max_resolution_; |
| } |
| result->result_metadata->Set(ANDROID_SCALER_CROP_REGION, chosen_crop_region, |
| ARRAY_SIZE(info.scaler_crop_region_default_)); |
| if (info.report_active_sensor_crop_) { |
| int32_t active_crop_region[4]; |
| // width |
| active_crop_region[2] = |
| (info.scaler_crop_region_default_[2] / info.zoom_ratio_); |
| // height |
| active_crop_region[3] = |
| (info.scaler_crop_region_default_[3] / info.zoom_ratio_); |
| // left |
| active_crop_region[0] = |
| (info.scaler_crop_region_default_[2] - active_crop_region[2]) / 2; |
| // top |
| active_crop_region[1] = |
| (info.scaler_crop_region_default_[3] - active_crop_region[3]) / 2; |
| result->result_metadata->Set( |
| ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_SENSOR_CROP_REGION, |
| active_crop_region, ARRAY_SIZE(info.scaler_crop_region_default_)); |
| } |
| } |
| if (info.report_extended_scene_mode_) { |
| result->result_metadata->Set(ANDROID_CONTROL_EXTENDED_SCENE_MODE, |
| &info.extended_scene_mode_, 1); |
| } |
| return result; |
| } |
| |
| status_t EmulatedRequestState::Initialize( |
| std::unique_ptr<EmulatedCameraDeviceInfo> deviceInfo) { |
| std::lock_guard<std::mutex> lock(request_state_mutex_); |
| device_info_ = std::move(deviceInfo); |
| |
| return OK; |
| } |
| |
| status_t EmulatedRequestState::GetDefaultRequest( |
| RequestTemplate type, std::unique_ptr<HalCameraMetadata>* default_settings) { |
| if (default_settings == nullptr) { |
| ALOGE("%s default_settings is nullptr", __FUNCTION__); |
| return BAD_VALUE; |
| } |
| |
| std::lock_guard<std::mutex> lock(request_state_mutex_); |
| auto idx = static_cast<size_t>(type); |
| if (idx >= kTemplateCount) { |
| ALOGE("%s: Unexpected request type: %d", __FUNCTION__, type); |
| return BAD_VALUE; |
| } |
| |
| if (device_info_->default_requests_[idx].get() == nullptr) { |
| ALOGE("%s: Unsupported request type: %d", __FUNCTION__, type); |
| return BAD_VALUE; |
| } |
| |
| *default_settings = HalCameraMetadata::Clone( |
| device_info_->default_requests_[idx]->GetRawCameraMetadata()); |
| |
| return OK; |
| } |
| |
| } // namespace android |
