| /* |
| * Copyright (C) 2017-2018 Intel Corporation. |
| * |
| * 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 "SettingsProcessor" |
| |
| #include "SettingsProcessor.h" |
| #include "CameraMetadataHelper.h" |
| #include "PlatformData.h" |
| #include "IPU3Types.h" |
| #include "IntelAFStateMachine.h" |
| |
| |
| #include "LogHelper.h" |
| |
| namespace cros { |
| namespace intel { |
| |
| SettingsProcessor::SettingsProcessor(int cameraId, |
| Intel3aPlus *a3aWrapper, IStreamConfigProvider &aStreamCfgProv) : |
| mCameraId(cameraId), |
| m3aWrapper(a3aWrapper), |
| mMinSensorModeFrameTime(INT32_MAX), |
| mStreamCfgProv(aStreamCfgProv), |
| mFixedFocus(false) |
| { |
| /** |
| * cache some static value for later use |
| */ |
| mAPA = PlatformData::getActivePixelArray(mCameraId); |
| cacheStaticMetadata(); |
| CLEAR(mCurrentFrameParams); |
| CLEAR(mSensorDescriptor); |
| } |
| |
| SettingsProcessor::~SettingsProcessor() |
| { |
| } |
| |
| status_t SettingsProcessor::init() |
| { |
| HAL_TRACE_CALL(CAMERA_DEBUG_LOG_LEVEL2, LOG_TAG); |
| |
| // save state for fix focus; |
| mFixedFocus = (m3aWrapper->getMinFocusDistance() == 0.0f); |
| |
| return OK; |
| } |
| |
| /** |
| * processRequestSettings |
| * |
| * Analyze the request control metadata tags and prepare the configuration for |
| * the AIQ algorithm to run. |
| * \param settings [IN] settings from the request |
| * \param reqAiqCfg [OUT] AIQ configuration |
| */ |
| status_t |
| SettingsProcessor::processRequestSettings(const android::CameraMetadata &settings, |
| RequestCtrlState &reqAiqCfg) |
| { |
| HAL_TRACE_CALL(CAMERA_DEBUG_LOG_LEVEL2, LOG_TAG); |
| status_t status = OK; |
| |
| /** |
| * Process cropping first since it is used by other settings |
| * like AE and AF |
| **/ |
| processCroppingRegion(settings, reqAiqCfg); |
| |
| processAeSettings(settings, reqAiqCfg); |
| reqAiqCfg.aeState = ALGORITHM_CONFIGURED; |
| |
| processAfSettings(settings, reqAiqCfg); |
| reqAiqCfg.afState = ALGORITHM_CONFIGURED; |
| |
| processAwbSettings(settings, reqAiqCfg); |
| reqAiqCfg.awbState = ALGORITHM_CONFIGURED; |
| |
| |
| if ((status = processIspSettings(settings, reqAiqCfg)) != OK) |
| return status; |
| |
| processImageEnhancementSettings(settings, reqAiqCfg); |
| processStabilizationSettings(settings, reqAiqCfg); |
| |
| status = processHotPixelSettings(settings, reqAiqCfg); |
| |
| PAInputParams params; |
| params.aiqInputParams = &reqAiqCfg.aiqInputParams; |
| m3aWrapper->fillPAInputParams(settings, params); |
| |
| SAInputParams saParams; |
| saParams.aiqInputParams = &reqAiqCfg.aiqInputParams; |
| m3aWrapper->fillSAInputParams(settings, saParams); |
| |
| reqAiqCfg.captureSettings->shadingMode = saParams.saMode; |
| reqAiqCfg.captureSettings->shadingMapMode = saParams.shadingMapMode; |
| |
| return processTestPatternMode(settings, reqAiqCfg); |
| } |
| |
| /** |
| * processCroppingRegion |
| * |
| * Checks if cropping region is set in the capture request settings. If it is |
| * then fills the corresponding region in the capture settings. |
| * if it is not it sets the default value, the Active Pixel Array |
| * |
| * \param settings[IN] metadata buffer where the settings are stored |
| * \param reqCfg[OUT] the cropping region is stored inside the capture settings |
| * of this structure |
| * |
| */ |
| void |
| SettingsProcessor::processCroppingRegion(const android::CameraMetadata &settings, |
| RequestCtrlState &reqCfg) |
| { |
| CameraWindow &cropRegion = reqCfg.captureSettings->cropRegion; |
| |
| // If crop region not available, fill active array size as the default value |
| //# ANDROID_METADATA_Control android.scaler.cropRegion done |
| camera_metadata_ro_entry entry = settings.find(ANDROID_SCALER_CROP_REGION); |
| /** |
| * Cropping region is invalid if width is 0 or if the rectangle is not |
| * fully defined (you need 4 values) |
| */ |
| //# ANDROID_METADATA_Dynamic android.scaler.cropRegion done |
| if (entry.count < 4 || entry.data.i32[2] == 0) { |
| //cropRegion is a reference and will alter captureSettings->cropRegion. |
| cropRegion = mAPA; |
| int32_t *cropWindow; |
| ia_coordinate topLeft = {0, 0}; |
| cropRegion.init(topLeft, |
| mAPA.width(), //width |
| mAPA.height(), //height |
| 0); |
| // meteringRectangle is filling 4 coordinates and weight (5 values) |
| // here crop region only needs the rectangle, so we copy only 4. |
| cropWindow = (int32_t*)mAPA.meteringRectangle(); |
| reqCfg.ctrlUnitResult->update(ANDROID_SCALER_CROP_REGION, cropWindow, 4); |
| } else { |
| ia_coordinate topLeft = {entry.data.i32[0],entry.data.i32[1]}; |
| cropRegion.init(topLeft, |
| entry.data.i32[2], //width |
| entry.data.i32[3], //height |
| 0); |
| reqCfg.ctrlUnitResult->update(ANDROID_SCALER_CROP_REGION, entry.data.i32, 4); |
| } |
| |
| // copy the crop region to the processingSettings so that tasks don't have |
| // to break the Law-Of-Demeter. |
| reqCfg.processingSettings->cropRegion = cropRegion; |
| } |
| |
| status_t SettingsProcessor::processIspSettings(const android::CameraMetadata &settings, |
| RequestCtrlState &reqAiqCfg) |
| { |
| HAL_TRACE_CALL(CAMERA_DEBUG_LOG_LEVEL2, LOG_TAG); |
| camera_metadata_ro_entry entry; |
| CLEAR(entry); |
| IspSettings *ispSettings = nullptr; |
| |
| if (reqAiqCfg.captureSettings) { |
| ispSettings = &reqAiqCfg.captureSettings->ispSettings; |
| } else { |
| LOGE("Capture Settings is nullptr!, bug"); |
| return UNKNOWN_ERROR; |
| } |
| |
| //# ANDROID_METADATA_Control android.edge.strength done |
| //# AM FUTURE |
| entry = settings.find(ANDROID_EDGE_STRENGTH); |
| if (entry.count == 1) { |
| // mapping from 1->10 to -127->128 |
| uint8_t strength = entry.data.u8[0]; |
| ispSettings->eeSetting.strength = ((strength * UINT8_MAX) / ANDROID_MAX_STRENGTH) - INT8_MIN; |
| reqAiqCfg.captureSettings->ispControls.ee.strength = strength; |
| } else { |
| // does not affect according to ia_isp specs. |
| ispSettings->eeSetting.strength = 0; |
| } |
| |
| //ANDROID_METADATA_Control edge.mode |
| entry = settings.find(ANDROID_EDGE_MODE); |
| reqAiqCfg.captureSettings->ispControls.ee.mode = (entry.count == 1) ? entry.data.u8[0] : 0; |
| |
| //# ANDROID_METADATA_Control android.noiseReduction.mode done |
| entry = settings.find(ANDROID_NOISE_REDUCTION_MODE); |
| uint8_t noiseReductionMode = 0; |
| MetadataHelper::getSetting(mStaticMetadataCache.availableNoiseReductionModes, entry, |
| &noiseReductionMode); |
| reqAiqCfg.captureSettings->ispControls.nr.mode = noiseReductionMode; |
| |
| switch (noiseReductionMode) { |
| case ANDROID_NOISE_REDUCTION_MODE_OFF: |
| ispSettings->nrSetting.feature_level = ia_isp_feature_level_off; |
| break; |
| case ANDROID_NOISE_REDUCTION_MODE_FAST: |
| // the speed of execution is the same for high or low quality |
| // therefore we apply also high quality in fast. |
| ispSettings->nrSetting.feature_level = ia_isp_feature_level_high; |
| break; |
| case ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY: |
| ispSettings->nrSetting.feature_level = ia_isp_feature_level_high; |
| break; |
| case ANDROID_NOISE_REDUCTION_MODE_MINIMAL: |
| ispSettings->nrSetting.feature_level = ia_isp_feature_level_low; |
| break; |
| case ANDROID_NOISE_REDUCTION_MODE_ZERO_SHUTTER_LAG: |
| ispSettings->nrSetting.feature_level = ia_isp_feature_level_low; |
| break; |
| default: |
| LOGE("ERROR: Unknown noise reduction mode %d", noiseReductionMode); |
| return BAD_VALUE; |
| } |
| //# ANDROID_METADATA_Control android.noiseReduction.strength done |
| //# AM FUTURE |
| entry = settings.find(ANDROID_NOISE_REDUCTION_STRENGTH); |
| if (entry.count == 1) { |
| // mapping from 1->10 to -127->128 |
| uint8_t strength = entry.data.u8[0]; |
| ispSettings->nrSetting.strength = ((strength * UINT8_MAX) / ANDROID_MAX_STRENGTH) - INT8_MIN; |
| reqAiqCfg.captureSettings->ispControls.nr.strength = strength; |
| } else { |
| // does not affect according to ia_isp specs. |
| ispSettings->nrSetting.strength = 0; |
| } |
| |
| //# ANDROID_METADATA_Control android.control.effectMode done |
| entry = settings.find(ANDROID_CONTROL_EFFECT_MODE); |
| uint8_t effectMode = 0; |
| MetadataHelper::getSetting(mStaticMetadataCache.availableEffectModes, entry, &effectMode); |
| reqAiqCfg.captureSettings->ispControls.effect = effectMode; |
| |
| switch (effectMode) { |
| case ANDROID_CONTROL_EFFECT_MODE_OFF: |
| ispSettings->effects = ia_isp_effect_none; |
| break; |
| case ANDROID_CONTROL_EFFECT_MODE_MONO: |
| ispSettings->effects = ia_isp_effect_grayscale; |
| break; |
| case ANDROID_CONTROL_EFFECT_MODE_NEGATIVE: |
| ispSettings->effects = ia_isp_effect_negative; |
| break; |
| case ANDROID_CONTROL_EFFECT_MODE_SEPIA: |
| ispSettings->effects = ia_isp_effect_sepia; |
| break; |
| case ANDROID_CONTROL_EFFECT_MODE_AQUA: |
| ispSettings->effects = ia_isp_effect_aqua; |
| break; |
| case ANDROID_CONTROL_EFFECT_MODE_SOLARIZE: |
| case ANDROID_CONTROL_EFFECT_MODE_POSTERIZE: |
| case ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD: |
| case ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD: |
| default: |
| LOGE("ERROR: Unknown effect mode %d", effectMode); |
| return BAD_VALUE; |
| } |
| //# ANDROID_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR reprocess.effectiveExposureFactor done |
| entry = settings.find(ANDROID_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR); |
| reqAiqCfg.captureSettings->effectiveExposureFactor = (entry.count == 1) ? entry.data.f[0] : 0.0; |
| |
| return OK; |
| } |
| |
| void SettingsProcessor::cacheStaticMetadata() |
| { |
| const camera_metadata_t *meta = PlatformData::getStaticMetadata(mCameraId); |
| mStaticMetadataCache.availableEffectModes = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_CONTROL_AVAILABLE_EFFECTS); |
| mStaticMetadataCache.availableNoiseReductionModes = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES); |
| //ipu3 not config tone map mode, do not print error. |
| mStaticMetadataCache.availableTonemapModes = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES, false); |
| mStaticMetadataCache.availableVideoStabilization = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES); |
| mStaticMetadataCache.availableOpticalStabilization = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION); |
| mStaticMetadataCache.currentAperture = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_LENS_INFO_AVAILABLE_APERTURES); |
| mStaticMetadataCache.flashInfoAvailable = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_FLASH_INFO_AVAILABLE); |
| mStaticMetadataCache.lensShadingMapSize = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_LENS_INFO_SHADING_MAP_SIZE); |
| mStaticMetadataCache.currentFocalLength = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS); |
| mStaticMetadataCache.availableHotPixelMapModes = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES); |
| mStaticMetadataCache.availableHotPixelModes = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES); |
| mStaticMetadataCache.availableEdgeModes = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_EDGE_AVAILABLE_EDGE_MODES); |
| mStaticMetadataCache.maxAnalogSensitivity = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY); |
| mStaticMetadataCache.pipelineDepth = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_REQUEST_PIPELINE_MAX_DEPTH); |
| mStaticMetadataCache.lensSupported = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE); |
| mStaticMetadataCache.availableTestPatternModes = |
| MetadataHelper::getMetadataEntry(meta, ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES); |
| } |
| |
| status_t |
| SettingsProcessor::processAfSettings(const android::CameraMetadata &settings, |
| RequestCtrlState &reqAiqCfg) |
| { |
| HAL_TRACE_CALL(CAMERA_DEBUG_LOG_LEVEL2, LOG_TAG); |
| status_t status = OK; |
| |
| AfInputParams inParams; |
| inParams.aiqInputParams = &reqAiqCfg.aiqInputParams; |
| inParams.afControls = &reqAiqCfg.aaaControls.af; |
| |
| m3aWrapper->fillAfInputParams(&settings, inParams); |
| |
| /** |
| * If we are in fixed Focus, we do not need to return any af window, since |
| * available af window is 0. |
| */ |
| if (mFixedFocus) |
| return status; |
| |
| /** |
| * We pass the AF region directly from the input params |
| * to the capture settings. |
| * We clip the AfRegion with the Cropping region as required by V3 API |
| */ |
| if (reqAiqCfg.aiqInputParams.afRegion.isValid()) { |
| /** |
| * clip the AF metering region with the cropping region |
| * cropping region is in Android coordinates, so it is the AF region |
| * at this point. |
| */ |
| reqAiqCfg.captureSettings->afRegion = reqAiqCfg.aiqInputParams.afRegion; |
| |
| reqAiqCfg.captureSettings->afRegion.clip(reqAiqCfg.captureSettings->cropRegion); |
| |
| /** |
| * Convert to IA coordinates before passing it to AF algo |
| */ |
| const CameraWindow &fromW = reqAiqCfg.captureSettings->afRegion; |
| CameraWindow toW; |
| m3aWrapper->convertFromAndroidToIaCoordinates(fromW, toW); |
| /** |
| * setting the metering mode to touch focus |
| */ |
| reqAiqCfg.aiqInputParams.afParams.focus_metering_mode = ia_aiq_af_metering_mode_touch; |
| |
| reqAiqCfg.aiqInputParams.afParams.focus_rect->top = toW.top(); |
| reqAiqCfg.aiqInputParams.afParams.focus_rect->left = toW.left(); |
| reqAiqCfg.aiqInputParams.afParams.focus_rect->bottom = toW.bottom(); |
| reqAiqCfg.aiqInputParams.afParams.focus_rect->right = toW.right(); |
| |
| } else { |
| reqAiqCfg.captureSettings->afRegion.reset(); |
| // This is the normal case when there is no AF region defined. |
| reqAiqCfg.captureSettings->afRegion = reqAiqCfg.captureSettings->cropRegion; |
| } |
| return status; |
| } |
| |
| /** |
| * This function fills ISP settings with manual image enhancement settings |
| * (brightness, contrast, hue, saturation and sharpness) coming from the app, |
| * in case they are supported by HAL. |
| * |
| * \param settings [IN] settings from the request |
| * \param reqAiqCfg [OUT] AIQ configuration |
| */ |
| status_t SettingsProcessor::processImageEnhancementSettings(const android::CameraMetadata &settings, |
| RequestCtrlState &reqAiqCfg) |
| { |
| HAL_TRACE_CALL(CAMERA_DEBUG_LOG_LEVEL2, LOG_TAG); |
| camera_metadata_ro_entry entry; |
| CLEAR(entry); |
| IspSettings *ispSettings = nullptr; |
| |
| if (reqAiqCfg.captureSettings) { |
| ispSettings = &reqAiqCfg.captureSettings->ispSettings; |
| } else { |
| LOGE("Capture Settings is nullptr!, bug"); |
| return UNKNOWN_ERROR; |
| } |
| |
| return OK; |
| } |
| |
| /** |
| * This function reads the COM_INTEL_IMAGE_ENHANCE values, maps them to |
| * the range that ia_aiq expects and updates metadata. |
| * |
| * \param[in] settings Settings from the request |
| * \param[in] enhancementName Enhancement name |
| * \param[in,out] reqAiqCfg AIQ configuration |
| * \return enhancement value in ia_aiq range |
| */ |
| char SettingsProcessor::mapImageEnhancementSettings(const android::CameraMetadata &settings, |
| const int enhancementName, |
| RequestCtrlState &reqAiqCfg) |
| { |
| camera_metadata_ro_entry entry; |
| CLEAR(entry); |
| entry = settings.find(enhancementName); |
| if (entry.count == 1) { |
| int enhancementValue = entry.data.i32[0]; |
| // The result can be updated immadiately since the enhancement values |
| // will not change |
| reqAiqCfg.ctrlUnitResult->update(enhancementName, |
| &enhancementValue, |
| 1); |
| if (abs(enhancementValue) <= UI_IMAGE_ENHANCEMENT_MAX) { |
| return(m3aWrapper->mapUiImageEnhancement2Aiq(enhancementValue)); |
| } else { |
| LOGE("Enhancement value %d outside expected range [%d,%d]", |
| enhancementValue, -UI_IMAGE_ENHANCEMENT_MAX, |
| UI_IMAGE_ENHANCEMENT_MAX); |
| } |
| } |
| return 0; |
| } |
| |
| |
| status_t |
| SettingsProcessor::processAeSettings(const android::CameraMetadata& settings, |
| RequestCtrlState &reqAiqCfg) |
| { |
| HAL_TRACE_CALL(CAMERA_DEBUG_LOG_LEVEL2, LOG_TAG); |
| status_t status = OK; |
| |
| AeInputParams aeInputParams; |
| aeInputParams.aiqInputParams = &reqAiqCfg.aiqInputParams; |
| aeInputParams.aaaControls = &reqAiqCfg.aaaControls; |
| aeInputParams.croppingRegion = &reqAiqCfg.captureSettings->cropRegion; |
| aeInputParams.aeRegion = &reqAiqCfg.captureSettings->aeRegion; |
| aeInputParams.sensorDescriptor = &mSensorDescriptor; |
| |
| m3aWrapper->fillAeInputParams(&settings, aeInputParams); |
| |
| if (aeInputParams.aiqInputParams) { |
| /* |
| * apply the sensor limits reported from the exposure sensor descriptor |
| * |
| * The exposure sensor descriptor is updated every time we change sensor |
| * mode. |
| * Each sensor mode has associated a maximum fps. We should not let AE |
| * to produce values that drive the sensor at a higher speed. |
| * |
| * This operation is already done inside fillAeInputParams, but |
| * unfortunately the input parameter is an int |
| * (AeInputParams.maxSupportedFps) therefore we apply the limit here |
| * with more precision. |
| * |
| * In other PSL the AeInputParams.maxSupportedFps passed to 3A is coming |
| * from the reported min stream duration in static metadata. |
| * |
| * In our case we use the limit reported by the sensor mode selected. |
| * The value mMinSensorModeFrameTime is updated after every stream |
| * config. |
| */ |
| ia_aiq_ae_input_params *aeParams = nullptr; |
| aeParams = &aeInputParams.aiqInputParams->aeInputParams; |
| if (aeParams->manual_limits->manual_frame_time_us_min < mMinSensorModeFrameTime) { |
| aeParams->manual_limits->manual_frame_time_us_min = mMinSensorModeFrameTime; |
| } |
| if (aeParams->manual_limits->manual_frame_time_us_max < mMinSensorModeFrameTime) { |
| aeParams->manual_limits->manual_frame_time_us_max = mMinSensorModeFrameTime; |
| } |
| } |
| |
| return status; |
| } |
| |
| status_t |
| SettingsProcessor::handleNewSensorDescriptor(ControlUnit::MessageSensorMode &msg) |
| { |
| HAL_TRACE_CALL(CAMERA_DEBUG_LOG_LEVEL1, LOG_TAG); |
| mCurrentFrameParams = msg.frameParams; |
| mSensorDescriptor = msg.exposureDesc; |
| |
| /* |
| * store the minimum frame time for this sensor mode. |
| * This is the maximum fps that the sensor mode supports. |
| * Use this to limit any frame rate requests from client. |
| * See fillAeInputParams() to understand how this value is used. |
| * min frame duration is: |
| * pix_per_line * lines_per_frame |
| * ---------------------------------------- |
| * pixel_clock |
| */ |
| mMinSensorModeFrameTime = (mSensorDescriptor.pixel_periods_per_line * |
| mSensorDescriptor.line_periods_per_field)/ |
| mSensorDescriptor.pixel_clock_freq_mhz; |
| |
| LOG1("---- New Sensor descriptor information received -----"); |
| |
| // todo revert this when graph config works |
| // The current frame parameters are all wrong, due to incomplete graph |
| // config implementation which seems to be in a constant flux. Fetch |
| // the sensor crop area from media ctl while things are as they are |
| const MediaCtlConfig *mediaCtlConfig = mStreamCfgProv.getMediaCtlConfig(IStreamConfigProvider::CIO2); |
| for (unsigned int i = 0; i < mediaCtlConfig->mSelectionParams.size(); i++) { |
| MediaCtlSelectionParams param = mediaCtlConfig->mSelectionParams[i]; |
| if (strstr(param.entityName.c_str(), "pixel array")) { |
| mCurrentFrameParams.cropped_image_width = param.width; |
| mCurrentFrameParams.cropped_image_height = param.height; |
| mCurrentFrameParams.horizontal_crop_offset = param.top; |
| mCurrentFrameParams.vertical_crop_offset = param.left; |
| } |
| } |
| |
| LOG1("Frame Params: crop offset: %dx%d crop rect: %dx%d" |
| " v-scale: %d/%d h-scale: %d/%d", |
| mCurrentFrameParams.horizontal_crop_offset, |
| mCurrentFrameParams.vertical_crop_offset, |
| mCurrentFrameParams.cropped_image_width, |
| mCurrentFrameParams.cropped_image_height, |
| mCurrentFrameParams.horizontal_scaling_numerator, |
| mCurrentFrameParams.horizontal_scaling_denominator, |
| mCurrentFrameParams.vertical_scaling_numerator, |
| mCurrentFrameParams.vertical_scaling_denominator); |
| |
| LOG1("Sensor descriptor: pix-clock: %f Mhz ppl: %d lpf: %d lpvb: %d " |
| "integration time min(margin) fine: %d (%d) coarse:%d(%d)", |
| mSensorDescriptor.pixel_clock_freq_mhz, |
| mSensorDescriptor.pixel_periods_per_line, |
| mSensorDescriptor.line_periods_per_field, |
| mSensorDescriptor.line_periods_vertical_blanking, |
| mSensorDescriptor.fine_integration_time_min, |
| mSensorDescriptor.fine_integration_time_max_margin, |
| mSensorDescriptor.coarse_integration_time_min, |
| mSensorDescriptor.coarse_integration_time_max_margin); |
| return OK; |
| } |
| |
| status_t |
| SettingsProcessor::processAwbSettings(const android::CameraMetadata &settings, |
| RequestCtrlState &reqAiqCfg) |
| { |
| HAL_TRACE_CALL(CAMERA_DEBUG_LOG_LEVEL2, LOG_TAG); |
| status_t status = OK; |
| |
| AwbInputParams awbInputParams; |
| awbInputParams.aiqInputParams = &reqAiqCfg.aiqInputParams; |
| awbInputParams.aaaControls = &reqAiqCfg.aaaControls; |
| |
| m3aWrapper->fillAwbInputParams(&settings, |
| awbInputParams); |
| |
| return status; |
| } |
| |
| status_t |
| SettingsProcessor::processStabilizationSettings(const android::CameraMetadata &settings, |
| RequestCtrlState &reqAiqCfg) |
| { |
| HAL_TRACE_CALL(CAMERA_DEBUG_LOG_LEVEL2, LOG_TAG); |
| camera_metadata_ro_entry entry; |
| //# ANDROID_METADATA_Control android.control.videoStabilizationMode done |
| entry = settings.find(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE); |
| MetadataHelper::getSetting(mStaticMetadataCache.availableVideoStabilization, entry, |
| &(reqAiqCfg.captureSettings->videoStabilizationMode)); |
| |
| //# ANDROID_METADATA_Control android.lens.opticalStabilizationMode done |
| entry = settings.find(ANDROID_LENS_OPTICAL_STABILIZATION_MODE); |
| MetadataHelper::getSetting(mStaticMetadataCache.availableOpticalStabilization, entry, |
| &(reqAiqCfg.captureSettings->opticalStabilizationMode)); |
| return OK; |
| } |
| |
| status_t SettingsProcessor::processHotPixelSettings(const android::CameraMetadata &settings, |
| RequestCtrlState &reqAiqCfg) |
| { |
| HAL_TRACE_CALL(CAMERA_DEBUG_LOG_LEVEL2, LOG_TAG); |
| camera_metadata_ro_entry entry; |
| //# ANDROID_METADATA_Control android.statistics.hotPixelMapMode done |
| entry = settings.find(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE); |
| MetadataHelper::getSetting(mStaticMetadataCache.availableHotPixelMapModes, entry, |
| &(reqAiqCfg.captureSettings->hotPixelMapMode)); |
| //# ANDROID_METADATA_Control android.hotPixel.mode done |
| entry = settings.find(ANDROID_HOT_PIXEL_MODE); |
| MetadataHelper::getSetting(mStaticMetadataCache.availableHotPixelModes, entry, |
| &(reqAiqCfg.captureSettings->hotPixelMode)); |
| return OK; |
| } |
| |
| status_t SettingsProcessor::processTestPatternMode(const android::CameraMetadata &settings, |
| RequestCtrlState &reqAiqCfg) |
| { |
| HAL_TRACE_CALL(CAMERA_DEBUG_LOG_LEVEL2, LOG_TAG); |
| camera_metadata_ro_entry entry; |
| |
| entry = settings.find(ANDROID_SENSOR_TEST_PATTERN_MODE); |
| MetadataHelper::getSetting(mStaticMetadataCache.availableTestPatternModes, entry, |
| &(reqAiqCfg.captureSettings->testPatternMode)); |
| |
| return OK; |
| } |
| |
| } /* namespace intel */ |
| } /* namespace cros */ |
