/* * Copyright (c) 2019 Rockchip 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. * */ #include "include/uAPI2/rk_aiq_user_api2_imgproc.h" #ifdef RK_SIMULATOR_HW #define CHECK_USER_API_ENABLE #endif #define RKAIQ_IMGPROC_CHECK_RET(ret, format, ...) \ if (ret) { \ LOGE(format, ##__VA_ARGS__); \ return ret; \ } #define IMGPROC_FUNC_ENTER LOGD("%s: enter", __FUNCTION__); #define IMGPROC_FUNC_EXIT LOGD("%s: exit", __FUNCTION__); RKAIQ_BEGIN_DECLARE /* ********************************************************** * API of AEC module of V2 ********************************************************** */ /* ***************************** * Desc: set ae mode * Argument: * mode contains: auto & manual * ***************************** */ XCamReturn rk_aiq_uapi2_setAeLock ( const rk_aiq_sys_ctx_t* ctx, bool on ) { IMGPROC_FUNC_ENTER XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_ExpSwAttrV2_t expSwAttr; if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param invalid!"); } ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "failed in getExpSwAttr!"); expSwAttr.Enable = (!on); ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "failed in setExpSwAttr!"); IMGPROC_FUNC_EXIT return (ret); } XCamReturn rk_aiq_uapi2_setExpMode ( const rk_aiq_sys_ctx_t* ctx, opMode_t mode ) { IMGPROC_FUNC_ENTER XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_ExpSwAttrV2_t expSwAttr; if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param invalid!"); } ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "setExpMode failed in getExpSwAttr!"); if (mode == OP_AUTO) { expSwAttr.AecOpType = RK_AIQ_OP_MODE_AUTO; } else if (mode == OP_MANUAL) { if (isHDRmode(ctx)) { expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL; expSwAttr.stManual.HdrAE.ManualGainEn = true; expSwAttr.stManual.HdrAE.ManualTimeEn = true; } else { expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL; expSwAttr.stManual.LinearAE.ManualGainEn = true; expSwAttr.stManual.LinearAE.ManualTimeEn = true; } } else { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "mode is not supported!"); } ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "setExpMode failed in setExpSwAttr!"); IMGPROC_FUNC_EXIT return (ret); } XCamReturn rk_aiq_uapi2_getExpMode ( const rk_aiq_sys_ctx_t* ctx, opMode_t *mode ) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_ExpSwAttrV2_t expSwAttr; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (mode == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param invalid!"); } ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "getExpMode failed in getExpSwAttr!"); if (expSwAttr.AecOpType == RK_AIQ_OP_MODE_AUTO) { *mode = OP_AUTO; } else if (expSwAttr.AecOpType == RK_AIQ_OP_MODE_MANUAL) { *mode = OP_MANUAL; } IMGPROC_FUNC_EXIT return (ret); } /* ***************************** * * Desc: set exposure parameter * Argument: * auto exposure mode: * exposure gain will be adjust between [gain->min, gain->max] * manual exposure mode: * gain->min == gain->max * ***************************** */ XCamReturn rk_aiq_uapi2_setExpGainRange ( const rk_aiq_sys_ctx_t* ctx, paRange_t *gain ) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_ExpSwAttrV2_t expSwAttr; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (gain == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param invalid!"); } LOGD("set range: [%f, %f]", gain->min, gain->max); if (gain->min < 1.0f || gain->max < 1.0f || (gain->min > gain->max)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "gain range is wrong!"); } ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetExpGainRange failed!"); expSwAttr.stAdvanced.SetAeRangeEn = true; if (isHDRmode(ctx)) { expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[0].Max = gain->max; expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[0].Min = gain->min; expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[1].Max = gain->max; expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[1].Min = gain->min; expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[2].Max = gain->max; expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[2].Min = gain->min; } else { expSwAttr.stAdvanced.SetLinAeRange.stGainRange.Max = gain->max; expSwAttr.stAdvanced.SetLinAeRange.stGainRange.Min = gain->min; } ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetExpGainRange failed!"); IMGPROC_FUNC_EXIT return (ret); } XCamReturn rk_aiq_uapi2_getExpGainRange ( const rk_aiq_sys_ctx_t* ctx, paRange_t *gain ) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_ExpSwAttrV2_t expSwAttr; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (gain == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\ngetExpGainRange failed!"); if (isHDRmode(ctx)) { int index = getHDRFrameNum(ctx); gain->max = expSwAttr.stAuto.HdrAeRange.stGainRange[index - 1].Max; gain->min = expSwAttr.stAuto.HdrAeRange.stGainRange[index - 1].Min; } else { gain->max = expSwAttr.stAuto.LinAeRange.stGainRange.Max; gain->min = expSwAttr.stAuto.LinAeRange.stGainRange.Min; } IMGPROC_FUNC_EXIT return (ret); } /* ***************************** * * Desc: set exposure parameter * Argument: * auto exposure mode: * exposure time will be adjust between [time->min, time->max] * manual exposure mode: * exposure time will be set gain->min == gain->max; * ***************************** */ XCamReturn rk_aiq_uapi2_setExpTimeRange ( const rk_aiq_sys_ctx_t* ctx, paRange_t *time ) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_ExpSwAttrV2_t expSwAttr; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (time == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } if ( time->min > time->max ) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "time range is wrong!"); } LOGD("set range: [%f, %f]", time->min, time->max); ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetExpTimeRange failed!"); expSwAttr.stAdvanced.SetAeRangeEn = true; if (isHDRmode(ctx)) { expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[0].Max = time->max; expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[0].Min = time->min; expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[1].Max = time->max; expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[1].Min = time->min; expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[2].Max = time->max; expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[2].Min = time->min; } else { expSwAttr.stAdvanced.SetLinAeRange.stExpTimeRange.Max = time->max; expSwAttr.stAdvanced.SetLinAeRange.stExpTimeRange.Min = time->min; } ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetExpTimeRange failed!"); IMGPROC_FUNC_EXIT return (ret); } XCamReturn rk_aiq_uapi2_getExpTimeRange ( const rk_aiq_sys_ctx_t* ctx, paRange_t *time ) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_ExpSwAttrV2_t expSwAttr; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (time == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\ngetExpTimeRange failed!"); if (isHDRmode(ctx)) { int index = getHDRFrameNum(ctx); time->max = expSwAttr.stAuto.HdrAeRange.stExpTimeRange[index - 1].Max; time->min = expSwAttr.stAuto.HdrAeRange.stExpTimeRange[index - 1].Min; } else { time->max = expSwAttr.stAuto.LinAeRange.stExpTimeRange.Max; time->min = expSwAttr.stAuto.LinAeRange.stExpTimeRange.Min; } IMGPROC_FUNC_EXIT return (ret); } /* ***************************** * * Desc: backlight compensation * Argument: * on: 1 on * 0 off * areaType: backlight compensation area * ***************************** */ XCamReturn rk_aiq_uapi2_setBLCMode(const rk_aiq_sys_ctx_t* ctx, bool on, aeMeasAreaType_t areaType) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_LinExpAttrV2_t LineExpAttr; memset(&LineExpAttr, 0x00, sizeof(Uapi_LinExpAttrV2_t)); IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } if (isHDRmode(ctx)) { ret = XCAM_RETURN_ERROR_FAILED; RKAIQ_IMGPROC_CHECK_RET(ret, "Not support in HDR mode!"); } ret = rk_aiq_user_api2_ae_getLinExpAttr(ctx, &LineExpAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "getLinExpAttr error!"); LineExpAttr.Params.BackLightCtrl.Enable = on ? 1 : 0; LineExpAttr.Params.BackLightCtrl.MeasArea = (CalibDb_AecMeasAreaModeV2_t)areaType; LineExpAttr.Params.BackLightCtrl.StrBias = 0; ret = rk_aiq_user_api2_ae_setLinExpAttr(ctx, LineExpAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "setBLCMode error!"); IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: backlight compensation strength,only available in normal mode * Argument: * strength: [1,100] ***************************** */ XCamReturn rk_aiq_uapi2_setBLCStrength(const rk_aiq_sys_ctx_t* ctx, int strength) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_LinExpAttrV2_t LineExpAttr; memset(&LineExpAttr, 0x00, sizeof(Uapi_LinExpAttrV2_t)); IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } if (isHDRmode(ctx)) { ret = XCAM_RETURN_ERROR_FAILED; RKAIQ_IMGPROC_CHECK_RET(ret, "Not support in HDR mode!"); } else { ret = rk_aiq_user_api2_ae_getLinExpAttr(ctx, &LineExpAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "getLinExpAttr error!"); if(0 == LineExpAttr.Params.BackLightCtrl.Enable) RKAIQ_IMGPROC_CHECK_RET(ret, "blc mode is not enabled!"); LineExpAttr.Params.BackLightCtrl.StrBias = strength; ret = rk_aiq_user_api2_ae_setLinExpAttr(ctx, LineExpAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "setBLCStrength error!"); } IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: highlight compensation * Argument: * on: 1 on * 0 off ***************************** */ XCamReturn rk_aiq_uapi2_setHLCMode(const rk_aiq_sys_ctx_t* ctx, bool on) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_LinExpAttrV2_t LinExpAttr; memset(&LinExpAttr, 0x00, sizeof(Uapi_LinExpAttrV2_t)); IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } if (isHDRmode(ctx)) { ret = XCAM_RETURN_ERROR_FAILED; RKAIQ_IMGPROC_CHECK_RET(ret, "Not support in HDR mode!"); } else { ret = rk_aiq_user_api2_ae_getLinExpAttr(ctx, &LinExpAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\n setHLCMode failed!"); LinExpAttr.Params.OverExpCtrl.Enable = on ? 1 : 0; LinExpAttr.Params.OverExpCtrl.StrBias = 0; ret = rk_aiq_user_api2_ae_setLinExpAttr(ctx, LinExpAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\n setHLCMode failed!"); } IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: highlight compensation strength * Argument: * strength: [1,100] ***************************** */ XCamReturn rk_aiq_uapi2_setHLCStrength(const rk_aiq_sys_ctx_t* ctx, int strength) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_LinExpAttrV2_t LinExpAttr; memset(&LinExpAttr, 0x00, sizeof(Uapi_LinExpAttrV2_t)); IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } if (isHDRmode(ctx)) { ret = XCAM_RETURN_ERROR_FAILED; RKAIQ_IMGPROC_CHECK_RET(ret, "Not support in HDR mode!"); } else { ret = rk_aiq_user_api2_ae_getLinExpAttr(ctx, &LinExpAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "getLinExpAttr error!"); if(0 == LinExpAttr.Params.OverExpCtrl.Enable) RKAIQ_IMGPROC_CHECK_RET(ret, "hlc mode is not enabled!"); LinExpAttr.Params.OverExpCtrl.StrBias = strength; ret = rk_aiq_user_api2_ae_setLinExpAttr(ctx, LinExpAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "setHLCStrength error!"); } IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set anti-flicker mode * Argument: * mode * ***************************** */ XCamReturn rk_aiq_uapi2_setAntiFlickerEn(const rk_aiq_sys_ctx_t* ctx, bool on) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_ExpSwAttrV2_t expSwAttr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetAntiFlickerEn failed!"); expSwAttr.stAuto.stAntiFlicker.enable = on; ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetAntiFlickerEn failed!"); IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set anti-flicker mode * Argument: * mode * ***************************** */ XCamReturn rk_aiq_uapi2_getAntiFlickerEn(const rk_aiq_sys_ctx_t* ctx, bool* on) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_ExpSwAttrV2_t expSwAttr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\ngetAntiFlickerEn!"); *on = expSwAttr.stAuto.stAntiFlicker.enable; IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set anti-flicker mode * Argument: * mode * ***************************** */ XCamReturn rk_aiq_uapi2_setAntiFlickerMode(const rk_aiq_sys_ctx_t* ctx, antiFlickerMode_t mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_ExpSwAttrV2_t expSwAttr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetAntiFlickerMode failed!"); if (mode == ANTIFLICKER_AUTO_MODE) { expSwAttr.stAuto.stAntiFlicker.enable = true; expSwAttr.stAuto.stAntiFlicker.Mode = AECV2_ANTIFLICKER_AUTO_MODE; } else if(mode == ANTIFLICKER_NORMAL_MODE) { expSwAttr.stAuto.stAntiFlicker.enable = true; expSwAttr.stAuto.stAntiFlicker.Mode = AECV2_ANTIFLICKER_NORMAL_MODE; } else { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "mode is invalid!"); } ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetAntiFlickerMode failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getAntiFlickerMode(const rk_aiq_sys_ctx_t* ctx, antiFlickerMode_t *mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_ExpSwAttrV2_t expSwAttr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\ngetAntiFlickerMode!"); if (expSwAttr.stAuto.stAntiFlicker.Mode == AECV2_ANTIFLICKER_AUTO_MODE) *mode = ANTIFLICKER_AUTO_MODE; else if (expSwAttr.stAuto.stAntiFlicker.Mode == AECV2_ANTIFLICKER_NORMAL_MODE) *mode = ANTIFLICKER_NORMAL_MODE; IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set power line frequence * Argument: * freq * ***************************** */ XCamReturn rk_aiq_uapi2_setExpPwrLineFreqMode(const rk_aiq_sys_ctx_t* ctx, expPwrLineFreq_t freq) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_ExpSwAttrV2_t expSwAttr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetExpPwrLineFreqMode failed!"); if (freq == EXP_PWR_LINE_FREQ_50HZ) { expSwAttr.stAuto.stAntiFlicker.enable = true; expSwAttr.stAuto.stAntiFlicker.Frequency = AECV2_FLICKER_FREQUENCY_50HZ; } else if (freq == EXP_PWR_LINE_FREQ_60HZ) { expSwAttr.stAuto.stAntiFlicker.enable = true; expSwAttr.stAuto.stAntiFlicker.Frequency = AECV2_FLICKER_FREQUENCY_60HZ; } else if (freq == EXP_PWR_LINE_FREQ_DIS) { expSwAttr.stAuto.stAntiFlicker.enable = true; expSwAttr.stAuto.stAntiFlicker.Frequency = AECV2_FLICKER_FREQUENCY_OFF; } else { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "freq is invalid!"); } ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetExpPwrLineFreqMode failed!"); IMGPROC_FUNC_EXIT return (ret); } XCamReturn rk_aiq_uapi2_getExpPwrLineFreqMode ( const rk_aiq_sys_ctx_t* ctx, expPwrLineFreq_t *freq ) { XCamReturn ret = XCAM_RETURN_NO_ERROR; Uapi_ExpSwAttrV2_t expSwAttr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetExpPwrLineFreqMode failed!"); if (expSwAttr.stAuto.stAntiFlicker.Frequency == AECV2_FLICKER_FREQUENCY_50HZ) { *freq = EXP_PWR_LINE_FREQ_50HZ; } else if (expSwAttr.stAuto.stAntiFlicker.Frequency == AECV2_FLICKER_FREQUENCY_60HZ) { *freq = EXP_PWR_LINE_FREQ_60HZ; } else if (expSwAttr.stAuto.stAntiFlicker.Frequency == AECV2_FLICKER_FREQUENCY_OFF) { *freq = EXP_PWR_LINE_FREQ_DIS; } else { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "freq is invalid!"); } IMGPROC_FUNC_EXIT return (ret); } /* ***************************** * * Desc: Adjust image gamma * * Argument: * GammaCoef: [0, 100] * SlopeAtZero: [-0.05, 0.05] ***************************** */ XCamReturn rk_aiq_uapi2_setGammaCoef(const rk_aiq_sys_ctx_t* ctx, float GammaCoef, float SlopeAtZero) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setGammaCoef failed!"); } if (GammaCoef < 0 || GammaCoef > 100) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, GammaCoef range is [0,100]!"); } if (SlopeAtZero < -0.05 || SlopeAtZero > 0.05) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, SlopeAtZero range is [-0.05,0.05]!"); } rk_aiq_gamma_attrib_V2_t gammaAttr; memset(&gammaAttr, 0x0, sizeof(rk_aiq_gamma_attrib_V2_t)); gammaAttr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT; gammaAttr.sync.done = false; if(CHECK_ISP_HW_V21()) { gammaAttr.atrrV21.mode = RK_AIQ_GAMMA_MODE_FAST; gammaAttr.atrrV21.stFast.en = true; gammaAttr.atrrV21.stFast.GammaCoef = GammaCoef; gammaAttr.atrrV21.stFast.SlopeAtZero = SlopeAtZero; } else if(CHECK_ISP_HW_V30()) { gammaAttr.atrrV30.mode = RK_AIQ_GAMMA_MODE_FAST; gammaAttr.atrrV30.stFast.en = true; gammaAttr.atrrV30.stFast.GammaCoef = GammaCoef; gammaAttr.atrrV30.stFast.SlopeAtZero = SlopeAtZero; } ret = rk_aiq_user_api2_agamma_SetAttrib(ctx, gammaAttr); IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set manual dehaze strength * this function is active for dehaze is manual mode * Argument: * level: [0, 100] * ***************************** */ XCamReturn rk_aiq_uapi2_setMDehazeStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; adehaze_sw_V2_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!"); } if (level < 1 || level > 100) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, strength range is [1,10]!"); } attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT; attr.sync.done = false; attr.mode = DEHAZE_API_DEHAZE_MANUAL; attr.stDehazeManu.level = level; ret = rk_aiq_user_api2_adehaze_setSwAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setMDhzStrth failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getMDehazeStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int *level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; adehaze_sw_V2_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!"); } ret = rk_aiq_user_api2_adehaze_getSwAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed in get attrib!"); if (attr.mode != DEHAZE_API_DEHAZE_MANUAL) { LOGE("Not in Dehaze manual mode!"); *level = 0; } else *level = attr.stDehazeManu.level; IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set manual enhance strength * this function is active for dehaze is manual mode * Argument: * level: [0, 100] * ***************************** */ XCamReturn rk_aiq_uapi2_setMEnhanceStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; adehaze_sw_V2_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!"); } if (level < 1 || level > 100) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, level range is [1,10]!"); } attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT; attr.sync.done = false; attr.mode = DEHAZE_API_ENHANCE_MANUAL; attr.stEnhanceManu.level = level; ret = rk_aiq_user_api2_adehaze_setSwAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setMEnhanceStrth failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getMEnhanceStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int *level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; adehaze_sw_V2_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!"); } ret = rk_aiq_user_api2_adehaze_getSwAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "getMEnhanceStrth failed in get attrib!"); if (attr.mode != DEHAZE_API_ENHANCE_MANUAL) { LOGE("Not in Enhance manual mode!"); *level = 0; } else *level = attr.stEnhanceManu.level; IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set manual drc Local TMO * this function is active for DRC is DRC Gain mode * use in RK356x * Argument: * LocalWeit: [0, 1] * GlobalContrast: [0, 1] * LoLitContrast: [0, 1] * ***************************** */ XCamReturn rk_aiq_uapi2_setDrcLocalTMO(const rk_aiq_sys_ctx_t* ctx, float LocalWeit, float GlobalContrast, float LoLitContrast) { XCamReturn ret = XCAM_RETURN_NO_ERROR; if(CHECK_ISP_HW_V20()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.0 do not support drc api!"); } else if(CHECK_ISP_HW_V30()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "RK356x do not support rk_aiq_uapi2_setDrcLocalTMO! Plesea use rk_aiq_uapi2_setDrcLocalData"); } else if(CHECK_ISP_HW_V21()) { drc_attrib_t attr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!"); } if (LocalWeit < 0 || LocalWeit > 1) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, LocalWeit range is [0,1]!"); } if (GlobalContrast < 0 || GlobalContrast > 1) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, GlobalContrast range is [0,1]!"); } if (LoLitContrast < 0 || LoLitContrast > 1) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, LoLitContrast range is [0,1]!"); } attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT; attr.sync.done = false; attr.opMode = DRC_OPMODE_LOCAL_TMO; attr.stLocalDataV21.LocalWeit = LocalWeit; attr.stLocalDataV21.GlobalContrast = GlobalContrast; attr.stLocalDataV21.LoLitContrast = LoLitContrast; ret = rk_aiq_user_api2_adrc_SetAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed!"); IMGPROC_FUNC_EXIT } return ret; } XCamReturn rk_aiq_uapi2_getDrcLocalTMO(const rk_aiq_sys_ctx_t* ctx, float * LocalWeit, float * GlobalContrast, float * LoLitContrast) { XCamReturn ret = XCAM_RETURN_NO_ERROR; if(CHECK_ISP_HW_V20()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.0 do not support drc api!"); } else if(CHECK_ISP_HW_V30()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "RK356x do not support rk_aiq_uapi2_getDrcLocalTMO! Plesea use rk_aiq_uapi2_getDrcLocalData"); } else if(CHECK_ISP_HW_V21()) { drc_attrib_t attr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!"); } ret = rk_aiq_user_api2_adrc_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed in get attrib!"); *LocalWeit = attr.stLocalDataV21.LocalWeit; *GlobalContrast = attr.stLocalDataV21.GlobalContrast; *LoLitContrast = attr.stLocalDataV21.LoLitContrast; IMGPROC_FUNC_EXIT } return ret; } /* ***************************** * * Desc: set manual drc Local Data * this function is active for DRC is DRC Gain mode * use in RK3588 * Argument: * LocalWeit: [0, 1] * GlobalContrast: [0, 1] * LoLitContrast: [0, 1] * LocalAutoEnable: [0, 1] * LocalAutoWeit: [0, 1] * ***************************** */ XCamReturn rk_aiq_uapi2_setDrcLocalData(const rk_aiq_sys_ctx_t* ctx, float LocalWeit, float GlobalContrast, float LoLitContrast, int LocalAutoEnable, float LocalAutoWeit) { XCamReturn ret = XCAM_RETURN_NO_ERROR; if(CHECK_ISP_HW_V20()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.0 do not support drc api!"); } else if(CHECK_ISP_HW_V21()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "RK3588 do not support rk_aiq_uapi2_setDrcLocalData! Plesea use rk_aiq_uapi2_setDrcLocalTMO"); } else if(CHECK_ISP_HW_V30()) { drc_attrib_t attr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!"); } if (LocalWeit < 0 || LocalWeit > 1) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, LocalWeit range is [0,1]!"); } if (GlobalContrast < 0 || GlobalContrast > 1) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, GlobalContrast range is [0,1]!"); } if (LoLitContrast < 0 || LoLitContrast > 1) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, LoLitContrast range is [0,1]!"); } if (LocalAutoEnable < 0 || LocalAutoEnable > 1) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, LocalAutoEnable range is [0,1]!"); } if (LocalAutoWeit < 0 || LocalAutoWeit > 1) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, LocalAutoWeit range is [0,1]!"); } attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT; attr.sync.done = false; attr.opMode = DRC_OPMODE_LOCAL_TMO; attr.stLocalDataV30.LocalWeit = LocalWeit; attr.stLocalDataV30.GlobalContrast = GlobalContrast; attr.stLocalDataV30.LoLitContrast = LoLitContrast; attr.stLocalDataV30.LocalAutoEnable = LocalAutoEnable; attr.stLocalDataV30.LocalAutoWeit = LocalAutoWeit; ret = rk_aiq_user_api2_adrc_SetAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed!"); IMGPROC_FUNC_EXIT } return ret; } XCamReturn rk_aiq_uapi2_getDrcLocalData(const rk_aiq_sys_ctx_t* ctx, float * LocalWeit, float * GlobalContrast, float * LoLitContrast, int* LocalAutoEnable, float* LocalAutoWeit) { XCamReturn ret = XCAM_RETURN_NO_ERROR; if(CHECK_ISP_HW_V20()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.0 do not support drc api!"); } else if(CHECK_ISP_HW_V21()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "RK3588 do not support rk_aiq_uapi2_setDrcLocalData! Plesea use rk_aiq_uapi2_setDrcLocalTMO"); } else if(CHECK_ISP_HW_V30()) { drc_attrib_t attr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!"); } ret = rk_aiq_user_api2_adrc_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed in get attrib!"); *LocalWeit = attr.stLocalDataV30.LocalWeit; *GlobalContrast = attr.stLocalDataV30.GlobalContrast; *LoLitContrast = attr.stLocalDataV30.LoLitContrast; *LocalAutoEnable = attr.stLocalDataV30.LocalAutoEnable; *LocalAutoWeit = attr.stLocalDataV30.LocalAutoWeit; IMGPROC_FUNC_EXIT } return ret; } /* ***************************** * * Desc: set manual drc HiLit * this function is active for DRC is HiLit mode * Argument: * Strength: [0, 1] * ***************************** */ XCamReturn rk_aiq_uapi2_setDrcHiLit(const rk_aiq_sys_ctx_t* ctx, float Strength) { XCamReturn ret = XCAM_RETURN_NO_ERROR; if(CHECK_ISP_HW_V20()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.0 do not support drc api!"); } else if(CHECK_ISP_HW_V21() || CHECK_ISP_HW_V30()) { drc_attrib_t attr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!"); } if (Strength < 0 || Strength > 1) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, Strength range is [0,1]!"); } attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT; attr.sync.done = false; attr.opMode = DRC_OPMODE_HILIT; attr.stHiLit.Strength = Strength; ret = rk_aiq_user_api2_adrc_SetAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed!"); IMGPROC_FUNC_EXIT } return ret; } XCamReturn rk_aiq_uapi2_getDrcHiLit(const rk_aiq_sys_ctx_t* ctx, float * Strength) { XCamReturn ret = XCAM_RETURN_NO_ERROR; if(CHECK_ISP_HW_V20()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.0 do not support drc api!"); } else if(CHECK_ISP_HW_V21() || CHECK_ISP_HW_V30()) { drc_attrib_t attr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!"); } ret = rk_aiq_user_api2_adrc_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed in get attrib!"); *Strength = attr.stHiLit.Strength; IMGPROC_FUNC_EXIT } return ret; } /* ***************************** * * Desc: set manual drc Gain * this function is active for DRC is DRC Gain mode * Argument: * Gain: [1, 8] * Alpha: [0, 1] * Clip: [0, 64] * ***************************** */ XCamReturn rk_aiq_uapi2_setDrcGain(const rk_aiq_sys_ctx_t* ctx, float Gain, float Alpha, float Clip) { XCamReturn ret = XCAM_RETURN_NO_ERROR; if(CHECK_ISP_HW_V20()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.0 do not support drc api!"); } else if(CHECK_ISP_HW_V21() || CHECK_ISP_HW_V30()) { drc_attrib_t attr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!"); } if (Gain < 1 || Gain > 8) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, Gain range is [1,8]!"); } if (Alpha < 0 || Alpha > 1) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, Alpha range is [0,1]!"); } if (Clip < 0 || Clip > 64) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, Clip range is [0,64]!"); } attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT; attr.sync.done = false; attr.opMode = DRC_OPMODE_DRC_GAIN; attr.stDrcGain.DrcGain = Gain; attr.stDrcGain.Alpha = Alpha; attr.stDrcGain.Clip = Clip; ret = rk_aiq_user_api2_adrc_SetAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed!"); IMGPROC_FUNC_EXIT } return ret; } XCamReturn rk_aiq_uapi2_getDrcGain(const rk_aiq_sys_ctx_t* ctx, float * Gain, float * Alpha, float * Clip) { XCamReturn ret = XCAM_RETURN_NO_ERROR; if(CHECK_ISP_HW_V20()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.0 do not support drc api!"); } else if(CHECK_ISP_HW_V21() || CHECK_ISP_HW_V30()) { drc_attrib_t attr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!"); } ret = rk_aiq_user_api2_adrc_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed in get attrib!"); *Gain = attr.stDrcGain.DrcGain; *Alpha = attr.stDrcGain.Alpha; *Clip = attr.stDrcGain.Clip; IMGPROC_FUNC_EXIT } return ret; } /* ***************************** * * Desc: set/get dark area boost strength * this function is active for normal mode * Argument: * level: [1, 10] * ***************************** */ XCamReturn rk_aiq_uapi2_getDarkAreaBoostStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int *level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; if(CHECK_ISP_HW_V20()) { atmo_attrib_t attr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, getDarkAreaBoostStrth failed!"); } if (isHDRmode(ctx)) { ret = XCAM_RETURN_ERROR_FAILED; RKAIQ_IMGPROC_CHECK_RET(ret, "Not valid in tmo mode!"); } ret = rk_aiq_user_api2_atmo_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "getDarkAreaBoostStrth failed!"); if (attr.opMode == TMO_OPMODE_DARKAREA) *level = attr.stDarkArea.level; else *level = 0; IMGPROC_FUNC_EXIT } else if(CHECK_ISP_HW_V21()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.1 do not support tmo api!"); } else if(CHECK_ISP_HW_V30()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP3.0 do not support tmo api!"); } return ret; } XCamReturn rk_aiq_uapi2_setDarkAreaBoostStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; if(CHECK_ISP_HW_V20()) { atmo_attrib_t attr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, getDarkAreaBoostStrth failed!"); } if (isHDRmode(ctx)) { atmo_attrib_t attr; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setMHDRStrth failed!"); } if (isHDRmode(ctx)) { ret = XCAM_RETURN_ERROR_FAILED; RKAIQ_IMGPROC_CHECK_RET(ret, "Not valid in HDR mode!"); } if (level > 10) { ret = XCAM_RETURN_ERROR_OUTOFRANGE; RKAIQ_IMGPROC_CHECK_RET(ret, "level(%d) is out of range, setDarkAreaBoostStrth failed!"); } attr.stDarkArea.level = level; attr.opMode = TMO_OPMODE_DARKAREA; ret = rk_aiq_user_api2_atmo_SetAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setDarkAreaBoostStrth failed!"); IMGPROC_FUNC_EXIT } } else if(CHECK_ISP_HW_V21()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.1 do not support tmo api!"); } else if(CHECK_ISP_HW_V30()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP3.0 do not support tmo api!"); } return ret; } /* ***************************** * * Desc: set/get manual hdr strength * this function is active for HDR is manual mode * Argument: * level: [1, 100] * ***************************** */ XCamReturn rk_aiq_uapi2_setMHDRStrth(const rk_aiq_sys_ctx_t* ctx, bool on, unsigned int level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; if(CHECK_ISP_HW_V20()) { atmo_attrib_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setMHDRStrth failed!"); } if (!isHDRmode(ctx)) { ret = XCAM_RETURN_ERROR_FAILED; RKAIQ_IMGPROC_CHECK_RET(ret, "not in HDR mode!"); } if (level < 1 || level > 100) { ret = XCAM_RETURN_ERROR_OUTOFRANGE; RKAIQ_IMGPROC_CHECK_RET(ret, "level(%d) is out of range, setMHDRStrth failed!"); } attr.stSetLevel.level = level; attr.opMode = TMO_OPMODE_SET_LEVEL; ret = rk_aiq_user_api2_atmo_SetAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setMHDRStrth failed!"); IMGPROC_FUNC_EXIT } else if(CHECK_ISP_HW_V21()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.1 do not support tmo api, ctx is NULL!"); } else if(CHECK_ISP_HW_V30()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP3.0 do not support tmo api!"); } return ret; } XCamReturn rk_aiq_uapi2_getMHDRStrth(const rk_aiq_sys_ctx_t* ctx, bool * on, unsigned int *level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; if(CHECK_ISP_HW_V20()) { atmo_attrib_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, getMHDRStrth failed!"); } if (!isHDRmode(ctx)) { ret = XCAM_RETURN_ERROR_FAILED; RKAIQ_IMGPROC_CHECK_RET(ret, "not in HDR mode!"); } ret = rk_aiq_user_api2_atmo_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "getMHDRStrth failed in get attrib!"); *level = attr.stSetLevel.level; IMGPROC_FUNC_EXIT } else if(CHECK_ISP_HW_V21()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.1 do not support tmo api, ctx is NULL!"); } else if(CHECK_ISP_HW_V30()) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ISP3.0 do not support tmo api!"); } return ret; } /* ********************************************************** * Noise reduction ********************************************************** */ /* ***************************** * * Desc: set noise reduction mode * Argument: * mode: * auto: auto noise reduction * manual：manual noise reduction * ***************************** */ XCamReturn rk_aiq_uapi2_setNRMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (CHECK_ISP_HW_V20()) { rk_aiq_nr_attrib_t attr; ret = rk_aiq_user_api2_anr_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret); if (mode == OP_AUTO) { attr.eMode = ANR_OP_MODE_AUTO; } else if (mode == OP_MANUAL) { attr.eMode = ANR_OP_MODE_MANUAL; } else { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!"); } ret = rk_aiq_user_api2_anr_SetAttrib(ctx, &attr); } if (CHECK_ISP_HW_V21()) { rk_aiq_ynr_attrib_v2_t ynrV2_attr; rk_aiq_bayernr_attrib_v2_t bayernrV2_attr; rk_aiq_cnr_attrib_v1_t cnrV1_attr; ret = rk_aiq_user_api2_aynrV2_GetAttrib(ctx, &ynrV2_attr); ret = rk_aiq_user_api2_abayernrV2_GetAttrib(ctx, &bayernrV2_attr); ret = rk_aiq_user_api2_acnrV1_GetAttrib(ctx, &cnrV1_attr); RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret); if (mode == OP_AUTO) { bayernrV2_attr.eMode = ABAYERNR_OP_MODE_AUTO; ynrV2_attr.eMode = AYNR_OP_MODE_AUTO; cnrV1_attr.eMode = ACNR_OP_MODE_AUTO; } else if (mode == OP_MANUAL) { bayernrV2_attr.eMode = ABAYERNR_OP_MODE_MANUAL; ynrV2_attr.eMode = AYNR_OP_MODE_MANUAL; cnrV1_attr.eMode = ACNR_OP_MODE_MANUAL; } else { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!"); } ret = rk_aiq_user_api2_aynrV2_SetAttrib(ctx, &ynrV2_attr); ret = rk_aiq_user_api2_abayernrV2_SetAttrib(ctx, &bayernrV2_attr); ret = rk_aiq_user_api2_acnrV1_SetAttrib(ctx, &cnrV1_attr); } if (CHECK_ISP_HW_V30()) { rk_aiq_ynr_attrib_v3_t ynrV3_attr; ynrV3_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; rk_aiq_cnr_attrib_v2_t cnrV2_attr; cnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; rk_aiq_bayer2dnr_attrib_v2_t bayer2dnrV2_attr; bayer2dnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; rk_aiq_bayertnr_attrib_v2_t bayertnrV2_attr; bayertnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; ret = rk_aiq_user_api2_aynrV3_GetAttrib(ctx, &ynrV3_attr); ret = rk_aiq_user_api2_acnrV2_GetAttrib(ctx, &cnrV2_attr); ret = rk_aiq_user_api2_abayer2dnrV2_GetAttrib(ctx, &bayer2dnrV2_attr); ret = rk_aiq_user_api2_abayertnrV2_GetAttrib(ctx, &bayertnrV2_attr); RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret); if (mode == OP_AUTO) { ynrV3_attr.eMode = AYNRV3_OP_MODE_AUTO; cnrV2_attr.eMode = ACNRV2_OP_MODE_AUTO; bayer2dnrV2_attr.eMode = ABAYER2DNR_OP_MODE_AUTO; bayertnrV2_attr.eMode = ABAYERTNRV2_OP_MODE_AUTO; } else if (mode == OP_MANUAL) { ynrV3_attr.eMode = AYNRV3_OP_MODE_MANUAL; cnrV2_attr.eMode = ACNRV2_OP_MODE_MANUAL; bayer2dnrV2_attr.eMode = ABAYER2DNR_OP_MODE_MANUAL; bayertnrV2_attr.eMode = ABAYERTNRV2_OP_MODE_MANUAL; } else if(mode == OP_REG_MANUAL) { ynrV3_attr.eMode = AYNRV3_OP_MODE_REG_MANUAL; cnrV2_attr.eMode = ACNRV2_OP_MODE_REG_MANUAL; bayer2dnrV2_attr.eMode = ABAYER2DNR_OP_MODE_REG_MANUAL; bayertnrV2_attr.eMode = ABAYERTNRV2_OP_MODE_REG_MANUAL; } else { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!"); } ret = rk_aiq_user_api2_aynrV3_SetAttrib(ctx, &ynrV3_attr); ret = rk_aiq_user_api2_acnrV2_SetAttrib(ctx, &cnrV2_attr); ret = rk_aiq_user_api2_abayer2dnrV2_SetAttrib(ctx, &bayer2dnrV2_attr); ret = rk_aiq_user_api2_abayertnrV2_SetAttrib(ctx, &bayertnrV2_attr); } RKAIQ_IMGPROC_CHECK_RET(ret, "setNRMode failed!", ret); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getNRMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (CHECK_ISP_HW_V20()) { rk_aiq_nr_attrib_t attr; ret = rk_aiq_user_api2_anr_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret); if (attr.eMode == ANR_OP_MODE_AUTO) { *mode = OP_AUTO; } else if (attr.eMode == ANR_OP_MODE_MANUAL) { *mode = OP_MANUAL; } else if (attr.eMode == ANR_OP_MODE_INVALID) { *mode = OP_INVAL; } } if (CHECK_ISP_HW_V21()) { rk_aiq_ynr_attrib_v2_t ynrV2_attr; rk_aiq_bayernr_attrib_v2_t bayernrV2_attr; rk_aiq_cnr_attrib_v1_t cnrV1_attr; ret = rk_aiq_user_api2_aynrV2_GetAttrib(ctx, &ynrV2_attr); ret = rk_aiq_user_api2_abayernrV2_GetAttrib(ctx, &bayernrV2_attr); ret = rk_aiq_user_api2_acnrV1_GetAttrib(ctx, &cnrV1_attr); RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret); if (bayernrV2_attr.eMode == ABAYERNR_OP_MODE_AUTO && ynrV2_attr.eMode == AYNR_OP_MODE_AUTO && cnrV1_attr.eMode == ACNR_OP_MODE_AUTO) { *mode = OP_AUTO; } else if (bayernrV2_attr.eMode == ABAYERNR_OP_MODE_MANUAL && ynrV2_attr.eMode == AYNR_OP_MODE_MANUAL && cnrV1_attr.eMode == ACNR_OP_MODE_MANUAL) { *mode = OP_MANUAL; } else if (bayernrV2_attr.eMode == ABAYERNR_OP_MODE_INVALID && ynrV2_attr.eMode == AYNR_OP_MODE_INVALID && cnrV1_attr.eMode == ACNR_OP_MODE_INVALID) { *mode = OP_INVAL; } else { LOGE_ANR("bayernr.mode:%d ynr.mode:%d cnr.mode:%d\n", bayernrV2_attr.eMode, ynrV2_attr.eMode, cnrV1_attr.eMode); } } if (CHECK_ISP_HW_V30()) { rk_aiq_ynr_attrib_v3_t ynrV3_attr; ynrV3_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; rk_aiq_cnr_attrib_v2_t cnrV2_attr; cnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; rk_aiq_bayer2dnr_attrib_v2_t bayer2dnrV2_attr; bayer2dnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; rk_aiq_bayertnr_attrib_v2_t bayertnrV2_attr; bayertnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; ret = rk_aiq_user_api2_aynrV3_GetAttrib(ctx, &ynrV3_attr); ret = rk_aiq_user_api2_acnrV2_GetAttrib(ctx, &cnrV2_attr); ret = rk_aiq_user_api2_abayer2dnrV2_GetAttrib(ctx, &bayer2dnrV2_attr); ret = rk_aiq_user_api2_abayertnrV2_GetAttrib(ctx, &bayertnrV2_attr); RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret); if(ynrV3_attr.eMode == AYNRV3_OP_MODE_AUTO && cnrV2_attr.eMode == ACNRV2_OP_MODE_AUTO && bayer2dnrV2_attr.eMode == ABAYER2DNR_OP_MODE_AUTO && bayertnrV2_attr.eMode == ABAYERTNRV2_OP_MODE_AUTO) { *mode = OP_AUTO; } else if(ynrV3_attr.eMode == AYNRV3_OP_MODE_MANUAL && cnrV2_attr.eMode == ACNRV2_OP_MODE_MANUAL && bayer2dnrV2_attr.eMode == ABAYER2DNR_OP_MODE_MANUAL && bayertnrV2_attr.eMode == ABAYERTNRV2_OP_MODE_MANUAL) { *mode = OP_MANUAL; } else if(ynrV3_attr.eMode == AYNRV3_OP_MODE_REG_MANUAL && cnrV2_attr.eMode == ACNRV2_OP_MODE_REG_MANUAL && bayer2dnrV2_attr.eMode == ABAYER2DNR_OP_MODE_REG_MANUAL && bayertnrV2_attr.eMode == ABAYERTNRV2_OP_MODE_REG_MANUAL) { *mode = OP_REG_MANUAL; } else { LOGE_ANR("ynr.mode:%d cnr.mode:%d bayer2dnr.mode:%d bayertnr.mode:%d\n", ynrV3_attr.eMode, cnrV2_attr.eMode, bayer2dnrV2_attr.eMode, bayertnrV2_attr.eMode); } } IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set normal noise reduction strength * Argument: * level: [0, 100] * Normal mode ***************************** */ XCamReturn rk_aiq_uapi2_setANRStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setANRStrth failed!"); } if (CHECK_ISP_HW_V20()) { ret = rk_aiq_user_api2_anr_SetLumaSFStrength(ctx, level / 100.0); ret = rk_aiq_user_api2_anr_SetLumaTFStrength(ctx, level / 100.0); RKAIQ_IMGPROC_CHECK_RET(ret, "setANRStrth failed!", ret); } if (CHECK_ISP_HW_V21()) { ret = rk_aiq_user_api2_aynrV2_SetStrength(ctx, level / 100.0); ret = rk_aiq_user_api2_abayernrV2_SetSFStrength(ctx, level / 100.0); ret = rk_aiq_user_api2_abayernrV2_SetTFStrength(ctx, level / 100.0); RKAIQ_IMGPROC_CHECK_RET(ret, "setANRStrth failed!", ret); } if (CHECK_ISP_HW_V30()) { rk_aiq_ynr_strength_v3_t ynrStrenght; ynrStrenght.strength_enable = true; ynrStrenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; ynrStrenght.percent = level / 100.0; ret = rk_aiq_user_api2_aynrV3_SetStrength(ctx, &ynrStrenght); rk_aiq_bayer2dnr_strength_v2_t bayer2dnrV2Strenght; bayer2dnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; bayer2dnrV2Strenght.strength_enable = true; bayer2dnrV2Strenght.percent = level / 100.0; ret = rk_aiq_user_api2_abayer2dnrV2_SetStrength(ctx, &bayer2dnrV2Strenght); rk_aiq_bayertnr_strength_v2_t bayertnrV2Strenght; bayertnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; bayertnrV2Strenght.strength_enable = true; bayertnrV2Strenght.percent = level / 100.0; ret = rk_aiq_user_api2_abayertnrV2_SetStrength(ctx, &bayertnrV2Strenght); RKAIQ_IMGPROC_CHECK_RET(ret, "setANRStrth failed!", ret); } IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getANRStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int *level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; float percent = 0.0f; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, getANRStrth failed!"); } if (CHECK_ISP_HW_V20()) { ret = rk_aiq_user_api2_anr_GetLumaTFStrength(ctx, &percent); RKAIQ_IMGPROC_CHECK_RET(ret, "getANRStrth failed!", ret); *level = (unsigned int)(percent * 100); } if (CHECK_ISP_HW_V21()) { ret = rk_aiq_user_api2_abayernrV2_GetTFStrength(ctx, &percent); RKAIQ_IMGPROC_CHECK_RET(ret, "getANRStrth failed!", ret); *level = (unsigned int)(percent * 100); } if (CHECK_ISP_HW_V30()) { rk_aiq_bayertnr_strength_v2_t bayertnrV2Strenght; bayertnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; ret = rk_aiq_user_api2_abayertnrV2_GetStrength(ctx, &bayertnrV2Strenght); percent = bayertnrV2Strenght.percent; RKAIQ_IMGPROC_CHECK_RET(ret, "getANRStrth failed!", ret); *level = (unsigned int)(percent * 100); } IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set manual spatial noise reduction strength * this function is active for NR is manual mode * Argument: * level: [0, 100] * ***************************** */ XCamReturn rk_aiq_uapi2_setMSpaNRStrth(const rk_aiq_sys_ctx_t* ctx, bool on, unsigned int level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setMSpaNRStrth failed!"); } if (CHECK_ISP_HW_V20()) { ret = rk_aiq_user_api2_anr_SetLumaSFStrength(ctx, level / 100.0); } if (CHECK_ISP_HW_V21()) { ret = rk_aiq_user_api2_abayernrV2_SetSFStrength(ctx, level / 100.0); ret = rk_aiq_user_api2_aynrV2_SetStrength(ctx, level / 100.0); } if (CHECK_ISP_HW_V30()) { rk_aiq_ynr_strength_v3_t ynrStrenght; ynrStrenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; ynrStrenght.strength_enable = true; ynrStrenght.percent = level / 100.0; ret = rk_aiq_user_api2_aynrV3_SetStrength(ctx, &ynrStrenght); rk_aiq_bayer2dnr_strength_v2_t bayer2dnrV2Strenght; bayer2dnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; bayer2dnrV2Strenght.strength_enable = true; bayer2dnrV2Strenght.percent = level / 100.0; ret = rk_aiq_user_api2_abayer2dnrV2_SetStrength(ctx, &bayer2dnrV2Strenght); } RKAIQ_IMGPROC_CHECK_RET(ret, "setMSpaNRStrth failed!", ret); IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: get manual spatial noise reduction strength * this function is active for NR is manual mode * Argument: * level: [0, 100] * ***************************** */ XCamReturn rk_aiq_uapi2_getMSpaNRStrth(const rk_aiq_sys_ctx_t* ctx, bool * on, unsigned int *level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; float percent = 0.0f; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, getMSpaNRStrth failed!"); } if (CHECK_ISP_HW_V20()) { ret = rk_aiq_user_api2_anr_GetLumaSFStrength(ctx, &percent); } if (CHECK_ISP_HW_V21()) { ret = rk_aiq_user_api2_abayernrV2_GetSFStrength(ctx, &percent); } if (CHECK_ISP_HW_V30()) { rk_aiq_bayer2dnr_strength_v2_t bayer2dnrV2Strenght; bayer2dnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; ret = rk_aiq_user_api2_abayer2dnrV2_GetStrength(ctx, &bayer2dnrV2Strenght); percent = bayer2dnrV2Strenght.percent; } RKAIQ_IMGPROC_CHECK_RET(ret, "getMSpaNRStrth failed!", ret); *level = (unsigned int)(percent * 100); IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set manual time noise reduction strength * this function is active for NR is manual mode * Argument: * level: [0, 100] * ***************************** */ XCamReturn rk_aiq_uapi2_setMTNRStrth(const rk_aiq_sys_ctx_t* ctx, bool on, unsigned int level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER LOGD("level=%d", level); if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setMTNRStrth failed!"); } if (CHECK_ISP_HW_V20()) { ret = rk_aiq_user_api2_anr_SetLumaTFStrength(ctx, level / 100.0); } if (CHECK_ISP_HW_V21()) { ret = rk_aiq_user_api2_abayernrV2_SetTFStrength(ctx, level / 100.0); } if (CHECK_ISP_HW_V30()) { rk_aiq_bayertnr_strength_v2_t bayertnrV2Strenght; bayertnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; bayertnrV2Strenght.strength_enable = true; bayertnrV2Strenght.percent = level / 100.0; ret = rk_aiq_user_api2_abayertnrV2_SetStrength(ctx, &bayertnrV2Strenght); } RKAIQ_IMGPROC_CHECK_RET(ret, "setMTNRStrth failed!", ret); IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: get manual time noise reduction strength * this function is active for NR is manual mode * Argument: * level: [0, 100] * ***************************** */ XCamReturn rk_aiq_uapi2_getMTNRStrth(const rk_aiq_sys_ctx_t* ctx, bool * on, unsigned int *level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; float percent = 0.0f; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, getMTNRStrth failed!"); } if (CHECK_ISP_HW_V20()) { ret = rk_aiq_user_api2_anr_GetLumaTFStrength(ctx, &percent); } if (CHECK_ISP_HW_V21()) { ret = rk_aiq_user_api2_abayernrV2_GetTFStrength(ctx, &percent); } if (CHECK_ISP_HW_V30()) { rk_aiq_bayertnr_strength_v2_t bayertnrV2Strenght; bayertnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; ret = rk_aiq_user_api2_abayertnrV2_GetStrength(ctx, &bayertnrV2Strenght); percent = bayertnrV2Strenght.percent; } RKAIQ_IMGPROC_CHECK_RET(ret, "getMTNRStrth failed!", ret); *level = (unsigned int)(percent * 100); IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: Adjust image sharpness level * Argument: * level: sharpness level, [0, 100] ***************************** */ XCamReturn rk_aiq_uapi2_setSharpness(const rk_aiq_sys_ctx_t* ctx, unsigned int level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; float fPercent = 0.0f; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, set sharpeness failed!"); } LOGD("setSharpness enter, level=%d\n", level); if (level < 0 || level > 100) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "level out of range, set sharpeness failed!"); } fPercent = level / 100.0f; if (CHECK_ISP_HW_V21()) { ret = rk_aiq_user_api2_asharpV3_SetStrength(ctx, fPercent); } if (CHECK_ISP_HW_V30()) { rk_aiq_sharp_strength_v4_t sharpV4Strenght; sharpV4Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; sharpV4Strenght.strength_enable = true; sharpV4Strenght.percent = fPercent; ret = rk_aiq_user_api2_asharpV4_SetStrength(ctx, &sharpV4Strenght); } RKAIQ_IMGPROC_CHECK_RET(ret, "set sharpeness failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getSharpness(const rk_aiq_sys_ctx_t* ctx, unsigned int *level) { XCamReturn ret = XCAM_RETURN_NO_ERROR; float fPercent = 0.0f; IMGPROC_FUNC_ENTER if (level == NULL || ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get sharpeness failed!"); } if (CHECK_ISP_HW_V21()) { ret = rk_aiq_user_api2_asharpV3_GetStrength(ctx, &fPercent); } if (CHECK_ISP_HW_V30()) { rk_aiq_sharp_strength_v4_t sharpV4Strenght; sharpV4Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; ret = rk_aiq_user_api2_asharpV4_GetStrength(ctx, &sharpV4Strenght); fPercent = sharpV4Strenght.percent; } RKAIQ_IMGPROC_CHECK_RET(ret, "get sharpeness failed!"); *level = (unsigned int)(fPercent * 100); IMGPROC_FUNC_EXIT return ret; } /* ********************************************************** * White balance & Color ********************************************************** */ /* ***************************** * * Desc: set white balance mode * Argument: * mode: auto: auto white balance * manual: manual white balance ***************************** */ XCamReturn rk_aiq_uapi2_setWBMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_uapiV2_wb_opMode_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if (mode >= OP_INVAL || mode < OP_AUTO) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "mode is invalid!"); } if (mode == OP_AUTO) { attr.mode = RK_AIQ_WB_MODE_AUTO; } else if (mode == OP_MANUAL) { attr.mode = RK_AIQ_WB_MODE_MANUAL; } else { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!"); } ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getWBMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_uapiV2_wb_opMode_t attr; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_awb_GetWpModeAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "getWBMode failed!"); if (attr.mode == RK_AIQ_WB_MODE_AUTO) { *mode = OP_AUTO; } else if (attr.mode == RK_AIQ_WB_MODE_MANUAL) { *mode = OP_MANUAL; } else { *mode = OP_INVAL; } IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: lock/unlock auto white balance * Argument: * * ***************************** */ XCamReturn rk_aiq_uapi2_lockAWB(const rk_aiq_sys_ctx_t* ctx) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_awb_Lock(ctx); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_unlockAWB(const rk_aiq_sys_ctx_t* ctx) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_awb_Unlock(ctx); IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set manual white balance scene mode * Argument: * ct_scene: * ***************************** */ XCamReturn rk_aiq_uapi2_setMWBScene(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_scene_t scene) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_wb_mwb_attrib_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setMWBScene failed!"); } if (scene < RK_AIQ_WBCT_INCANDESCENT || scene > RK_AIQ_WBCT_SHADE) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "invalid scene mode, setMWBScene failed!"); } rk_aiq_uapiV2_wb_opMode_t opMode; memset(&opMode, 0, sizeof(opMode)); opMode.mode = RK_AIQ_WB_MODE_MANUAL; ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, opMode); RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!"); attr.mode = RK_AIQ_MWB_MODE_SCENE; attr.para.scene = scene; ret = rk_aiq_user_api2_awb_SetMwbAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setMWBScene failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getMWBScene(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_scene_t *scene) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_wb_mwb_attrib_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if ((ctx == NULL) || (scene == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getMWBScene failed!"); } //attr.mode = RK_AIQ_WB_MODE_MANUAL; ret = rk_aiq_user_api2_awb_GetMwbAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "getMWBScene failed!"); if(attr.mode == RK_AIQ_MWB_MODE_SCENE) { *scene = attr.para.scene; } else { LOGE("get manual wb scene failed, since current manual mode is not RK_AIQ_MWB_MODE_SCENE "); } IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set manual white balance r/b gain * Argument: * ct_scene: * ***************************** */ XCamReturn rk_aiq_uapi2_setMWBGain(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_gain_t *gain) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_wb_mwb_attrib_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if ((ctx == NULL) || (gain == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setMWBGain failed!"); } rk_aiq_uapiV2_wb_opMode_t opMode; memset(&opMode, 0, sizeof(opMode)); opMode.mode = RK_AIQ_WB_MODE_MANUAL; ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, opMode); RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!"); attr.mode = RK_AIQ_MWB_MODE_WBGAIN; attr.para.gain = *gain; ret = rk_aiq_user_api2_awb_SetMwbAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setMWBGain failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getWBGain(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_gain_t *gain) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_wb_querry_info_t query_info; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (gain == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getMWBGain failed!"); } ret = rk_aiq_user_api2_awb_QueryWBInfo(ctx, &query_info); RKAIQ_IMGPROC_CHECK_RET(ret, "getMWBGain failed!"); *gain = query_info.gain; IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set manual white balance color temperature * Argument: * ct: color temperature value [2800, 7500]K * ***************************** */ XCamReturn rk_aiq_uapi2_setMWBCT(const rk_aiq_sys_ctx_t* ctx, unsigned int ct) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_wb_mwb_attrib_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setMWBCT failed!"); } rk_aiq_uapiV2_wb_opMode_t opMode; memset(&opMode, 0, sizeof(opMode)); opMode.mode = RK_AIQ_WB_MODE_MANUAL; ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, opMode); RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!"); attr.mode = RK_AIQ_MWB_MODE_CCT; attr.para.cct.CCT = (float)ct; attr.para.cct.CCRI = 0.0f; ret = rk_aiq_user_api2_awb_SetMwbAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setMWBCT failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getWBCT(const rk_aiq_sys_ctx_t* ctx, unsigned int *ct) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_wb_cct_t cct; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (ct == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getMWBCT failed!"); } ret = rk_aiq_user_api2_awb_GetCCT(ctx, &cct); *ct = (unsigned int)cct.CCT; IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setAwbGainOffsetAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wb_awb_wbGainOffset_t offset) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setWbGainOffsetAttrib failed!"); } rk_aiq_uapiV2_wb_opMode_t opMode; memset(&opMode, 0, sizeof(opMode)); opMode.mode = RK_AIQ_WB_MODE_AUTO; opMode.sync.sync_mode = offset.sync.sync_mode; ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, opMode); RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!"); ret = rk_aiq_user_api2_awb_SetWbGainOffsetAttrib(ctx, offset); RKAIQ_IMGPROC_CHECK_RET(ret, "setWbGainOffsetAttrib failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getAwbGainOffsetAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wb_awb_wbGainOffset_t *offset) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (offset == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getWbGainOffsetAttrib( failed!"); } ret = rk_aiq_user_api2_awb_GetWbGainOffsetAttrib(ctx, offset); RKAIQ_IMGPROC_CHECK_RET(ret, "getWbGainOffsetAttrib failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setAwbGainAdjustAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wb_awb_wbGainAdjust_t adjust) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setWbGainAdjustAttrib failed!"); } rk_aiq_uapiV2_wb_opMode_t opMode; memset(&opMode, 0, sizeof(opMode)); opMode.sync.sync_mode = adjust.sync.sync_mode; opMode.mode = RK_AIQ_WB_MODE_AUTO; ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, opMode); RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!"); ret = rk_aiq_user_api2_awb_SetWbGainAdjustAttrib(ctx, adjust); RKAIQ_IMGPROC_CHECK_RET(ret, "setWbGainAdjustAttrib failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getAwbGainAdjustAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wb_awb_wbGainAdjust_t *adjust) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (adjust == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getWbGainAdjustAttrib failed!"); } ret = rk_aiq_user_api2_awb_GetWbGainAdjustAttrib(ctx, adjust); RKAIQ_IMGPROC_CHECK_RET(ret, "getWbGainAdjustAttrib failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setAwbMultiWindowAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wb_awb_mulWindow_t multiwindow) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setAwbMultiWindowAttrib failed!"); } rk_aiq_uapiV2_wb_opMode_t opMode; memset(&opMode, 0, sizeof(opMode)); opMode.mode = RK_AIQ_WB_MODE_AUTO; opMode.sync.sync_mode = multiwindow.sync.sync_mode; ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, opMode); RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!"); ret = rk_aiq_user_api2_awb_SetMultiWindowAttrib(ctx, multiwindow); RKAIQ_IMGPROC_CHECK_RET(ret, "setAwbMultiWindowAttrib failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getAwbMultiWindowAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wb_awb_mulWindow_t *multiwindow) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (multiwindow == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getAwbMultiWindowAttrib failed!"); } ret = rk_aiq_user_api2_awb_GetMultiWindowAttrib(ctx, multiwindow); RKAIQ_IMGPROC_CHECK_RET(ret, "getAwbMultiWindowAttrib failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setAwbV30AllAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wbV30_attrib_t attr) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setAwbV30AllAttrib failed!"); } ret = rk_aiq_user_api2_awbV30_SetAllAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setAwbV30AllAttrib failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getAwbV30AllAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wbV30_attrib_t *attr) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (attr == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getAwbV30AllAttrib failed!"); } ret = rk_aiq_user_api2_awbV30_GetAllAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "getAwbV30AllAttrib failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setAwbV21AllAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wbV21_attrib_t attr) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setAwbV21AllAttrib failed!"); } ret = rk_aiq_user_api2_awbV21_SetAllAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setAwbV21AllAttrib failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getAwbV21AllAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wbV21_attrib_t *attr) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (attr == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getAwbV21AllAttrib failed!"); } ret = rk_aiq_user_api2_awbV21_GetAllAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "getAwbV21AllAttrib failed!"); IMGPROC_FUNC_EXIT return ret; } /* ********************************************************** * Focus & Zoom ********************************************************** */ XCamReturn rk_aiq_uapi2_setFocusMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_af_attrib_t attr; ret = rk_aiq_user_api2_af_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusMode failed!"); if (mode == OP_AUTO) { attr.AfMode = RKAIQ_AF_MODE_CONTINUOUS_PICTURE; } else if (mode == OP_MANUAL) { attr.AfMode = RKAIQ_AF_MODE_FIXED; } else if (mode == OP_SEMI_AUTO) { attr.AfMode = RKAIQ_AF_MODE_ONESHOT_AFTER_ZOOM; } else { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!"); } attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; ret = rk_aiq_user_api2_af_SetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusMode failed!"); return ret; } XCamReturn rk_aiq_uapi2_getFocusMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_af_attrib_t attr; ret = rk_aiq_user_api2_af_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "getFocusMode failed!"); if (attr.AfMode == RKAIQ_AF_MODE_FIXED) { *mode = OP_MANUAL; } else if (attr.AfMode == RKAIQ_AF_MODE_NOT_SET) { *mode = OP_INVAL; } else if (attr.AfMode == RKAIQ_AF_MODE_ONESHOT_AFTER_ZOOM) { *mode = OP_SEMI_AUTO; } else { *mode = OP_AUTO; } return ret; } XCamReturn rk_aiq_uapi2_setFocusPosition(const rk_aiq_sys_ctx_t* ctx, short code) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_af_attrib_t attr; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setFixedModeCode failed!"); attr.fixedModeDefCode = code; attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; ret = rk_aiq_user_api2_af_SetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setFixedModeCode failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getFocusPosition(const rk_aiq_sys_ctx_t* ctx, short * code) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_af_attrib_t attr; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "getFixedModeCode failed!"); *code = attr.fixedModeDefCode; IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setFocusWin(const rk_aiq_sys_ctx_t* ctx, paRect_t *rect) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_af_attrib_t attr; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api_af_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusWin failed!"); attr.h_offs = rect->x; attr.v_offs = rect->y; attr.h_size = rect->w; attr.v_size = rect->h; attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC; ret = rk_aiq_user_api2_af_SetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusWin failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getFocusWin(const rk_aiq_sys_ctx_t* ctx, paRect_t *rect) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_af_attrib_t attr; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "getFocusWin failed!"); rect->x = attr.h_offs; rect->y = attr.v_offs; rect->w = attr.h_size; rect->h = attr.v_size; IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_lockFocus(const rk_aiq_sys_ctx_t* ctx) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_Lock(ctx); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_unlockFocus(const rk_aiq_sys_ctx_t* ctx) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_Unlock(ctx); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_oneshotFocus(const rk_aiq_sys_ctx_t* ctx) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_Oneshot(ctx); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_manualTrigerFocus(const rk_aiq_sys_ctx_t* ctx) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_ManualTriger(ctx); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_trackingFocus(const rk_aiq_sys_ctx_t* ctx) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_Tracking(ctx); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getSearchPath(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_sec_path_t* path) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_GetSearchPath(ctx, path); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getSearchResult(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_result_t* result) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_GetSearchResult(ctx, result); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setOpZoomPosition(const rk_aiq_sys_ctx_t* ctx, int pos) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_SetZoomIndex(ctx, pos); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getOpZoomPosition(const rk_aiq_sys_ctx_t* ctx, int *pos) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_GetZoomIndex(ctx, pos); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_endOpZoomChange(const rk_aiq_sys_ctx_t* ctx) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_EndZoomChg(ctx); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getZoomRange(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_zoomrange * range) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_GetZoomRange(ctx, range); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getFocusRange(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_focusrange* range) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_GetFocusRange(ctx, range); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_startZoomCalib(const rk_aiq_sys_ctx_t* ctx) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_StartZoomCalib(ctx); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_resetZoom(const rk_aiq_sys_ctx_t* ctx) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_resetZoom(ctx); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setAngleZ(const rk_aiq_sys_ctx_t* ctx, float angleZ) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_setAngleZ(ctx, angleZ); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getCustomAfRes(const rk_aiq_sys_ctx_t* ctx, rk_tool_customAf_res_t *attr) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_getCustomAfRes(ctx, attr); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setCustomAfRes(const rk_aiq_sys_ctx_t* ctx, rk_tool_customAf_res_t *attr) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_af_setCustomAfRes(ctx, attr); IMGPROC_FUNC_EXIT return ret; } /* ********************************************************** * Color Correction ********************************************************** */ /* ***************************** * * Desc: set/get color correction mode * Argument: * mode: * auto: auto color correction * manual: manual color correction * ***************************** */ XCamReturn rk_aiq_uapi2_setCCMMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_ccm_attrib_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if (mode >= OP_INVAL || mode < OP_AUTO) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "mode is invalid!"); } ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setCCMMode failed in getting accm attrib!"); attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT; if (mode == OP_AUTO) { attr.mode = RK_AIQ_CCM_MODE_AUTO; } else if (mode == OP_MANUAL) { attr.mode = RK_AIQ_CCM_MODE_MANUAL; } else { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!"); } ret = rk_aiq_user_api2_accm_SetAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "setCCMMode failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getCCMMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_ccm_attrib_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "getCCMMode failed!"); if (attr.mode == RK_AIQ_CCM_MODE_AUTO) { *mode = OP_AUTO; } else if (attr.mode == RK_AIQ_CCM_MODE_MANUAL) { *mode = OP_MANUAL; } else { *mode = OP_INVAL; } IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set manual color correction matrix * this function is active for color correction is manual mode get color correction matrix * Argument: * mccm: * 3x3 matrix * 1x3 offset * ***************************** */ XCamReturn rk_aiq_uapi2_setMCcCoef(const rk_aiq_sys_ctx_t* ctx, rk_aiq_ccm_matrix_t * mccm) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_ccm_attrib_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if ((ctx == NULL) || (mccm == NULL) ) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, set CCM Manual Matrix failed!"); } ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "Set CCM Manual Matrix failed in getting accm attrib!!"); attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT; attr.mode = RK_AIQ_CCM_MODE_MANUAL; memcpy(attr.stManual.ccMatrix, mccm->ccMatrix, sizeof(float) * 9); memcpy(attr.stManual.ccOffsets, mccm->ccOffsets, sizeof(float) * 3); ret = rk_aiq_user_api2_accm_SetAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "set CCM Manual Matrix failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getMCcCoef(const rk_aiq_sys_ctx_t* ctx, rk_aiq_ccm_matrix_t * mccm) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_ccm_querry_info_t ccm_querry_info; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (mccm == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get CCM Matrix failed!"); } ret = rk_aiq_user_api2_accm_QueryCcmInfo(ctx, &ccm_querry_info); RKAIQ_IMGPROC_CHECK_RET(ret, "get CCM Matrix failed!"); for (int i = 0; i < 9; i++) mccm->ccMatrix[i] = ccm_querry_info.ccMatrix[i]; for (int i = 0; i < 3; i++) mccm->ccOffsets[i] = ccm_querry_info.ccOffsets[i]; IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: get auto color correction saturation * this function is active for color correction is auto mode * Argument: * finalsat : range in [0, 100] * ***************************** */ XCamReturn rk_aiq_uapi2_getACcmSat(const rk_aiq_sys_ctx_t* ctx, float *finalsat) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_ccm_querry_info_t ccm_querry_info; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (finalsat == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get Auto CCM Saturation failed!"); } ret = rk_aiq_user_api2_accm_QueryCcmInfo(ctx, &ccm_querry_info); RKAIQ_IMGPROC_CHECK_RET(ret, "get CCM Auto CCM Saturation failed!"); *finalsat = ccm_querry_info.finalSat; IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: get auto color correction used ccm name * this function is active for color correction is auto mode * Argument: * ccm_name[2] * ***************************** */ XCamReturn rk_aiq_uapi2_getACcmMatrixName(const rk_aiq_sys_ctx_t* ctx, char **ccm_name) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_ccm_querry_info_t ccm_querry_info; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (ccm_name == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get Auto CCM Name failed!"); } ret = rk_aiq_user_api2_accm_QueryCcmInfo(ctx, &ccm_querry_info); RKAIQ_IMGPROC_CHECK_RET(ret, "get CCM Auto CCM Name failed!"); strcpy(ccm_name[0], ccm_querry_info.ccmname1); strcpy(ccm_name[1], ccm_querry_info.ccmname2); IMGPROC_FUNC_EXIT return ret; } /* ********************************************************** * 3-Dimensional Look Up Table ********************************************************** */ /* ***************************** * * Desc: set/get 3dlut mode * Argument: * mode: * auto: auto 3dlut * manual: manual 3dlut * ***************************** */ XCamReturn rk_aiq_uapi2_setLut3dMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_lut3d_attrib_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if (mode >= OP_INVAL || mode < OP_AUTO) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "mode is invalid!"); } ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "set 3DLUT Mode failed in getting 3dlut attrib!"); attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT; if (mode == OP_AUTO) { attr.mode = RK_AIQ_LUT3D_MODE_AUTO; } else if (mode == OP_MANUAL) { attr.mode = RK_AIQ_LUT3D_MODE_MANUAL; } else { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!"); } ret = rk_aiq_user_api2_a3dlut_SetAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "set 3DLUT Mode failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getLut3dMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_lut3d_attrib_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "get 3DLUT Mode failed!"); if (attr.mode == RK_AIQ_LUT3D_MODE_AUTO) { *mode = OP_AUTO; } else if (attr.mode == RK_AIQ_LUT3D_MODE_MANUAL) { *mode = OP_MANUAL; } else { *mode = OP_INVAL; } IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: set manual 3d Look-up-table * this function is active for 3dlut is manual mode get 3d Look-up-table * Argument: * mlut: * lut_r[729] * lut_g[729] * lut_b[729] * ***************************** */ XCamReturn rk_aiq_uapi2_setM3dLut(const rk_aiq_sys_ctx_t* ctx, rk_aiq_lut3d_table_t *mlut) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_lut3d_attrib_t attr; memset(&attr, 0, sizeof(attr)); IMGPROC_FUNC_ENTER if ((ctx == NULL) || (mlut == NULL) ) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, set manual 3d Look-up-table failed!"); } ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr); RKAIQ_IMGPROC_CHECK_RET(ret, "set manual 3d Look-up-table in getting 3dlut attrib!"); attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT; attr.mode = RK_AIQ_LUT3D_MODE_MANUAL; memcpy(attr.stManual.look_up_table_r, mlut->look_up_table_r, sizeof(unsigned short) * 729); memcpy(attr.stManual.look_up_table_g, mlut->look_up_table_g, sizeof(unsigned short) * 729); memcpy(attr.stManual.look_up_table_b, mlut->look_up_table_b, sizeof(unsigned short) * 729); ret = rk_aiq_user_api2_a3dlut_SetAttrib(ctx, attr); RKAIQ_IMGPROC_CHECK_RET(ret, "set manual 3d Look-up-table failed!"); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_getM3dLut(const rk_aiq_sys_ctx_t* ctx, rk_aiq_lut3d_table_t *mlut) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_lut3d_querry_info_t lut3d_querry_info; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (mlut == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get 3d Look-up-table failed!"); } ret = rk_aiq_user_api2_a3dlut_Query3dlutInfo(ctx, &lut3d_querry_info); RKAIQ_IMGPROC_CHECK_RET(ret, "get 3d Look-up-table failed!"); memcpy(mlut->look_up_table_r, lut3d_querry_info.look_up_table_r, sizeof(unsigned short) * 729); memcpy(mlut->look_up_table_g, lut3d_querry_info.look_up_table_g, sizeof(unsigned short) * 729); memcpy(mlut->look_up_table_b, lut3d_querry_info.look_up_table_b, sizeof(unsigned short) * 729); IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: get auto 3d Look-up-table strength * this function is active for 3d Look-up-table is auto mode * Argument: * alpha : range in [0, 1] * ***************************** */ XCamReturn rk_aiq_uapi2_getA3dLutStrth(const rk_aiq_sys_ctx_t* ctx, float *alpha) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_lut3d_querry_info_t lut3d_querry_info; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (alpha == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getAuto3DLUT 3d Look-up-table Strength failed!"); } ret = rk_aiq_user_api2_a3dlut_Query3dlutInfo(ctx, &lut3d_querry_info); RKAIQ_IMGPROC_CHECK_RET(ret, "getAuto3DLUT 3d Look-up-table Strength failed!"); *alpha = lut3d_querry_info.alpha; IMGPROC_FUNC_EXIT return ret; } /* ***************************** * * Desc: get auto 3d Look-up-table used lut name * this function is active for 3d Look-up-table is auto mode * Argument: * name * ***************************** */ XCamReturn rk_aiq_uapi2_getA3dLutName(const rk_aiq_sys_ctx_t* ctx, char *name) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_lut3d_querry_info_t lut3d_querry_info; IMGPROC_FUNC_ENTER if ((ctx == NULL) || (name == NULL)) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getAuto3DLUT 3d Look-up-table Name failed!"); } ret = rk_aiq_user_api2_a3dlut_Query3dlutInfo(ctx, &lut3d_querry_info); RKAIQ_IMGPROC_CHECK_RET(ret, "getAuto3DLUT 3d Look-up-table Name failed!"); strcpy(name, lut3d_querry_info.name); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setLdchEn(const rk_aiq_sys_ctx_t* ctx, bool en) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } rk_aiq_ldch_attrib_t ldchAttr; ret = rk_aiq_user_api2_aldch_GetAttrib(ctx, &ldchAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get ldch attrib failed!"); ldchAttr.en = en; ret = rk_aiq_user_api2_aldch_SetAttrib(ctx, ldchAttr); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setLdchCorrectLevel(const rk_aiq_sys_ctx_t* ctx, int correctLevel) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } rk_aiq_ldch_attrib_t ldchAttr; ret = rk_aiq_user_api2_aldch_GetAttrib(ctx, &ldchAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get ldch attrib failed!"); ldchAttr.correct_level = correctLevel; ret = rk_aiq_user_api2_aldch_SetAttrib(ctx, ldchAttr); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setFecEn(const rk_aiq_sys_ctx_t* ctx, bool en) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } rk_aiq_fec_attrib_t fecAttr; ret = rk_aiq_user_api2_afec_GetAttrib(ctx, &fecAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!"); fecAttr.en = en; ret = rk_aiq_user_api2_afec_SetAttrib(ctx, fecAttr); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setFecBypass(const rk_aiq_sys_ctx_t* ctx, bool bypass) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } rk_aiq_fec_attrib_t fecAttr; ret = rk_aiq_user_api2_afec_GetAttrib(ctx, &fecAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!"); fecAttr.bypass = bypass; ret = rk_aiq_user_api2_afec_SetAttrib(ctx, fecAttr); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setFecCorrectLevel(const rk_aiq_sys_ctx_t* ctx, int correctLevel) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } rk_aiq_fec_attrib_t fecAttr; ret = rk_aiq_user_api2_afec_GetAttrib(ctx, &fecAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!"); fecAttr.correct_level = correctLevel; ret = rk_aiq_user_api2_afec_SetAttrib(ctx, fecAttr); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setFecCorrectDirection(const rk_aiq_sys_ctx_t* ctx, const fec_correct_direction_t direction) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } rk_aiq_fec_attrib_t fecAttr; ret = rk_aiq_user_api2_afec_GetAttrib(ctx, &fecAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!"); fecAttr.direction = direction; ret = rk_aiq_user_api2_afec_SetAttrib(ctx, fecAttr); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setFecCorrectMode(const rk_aiq_sys_ctx_t* ctx, const fec_correct_mode_t mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; IMGPROC_FUNC_ENTER if (ctx == NULL) { ret = XCAM_RETURN_ERROR_PARAM; RKAIQ_IMGPROC_CHECK_RET(ret, "param error!"); } rk_aiq_fec_attrib_t fecAttr; ret = rk_aiq_user_api2_afec_GetAttrib(ctx, &fecAttr); RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!"); fecAttr.mode = mode; ret = rk_aiq_user_api2_afec_SetAttrib(ctx, fecAttr); IMGPROC_FUNC_EXIT return ret; } XCamReturn rk_aiq_uapi2_setGrayMode(const rk_aiq_sys_ctx_t* ctx, rk_aiq_gray_mode_t mode) { XCamReturn ret = XCAM_RETURN_NO_ERROR; if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) { #ifdef RKAIQ_ENABLE_CAMGROUP const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx; for (auto camCtx : camgroup_ctx->cam_ctxs_array) { if (!camCtx) continue; ret = camCtx->_analyzer->setGrayMode(mode); } #else return XCAM_RETURN_ERROR_FAILED; #endif } else { ret = ctx->_analyzer->setGrayMode(mode); } return ret; } rk_aiq_gray_mode_t rk_aiq_uapi2_getGrayMode(const rk_aiq_sys_ctx_t* ctx) { if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) { #ifdef RKAIQ_ENABLE_CAMGROUP const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx; for (auto camCtx : camgroup_ctx->cam_ctxs_array) { if (!camCtx) continue; return camCtx->_analyzer->getGrayMode(); } #else return RK_AIQ_GRAY_MODE_OFF; #endif } else { return ctx->_analyzer->getGrayMode(); } return RK_AIQ_GRAY_MODE_OFF; } RKAIQ_END_DECLARE