// Copyright 2020 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. // #ifdef RKAIQ #include #include #include #include #include #include #include #include #include #include "rk_aiq_mems_sensor.h" #include "sample_comm.h" #define MAX_AIQ_CTX 4 static rk_aiq_sys_ctx_t *g_aiq_ctx[MAX_AIQ_CTX]; #ifdef RKAIQ_GRP static rk_aiq_camgroup_ctx_t *g_aiq_camgroup_ctx[MAX_AIQ_CTX]; #endif static pthread_mutex_t aiq_ctx_mutex[MAX_AIQ_CTX] = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER}; pthread_mutex_t lock[MAX_AIQ_CTX] = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER}; static unsigned char gs_LDC_mode[MAX_AIQ_CTX] = {-1, -1, -1, -1}; rk_aiq_cpsl_cfg_t g_cpsl_cfg[MAX_AIQ_CTX]; rk_aiq_wb_gain_t gs_wb_auto_gain = {2.083900, 1.000000, 1.000000, 2.018500}; RK_U32 g_2dnr_default_level = 50; RK_U32 g_3dnr_default_level = 50; RK_S32 g_devBufCnt[MAX_AIQ_CTX] = {2, 2, 2, 2, 2, 2, 2, 2}; rk_aiq_working_mode_t g_WDRMode[MAX_AIQ_CTX]; typedef enum _SHUTTERSPEED_TYPE_E { SHUTTERSPEED_1_25 = 0, SHUTTERSPEED_1_30, SHUTTERSPEED_1_75, SHUTTERSPEED_1_100, SHUTTERSPEED_1_120, SHUTTERSPEED_1_150, SHUTTERSPEED_1_250, SHUTTERSPEED_1_300, SHUTTERSPEED_1_425, SHUTTERSPEED_1_600, SHUTTERSPEED_1_1000, SHUTTERSPEED_1_1250, SHUTTERSPEED_1_1750, SHUTTERSPEED_1_2500, SHUTTERSPEED_1_3000, SHUTTERSPEED_1_6000, SHUTTERSPEED_1_10000, SHUTTERSPEED_BUTT } SHUTTERSPEED_TYPE_E; typedef struct rk_SHUTTER_ATTR_S { SHUTTERSPEED_TYPE_E enShutterSpeed; float fExposureTime; } SHUTTER_ATTR_S; static SHUTTER_ATTR_S g_stShutterAttr[SHUTTERSPEED_BUTT] = { {SHUTTERSPEED_1_25, 1.0 / 25.0}, {SHUTTERSPEED_1_30, 1.0 / 30.0}, {SHUTTERSPEED_1_75, 1.0 / 75.0}, {SHUTTERSPEED_1_100, 1.0 / 100.0}, {SHUTTERSPEED_1_120, 1.0 / 120.0}, {SHUTTERSPEED_1_150, 1.0 / 150.0}, {SHUTTERSPEED_1_250, 1.0 / 250.0}, {SHUTTERSPEED_1_300, 1.0 / 300.0}, {SHUTTERSPEED_1_425, 1.0 / 425.0}, {SHUTTERSPEED_1_600, 1.0 / 600.0}, {SHUTTERSPEED_1_1000, 1.0 / 1000.0}, {SHUTTERSPEED_1_1250, 1.0 / 1250.0}, {SHUTTERSPEED_1_1750, 1.0 / 1750.0}, {SHUTTERSPEED_1_2500, 1.0 / 2500.0}, {SHUTTERSPEED_1_3000, 1.0 / 3000.0}, {SHUTTERSPEED_1_6000, 1.0 / 6000.0}, {SHUTTERSPEED_1_10000, 1.0 / 10000.0}}; typedef enum rk_HDR_MODE_E { HDR_MODE_OFF, HDR_MODE_HDR2, HDR_MODE_HDR3, } HDR_MODE_E; RK_S32 SAMPLE_COMM_PreInit_devBufCnt(RK_S32 CamId, RK_S32 Bufcnt) { if (Bufcnt < 0) { printf("Invlaid ISP read Buffer, please check!\n"); return RK_FAILURE; } g_devBufCnt[CamId] = Bufcnt; return 0; } RK_S32 SAMPLE_COMM_ISP_Init(RK_S32 CamId, rk_aiq_working_mode_t WDRMode, RK_BOOL MultiCam, const char *iq_file_dir) { if (CamId >= MAX_AIQ_CTX) { printf("%s : CamId is over 3\n", __FUNCTION__); return -1; } // char *iq_file_dir = "iqfiles/"; setlinebuf(stdout); if (iq_file_dir == NULL) { printf("SAMPLE_COMM_ISP_Init : not start.\n"); g_aiq_ctx[CamId] = NULL; return 0; } // must set HDR_MODE, before init g_WDRMode[CamId] = WDRMode; char hdr_str[16]; snprintf(hdr_str, sizeof(hdr_str), "%d", (int)WDRMode); setenv("HDR_MODE", hdr_str, 1); rk_aiq_sys_ctx_t *aiq_ctx; rk_aiq_static_info_t aiq_static_info; // rk_aiq_uapi_sysctl_enumStaticMetas(CamId, &aiq_static_info); rk_aiq_uapi_sysctl_enumStaticMetasByPhyId(CamId, &aiq_static_info); printf("ID: %d, sensor_name is %s, iqfiles is %s\n", CamId, aiq_static_info.sensor_info.sensor_name, iq_file_dir); aiq_ctx = rk_aiq_uapi_sysctl_init(aiq_static_info.sensor_info.sensor_name, iq_file_dir, NULL, NULL); if (MultiCam) rk_aiq_uapi_sysctl_setMulCamConc(aiq_ctx, true); g_aiq_ctx[CamId] = aiq_ctx; return 0; } // register mems_sensor_intf api to aiq_ctx when EIS on RK_S32 SAMPLE_COMM_ISP_RegMemsSensorIntf(RK_S32 CamId, rk_aiq_mems_sensor_intf_t *api) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } if (rk_aiq_uapi_sysctl_regMemsSensorIntf(g_aiq_ctx[CamId], api)) { printf("rk_aiq_uapi_sysctl_regMemsSensorIntf failed !\n"); g_aiq_ctx[CamId] = NULL; return -1; } printf("rk_aiq_uapi_sysctl_regMemsSensorIntf succeed\n"); return 0; } RK_S32 SAMPLE_COMM_ISP_UpdateIq(RK_S32 CamId, char *iqfile) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; printf(" rk_aiq_uapi_sysctl_updateIq %s\n", iqfile); ret = rk_aiq_uapi_sysctl_updateIq(g_aiq_ctx[CamId], iqfile); return ret; } /* set after SAMPLE_COMM_ISP_Init and before SAMPLE_COMM_ISP_Run */ RK_S32 SAMPLE_COMM_ISP_SetFecEn(RK_S32 CamId, RK_BOOL bFECEnable) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; printf("rk_aiq_uapi_sysctl_init bFECEnable %d\n", bFECEnable); ret = rk_aiq_uapi_setFecEn(g_aiq_ctx[CamId], bFECEnable); return ret; } RK_S32 SAMPLE_COMM_ISP_Stop(RK_S32 CamId) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } printf("rk_aiq_uapi_sysctl_stop enter\n"); rk_aiq_uapi_sysctl_stop(g_aiq_ctx[CamId], false); printf("rk_aiq_uapi_sysctl_deinit enter\n"); rk_aiq_uapi_sysctl_deinit(g_aiq_ctx[CamId]); printf("rk_aiq_uapi_sysctl_deinit exit\n"); g_aiq_ctx[CamId] = NULL; return 0; } RK_S32 SAMPLE_COMM_ISP_Run(RK_S32 CamId) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } if (rk_aiq_uapi_sysctl_prepare(g_aiq_ctx[CamId], 0, 0, g_WDRMode[CamId])) { printf("rkaiq engine prepare failed !\n"); g_aiq_ctx[CamId] = NULL; return -1; } printf("rk_aiq_uapi_sysctl_init/prepare succeed\n"); if (rk_aiq_uapi_sysctl_start(g_aiq_ctx[CamId])) { printf("rk_aiq_uapi_sysctl_start failed\n"); return -1; } printf("rk_aiq_uapi_sysctl_start succeed\n"); return 0; } RK_S32 SAMPLE_COMM_ISP_DumpExpInfo(RK_S32 CamId, rk_aiq_working_mode_t WDRMode) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } char aStr[128] = {'\0'}; Uapi_ExpQueryInfo_t stExpInfo; rk_aiq_wb_cct_t stCCT; RK_S32 ret = 0; ret = rk_aiq_user_api_ae_queryExpResInfo(g_aiq_ctx[CamId], &stExpInfo); ret |= rk_aiq_user_api_awb_GetCCT(g_aiq_ctx[CamId], &stCCT); if (WDRMode == RK_AIQ_WORKING_MODE_NORMAL) { sprintf(aStr, "M:%.0f-%.1f LM:%.1f CT:%.1f", stExpInfo.CurExpInfo.LinearExp.exp_real_params.integration_time * 1000 * 1000, stExpInfo.CurExpInfo.LinearExp.exp_real_params.analog_gain, stExpInfo.MeanLuma, stCCT.CCT); } else { sprintf( aStr, "S:%.0f-%.1f M:%.0f-%.1f L:%.0f-%.1f SLM:%.1f MLM:%.1f " "LLM:%.1f CT:%.1f", stExpInfo.CurExpInfo.HdrExp[0].exp_real_params.integration_time * 1000 * 1000, stExpInfo.CurExpInfo.HdrExp[0].exp_real_params.analog_gain, stExpInfo.CurExpInfo.HdrExp[1].exp_real_params.integration_time * 1000 * 1000, stExpInfo.CurExpInfo.HdrExp[1].exp_real_params.analog_gain, stExpInfo.CurExpInfo.HdrExp[2].exp_real_params.integration_time * 1000 * 1000, stExpInfo.CurExpInfo.HdrExp[2].exp_real_params.analog_gain, stExpInfo.HdrMeanLuma[0], stExpInfo.HdrMeanLuma[1], stExpInfo.HdrMeanLuma[2], stCCT.CCT); } printf("isp exp dump: %s\n", aStr); return ret; } RK_S32 SAMPLE_COMM_ISP_SetFrameRate(RK_S32 CamId, RK_U32 uFps) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; printf("SAMPLE_COMM_ISP_SetFrameRate start %d\n", uFps); frameRateInfo_t info; info.mode = OP_MANUAL; info.fps = uFps; ret = rk_aiq_uapi_setFrameRate(g_aiq_ctx[CamId], info); printf("SAMPLE_COMM_ISP_SetFrameRate %d\n", uFps); return ret; } RK_S32 SAMPLE_COMM_ISP_SetLDCH(RK_S32 CamId, RK_U32 level, RK_BOOL bIfEnable) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; ret = rk_aiq_uapi_setLdchEn(g_aiq_ctx[CamId], level > 0); if (level > 0 && level <= 255) ret |= rk_aiq_uapi_setLdchCorrectLevel(g_aiq_ctx[CamId], level); return ret; } /*only support switch between HDR and normal*/ RK_S32 SAMPLE_COMM_ISP_SetWDRModeDyn(RK_S32 CamId, rk_aiq_working_mode_t WDRMode) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; ret = rk_aiq_uapi_sysctl_swWorkingModeDyn(g_aiq_ctx[CamId], WDRMode); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_Brightness(RK_S32 CamId, RK_U32 value) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_uapi_setBrightness(g_aiq_ctx[CamId], value); // value[0,255] } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_Contrast(RK_S32 CamId, RK_U32 value) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_uapi_setContrast(g_aiq_ctx[CamId], value); // value[0,255] } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_Saturation(RK_S32 CamId, RK_U32 value) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_uapi_setSaturation(g_aiq_ctx[CamId], value); // value[0,255] } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_Sharpness(RK_S32 CamId, RK_U32 value) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; RK_U32 level = value / 2.55; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_uapi_setSharpness(g_aiq_ctx[CamId], level); // value[0,255]->level[0,100] } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_ManualExposureAutoGain(RK_S32 CamId, RK_U32 u32Shutter) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; Uapi_ExpSwAttr_t stExpSwAttr; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_user_api_ae_getExpSwAttr(g_aiq_ctx[CamId], &stExpSwAttr); stExpSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL; stExpSwAttr.stManual.stLinMe.ManualGainEn = RK_FALSE; stExpSwAttr.stManual.stLinMe.ManualTimeEn = RK_TRUE; stExpSwAttr.stManual.stLinMe.TimeValue = g_stShutterAttr[u32Shutter % SHUTTERSPEED_BUTT].fExposureTime; stExpSwAttr.stManual.stHdrMe.ManualGainEn = RK_FALSE; stExpSwAttr.stManual.stHdrMe.ManualTimeEn = RK_TRUE; stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[0] = g_stShutterAttr[u32Shutter % SHUTTERSPEED_BUTT].fExposureTime; stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[1] = g_stShutterAttr[u32Shutter % SHUTTERSPEED_BUTT].fExposureTime; stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[2] = g_stShutterAttr[u32Shutter % SHUTTERSPEED_BUTT].fExposureTime; ret |= rk_aiq_user_api_ae_setExpSwAttr(g_aiq_ctx[CamId], stExpSwAttr); } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_ManualExposureManualGain(RK_S32 CamId, RK_U32 u32Shutter, RK_U32 u32Gain) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; Uapi_ExpSwAttr_t stExpSwAttr; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_user_api_ae_getExpSwAttr(g_aiq_ctx[CamId], &stExpSwAttr); stExpSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL; stExpSwAttr.stManual.stLinMe.ManualGainEn = RK_TRUE; stExpSwAttr.stManual.stLinMe.ManualTimeEn = RK_TRUE; stExpSwAttr.stManual.stLinMe.TimeValue = g_stShutterAttr[u32Shutter % SHUTTERSPEED_BUTT].fExposureTime; //(1+gain)*4;//gain[0~255] -> GainValue[1~1024] stExpSwAttr.stManual.stLinMe.GainValue = (1.0 + u32Gain); stExpSwAttr.stManual.stHdrMe.ManualGainEn = RK_TRUE; stExpSwAttr.stManual.stHdrMe.ManualTimeEn = RK_TRUE; stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[0] = g_stShutterAttr[u32Shutter % SHUTTERSPEED_BUTT].fExposureTime; stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[1] = g_stShutterAttr[u32Shutter % SHUTTERSPEED_BUTT].fExposureTime; stExpSwAttr.stManual.stHdrMe.TimeValue.fCoeff[2] = g_stShutterAttr[u32Shutter % SHUTTERSPEED_BUTT].fExposureTime; //(1+gain)*4;//gain[0~255] -> GainValue[1~1024] stExpSwAttr.stManual.stHdrMe.GainValue.fCoeff[0] = (1.0 + u32Gain); //(1+gain)*4;//gain[0~255] -> GainValue[1~1024] stExpSwAttr.stManual.stHdrMe.GainValue.fCoeff[1] = (1.0 + u32Gain); //(1+gain)*4;//gain[0~255] -> GainValue[1~1024] stExpSwAttr.stManual.stHdrMe.GainValue.fCoeff[2] = (1.0 + u32Gain); ret |= rk_aiq_user_api_ae_setExpSwAttr(g_aiq_ctx[CamId], stExpSwAttr); } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_AutoExposure(RK_S32 CamId) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; Uapi_ExpSwAttr_t stExpSwAttr; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_user_api_ae_getExpSwAttr(g_aiq_ctx[CamId], &stExpSwAttr); stExpSwAttr.AecOpType = RK_AIQ_OP_MODE_AUTO; ret |= rk_aiq_user_api_ae_setExpSwAttr(g_aiq_ctx[CamId], stExpSwAttr); } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_Exposure(RK_S32 CamId, RK_BOOL bIsAutoExposure, RK_U32 bIsAGC, RK_U32 u32ElectronicShutter, RK_U32 u32Agc) { RK_S32 ret = 0; if (!bIsAutoExposure) { if (bIsAGC) { ret = SAMPLE_COMM_ISP_SET_ManualExposureAutoGain(CamId, u32ElectronicShutter); } else { ret = SAMPLE_COMM_ISP_SET_ManualExposureManualGain( CamId, u32ElectronicShutter, u32Agc); } } else { ret = SAMPLE_COMM_ISP_SET_AutoExposure(CamId); } return ret; } RK_S32 SAMPLE_COMM_ISP_SET_BackLight(RK_S32 CamId, RK_BOOL bEnable, RK_U32 u32Strength) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { if (bEnable) { ret = rk_aiq_uapi_setBLCMode(g_aiq_ctx[CamId], RK_TRUE, AE_MEAS_AREA_AUTO); usleep(30000); //[0~2]->[1~100] ret |= rk_aiq_uapi_setBLCStrength(g_aiq_ctx[CamId], 33 * (u32Strength + 1)); } else { ret = rk_aiq_uapi_setBLCMode(g_aiq_ctx[CamId], RK_FALSE, AE_MEAS_AREA_AUTO); } } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_LightInhibition(RK_S32 CamId, RK_BOOL bEnable, RK_U8 u8Strength, RK_U8 u8Level) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { if (bEnable) { ret = rk_aiq_uapi_setHLCMode(g_aiq_ctx[CamId], RK_TRUE); if (ret == 0) { //[0~255] -> level[0~100] ret = rk_aiq_uapi_setHLCStrength(g_aiq_ctx[CamId], u8Strength / 2.55); //[0~255] -> level[0~10] ret = rk_aiq_uapi_setDarkAreaBoostStrth(g_aiq_ctx[CamId], u8Level / 25); } } else { ret = rk_aiq_uapi_setHLCMode(g_aiq_ctx[CamId], RK_FALSE); } } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_CPSL_CFG(RK_S32 CamId, rk_aiq_cpsl_cfg_t *cpsl) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_uapi_sysctl_setCpsLtCfg(g_aiq_ctx[CamId], cpsl); } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_OpenColorCloseLed(RK_S32 CamId) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&lock[CamId]); g_cpsl_cfg[CamId].lght_src = RK_AIQ_CPSLS_IR; g_cpsl_cfg[CamId].mode = RK_AIQ_OP_MODE_MANUAL; g_cpsl_cfg[CamId].gray_on = RK_FALSE; g_cpsl_cfg[CamId].u.m.on = 0; g_cpsl_cfg[CamId].u.m.strength_led = 0; g_cpsl_cfg[CamId].u.m.strength_ir = 0; ret = SAMPLE_COMM_ISP_SET_CPSL_CFG(CamId, &g_cpsl_cfg[CamId]); pthread_mutex_unlock(&lock[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_GrayOpenLed(RK_S32 CamId, RK_U8 u8Strength) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&lock[CamId]); g_cpsl_cfg[CamId].mode = RK_AIQ_OP_MODE_MANUAL; g_cpsl_cfg[CamId].lght_src = RK_AIQ_CPSLS_IR; g_cpsl_cfg[CamId].gray_on = RK_TRUE; g_cpsl_cfg[CamId].u.m.on = 1; g_cpsl_cfg[CamId].u.m.strength_led = u8Strength / 5 + 3; g_cpsl_cfg[CamId].u.m.strength_ir = u8Strength / 5 + 3; ret = SAMPLE_COMM_ISP_SET_CPSL_CFG(CamId, &g_cpsl_cfg[CamId]); pthread_mutex_unlock(&lock[CamId]); return ret; } RK_S32 SAMPLE_COMMON_ISP_SET_AutoWhiteBalance(RK_S32 CamId) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_uapi_setWBMode(g_aiq_ctx[CamId], OP_AUTO); } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMMON_ISP_SET_ManualWhiteBalance(RK_S32 CamId, RK_U32 u32RGain, RK_U32 u32GGain, RK_U32 u32BGain) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; rk_aiq_wb_gain_t gain; u32RGain = (u32RGain == 0) ? 1 : u32RGain; u32GGain = (u32GGain == 0) ? 1 : u32GGain; u32BGain = (u32BGain == 0) ? 1 : u32BGain; // gain.bgain = (b_gain / 255.0f) * 4;//[0,255]->(0.0, 4.0] // gain.grgain = (g_gain / 255.0f) * 4;//[0,255]->(0.0, 4.0] // gain.gbgain = (g_gain / 255.0f) * 4;//[0,255]->(0.0, 4.0] // gain.rgain = (r_gain / 255.0f) * 4;//[0,255]->(0.0, 4.0] //[0,255]->(0.0, 4.0] gain.rgain = (u32RGain / 128.0f) * gs_wb_auto_gain.rgain; //[0,255]->(0.0, 4.0] gain.grgain = (u32GGain / 128.0f) * gs_wb_auto_gain.grgain; //[0,255]->(0.0, 4.0] gain.gbgain = (u32GGain / 128.0f) * gs_wb_auto_gain.gbgain; //[0,255]->(0.0, 4.0] gain.bgain = (u32BGain / 128.0f) * gs_wb_auto_gain.bgain; printf("convert gain r g g b %f, %f, %f, %f\n", gain.rgain, gain.grgain, gain.gbgain, gain.bgain); printf("auto gain r g g b %f, %f, %f, %f\n", gs_wb_auto_gain.rgain, gs_wb_auto_gain.grgain, gs_wb_auto_gain.gbgain, gs_wb_auto_gain.bgain); pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_uapi_setMWBGain(g_aiq_ctx[CamId], &gain); } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMMON_ISP_GET_WhiteBalanceGain(RK_S32 CamId, rk_aiq_wb_gain_t *gain) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_uapi_getMWBGain(g_aiq_ctx[CamId], gain); } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); printf("Rgain = %f, Grgain = %f, Gbgain = %f, Bgain = %f\n", gain->rgain, gain->grgain, gain->gbgain, gain->bgain); return ret; } // mode 0:off, 1:2d, 2:3d, 3: 2d+3d RK_S32 SAMPLE_COMMON_ISP_SET_DNRStrength(RK_S32 CamId, RK_U32 u32Mode, RK_U32 u322DValue, RK_U32 u323Dvalue) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; RK_U32 u32_2d_value = (u322DValue / 128.0f) * g_2dnr_default_level; RK_U32 u32_3d_value = (u323Dvalue / 128.0f) * g_3dnr_default_level; printf(" mode = %d n_2d_value = %d n_3d_value = %d\r\n", u32Mode, u322DValue, u323Dvalue); printf("u_2d_value = %d n_3d_value = %d\r\n", u32_2d_value, u32_3d_value); printf("g_2dnr_default_level = %d g_3dnr_default_level = %d\r\n", g_2dnr_default_level, g_3dnr_default_level); pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { if (u32Mode == 0) { ret = rk_aiq_uapi_sysctl_setModuleCtl(g_aiq_ctx[CamId], RK_MODULE_NR, true); // 2D ret |= rk_aiq_uapi_sysctl_setModuleCtl(g_aiq_ctx[CamId], RK_MODULE_TNR, true); // 3D ret |= rk_aiq_uapi_setMSpaNRStrth(g_aiq_ctx[CamId], true, g_2dnr_default_level); //[0,100] ret |= rk_aiq_uapi_setMTNRStrth(g_aiq_ctx[CamId], true, g_3dnr_default_level); //[0,100] } else if (u32Mode == 1) // 2D { ret = rk_aiq_uapi_sysctl_setModuleCtl(g_aiq_ctx[CamId], RK_MODULE_NR, true); // 2D ret |= rk_aiq_uapi_sysctl_setModuleCtl(g_aiq_ctx[CamId], RK_MODULE_TNR, true); // 3D ret |= rk_aiq_uapi_setMSpaNRStrth(g_aiq_ctx[CamId], true, u32_2d_value); ////[0,255] -> [0,100] ret |= rk_aiq_uapi_setMTNRStrth(g_aiq_ctx[CamId], true, g_3dnr_default_level); } else if (u32Mode == 2) // 3D { ret = rk_aiq_uapi_sysctl_setModuleCtl(g_aiq_ctx[CamId], RK_MODULE_NR, true); // 2D ret |= rk_aiq_uapi_sysctl_setModuleCtl(g_aiq_ctx[CamId], RK_MODULE_TNR, true); // 3D ret |= rk_aiq_uapi_setMSpaNRStrth(g_aiq_ctx[CamId], true, g_2dnr_default_level); //[0,100]->[0,255] ret |= rk_aiq_uapi_setMTNRStrth(g_aiq_ctx[CamId], true, u32_3d_value); } else if (u32Mode == 3) //)//2D+3D { ret = rk_aiq_uapi_sysctl_setModuleCtl(g_aiq_ctx[CamId], RK_MODULE_NR, true); // 2D ret |= rk_aiq_uapi_sysctl_setModuleCtl(g_aiq_ctx[CamId], RK_MODULE_TNR, true); // 3D ret |= rk_aiq_uapi_setMSpaNRStrth(g_aiq_ctx[CamId], true, u32_2d_value); //[0,255] -> [0,100] ret |= rk_aiq_uapi_setMTNRStrth(g_aiq_ctx[CamId], true, u32_3d_value); //[0,255] -> [0,100] } } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMMON_ISP_GET_DNRStrength(RK_S32 CamId, RK_U32 *u322DValue, RK_U32 *u323Dvalue) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); bool on; if (g_aiq_ctx[CamId]) { ret = rk_aiq_uapi_getMSpaNRStrth(g_aiq_ctx[CamId], &on, u322DValue); ret |= rk_aiq_uapi_getMTNRStrth(g_aiq_ctx[CamId], &on, u323Dvalue); } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMMON_ISP_SET_Flicker(RK_S32 CamId, RK_U8 u32Flicker) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; frameRateInfo_t info; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { if (u32Flicker == 0) // NTSC(60HZ) { ret = rk_aiq_uapi_setExpPwrLineFreqMode(g_aiq_ctx[CamId], EXP_PWR_LINE_FREQ_60HZ); info.mode = OP_MANUAL; info.fps = 30; ret |= rk_aiq_uapi_setFrameRate(g_aiq_ctx[CamId], info); } else if (u32Flicker == 1) // PAL(50HZ) { ret = rk_aiq_uapi_setExpPwrLineFreqMode(g_aiq_ctx[CamId], EXP_PWR_LINE_FREQ_50HZ); info.mode = OP_MANUAL; info.fps = 25; ret |= rk_aiq_uapi_setFrameRate(g_aiq_ctx[CamId], info); } } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } // for normal or hdr2 RK_S32 SAMPLE_COMM_ISP_SET_HDR(RK_S32 CamId, rk_aiq_working_mode_t mode) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_uapi_sysctl_swWorkingModeDyn(g_aiq_ctx[CamId], mode); } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } // mode 0 0ff 1 on 2 auto RK_S32 SAMPLE_COMM_ISP_SET_DefogEnable(RK_S32 CamId, RK_U32 u32Mode) { /* int defog = (u32Mode == 0) ? 0 : 1; if(gs_defog_mode == defog) { return 0; } gs_defog_mode = defog; */ if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { if (u32Mode == 0) { ret = rk_aiq_uapi_disableDhz(g_aiq_ctx[CamId]); } else { ret = rk_aiq_uapi_enableDhz(g_aiq_ctx[CamId]); } } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_DefogStrength(RK_S32 CamId, RK_U32 u32Mode, RK_U32 u32Value) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); unsigned int level = u32Value / 25.5; level = (level < 1) ? 1 : level; level = (level > 10) ? 10 : level; printf("defog level = %d\n", level); if (g_aiq_ctx[CamId]) { if (u32Mode == 1) { ret = rk_aiq_uapi_setDhzMode(g_aiq_ctx[CamId], OP_MANUAL); ret |= rk_aiq_uapi_setMDhzStrth(g_aiq_ctx[CamId], true, level); //[0,255]->[1,10] } else if (u32Mode == 2) { ret = rk_aiq_uapi_setDhzMode(g_aiq_ctx[CamId], OP_AUTO); } } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_Correction(RK_S32 CamId, RK_U32 u32Mode, RK_U32 u32Value) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { if (gs_LDC_mode[CamId] != u32Mode) { if (u32Mode) { ret = rk_aiq_uapi_setLdchEn(g_aiq_ctx[CamId], true); } else { ret = rk_aiq_uapi_setLdchEn(g_aiq_ctx[CamId], false); } gs_LDC_mode[CamId] = u32Mode; } if (u32Mode) { ret |= rk_aiq_uapi_setLdchCorrectLevel(g_aiq_ctx[CamId], (u32Value < 2 ? 2 : u32Value)); } } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_mirror(RK_S32 CamId, RK_U32 u32Value) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } int mirror = 0; int flip = 0; RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); switch (u32Value) { case 0: mirror = 0; flip = 0; break; case 1: mirror = 1; flip = 0; break; case 2: mirror = 0; flip = 1; break; case 3: mirror = 1; flip = 1; break; default: mirror = 0; flip = 0; break; } if (g_aiq_ctx[CamId]) { ret = rk_aiq_uapi_setMirroFlip(g_aiq_ctx[CamId], mirror, flip, 4); } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_BypassStreamRotation(RK_S32 CamId, RK_S32 S32Rotation) { if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; rk_aiq_rotation_t rk_rotation = RK_AIQ_ROTATION_0; if (S32Rotation == 0) { rk_rotation = RK_AIQ_ROTATION_0; } else if (S32Rotation == 90) { rk_rotation = RK_AIQ_ROTATION_90; } else if (S32Rotation == 270) { rk_rotation = RK_AIQ_ROTATION_270; } pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_uapi_sysctl_setSharpFbcRotation(g_aiq_ctx[CamId], rk_rotation); } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_SET_Crop(RK_S32 CamId, rk_aiq_rect_t rect) { /* rk_aiq_rect_t rect; rect.left = 0; rect.top = 0; rect.width = 2560; rect.height = 1440; rk_aiq_uapi_sysctl_setCrop(aiq_ctx, rect);*/ if (CamId >= MAX_AIQ_CTX || !g_aiq_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } RK_S32 ret = 0; pthread_mutex_lock(&aiq_ctx_mutex[CamId]); if (g_aiq_ctx[CamId]) { ret = rk_aiq_uapi_sysctl_setCrop(g_aiq_ctx[CamId], rect); } pthread_mutex_unlock(&aiq_ctx_mutex[CamId]); return ret; } RK_S32 SAMPLE_COMM_ISP_GetAINrParams(RK_S32 CamId, rk_ainr_param *param) { RK_S32 ret = 0; ret = rk_aiq_uapi_sysctl_getAinrParams(g_aiq_ctx[CamId], param); if (ret != 0) { printf("rk_aiq_uapi_sysctl_getAinrParams failure\n"); return -1; } return ret; } #ifdef RKAIQ_GRP static int isp_get_ldch_mesh_size(uint16_t *meshdata) { int file_size = 0; if (!meshdata) { printf("meshdata is null \n"); return -1; } unsigned short hpic, vpic, hsize, vsize, hstep, vstep = 0; hpic = (unsigned short)meshdata[0]; vpic = (unsigned short)meshdata[1]; hsize = (unsigned short)meshdata[2]; vsize = (unsigned short)meshdata[3]; hstep = (unsigned short)meshdata[4]; vstep = (unsigned short)meshdata[5]; printf("----------lut info: [%d-%d-%d-%d-%d-%d]\n", hpic, vpic, hsize, vsize, hstep, vstep); file_size = hsize * vsize * sizeof(unsigned short) + 12; return file_size; } XCamReturn SAMPLE_COMM_ISP_CamGroup_setMeshToLdch(int CamGrpId, uint8_t SetLdchMode, uint16_t **LdchMesh) { XCamReturn ret = XCAM_RETURN_NO_ERROR; rk_aiq_sys_ctx_t *aiq_ctx = NULL; rk_aiq_camgroup_camInfos_t camInfos; rk_aiq_ldch_attrib_t ldchAttr; memset(&camInfos, 0, sizeof(camInfos)); if (SetLdchMode < 1 || SetLdchMode > 2) { printf("this Ldch mode:%d, if want to set ldch, 1: read file set ldch, 2: read " "buff set ldch\n", SetLdchMode); return -1; } if (rk_aiq_uapi_camgroup_getCamInfos(g_aiq_camgroup_ctx[CamGrpId], &camInfos) == XCAM_RETURN_NO_ERROR) { for (int i = 0; i < camInfos.valid_sns_num; i++) { aiq_ctx = rk_aiq_uapi_camgroup_getAiqCtxBySnsNm(g_aiq_camgroup_ctx[CamGrpId], camInfos.sns_ent_nm[i]); if (!aiq_ctx) { printf("rk_aiq_uapi_camgroup_getAiqCtxBySnsNm return aiq_ctx is Null\n"); return -1; } printf("aiq_ctx sns name: %s, camPhyId %d\n", camInfos.sns_ent_nm[i], camInfos.sns_camPhyId[i]); memset(&ldchAttr, 0, sizeof(rk_aiq_ldch_attrib_t)); ret = rk_aiq_user_api_aldch_GetAttrib(aiq_ctx, &ldchAttr); if (ret == XCAM_RETURN_NO_ERROR) { if (SetLdchMode == 2) { ldchAttr.update_lut_mode = RK_AIQ_LDCH_UPDATE_LUT_FROM_EXTERNAL_BUFFER; ldchAttr.en = true; ldchAttr.lut.update_flag = true; ldchAttr.lut.u.buffer.addr = LdchMesh[i]; ldchAttr.lut.u.buffer.size = isp_get_ldch_mesh_size(LdchMesh[i]); } else { char *pLastWord = NULL; pLastWord = strrchr(LdchMesh[i], '/'); if (!pLastWord) { printf("---- error !!! the: %s path isn't to be parsed!!!!\n", (char *)LdchMesh[i]); return -1; } ldchAttr.en = true; ldchAttr.lut.update_flag = true; ldchAttr.update_lut_mode = RK_AIQ_LDCH_UPDATE_LUT_FROM_EXTERNAL_FILE; memcpy(ldchAttr.lut.u.file.config_file_dir, (char *)LdchMesh[i], (pLastWord - (char *)LdchMesh[i]) + 1); sprintf(ldchAttr.lut.u.file.mesh_file_name, "%s", (pLastWord + 1)); printf("lut file_dir: %s, mesh_file: %s\n", ldchAttr.lut.u.file.config_file_dir, ldchAttr.lut.u.file.mesh_file_name); } ret = rk_aiq_user_api_aldch_SetAttrib(aiq_ctx, ldchAttr); if (ret != XCAM_RETURN_NO_ERROR) { printf("Failed to set ldch attrib : %d\n", ret); return ret; } } } } return ret; } RK_S32 SAMPLE_COMM_ISP_CamGroup_Init(RK_S32 CamGroupId, rk_aiq_working_mode_t WDRMode, bool MultiCam, int OpenLdch, void *LdchMesh[], rk_aiq_camgroup_instance_cfg_t *pCamGroupCfg) { int i, ret; char sensor_name_array[MAX_AIQ_CTX][128]; rk_aiq_static_info_t aiq_static_info; if (CamGroupId >= MAX_AIQ_CTX) { printf("%s : CamId is over %d\n", __FUNCTION__, MAX_AIQ_CTX); return -1; } for (i = 0; i < pCamGroupCfg->sns_num; i++) { ret = rk_aiq_uapi_sysctl_enumStaticMetasByPhyId(i, &aiq_static_info); if (ret != 0) { printf("rk_aiq_uapi_sysctl_enumStaticMetasByPhyId failure \n"); return -1; } printf("CamGroupId:%d, cam_id: %d, sensor_name is %s, iqfiles is %s\n", CamGroupId, i, aiq_static_info.sensor_info.sensor_name, pCamGroupCfg->config_file_dir); memcpy(sensor_name_array[i], aiq_static_info.sensor_info.sensor_name, strlen(aiq_static_info.sensor_info.sensor_name) + 1); pCamGroupCfg->sns_ent_nm_array[i] = sensor_name_array[i]; printf("pCamGroupCfg->sns_ent_nm_array[%d] is %s\n", i, pCamGroupCfg->sns_ent_nm_array[i]); // ret = rk_aiq_uapi2_sysctl_preInit_devBufCnt( // aiq_static_info.sensor_info.sensor_name, "rkraw_rx", 2); // if (ret != 0) { // printf("rk_aiq_uapi2_sysctl_preInit_devBufCnt failure\n"); // return -1; //} } g_aiq_camgroup_ctx[CamGroupId] = rk_aiq_uapi_camgroup_create(pCamGroupCfg); if (!g_aiq_camgroup_ctx[CamGroupId]) { printf("create camgroup ctx error!\n"); return -1; } /* set LDCH must before */ if (OpenLdch) { SAMPLE_COMM_ISP_CamGroup_setMeshToLdch(CamGroupId, OpenLdch, LdchMesh); } else { // rv1126 must enable Ldch if you want to dymamic open and close. SAMPLE_COMM_ISP_CamGroup_SetLDCH(CamGroupId, 1, true); } ret = rk_aiq_uapi_camgroup_prepare(g_aiq_camgroup_ctx[CamGroupId], WDRMode); ret |= rk_aiq_uapi_camgroup_start(g_aiq_camgroup_ctx[CamGroupId]); if (ret != 0) { printf("rk_aiq_uapi_camgroup_prepare / start failure \n"); return -1; } printf("rk_aiq_uapi_camgroup_start over\n"); return ret; } RK_S32 SAMPLE_COMM_ISP_CamGroup_Stop(RK_S32 CamGroupId) { if (CamGroupId >= MAX_AIQ_CTX || !g_aiq_camgroup_ctx[CamGroupId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } printf("rk_aiq_uapi_camgroup_stop enter\n"); rk_aiq_uapi_camgroup_stop(g_aiq_camgroup_ctx[CamGroupId]); printf("rk_aiq_uapi_camgroup_destroy enter\n"); rk_aiq_uapi_camgroup_destroy(g_aiq_camgroup_ctx[CamGroupId]); printf("rk_aiq_uapi_camgroup_destroy exit\n"); g_aiq_camgroup_ctx[CamGroupId] = NULL; return 0; } RK_S32 SAMPLE_COMM_ISP_CamGroup_SetFrameRate(RK_S32 CamId, RK_U32 uFps) { if (CamId >= MAX_AIQ_CTX || !g_aiq_camgroup_ctx[CamId]) { printf("%s : CamId is over 3 or not init\n", __FUNCTION__); return -1; } int ret; Uapi_ExpSwAttr_t expSwAttr; ret = rk_aiq_user_api_ae_getExpSwAttr((rk_aiq_sys_ctx_t *)g_aiq_camgroup_ctx[CamId], &expSwAttr); if (uFps == 0) { expSwAttr.stAuto.stFrmRate.isFpsFix = false; } else { expSwAttr.stAuto.stFrmRate.isFpsFix = true; expSwAttr.stAuto.stFrmRate.FpsValue = uFps; } ret = rk_aiq_user_api_ae_setExpSwAttr((rk_aiq_sys_ctx_t *)g_aiq_camgroup_ctx[CamId], expSwAttr); return ret; } RK_S32 SAMPLE_COMM_ISP_CamGroup_SetLDCH(RK_U32 CamId, RK_U32 u32Level, RK_BOOL bIfEnable) { RK_S32 s32Ret = RK_FAILURE; rk_aiq_ldch_attrib_t ldchAttr; memset(&ldchAttr, 0, sizeof(rk_aiq_ldch_attrib_t)); if (CamId >= MAX_AIQ_CTX || !g_aiq_camgroup_ctx[CamId]) { printf("%s : CamId is over %d or not init\n", __FUNCTION__, MAX_AIQ_CTX); return RK_FAILURE; } s32Ret = rk_aiq_user_api_aldch_GetAttrib( (rk_aiq_sys_ctx_t *)g_aiq_camgroup_ctx[CamId], &ldchAttr); if (s32Ret != RK_SUCCESS) { RK_LOGE("rk_aiq_user_api_aldch_GetAttrib FAILURE:%X", s32Ret); return s32Ret; } ldchAttr.en = bIfEnable; ldchAttr.correct_level = u32Level; s32Ret = rk_aiq_user_api_aldch_SetAttrib( (rk_aiq_sys_ctx_t *)g_aiq_camgroup_ctx[CamId], ldchAttr); if (s32Ret != RK_SUCCESS) { RK_LOGE("rk_aiq_user_api_aldch_SetAttrib FAILURE:%d", s32Ret); return s32Ret; } return RK_SUCCESS; } #endif // #endif