| /* |
| * handler_interface.cpp - handler interface |
| * |
| * Copyright (c) 2014-2015 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. |
| * |
| * Author: Wind Yuan <feng.yuan@intel.com> |
| */ |
| |
| #include "handler_interface.h" |
| |
| namespace XCam { |
| |
| AeHandler::AeHandler() |
| : _mode (XCAM_AE_MODE_AUTO) |
| , _metering_mode () |
| , _window () |
| , _flicker_mode () |
| , _speed (1.0) |
| , _exposure_time_min (UINT64_C(0)) |
| , _exposure_time_max (UINT64_C(0)) |
| , _max_analog_gain (0.0) |
| , _manual_exposure_time (UINT64_C (0)) |
| , _manual_analog_gain (0.0) |
| , _aperture_fn (0.0) |
| , _ev_shift (0.0) |
| { |
| _window.x_start = 0; |
| _window.y_start = 0; |
| _window.x_end = 0; |
| _window.y_end = 0; |
| _window.weight = 0; |
| } |
| |
| bool |
| AeHandler::set_mode (XCamAeMode mode) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _mode = mode; |
| |
| XCAM_LOG_DEBUG ("ae set mode [%d]", mode); |
| return true; |
| } |
| |
| bool |
| AeHandler::set_metering_mode (XCamAeMeteringMode mode) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _metering_mode = mode; |
| |
| XCAM_LOG_DEBUG ("ae set metering mode [%d]", mode); |
| return true; |
| } |
| |
| bool |
| AeHandler::set_window (XCam3AWindow *window) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _window = *window; |
| |
| XCAM_LOG_DEBUG ("ae set metering mode window [x:%d, y:%d, x_end:%d, y_end:%d, weight:%d]", |
| window->x_start, |
| window->y_start, |
| window->x_end, |
| window->y_end, |
| window->weight); |
| return true; |
| } |
| |
| bool |
| AeHandler::set_ev_shift (double ev_shift) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _ev_shift = ev_shift; |
| |
| XCAM_LOG_DEBUG ("ae set ev shift:%.03f", ev_shift); |
| return true; |
| } |
| |
| bool |
| AeHandler::set_speed (double speed) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _speed = speed; |
| |
| XCAM_LOG_DEBUG ("ae set speed:%.03f", speed); |
| return true; |
| } |
| |
| bool |
| AeHandler::set_flicker_mode (XCamFlickerMode flicker) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _flicker_mode = flicker; |
| |
| XCAM_LOG_DEBUG ("ae set flicker:%d", flicker); |
| return true; |
| } |
| |
| XCamFlickerMode |
| AeHandler::get_flicker_mode () |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| return _flicker_mode; |
| } |
| |
| int64_t |
| AeHandler::get_current_exposure_time () |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| if (_mode == XCAM_AE_MODE_MANUAL) |
| return _manual_exposure_time; |
| return INT64_C(-1); |
| } |
| |
| double |
| AeHandler::get_current_analog_gain () |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| if (_mode == XCAM_AE_MODE_MANUAL) |
| return _manual_analog_gain; |
| return 0.0; |
| } |
| |
| bool |
| AeHandler::set_manual_exposure_time (int64_t time_in_us) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _manual_exposure_time = time_in_us; |
| |
| XCAM_LOG_DEBUG ("ae set manual exposure time: %lldus", time_in_us); |
| return true; |
| } |
| |
| bool |
| AeHandler::set_manual_analog_gain (double gain) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _manual_analog_gain = gain; |
| |
| XCAM_LOG_DEBUG ("ae set manual analog gain: %.03f", gain); |
| return true; |
| } |
| |
| bool |
| AeHandler::set_aperture (double fn) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _aperture_fn = fn; |
| |
| XCAM_LOG_DEBUG ("ae set aperture fn: %.03f", fn); |
| return true; |
| } |
| |
| bool |
| AeHandler::set_max_analog_gain (double max_gain) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _max_analog_gain = max_gain; |
| |
| XCAM_LOG_DEBUG ("ae set max analog_gain: %.03f", max_gain); |
| return true; |
| } |
| |
| double AeHandler::get_max_analog_gain () |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| return _max_analog_gain; |
| } |
| |
| bool AeHandler::set_exposure_time_range (int64_t min_time_in_us, int64_t max_time_in_us) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _exposure_time_min = min_time_in_us; |
| _exposure_time_max = max_time_in_us; |
| |
| XCAM_LOG_DEBUG ("ae set exposrue range[%lldus, %lldus]", min_time_in_us, max_time_in_us); |
| return true; |
| } |
| |
| bool |
| AeHandler::get_exposure_time_range (int64_t *min_time_in_us, int64_t *max_time_in_us) |
| { |
| XCAM_ASSERT (min_time_in_us && max_time_in_us); |
| |
| AnalyzerHandler::HanlderLock lock(this); |
| *min_time_in_us = _exposure_time_min; |
| *max_time_in_us = _exposure_time_max; |
| |
| return true; |
| } |
| |
| AwbHandler::AwbHandler() |
| : _mode (XCAM_AWB_MODE_AUTO) |
| , _speed (1.0) |
| , _cct_min (0) |
| , _cct_max (0) |
| , _gr_gain (0.0) |
| , _r_gain (0.0) |
| , _b_gain (0.0) |
| , _gb_gain (0.0) |
| {} |
| |
| bool |
| AwbHandler::set_mode (XCamAwbMode mode) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _mode = mode; |
| |
| XCAM_LOG_DEBUG ("awb set mode [%d]", mode); |
| return true; |
| } |
| |
| bool |
| AwbHandler::set_speed (double speed) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, |
| (0.0 < speed) && (speed <= 1.0), |
| false, |
| "awb speed(%f) is out of range, suggest (0.0, 1.0]", speed); |
| |
| AnalyzerHandler::HanlderLock lock(this); |
| _speed = speed; |
| |
| XCAM_LOG_DEBUG ("awb set speed [%f]", speed); |
| return true; |
| } |
| |
| bool |
| AwbHandler::set_color_temperature_range (uint32_t cct_min, uint32_t cct_max) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, |
| (cct_min <= cct_max), |
| false, |
| "awb set wrong cct(%u, %u) parameters", cct_min, cct_max); |
| |
| AnalyzerHandler::HanlderLock lock(this); |
| _cct_min = cct_min; |
| _cct_max = cct_max; |
| |
| XCAM_LOG_DEBUG ("awb set cct range [%u, %u]", cct_min, cct_max); |
| return true; |
| } |
| |
| bool |
| AwbHandler::set_manual_gain (double gr, double r, double b, double gb) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, |
| gr >= 0.0 && r >= 0.0 && b >= 0.0 && gb >= 0.0, |
| false, |
| "awb manual gain value must >= 0.0"); |
| |
| AnalyzerHandler::HanlderLock lock(this); |
| _gr_gain = gr; |
| _r_gain = r; |
| _b_gain = b; |
| _gb_gain = gb; |
| XCAM_LOG_DEBUG ("awb set manual gain value(gr:%.03f, r:%.03f, b:%.03f, gb:%.03f)", gr, r, b, gb); |
| return true; |
| } |
| |
| CommonHandler::CommonHandler() |
| : _is_manual_gamma (false) |
| , _nr_level (0.0) |
| , _tnr_level (0.0) |
| , _brightness (0.0) |
| , _contrast (0.0) |
| , _hue (0.0) |
| , _saturation (0.0) |
| , _sharpness (0.0) |
| , _enable_dvs (false) |
| , _enable_gbce (false) |
| , _enable_night_mode (false) |
| {} |
| |
| bool CommonHandler::set_dvs (bool enable) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _enable_dvs = enable; |
| |
| XCAM_LOG_DEBUG ("common 3A enable dvs:%s", XCAM_BOOL2STR(enable)); |
| return true; |
| } |
| |
| bool |
| CommonHandler::set_gbce (bool enable) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _enable_gbce = enable; |
| |
| XCAM_LOG_DEBUG ("common 3A enable gbce:%s", XCAM_BOOL2STR(enable)); |
| return true; |
| } |
| |
| bool |
| CommonHandler::set_night_mode (bool enable) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| _enable_night_mode = enable; |
| |
| XCAM_LOG_DEBUG ("common 3A enable night mode:%s", XCAM_BOOL2STR(enable)); |
| return true; |
| } |
| |
| /* Picture quality */ |
| bool |
| CommonHandler::set_noise_reduction_level (double level) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, |
| level >= -1.0 && level < 1.0, |
| false, |
| "set NR levlel(%.03f) out of range[-1.0, 1.0]", level); |
| |
| AnalyzerHandler::HanlderLock lock(this); |
| _nr_level = level; |
| |
| XCAM_LOG_DEBUG ("common 3A set NR level:%.03f", level); |
| return true; |
| } |
| |
| bool |
| CommonHandler::set_temporal_noise_reduction_level (double level) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, |
| level >= -1.0 && level < 1.0, |
| false, |
| "set TNR levlel(%.03f) out of range[-1.0, 1.0]", level); |
| |
| AnalyzerHandler::HanlderLock lock(this); |
| _tnr_level = level; |
| |
| XCAM_LOG_DEBUG ("common 3A set TNR level:%.03f", level); |
| return true; |
| } |
| |
| bool |
| CommonHandler::set_manual_brightness (double level) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, |
| level >= -1.0 && level < 1.0, |
| false, |
| "set brightness levlel(%.03f) out of range[-1.0, 1.0]", level); |
| |
| AnalyzerHandler::HanlderLock lock(this); |
| _brightness = level; |
| |
| XCAM_LOG_DEBUG ("common 3A set brightness level:%.03f", level); |
| return true; |
| } |
| |
| bool CommonHandler::set_manual_contrast (double level) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, |
| level >= -1.0 && level < 1.0, |
| false, |
| "set contrast levlel(%.03f) out of range[-1.0, 1.0]", level); |
| |
| AnalyzerHandler::HanlderLock lock(this); |
| _contrast = level; |
| |
| XCAM_LOG_DEBUG ("common 3A set contrast level:%.03f", level); |
| return true; |
| } |
| |
| bool CommonHandler::set_manual_hue (double level) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, |
| level >= -1.0 && level < 1.0, |
| false, |
| "set hue levlel(%.03f) out of range[-1.0, 1.0]", level); |
| |
| AnalyzerHandler::HanlderLock lock(this); |
| _hue = level; |
| |
| XCAM_LOG_DEBUG ("common 3A set hue level:%.03f", level); |
| return true; |
| } |
| |
| bool |
| CommonHandler::set_manual_saturation (double level) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, |
| level >= -1.0 && level < 1.0, |
| false, |
| "set saturation levlel(%.03f) out of range[-1.0, 1.0]", level); |
| |
| AnalyzerHandler::HanlderLock lock(this); |
| _saturation = level; |
| |
| XCAM_LOG_DEBUG ("common 3A set saturation level:%.03f", level); |
| return true; |
| } |
| |
| bool CommonHandler::set_manual_sharpness (double level) |
| { |
| XCAM_FAIL_RETURN ( |
| ERROR, |
| level >= -1.0 && level < 1.0, |
| false, |
| "set sharpness levlel(%.03f) out of range[-1.0, 1.0]", level); |
| |
| AnalyzerHandler::HanlderLock lock(this); |
| _sharpness = level; |
| |
| XCAM_LOG_DEBUG ("common 3A set sharpness level:%.03f", level); |
| return true; |
| } |
| |
| bool |
| CommonHandler::set_gamma_table (double *r_table, double *g_table, double *b_table) |
| { |
| AnalyzerHandler::HanlderLock lock(this); |
| if (!r_table && ! g_table && !b_table) { |
| _is_manual_gamma = false; |
| XCAM_LOG_DEBUG ("common 3A disabled gamma"); |
| return true; |
| } |
| |
| if (!r_table || !g_table || !b_table) { |
| XCAM_LOG_ERROR ("common 3A gamma table parameters wrong"); |
| return false; |
| } |
| |
| for (uint32_t i = 0; i < XCAM_GAMMA_TABLE_SIZE; ++i) { |
| _r_gamma [i] = r_table [i]; |
| _g_gamma [i] = g_table [i]; |
| _b_gamma [i] = b_table [i]; |
| } |
| _is_manual_gamma = true; |
| |
| XCAM_LOG_DEBUG ("common 3A enabled RGB gamma"); |
| return true; |
| } |
| |
| }; |