/* * rkisp_aiq_core.h * * 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 "RkAiqCore.h" #include #include #include "RkAiqHandleInt.h" #include "v4l2_buffer_proxy.h" #include "acp/rk_aiq_algo_acp_itf.h" #include "ae/rk_aiq_algo_ae_itf.h" #include "awb/rk_aiq_algo_awb_itf.h" #include "af/rk_aiq_algo_af_itf.h" #include "anr/rk_aiq_algo_anr_itf.h" #include "asd/rk_aiq_algo_asd_itf.h" #include "amerge/rk_aiq_algo_amerge_itf.h" #include "atmo/rk_aiq_algo_atmo_itf.h" #include "adrc/rk_aiq_algo_adrc_itf.h" #include "asharp/rk_aiq_algo_asharp_itf.h" #include "adehaze/rk_aiq_algo_adhaz_itf.h" #include "ablc/rk_aiq_algo_ablc_itf.h" #include "adpcc/rk_aiq_algo_adpcc_itf.h" #include "alsc/rk_aiq_algo_alsc_itf.h" #include "agic/rk_aiq_algo_agic_itf.h" #include "adebayer/rk_aiq_algo_adebayer_itf.h" #include "accm/rk_aiq_algo_accm_itf.h" #include "agamma/rk_aiq_algo_agamma_itf.h" #include "adegamma/rk_aiq_algo_adegamma_itf.h" #include "awdr/rk_aiq_algo_awdr_itf.h" #include "a3dlut/rk_aiq_algo_a3dlut_itf.h" #include "aldch/rk_aiq_algo_aldch_itf.h" #include "ar2y/rk_aiq_algo_ar2y_itf.h" #include "aie/rk_aiq_algo_aie_itf.h" #include "aorb/rk_aiq_algo_aorb_itf.h" #include "afec/rk_aiq_algo_afec_itf.h" #include "acgc/rk_aiq_algo_acgc_itf.h" #include "aeis/rk_aiq_algo_aeis_itf.h" #include "amd/rk_aiq_algo_amd_itf.h" #include "arawnr/rk_aiq_abayernr_algo_itf_v1.h" #include "aynr/rk_aiq_aynr_algo_itf_v1.h" #include "auvnr/rk_aiq_auvnr_algo_itf_v1.h" #include "amfnr/rk_aiq_amfnr_algo_itf_v1.h" #include "again/rk_aiq_again_algo_itf.h" #ifdef RK_SIMULATOR_HW #include "simulator/isp20_hw_simulator.h" #else #include "isp20/Isp20Evts.h" #include "isp20/Isp20StatsBuffer.h" #include "isp20/rkisp2-config.h" #include "isp20/rkispp-config.h" #endif #include #include #include "SPStreamProcUnit.h" // #include "MessageBus.h" #include "shared_data_api_wrapper.h" #include "RkAiqAnalyzeGroupManager.h" namespace RkCam { #define EPSINON 0.0000001 /* * isp/ispp pipeline algos ordered array, and the analyzer * will run these algos one by one. */ /* * isp gets the stats from frame n-1, * and the new parameters take effect on frame n+1 */ #define ISP_PARAMS_EFFECT_DELAY_CNT 2 static RkAiqGrpCondition_t aeGrpCond[] = { [0] = { XCAM_MESSAGE_AEC_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT }, }; static RkAiqGrpConditions_t aeGrpConds = { grp_conds_array_info(aeGrpCond) }; static RkAiqGrpCondition_t awbGrpCond[] = { [0] = {XCAM_MESSAGE_AE_PRE_RES_OK, 0}, [1] = {XCAM_MESSAGE_AWB_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT }, }; static RkAiqGrpConditions_t awbGrpConds = {grp_conds_array_info(awbGrpCond) }; static RkAiqGrpCondition_t measGrpCond[] = { [0] = { XCAM_MESSAGE_ISP_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT }, }; static RkAiqGrpConditions_t measGrpConds = { grp_conds_array_info(measGrpCond) }; static RkAiqGrpCondition_t otherGrpCond[] = { [0] = { XCAM_MESSAGE_SOF_INFO_OK, 0 }, }; static RkAiqGrpConditions_t otherGrpConds = { grp_conds_array_info(otherGrpCond) }; static RkAiqGrpCondition_t amdGrpCond[] = { [0] = { XCAM_MESSAGE_SOF_INFO_OK, 0 }, [1] = { XCAM_MESSAGE_ISP_POLL_SP_OK, 0 }, [2] = { XCAM_MESSAGE_ISP_GAIN_OK, 0 }, }; static RkAiqGrpConditions_t amdGrpConds = { grp_conds_array_info(amdGrpCond) }; static RkAiqGrpCondition_t amfnrGrpCond[] = { [0] = { XCAM_MESSAGE_SOF_INFO_OK, 0 }, [1] = { XCAM_MESSAGE_ISP_GAIN_OK, 0 }, [2] = { XCAM_MESSAGE_ISPP_GAIN_KG_OK, 0 }, [3] = { XCAM_MESSAGE_AMD_PROC_RES_OK, 0 }, }; static RkAiqGrpConditions_t amfnrGrpConds = { grp_conds_array_info(amfnrGrpCond) }; static RkAiqGrpCondition_t aynrGrpCond[] = { [0] = { XCAM_MESSAGE_SOF_INFO_OK, 0 }, [1] = { XCAM_MESSAGE_ISP_GAIN_OK, 0 }, [2] = { XCAM_MESSAGE_ISPP_GAIN_WR_OK, 0 }, [3] = { XCAM_MESSAGE_AMD_PROC_RES_OK, 0 }, }; static RkAiqGrpConditions_t aynrGrpConds = { grp_conds_array_info(aynrGrpCond) }; static RkAiqGrpCondition_t lscGrpCond[] = { [0] = { XCAM_MESSAGE_SOF_INFO_OK, 0 }, [1] = { XCAM_MESSAGE_ISP_POLL_TX_OK, 0 }, [2] = { XCAM_MESSAGE_AWB_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT }, [3] = { XCAM_MESSAGE_AE_PROC_RES_OK, 0 }, }; static RkAiqGrpConditions_t lscGrpConds = { grp_conds_array_info(lscGrpCond) }; static RkAiqGrpCondition_t eisGrpCond[] = { [0] = { XCAM_MESSAGE_SOF_INFO_OK, 0 }, [1] = { XCAM_MESSAGE_ORB_STATS_OK, 0 }, [2] = { XCAM_MESSAGE_NR_IMG_OK, 0 }, }; static RkAiqGrpConditions_t eisGrpConds = { grp_conds_array_info(eisGrpCond) }; static RkAiqGrpCondition_t orbGrpCond[] = { [0] = { XCAM_MESSAGE_ORB_STATS_OK, 0 }, }; static RkAiqGrpConditions_t orbGrpConds = { grp_conds_array_info(orbGrpCond) }; const static struct RkAiqAlgoDesCommExt g_default_3a_des[] = { { &g_RkIspAlgoDescAe.common, RK_AIQ_CORE_ANALYZE_AE, 0, 0, aeGrpConds }, { &g_RkIspAlgoDescAwb.common, RK_AIQ_CORE_ANALYZE_AWB, 0, 0, awbGrpConds }, { &g_RkIspAlgoDescAf.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, measGrpConds }, { &g_RkIspAlgoDescAblc.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAdegamma.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAdpcc.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, measGrpConds }, { &g_RkIspAlgoDescAmerge.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, measGrpConds }, { &g_RkIspAlgoDescAtmo.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, measGrpConds }, #if ANR_NO_SEPERATE_MARCO { &g_RkIspAlgoDescAnr.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, measGrpConds }, #else #if 0 { &g_RkIspAlgoDescArawnr.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, measGrpConds }, { &g_RkIspAlgoDescAynr.common, RK_AIQ_CORE_ANALYZE_AYNR, 0, 0, aynrGrpConds }, { &g_RkIspAlgoDescAcnr.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, measGrpConds }, { &g_RkIspAlgoDescAmfnr.common, RK_AIQ_CORE_ANALYZE_AMFNR, 0, 0, amfnrGrpConds }, { &g_RkIspAlgoDescAgain.common, RK_AIQ_CORE_ANALYZE_AMFNR, 0, 0, amfnrGrpConds }, #else { &g_RkIspAlgoDescArawnr.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, measGrpConds}, { &g_RkIspAlgoDescAynr.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds}, { &g_RkIspAlgoDescAcnr.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds}, { &g_RkIspAlgoDescAmfnr.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds}, { &g_RkIspAlgoDescAgain.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds}, #endif #endif { &g_RkIspAlgoDescAlsc.common, RK_AIQ_CORE_ANALYZE_LSC, 0, 0, lscGrpConds }, { &g_RkIspAlgoDescAgic.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAdebayer.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAccm.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, measGrpConds }, { &g_RkIspAlgoDescAgamma.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAwdr.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAdhaz.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescA3dlut.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAldch.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAr2y.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAcp.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAie.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAsharp.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAorb.common, RK_AIQ_CORE_ANALYZE_ORB, 0, 0, orbGrpConds }, { &g_RkIspAlgoDescAcgc.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAsd.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, //{ &g_RkIspAlgoDescAfec.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, otherGrpConds }, { &g_RkIspAlgoDescAeis.common, RK_AIQ_CORE_ANALYZE_EIS, 0, 0, eisGrpConds }, #if 0 { &g_RkIspAlgoDescAmd.common, RK_AIQ_CORE_ANALYZE_AMD, 0, 0, amdGrpConds }, #endif { NULL, RK_AIQ_CORE_ANALYZE_ALL, 0, 0 }, }; bool RkAiqCoreThread::loop() { ENTER_ANALYZER_FUNCTION(); const static int32_t timeout = -1; SmartPtr stats = mStatsQueue.pop (timeout); if (!stats.ptr()) { LOGW_ANALYZER("RkAiqCoreThread got empty stats, stop thread"); return false; } XCamReturn ret = mRkAiqCore->analyze (stats); if (ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_BYPASS) return true; LOGE_ANALYZER("RkAiqCoreThread failed to analyze 3a stats"); EXIT_ANALYZER_FUNCTION(); return false; } bool RkAiqCoreEvtsThread::loop() { ENTER_ANALYZER_FUNCTION(); const static int32_t timeout = -1; SmartPtr evts = mEvtsQueue.pop (timeout); if (!evts.ptr()) { LOGW_ANALYZER("RkAiqCoreEvtsThread got empty stats, stop thread"); return false; } XCamReturn ret = mRkAiqCore->events_analyze (evts); if (ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_BYPASS) return true; LOGE_ANALYZER("RkAiqCoreEvtsThread failed to analyze events"); EXIT_ANALYZER_FUNCTION(); return false; } // notice that some pool shared items may be cached by other // modules(e.g. CamHwIsp20), so here should consider the cached number uint16_t RkAiqCore::DEFAULT_POOL_SIZE = 15; RkAiqCore::RkAiqCore() : mRkAiqCoreTh(new RkAiqCoreThread(this)) , mRkAiqCorePpTh(new RkAiqCoreThread(this)) , mRkAiqCoreEvtsTh(new RkAiqCoreEvtsThread(this)) , mState(RK_AIQ_CORE_STATE_INVALID) , mRkAiqCoreMsgTh(new MessageThread(this)) , mCb(NULL) , mAiqParamsPool(new RkAiqFullParamsPool("RkAiqFullParams", 16)) , mAiqCpslParamsPool(new RkAiqCpslParamsPool("RkAiqCpslParamsPool", 4)) , mAiqStatsPool(new RkAiqStatsPool("RkAiqStatsPool", 4)) , mAiqIspStatsIntPool(new RkAiqIspStatsIntPool("RkAiqIspStatsIntPool", 10)) , mAiqSofInfoWrapperPool(new RkAiqSofInfoWrapperPool("RkAiqSofPoolWrapper", 16)) , mAiqAecStatsPool(new RkAiqAecStatsPool("RkAiqAecStatsPool", 10)) , mAiqAwbStatsPool(new RkAiqAwbStatsPool("RkAiqAwbStatsPool", 10)) , mAiqAtmoStatsPool(new RkAiqAtmoStatsPool("RkAiqAtmoStatsPool", 10)) , mAiqAdehazeStatsPool(new RkAiqAdehazeStatsPool("RkAiqAdehazeStatsPool", 10)) , mAiqAfStatsPool(new RkAiqAfStatsPool("RkAiqAfStatsPool", 10)) , mAiqOrbStatsIntPool(new RkAiqOrbStatsPool("RkAiqOrbStatsPool", 10)) , mCustomEnAlgosMask(0xffffffff) { ENTER_ANALYZER_FUNCTION(); // mAlogsSharedParams.reset(); mAlogsComSharedParams.reset(); xcam_mem_clear(mHwInfo); mCurCpslOn = false; mStrthLed = 0.0f; mStrthIr = 0.0f; mGrayMode = RK_AIQ_GRAY_MODE_CPSL; firstStatsReceived = false; SmartPtr fullParam = new RkAiqFullParams(); mAiqCurParams = new RkAiqFullParamsProxy(fullParam ); mHasPp = true; mIspOnline = false; mAlgosDesArray = g_default_3a_des; mIspHwVer = 0; mSafeEnableAlgo = true; mLastAnalyzedId = 0; mTranslator = new RkAiqResourceTranslator(); EXIT_ANALYZER_FUNCTION(); } RkAiqCore::~RkAiqCore() { ENTER_ANALYZER_FUNCTION(); if (mAlogsComSharedParams.resourcePath) { xcam_free((void*)(mAlogsComSharedParams.resourcePath)); mAlogsComSharedParams.resourcePath = NULL; } EXIT_ANALYZER_FUNCTION(); } void RkAiqCore::initCpsl() { queryCpsLtCap(mCpslCap); rk_aiq_cpsl_cfg_t* cfg = &mAlogsComSharedParams.cpslCfg; const CamCalibDbContext_t* aiqCalib = mAlogsComSharedParams.calibv2; CalibDbV2_Cpsl_t* calibv2_cpsl_db = (CalibDbV2_Cpsl_t*)(CALIBDBV2_GET_MODULE_PTR((void*)aiqCalib, cpsl)); CalibDbV2_Cpsl_Param_t* calibv2_cpsl_calib = &calibv2_cpsl_db->param; // TODO: something from calib if (mCpslCap.modes_num > 0 && calibv2_cpsl_calib->enable) { if (calibv2_cpsl_calib->mode == 0) { cfg->mode = RK_AIQ_OP_MODE_AUTO; } else if (calibv2_cpsl_calib->mode == 1) { cfg->mode = RK_AIQ_OP_MODE_MANUAL; } else { cfg->mode = RK_AIQ_OP_MODE_INVALID; } if (calibv2_cpsl_calib->light_src == 0) { cfg->lght_src = RK_AIQ_CPSLS_LED; } else if (calibv2_cpsl_calib->light_src == 1) { cfg->lght_src = RK_AIQ_CPSLS_IR; } else if (calibv2_cpsl_calib->light_src == 2) { cfg->lght_src = RK_AIQ_CPSLS_MIX; } else { cfg->lght_src = RK_AIQ_CPSLS_INVALID; } cfg->gray_on = calibv2_cpsl_calib->force_gray; if (cfg->mode == RK_AIQ_OP_MODE_AUTO) { cfg->u.a.sensitivity = calibv2_cpsl_calib->auto_adjust_sens; cfg->u.a.sw_interval = calibv2_cpsl_calib->auto_sw_interval; LOGI_ANALYZER("mode sensitivity %f, interval time %d s\n", cfg->u.a.sensitivity, cfg->u.a.sw_interval); } else { cfg->u.m.on = calibv2_cpsl_calib->manual_on; cfg->u.m.strength_ir = calibv2_cpsl_calib->manual_strength; cfg->u.m.strength_led = calibv2_cpsl_calib->manual_strength; LOGI_ANALYZER("on %d, strength_led %f, strength_ir %f \n", cfg->u.m.on, cfg->u.m.strength_led, cfg->u.m.strength_ir); } } else { cfg->mode = RK_AIQ_OP_MODE_INVALID; LOGI_ANALYZER("not support light compensation \n"); } } XCamReturn RkAiqCore::init(const char* sns_ent_name, const CamCalibDbContext_t* aiqCalib, const CamCalibDbV2Context_t* aiqCalibv2) { ENTER_ANALYZER_FUNCTION(); if (mState != RK_AIQ_CORE_STATE_INVALID) { LOGE_ANALYZER("wrong state %d\n", mState); return XCAM_RETURN_ERROR_ANALYZER; } mAlogsComSharedParams.calib = aiqCalib; mAlogsComSharedParams.calibv2 = aiqCalibv2; const CalibDb_AlgoSwitch_t *algoSwitch = &aiqCalibv2->sys_cfg->algoSwitch; if (algoSwitch->enable && algoSwitch->enable_algos) { mCustomEnAlgosMask = 0x0; for (uint16_t i = 0; i < algoSwitch->enable_algos_len; i++) mCustomEnAlgosMask |= 1 << algoSwitch->enable_algos[i]; } LOGI_ANALYZER("mCustomEnAlgosMask: 0x%x\n", mCustomEnAlgosMask); addDefaultAlgos(mAlgosDesArray); initCpsl(); newAiqParamsPool(); newAiqGroupAnayzer(); mState = RK_AIQ_CORE_STATE_INITED; return XCAM_RETURN_NO_ERROR; EXIT_ANALYZER_FUNCTION(); } XCamReturn RkAiqCore::deInit() { ENTER_ANALYZER_FUNCTION(); for (auto mapIt = mAlogsGroupSharedParamsMap.begin(); \ mapIt != mAlogsGroupSharedParamsMap.end();) { delete mapIt->second; mAlogsGroupSharedParamsMap.erase(mapIt++); } mAlogsGroupList.clear(); if (mState == RK_AIQ_CORE_STATE_STARTED || mState == RK_AIQ_CORE_STATE_RUNNING) { LOGE_ANALYZER("wrong state %d\n", mState); return XCAM_RETURN_ERROR_ANALYZER; } mState = RK_AIQ_CORE_STATE_INVALID; EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::start() { ENTER_ANALYZER_FUNCTION(); if ((mState != RK_AIQ_CORE_STATE_PREPARED) && (mState != RK_AIQ_CORE_STATE_STOPED)) { LOGE_ANALYZER("wrong state %d\n", mState); return XCAM_RETURN_ERROR_ANALYZER; } mRkAiqCoreTh->triger_start(); mRkAiqCoreTh->start(); if (mHasPp) { mRkAiqCorePpTh->triger_start(); mRkAiqCorePpTh->start(); } mRkAiqCoreEvtsTh->triger_start(); mRkAiqCoreEvtsTh->start(); mRkAiqCoreMsgTh->triger_start(); mRkAiqCoreMsgTh->start(); mRkAiqCoreGroupManager->start(); if (mThumbnailsService.ptr()) { mThumbnailsService->Start(); } mState = RK_AIQ_CORE_STATE_STARTED; EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::stop() { ENTER_ANALYZER_FUNCTION(); if (mState != RK_AIQ_CORE_STATE_STARTED && mState != RK_AIQ_CORE_STATE_RUNNING) { LOGW_ANALYZER("in state %d\n", mState); return XCAM_RETURN_NO_ERROR; } mRkAiqCoreTh->triger_stop(); mRkAiqCoreTh->stop(); if (mHasPp) { mRkAiqCorePpTh->triger_stop(); mRkAiqCorePpTh->stop(); } mRkAiqCoreEvtsTh->triger_stop(); mRkAiqCoreEvtsTh->stop(); mRkAiqCoreMsgTh->triger_stop(); mRkAiqCoreMsgTh->stop(); mRkAiqCoreGroupManager->stop(); if (mThumbnailsService.ptr()) { mThumbnailsService->Stop(); } mAiqStatsCachedList.clear(); mAiqStatsOutMap.clear(); mAlogsComSharedParams.conf_type = RK_AIQ_ALGO_CONFTYPE_INIT; mState = RK_AIQ_CORE_STATE_STOPED; firstStatsReceived = false; mLastAnalyzedId = 0; mIspStatsCond.broadcast (); EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::prepare(const rk_aiq_exposure_sensor_descriptor* sensor_des, int mode) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; // check state if ((mState == RK_AIQ_CORE_STATE_STARTED) || (mState == RK_AIQ_CORE_STATE_INVALID) || (mState == RK_AIQ_CORE_STATE_RUNNING)) { LOGW_ANALYZER("in state %d\n", mState); return XCAM_RETURN_NO_ERROR; } bool res_changed = (mAlogsComSharedParams.snsDes.isp_acq_width != 0) && (sensor_des->isp_acq_width != mAlogsComSharedParams.snsDes.isp_acq_width || sensor_des->isp_acq_height != mAlogsComSharedParams.snsDes.isp_acq_height); if (res_changed) { mAlogsComSharedParams.conf_type |= RK_AIQ_ALGO_CONFTYPE_CHANGERES; LOGD_ANALYZER("resolution changed !"); } if ((mState == RK_AIQ_CORE_STATE_STOPED) || (mState == RK_AIQ_CORE_STATE_PREPARED)) { mAlogsComSharedParams.conf_type |= RK_AIQ_ALGO_CONFTYPE_KEEPSTATUS; LOGD_ANALYZER("prepare from stopped, should keep algo status !"); } mAlogsComSharedParams.snsDes = *sensor_des; mAlogsComSharedParams.working_mode = mode; mAlogsComSharedParams.spWidth = mSpWidth; mAlogsComSharedParams.spHeight = mSpHeight; mAlogsComSharedParams.spAlignedWidth = mSpAlignedWidth; mAlogsComSharedParams.spAlignedHeight = mSpAlignedHeight; CalibDbV2_ColorAsGrey_t *colorAsGrey = (CalibDbV2_ColorAsGrey_t*)CALIBDBV2_GET_MODULE_PTR((void*)(mAlogsComSharedParams.calibv2), colorAsGrey); CalibDbV2_Thumbnails_t* thumbnails_config_db = (CalibDbV2_Thumbnails_t*)CALIBDBV2_GET_MODULE_PTR((void*)(mAlogsComSharedParams.calibv2), thumbnails); if (thumbnails_config_db) { CalibDbV2_Thumbnails_Param_t* thumbnails_config = &thumbnails_config_db->param; if (thumbnails_config->thumbnail_configs_len > 0) { mThumbnailsService = new ThumbnailsService(); if (mThumbnailsService.ptr()) { auto ret = mThumbnailsService->Prepare(thumbnails_config); if (ret == XCAM_RETURN_NO_ERROR) { auto cb = std::bind(&RkAiqCore::onThumbnailsResult, this, std::placeholders::_1); mThumbnailsService->SetResultCallback(cb); } else { mThumbnailsService.release(); } } } } if ((mAlogsComSharedParams.snsDes.sensor_pixelformat == V4L2_PIX_FMT_GREY) || (mAlogsComSharedParams.snsDes.sensor_pixelformat == V4L2_PIX_FMT_Y10) || (mAlogsComSharedParams.snsDes.sensor_pixelformat == V4L2_PIX_FMT_Y12)) { mAlogsComSharedParams.is_bw_sensor = true; mGrayMode = RK_AIQ_GRAY_MODE_ON; mAlogsComSharedParams.gray_mode = true; } else { mAlogsComSharedParams.is_bw_sensor = false; if (colorAsGrey->param.enable) { mAlogsComSharedParams.gray_mode = true; mGrayMode = RK_AIQ_GRAY_MODE_ON; } } for (auto algoHdl : mCurIspAlgoHandleList) { if (algoHdl.ptr() && algoHdl->getEnable()) { /* update user initial params */ \ ret = algoHdl->updateConfig(true); RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d update initial user params failed", algoHdl->getAlgoType()); algoHdl->setReConfig(mState == RK_AIQ_CORE_STATE_STOPED); ret = algoHdl->prepare(); RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d prepare failed", algoHdl->getAlgoType()); } } for (auto algoHdl : mCurIsppAlgoHandleList) { if (algoHdl.ptr() && algoHdl->getEnable()) { /* update user initial params */ \ ret = algoHdl->updateConfig(true); RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d update initial user params failed", algoHdl->getAlgoType()); algoHdl->setReConfig(mState == RK_AIQ_CORE_STATE_STOPED); ret = algoHdl->prepare(); RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d prepare failed", algoHdl->getAlgoType()); } } mAlogsComSharedParams.init = true; analyzeInternal(RK_AIQ_CORE_ANALYZE_ALL); mAlogsComSharedParams.init = false; #if 0 if (mAiqCurParams->data()->mIspMeasParams.ptr()) { mAiqCurParams->data()->mIspMeasParams->data()->frame_id = 0; } if (mAiqCurParams->data()->mIspOtherParams.ptr()) { mAiqCurParams->data()->mIspOtherParams->data()->frame_id = 0; } if (mAiqCurParams->data()->mIsppMeasParams.ptr()) { mAiqCurParams->data()->mIsppMeasParams->data()->frame_id = 0; } if (mAiqCurParams->data()->mIsppOtherParams.ptr()) { mAiqCurParams->data()->mIsppOtherParams->data()->frame_id = 0; } #endif mState = RK_AIQ_CORE_STATE_PREPARED; EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } SmartPtr RkAiqCore::analyzeInternal(enum rk_aiq_core_analyze_type_e type) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; if (mAlogsComSharedParams.init) { // run algos without stats to generate // initial params CalibDb_Aec_ParaV2_t* calibv2_ae_calib = (CalibDb_Aec_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)(mAlogsComSharedParams.calibv2), ae_calib)); auto mapIter = mAlogsGroupSharedParamsMap.begin(); while (mapIter != mAlogsGroupSharedParamsMap.end()) { RkAiqAlgosGroupShared_t* &shared = mapIter->second; shared->reset(); if (!shared->ispStats) { SmartPtr ispStats = NULL; if (mAiqIspStatsIntPool->has_free_items()) { ispStats = mAiqIspStatsIntPool->get_item(); } shared->ispStats = ispStats->data().ptr(); } shared->frameId = 0; shared->ispStats->aec_stats_valid = false; shared->ispStats->awb_stats_valid = false; shared->ispStats->awb_cfg_effect_valid = false; shared->ispStats->af_stats_valid = false; shared->ispStats->atmo_stats_valid = false; shared->aecStatsBuf = nullptr; shared->curExp.LinearExp.exp_real_params.analog_gain = \ calibv2_ae_calib->LinearAeCtrl.InitExp.InitGainValue; shared->curExp.LinearExp.exp_real_params.integration_time = \ calibv2_ae_calib->LinearAeCtrl.InitExp.InitTimeValue; for (int32_t i = 0; i < 3; i++) { shared->curExp.HdrExp[i].exp_real_params.analog_gain = \ calibv2_ae_calib->HdrAeCtrl.InitExp.InitGainValue[i]; shared->curExp.HdrExp[i].exp_real_params.integration_time = \ calibv2_ae_calib->HdrAeCtrl.InitExp.InitTimeValue[i]; } mapIter++; } } SmartPtr aiqParamProxy = NULL; if (mAiqParamsPool->has_free_items()) aiqParamProxy = mAiqParamsPool->get_item(); if (!aiqParamProxy.ptr()) { LOGE_ANALYZER("no free aiq params buffer!"); return NULL; } RkAiqFullParams* aiqParams = aiqParamProxy->data().ptr(); aiqParams->reset(); ret = getAiqParamsBuffer(aiqParams, type); if (ret != XCAM_RETURN_NO_ERROR) return NULL; #if 0 // for test int fd = open("/tmp/cpsl", O_RDWR); if (fd != -1) { char c; read(fd, &c, 1); int enable = atoi(&c); rk_aiq_cpsl_cfg_t cfg; cfg.mode = (RKAiqOPMode_t)enable; cfg.lght_src = RK_AIQ_CPSLS_LED; if (cfg.mode == RK_AIQ_OP_MODE_AUTO) { cfg.u.a.sensitivity = 100; cfg.u.a.sw_interval = 60; cfg.gray_on = false; LOGI_ANALYZER("mode sensitivity %f, interval time %d s\n", cfg.u.a.sensitivity, cfg.u.a.sw_interval); } else { cfg.gray_on = true; cfg.u.m.on = true; cfg.u.m.strength_ir = 100; cfg.u.m.strength_led = 100; LOGI_ANALYZER("on %d, strength_led %f, strength_ir %f\n", cfg.u.m.on, cfg.u.m.strength_led, cfg.u.m.strength_ir); } close(fd); setCpsLtCfg(cfg); } #endif ret = preProcess(type); RKAIQCORE_CHECK_RET_NULL(ret, "preprocess failed"); if (type == RK_AIQ_CORE_ANALYZE_OTHER) { genCpslResult(aiqParams); } ret = processing(type); RKAIQCORE_CHECK_RET_NULL(ret, "processing failed"); ret = postProcess(type); RKAIQCORE_CHECK_RET_NULL(ret, "post process failed"); ret = genIspParamsResult(aiqParams, type); EXIT_ANALYZER_FUNCTION(); return aiqParamProxy; } XCamReturn RkAiqCore::getAiqParamsBuffer(RkAiqFullParams* aiqParams, enum rk_aiq_core_analyze_type_e type) { #define NEW_PARAMS_BUFFER(lc, BC) \ if (mAiqIsp##lc##ParamsPool->has_free_items()) { \ aiqParams->m##lc##Params = mAiqIsp##lc##ParamsPool->get_item(); \ aiqParams->m##lc##Params->data()->frame_id = -1; \ } else { \ LOGE_ANALYZER("no free %s buffer!", #BC); \ return XCAM_RETURN_ERROR_MEM; \ } \ std::list& algo_list = mRkAiqCoreGroupManager->getGroupAlgoList(type); for (auto type : algo_list) { switch (type) { case RK_AIQ_ALGO_TYPE_AE: if (mAiqExpParamsPool->has_free_items()) { aiqParams->mExposureParams = mAiqExpParamsPool->get_item(); } else { LOGE_ANALYZER("no free exposure params buffer!"); return XCAM_RETURN_ERROR_MEM; } if (mAiqIrisParamsPool->has_free_items()) { aiqParams->mIrisParams = mAiqIrisParamsPool->get_item(); } else { LOGE_ANALYZER("no free iris params buffer!"); return XCAM_RETURN_ERROR_MEM; } NEW_PARAMS_BUFFER(Aec, aec); NEW_PARAMS_BUFFER(Hist, hist); break; case RK_AIQ_ALGO_TYPE_AWB: NEW_PARAMS_BUFFER(Awb, awb); NEW_PARAMS_BUFFER(AwbGain, awb_gain); break; case RK_AIQ_ALGO_TYPE_AF: if (mAiqFocusParamsPool->has_free_items()) { aiqParams->mFocusParams = mAiqFocusParamsPool->get_item(); } else { LOGE_ANALYZER("no free focus params buffer!"); return XCAM_RETURN_ERROR_MEM; } NEW_PARAMS_BUFFER(Af, af); break; case RK_AIQ_ALGO_TYPE_ABLC: NEW_PARAMS_BUFFER(Blc, blc); break; case RK_AIQ_ALGO_TYPE_ADPCC: NEW_PARAMS_BUFFER(Dpcc, dpcc); break; #if 0 case RK_AIQ_ALGO_TYPE_AHDR: NEW_PARAMS_BUFFER(Hdr, hdr); break; #else case RK_AIQ_ALGO_TYPE_AMERGE: NEW_PARAMS_BUFFER(Merge, merge); break; case RK_AIQ_ALGO_TYPE_ATMO: NEW_PARAMS_BUFFER(Tmo, tmo); break; #endif case RK_AIQ_ALGO_TYPE_ALSC: NEW_PARAMS_BUFFER(Lsc, lsc); break; case RK_AIQ_ALGO_TYPE_AGIC: NEW_PARAMS_BUFFER(Gic, gic); break; case RK_AIQ_ALGO_TYPE_ADEBAYER: NEW_PARAMS_BUFFER(Debayer, debayer); break; case RK_AIQ_ALGO_TYPE_ACCM: NEW_PARAMS_BUFFER(Ccm, ccm); break; case RK_AIQ_ALGO_TYPE_AGAMMA: NEW_PARAMS_BUFFER(Agamma, agamma); break; case RK_AIQ_ALGO_TYPE_AWDR: NEW_PARAMS_BUFFER(Wdr, wdr); break; case RK_AIQ_ALGO_TYPE_ADHAZ: NEW_PARAMS_BUFFER(Dehaze, dehaze); break; case RK_AIQ_ALGO_TYPE_A3DLUT: NEW_PARAMS_BUFFER(Lut3d, lut3d); break; case RK_AIQ_ALGO_TYPE_ALDCH: NEW_PARAMS_BUFFER(Ldch, ldch); break; case RK_AIQ_ALGO_TYPE_AR2Y: break; case RK_AIQ_ALGO_TYPE_ACP: NEW_PARAMS_BUFFER(Cp, cp); break; case RK_AIQ_ALGO_TYPE_AIE: NEW_PARAMS_BUFFER(Ie, ie); break; case RK_AIQ_ALGO_TYPE_ACGC: NEW_PARAMS_BUFFER(Cgc, cgc); break; case RK_AIQ_ALGO_TYPE_ASD: break; case RK_AIQ_ALGO_TYPE_ADRC: break; case RK_AIQ_ALGO_TYPE_ADEGAMMA: NEW_PARAMS_BUFFER(Adegamma, adegamma); break; case RK_AIQ_ALGO_TYPE_ARAWNR: NEW_PARAMS_BUFFER(Rawnr, rawnr); break; case RK_AIQ_ALGO_TYPE_AMFNR: NEW_PARAMS_BUFFER(Tnr, tnr); break; case RK_AIQ_ALGO_TYPE_AYNR: NEW_PARAMS_BUFFER(Ynr, ynr); break; case RK_AIQ_ALGO_TYPE_ACNR: NEW_PARAMS_BUFFER(Uvnr, uvnr); break; case RK_AIQ_ALGO_TYPE_ASHARP: NEW_PARAMS_BUFFER(Sharpen, sharpen); NEW_PARAMS_BUFFER(Edgeflt, edgeflt); break; case RK_AIQ_ALGO_TYPE_AORB: NEW_PARAMS_BUFFER(Orb, orb); break; case RK_AIQ_ALGO_TYPE_AFEC: case RK_AIQ_ALGO_TYPE_AEIS: NEW_PARAMS_BUFFER(Fec, fec); break; case RK_AIQ_ALGO_TYPE_ANR: NEW_PARAMS_BUFFER(Rawnr, rawnr); NEW_PARAMS_BUFFER(Tnr, tnr); NEW_PARAMS_BUFFER(Ynr, ynr); NEW_PARAMS_BUFFER(Uvnr, uvnr); NEW_PARAMS_BUFFER(Gain, gain); NEW_PARAMS_BUFFER(Motion, motion); break; case RK_AIQ_ALGO_TYPE_AMD: NEW_PARAMS_BUFFER(Md, md); break; default: break; } } return XCAM_RETURN_NO_ERROR; } void RkAiqCore::setResultExpectedEffId(uint32_t& eff_id, enum RkAiqAlgoType_e type) { int groupId = getGroupId(type); RkAiqAlgosGroupShared_t* shared = nullptr; if (groupId < 0) { LOGE_ANALYZER("get group of type %d failed !", type); return; } if (getGroupSharedParams(groupId, shared) != XCAM_RETURN_NO_ERROR) { LOGE_ANALYZER("no shared params for type %d !", type); return; } if (mAlogsComSharedParams.init) { // init params, set before streaming eff_id = 0; } else eff_id = shared->frameId; } XCamReturn RkAiqCore::genIspParamsResult(RkAiqFullParams *aiqParams, enum rk_aiq_core_analyze_type_e type) { SmartPtr curParams = mAiqCurParams->data(); for (auto algoHdl : mCurIspAlgoHandleList) { if (algoHdl.ptr() && algoHdl->getEnable() && (mAlgoTypeToGrpMaskMap[algoHdl->getAlgoType()] & grpId2GrpMask(type))) { switch (algoHdl->getAlgoType()) { case RK_AIQ_ALGO_TYPE_AE: genIspAeResult(aiqParams); curParams->mExposureParams = aiqParams->mExposureParams; curParams->mAecParams = aiqParams->mAecParams; curParams->mHistParams = aiqParams->mHistParams; break; case RK_AIQ_ALGO_TYPE_AWB: genIspAwbResult(aiqParams); curParams->mAwbParams = aiqParams->mAwbParams; curParams->mAwbGainParams = aiqParams->mAwbGainParams; break; case RK_AIQ_ALGO_TYPE_AF: genIspAfResult(aiqParams); curParams->mAfParams = aiqParams->mAfParams; curParams->mFocusParams = aiqParams->mFocusParams; break; case RK_AIQ_ALGO_TYPE_ABLC: genIspAblcResult(aiqParams); curParams->mBlcParams = aiqParams->mBlcParams; break; case RK_AIQ_ALGO_TYPE_ADPCC: genIspAdpccResult(aiqParams); curParams->mDpccParams = aiqParams->mDpccParams; break; case RK_AIQ_ALGO_TYPE_AMERGE: genIspAmergeResult(aiqParams); curParams->mMergeParams = aiqParams->mMergeParams; break; case RK_AIQ_ALGO_TYPE_ATMO: genIspAtmoResult(aiqParams); curParams->mTmoParams = aiqParams->mTmoParams; break; case RK_AIQ_ALGO_TYPE_ALSC: genIspAlscResult(aiqParams); curParams->mLscParams = aiqParams->mLscParams; break; case RK_AIQ_ALGO_TYPE_AGIC: genIspAgicResult(aiqParams); curParams->mGicParams = aiqParams->mGicParams; break; case RK_AIQ_ALGO_TYPE_ADEBAYER: genIspAdebayerResult(aiqParams); curParams->mDebayerParams = aiqParams->mDebayerParams; break; case RK_AIQ_ALGO_TYPE_ACCM: genIspAccmResult(aiqParams); curParams->mCcmParams = aiqParams->mCcmParams; break; case RK_AIQ_ALGO_TYPE_AGAMMA: genIspAgammaResult(aiqParams); curParams->mAgammaParams = aiqParams->mAgammaParams; break; case RK_AIQ_ALGO_TYPE_AWDR: genIspAwdrResult(aiqParams); curParams->mWdrParams = aiqParams->mWdrParams; break; case RK_AIQ_ALGO_TYPE_ADHAZ: genIspAdhazResult(aiqParams); curParams->mDehazeParams = aiqParams->mDehazeParams; break; case RK_AIQ_ALGO_TYPE_A3DLUT: genIspA3dlutResult(aiqParams); curParams->mLut3dParams = aiqParams->mLut3dParams; break; case RK_AIQ_ALGO_TYPE_ALDCH: genIspAldchResult(aiqParams); curParams->mLdchParams = aiqParams->mLdchParams; break; case RK_AIQ_ALGO_TYPE_AR2Y: break; case RK_AIQ_ALGO_TYPE_ACP: genIspAcpResult(aiqParams); curParams->mCpParams = aiqParams->mCpParams; break; case RK_AIQ_ALGO_TYPE_AIE: genIspAieResult(aiqParams); curParams->mIeParams = aiqParams->mIeParams; break; case RK_AIQ_ALGO_TYPE_ACGC: genIspAcgcResult(aiqParams); curParams->mCgcParams = aiqParams->mCgcParams; break; case RK_AIQ_ALGO_TYPE_ASD: break; case RK_AIQ_ALGO_TYPE_ADRC: break; case RK_AIQ_ALGO_TYPE_ADEGAMMA: genIspAdegammaResult(aiqParams); curParams->mAdegammaParams = aiqParams->mAdegammaParams; break; case RK_AIQ_ALGO_TYPE_ARAWNR: genIspArawnrResult(aiqParams); curParams->mRawnrParams = aiqParams->mRawnrParams; break; case RK_AIQ_ALGO_TYPE_AMFNR: genIspAmfnrResult(aiqParams); curParams->mTnrParams = aiqParams->mTnrParams; break; case RK_AIQ_ALGO_TYPE_ACNR: genIspAcnrResult(aiqParams); curParams->mUvnrParams = aiqParams->mUvnrParams; break; case RK_AIQ_ALGO_TYPE_AYNR: genIspAynrResult(aiqParams); curParams->mYnrParams = aiqParams->mYnrParams; break; case RK_AIQ_ALGO_TYPE_AGAIN: genIspAgainResult(aiqParams); curParams->mGainParams = aiqParams->mGainParams; break; case RK_AIQ_ALGO_TYPE_ANR: genIspAnrResult(aiqParams); curParams->mRawnrParams = aiqParams->mRawnrParams; curParams->mUvnrParams = aiqParams->mUvnrParams; curParams->mYnrParams = aiqParams->mYnrParams; curParams->mTnrParams = aiqParams->mTnrParams; curParams->mYnrParams = aiqParams->mYnrParams; curParams->mGainParams = aiqParams->mGainParams; curParams->mMotionParams = aiqParams->mMotionParams; break; case RK_AIQ_ALGO_TYPE_ASHARP: genIspAsharpResult(aiqParams); curParams->mSharpenParams = aiqParams->mSharpenParams; curParams->mEdgefltParams = aiqParams->mEdgefltParams; break; case RK_AIQ_ALGO_TYPE_AMD: genIspAmdResult(aiqParams); curParams->mMdParams = aiqParams->mMdParams; break; case RK_AIQ_ALGO_TYPE_AORB: genIspAorbResult(aiqParams); curParams->mOrbParams = aiqParams->mOrbParams; break; case RK_AIQ_ALGO_TYPE_AFEC: case RK_AIQ_ALGO_TYPE_AEIS: genIspAfecResult(aiqParams); genIspAeisResult(aiqParams); curParams->mFecParams = aiqParams->mFecParams; break; default: break; } } } return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::genIspAeResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AE); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAe* ae_proc = shared->procResComb.ae_proc_res; RkAiqAlgoPostResAe* ae_post = shared->postResComb.ae_post_res; rk_aiq_isp_aec_params_v20_t *aec_param = params->mAecParams->data().ptr(); rk_aiq_isp_hist_params_v20_t *hist_param = params->mHistParams->data().ptr(); SmartPtr exp_param = params->mExposureParams->data(); SmartPtr iris_param = params->mIrisParams->data(); if (!ae_proc) { LOGD_ANALYZER("no ae_proc result"); return XCAM_RETURN_NO_ERROR; } if (!ae_post) { LOGD_ANALYZER("no ae_post result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen ae common result int algo_id = (*handle)->getAlgoId(); // gen common result exp_param->aecExpInfo.LinearExp = ae_proc->new_ae_exp.LinearExp; memcpy(exp_param->aecExpInfo.HdrExp, ae_proc->new_ae_exp.HdrExp, sizeof(ae_proc->new_ae_exp.HdrExp)); exp_param->aecExpInfo.frame_length_lines = ae_proc->new_ae_exp.frame_length_lines; exp_param->aecExpInfo.line_length_pixels = ae_proc->new_ae_exp.line_length_pixels; exp_param->aecExpInfo.pixel_clock_freq_mhz = ae_proc->new_ae_exp.pixel_clock_freq_mhz; exp_param->aecExpInfo.Iris.PIris = ae_proc->new_ae_exp.Iris.PIris; // TODO Merge //iris_param->IrisType = ae_proc->new_ae_exp.Iris.IrisType; iris_param->PIris.step = ae_proc->new_ae_exp.Iris.PIris.step; iris_param->PIris.update = ae_proc->new_ae_exp.Iris.PIris.update; #if 0 isp_param->aec_meas = ae_proc->ae_meas; isp_param->hist_meas = ae_proc->hist_meas; #else setResultExpectedEffId(aec_param->frame_id, RK_AIQ_ALGO_TYPE_AE); setResultExpectedEffId(hist_param->frame_id, RK_AIQ_ALGO_TYPE_AE); aec_param->result = ae_proc->ae_meas; hist_param->result = ae_proc->hist_meas; #endif // gen rk ae result if (algo_id == 0) { RkAiqAlgoProcResAeInt* ae_rk = (RkAiqAlgoProcResAeInt*)ae_proc; memcpy(exp_param->exp_tbl, ae_rk->ae_proc_res_rk.exp_set_tbl, sizeof(exp_param->exp_tbl)); exp_param->exp_tbl_size = ae_rk->ae_proc_res_rk.exp_set_cnt; exp_param->algo_id = algo_id; RkAiqAlgoPostResAeInt* ae_post_rk = (RkAiqAlgoPostResAeInt*)ae_post; iris_param->DCIris.update = ae_post_rk->ae_post_res_rk.DCIris.update; iris_param->DCIris.pwmDuty = ae_post_rk->ae_post_res_rk.DCIris.pwmDuty; } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAwbResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AWB); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAwb* awb_com = shared->procResComb.awb_proc_res; rk_aiq_isp_awb_params_v20_t *awb_param = params->mAwbParams->data().ptr(); rk_aiq_isp_awb_gain_params_v20_t *awb_gain_param = params->mAwbGainParams->data().ptr(); if (!awb_com) { LOGD_ANALYZER("no awb result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen awb common result RkAiqAlgoProcResAwb* awb_rk = (RkAiqAlgoProcResAwb*)awb_com; #if 0 isp_param->awb_gain_update = awb_rk->awb_gain_update; isp_param->awb_cfg_update = awb_rk->awb_cfg_update; isp_param->awb_gain = awb_rk->awb_gain_algo; isp_param->awb_cfg = awb_rk->awb_hw0_para; //isp_param->awb_cfg_v201 = awb_rk->awb_hw1_para; #else // TODO: update states // awb_gain_param->result.awb_gain_update = awb_rk->awb_gain_update; // isp_param->awb_cfg_update = awb_rk->awb_cfg_update; setResultExpectedEffId(awb_gain_param->frame_id, RK_AIQ_ALGO_TYPE_AWB); setResultExpectedEffId(awb_param->frame_id, RK_AIQ_ALGO_TYPE_AWB); awb_gain_param->result = awb_rk->awb_gain_algo; awb_param->result = awb_rk->awb_hw0_para; #endif int algo_id = (*handle)->getAlgoId(); // gen rk awb result if (algo_id == 0) { RkAiqAlgoProcResAwbInt* awb_rk_int = (RkAiqAlgoProcResAwbInt*)awb_com; } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAfResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AF); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAf* af_com = shared->procResComb.af_proc_res; rk_aiq_isp_af_params_v20_t* af_param = params->mAfParams->data().ptr(); SmartPtr focus_param = params->mFocusParams->data(); rk_aiq_focus_params_t* p_focus_param = &focus_param->result; #if 0 isp_param->af_cfg_update = false; #else // af_param->af_cfg_update = false; #endif p_focus_param->lens_pos_valid = false; p_focus_param->zoom_pos_valid = false; if (!af_com) { LOGD_ANALYZER("no af result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen af common result int algo_id = (*handle)->getAlgoId(); // gen rk af result if (algo_id == 0) { RkAiqAlgoProcResAfInt* af_rk = (RkAiqAlgoProcResAfInt*)af_com; #if 0 isp_param->af_meas = af_rk->af_proc_res_com.af_isp_param; isp_param->af_cfg_update = af_rk->af_proc_res_com.af_cfg_update; #else setResultExpectedEffId(af_param->frame_id, RK_AIQ_ALGO_TYPE_AF); af_param->result = af_rk->af_proc_res_com.af_isp_param; // isp_param->af_cfg_update = af_rk->af_proc_res_com.af_cfg_update; #endif p_focus_param->next_lens_pos = af_rk->af_proc_res_com.af_focus_param.next_lens_pos; p_focus_param->next_zoom_pos = af_rk->af_proc_res_com.af_focus_param.next_zoom_pos; p_focus_param->lens_pos_valid = af_rk->af_proc_res_com.af_focus_param.lens_pos_valid; p_focus_param->zoom_pos_valid = af_rk->af_proc_res_com.af_focus_param.zoom_pos_valid; } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAmergeResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AMERGE); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAmerge* amerge_com = shared->procResComb.amerge_proc_res; rk_aiq_isp_merge_params_v20_t* merge_param = params->mMergeParams->data().ptr(); if (!amerge_com) { LOGD_ANALYZER("no amerge result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen ahdr common result int algo_id = (*handle)->getAlgoId(); // gen rk ahdr result if (algo_id == 0) { RkAiqAlgoProcResAmergeInt* amerge_rk = (RkAiqAlgoProcResAmergeInt*)amerge_com; setResultExpectedEffId(merge_param->frame_id, RK_AIQ_ALGO_TYPE_AMERGE); merge_param->result.Res.sw_hdrmge_mode = amerge_rk->AmergeProcRes.Res.sw_hdrmge_mode; merge_param->result.Res.sw_hdrmge_lm_dif_0p9 = amerge_rk->AmergeProcRes.Res.sw_hdrmge_lm_dif_0p9; merge_param->result.Res.sw_hdrmge_ms_dif_0p8 = amerge_rk->AmergeProcRes.Res.sw_hdrmge_ms_dif_0p8; merge_param->result.Res.sw_hdrmge_lm_dif_0p15 = amerge_rk->AmergeProcRes.Res.sw_hdrmge_lm_dif_0p15; merge_param->result.Res.sw_hdrmge_ms_dif_0p15 = amerge_rk->AmergeProcRes.Res.sw_hdrmge_ms_dif_0p15; merge_param->result.Res.sw_hdrmge_gain0 = amerge_rk->AmergeProcRes.Res.sw_hdrmge_gain0; merge_param->result.Res.sw_hdrmge_gain0_inv = amerge_rk->AmergeProcRes.Res.sw_hdrmge_gain0_inv; merge_param->result.Res.sw_hdrmge_gain1 = amerge_rk->AmergeProcRes.Res.sw_hdrmge_gain1; merge_param->result.Res.sw_hdrmge_gain1_inv = amerge_rk->AmergeProcRes.Res.sw_hdrmge_gain1_inv; merge_param->result.Res.sw_hdrmge_gain2 = amerge_rk->AmergeProcRes.Res.sw_hdrmge_gain2; for(int i = 0; i < 17; i++) { merge_param->result.Res.sw_hdrmge_e_y[i] = amerge_rk->AmergeProcRes.Res.sw_hdrmge_e_y[i]; merge_param->result.Res.sw_hdrmge_l1_y[i] = amerge_rk->AmergeProcRes.Res.sw_hdrmge_l1_y[i]; merge_param->result.Res.sw_hdrmge_l0_y[i] = amerge_rk->AmergeProcRes.Res.sw_hdrmge_l0_y[i]; } merge_param->result.LongFrameMode = amerge_rk->AmergeProcRes.LongFrameMode; } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAtmoResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ATMO); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAtmo* atmo_com = shared->procResComb.atmo_proc_res; rk_aiq_isp_tmo_params_v20_t* tmo_param = params->mTmoParams->data().ptr(); if (!atmo_com) { LOGD_ANALYZER("no atmo result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen ahdr common result int algo_id = (*handle)->getAlgoId(); // gen rk ahdr result if (algo_id == 0) { RkAiqAlgoProcResAtmoInt* atmo_rk = (RkAiqAlgoProcResAtmoInt*)atmo_com; setResultExpectedEffId(tmo_param->frame_id, RK_AIQ_ALGO_TYPE_ATMO); tmo_param->result.Res.sw_hdrtmo_lgmax = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_lgmax; tmo_param->result.Res.sw_hdrtmo_lgscl = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_lgscl; tmo_param->result.Res.sw_hdrtmo_lgscl_inv = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_lgscl_inv; tmo_param->result.Res.sw_hdrtmo_clipratio0 = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_clipratio0; tmo_param->result.Res.sw_hdrtmo_clipratio1 = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_clipratio1; tmo_param->result.Res.sw_hdrtmo_clipgap0 = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_clipgap0; tmo_param->result.Res.sw_hdrtmo_clipgap1 = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_clipgap1; tmo_param->result.Res.sw_hdrtmo_ratiol = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_ratiol; tmo_param->result.Res.sw_hdrtmo_hist_min = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_hist_min; tmo_param->result.Res.sw_hdrtmo_hist_low = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_hist_low; tmo_param->result.Res.sw_hdrtmo_hist_high = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_hist_high; tmo_param->result.Res.sw_hdrtmo_hist_0p3 = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_hist_0p3; tmo_param->result.Res.sw_hdrtmo_hist_shift = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_hist_shift; tmo_param->result.Res.sw_hdrtmo_palpha_0p18 = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_palpha_0p18; tmo_param->result.Res.sw_hdrtmo_palpha_lw0p5 = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_palpha_lw0p5; tmo_param->result.Res.sw_hdrtmo_palpha_lwscl = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_palpha_lwscl; tmo_param->result.Res.sw_hdrtmo_maxpalpha = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_maxpalpha; tmo_param->result.Res.sw_hdrtmo_maxgain = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_maxgain; tmo_param->result.Res.sw_hdrtmo_cfg_alpha = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_cfg_alpha; tmo_param->result.Res.sw_hdrtmo_set_gainoff = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_gainoff; tmo_param->result.Res.sw_hdrtmo_set_lgmin = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_lgmin; tmo_param->result.Res.sw_hdrtmo_set_lgmax = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_lgmax; tmo_param->result.Res.sw_hdrtmo_set_lgmean = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_lgmean; tmo_param->result.Res.sw_hdrtmo_set_weightkey = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_weightkey; tmo_param->result.Res.sw_hdrtmo_set_lgrange0 = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_lgrange0; tmo_param->result.Res.sw_hdrtmo_set_lgrange1 = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_lgrange1; tmo_param->result.Res.sw_hdrtmo_set_lgavgmax = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_lgavgmax; tmo_param->result.Res.sw_hdrtmo_set_palpha = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_set_palpha; tmo_param->result.Res.sw_hdrtmo_gain_ld_off1 = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_gain_ld_off1; tmo_param->result.Res.sw_hdrtmo_gain_ld_off2 = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_gain_ld_off2; tmo_param->result.Res.sw_hdrtmo_cnt_vsize = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_cnt_vsize; tmo_param->result.Res.sw_hdrtmo_big_en = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_big_en; tmo_param->result.Res.sw_hdrtmo_nobig_en = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_nobig_en; tmo_param->result.Res.sw_hdrtmo_newhist_en = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_newhist_en; tmo_param->result.Res.sw_hdrtmo_cnt_mode = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_cnt_mode; tmo_param->result.Res.sw_hdrtmo_expl_lgratio = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_expl_lgratio; tmo_param->result.Res.sw_hdrtmo_lgscl_ratio = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_lgscl_ratio; tmo_param->result.LongFrameMode = atmo_rk->AtmoProcRes.Res.sw_hdrtmo_lgscl_ratio; tmo_param->result.isHdrGlobalTmo = atmo_rk->AtmoProcRes.isHdrGlobalTmo; tmo_param->result.bTmoEn = atmo_rk->AtmoProcRes.bTmoEn; tmo_param->result.isLinearTmo = atmo_rk->AtmoProcRes.isLinearTmo; tmo_param->result.TmoFlicker.GlobalTmoStrengthDown = atmo_rk->AtmoProcRes.TmoFlicker.GlobalTmoStrengthDown; tmo_param->result.TmoFlicker.GlobalTmoStrength = atmo_rk->AtmoProcRes.TmoFlicker.GlobalTmoStrength; tmo_param->result.TmoFlicker.iir = atmo_rk->AtmoProcRes.TmoFlicker.iir; tmo_param->result.TmoFlicker.iirmax = atmo_rk->AtmoProcRes.TmoFlicker.iirmax; tmo_param->result.TmoFlicker.height = atmo_rk->AtmoProcRes.TmoFlicker.height; tmo_param->result.TmoFlicker.width = atmo_rk->AtmoProcRes.TmoFlicker.width; tmo_param->result.TmoFlicker.PredictK.correction_factor = atmo_rk->AtmoProcRes.TmoFlicker.PredictK.correction_factor; tmo_param->result.TmoFlicker.PredictK.correction_offset = atmo_rk->AtmoProcRes.TmoFlicker.PredictK.correction_offset; tmo_param->result.TmoFlicker.PredictK.Hdr3xLongPercent = atmo_rk->AtmoProcRes.TmoFlicker.PredictK.Hdr3xLongPercent; tmo_param->result.TmoFlicker.PredictK.UseLongUpTh = atmo_rk->AtmoProcRes.TmoFlicker.PredictK.UseLongUpTh; tmo_param->result.TmoFlicker.PredictK.UseLongLowTh = atmo_rk->AtmoProcRes.TmoFlicker.PredictK.UseLongLowTh; for(int i = 0; i < 3; i++) tmo_param->result.TmoFlicker.LumaDeviation[i] = atmo_rk->AtmoProcRes.TmoFlicker.LumaDeviation[i]; tmo_param->result.TmoFlicker.StableThr = atmo_rk->AtmoProcRes.TmoFlicker.StableThr; } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAnrResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ANR); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAnr* anr_com = shared->procResComb.anr_proc_res; if (!anr_com /*|| !params->mIsppOtherParams.ptr()*/) { LOGD_ANALYZER("no anr result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen anr common result int algo_id = (*handle)->getAlgoId(); // gen rk anr result if (algo_id == 0) { RkAiqAlgoProcResAnrInt* anr_rk = (RkAiqAlgoProcResAnrInt*)anr_com; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = static_cast(params->mIspMeasParams->data().ptr()); LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__); memcpy(&isp_param->rkaiq_anr_proc_res.stBayernrParamSelect, &anr_rk->stAnrProcResult.stBayernrParamSelect, sizeof(RKAnr_Bayernr_Params_Select_t)); memcpy(&isp_param->rkaiq_anr_proc_res.stUvnrParamSelect, &anr_rk->stAnrProcResult.stUvnrParamSelect, sizeof(RKAnr_Uvnr_Params_Select_t)); memcpy(&isp_param->rkaiq_anr_proc_res.stMfnrParamSelect, &anr_rk->stAnrProcResult.stMfnrParamSelect, sizeof(RKAnr_Mfnr_Params_Select_t)); memcpy(&isp_param->rkaiq_anr_proc_res.stYnrParamSelect, &anr_rk->stAnrProcResult.stYnrParamSelect, sizeof(RKAnr_Ynr_Params_Select_t)); LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__); #else LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__); rk_aiq_isp_rawnr_params_v20_t *rawnr_params = params->mRawnrParams->data().ptr(); rawnr_params ->update_mask |= RKAIQ_ISPP_NR_ID; memcpy(&rawnr_params->result, &anr_rk->stAnrProcResult.stBayernrFix, sizeof(rk_aiq_isp_rawnr_t)); setResultExpectedEffId(rawnr_params->frame_id, RK_AIQ_ALGO_TYPE_ANR); rk_aiq_isp_gain_params_v20_t *gain_params = params->mGainParams->data().ptr(); memcpy(&gain_params->result, &anr_rk->stAnrProcResult.stGainFix, sizeof(rk_aiq_isp_gain_t)); setResultExpectedEffId(gain_params->frame_id, RK_AIQ_ALGO_TYPE_ANR); rk_aiq_isp_motion_params_v20_t *motion_params = params->mMotionParams->data().ptr(); memcpy(&motion_params->result, &anr_rk->stAnrProcResult.stMotion, sizeof(anr_rk->stAnrProcResult.stMotion)); setResultExpectedEffId(motion_params->frame_id, RK_AIQ_ALGO_TYPE_ANR); LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__); LOGD_ANR("oyyf: %s:%d output ispp param start\n", __FUNCTION__, __LINE__); rk_aiq_isp_ynr_params_v20_t *ynr_params = params->mYnrParams->data().ptr(); memcpy(&ynr_params->result, &anr_rk->stAnrProcResult.stYnrFix, sizeof(RKAnr_Ynr_Fix_t)); setResultExpectedEffId(ynr_params->frame_id, RK_AIQ_ALGO_TYPE_ANR); rk_aiq_isp_uvnr_params_v20_t *uvnr_params = params->mUvnrParams->data().ptr(); uvnr_params ->update_mask |= RKAIQ_ISPP_NR_ID; memcpy(&uvnr_params->result, &anr_rk->stAnrProcResult.stUvnrFix, sizeof(RKAnr_Uvnr_Fix_t)); setResultExpectedEffId(uvnr_params->frame_id, RK_AIQ_ALGO_TYPE_ANR); rk_aiq_isp_tnr_params_v20_t *tnr_params = params->mTnrParams->data().ptr(); memcpy(&tnr_params->result, &anr_rk->stAnrProcResult.stMfnrFix, sizeof(RKAnr_Mfnr_Fix_t)); setResultExpectedEffId(tnr_params->frame_id, RK_AIQ_ALGO_TYPE_ANR); LOGD_ANR("oyyf: %s:%d output ispp param end \n", __FUNCTION__, __LINE__); #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAdhazResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ADHAZ); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAdhaz* adhaz_com = shared->procResComb.adhaz_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else rk_aiq_isp_dehaze_params_v20_t* dehaze_param = params->mDehazeParams->data().ptr(); #endif if (!adhaz_com) { LOGD_ANALYZER("no adhaz result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen adhaz common result RkAiqAlgoProcResAdhaz* adhaz_rk = (RkAiqAlgoProcResAdhaz*)adhaz_com; setResultExpectedEffId(dehaze_param->frame_id, RK_AIQ_ALGO_TYPE_ADHAZ); dehaze_param->result = adhaz_rk->AdehzeProcRes.ProcResV20; int algo_id = (*handle)->getAlgoId(); // gen rk adhaz result if (algo_id == 0) { RkAiqAlgoProcResAdhazInt* adhaz_rk = (RkAiqAlgoProcResAdhazInt*)adhaz_com; dehaze_param->result.enhance_en = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.enhance_en; dehaze_param->result.hist_chn = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.hist_chn; dehaze_param->result.hpara_en = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.hpara_en; dehaze_param->result.hist_en = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.hist_en; dehaze_param->result.dc_en = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.dc_en; dehaze_param->result.big_en = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.big_en; dehaze_param->result.nobig_en = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.nobig_en; dehaze_param->result.yblk_th = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.yblk_th; dehaze_param->result.yhist_th = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.yhist_th; dehaze_param->result.dc_max_th = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.dc_max_th; dehaze_param->result.dc_min_th = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.dc_min_th; dehaze_param->result.wt_max = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.wt_max; dehaze_param->result.bright_max = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.bright_max; dehaze_param->result.bright_min = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.bright_min; dehaze_param->result.tmax_base = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.tmax_base; dehaze_param->result.dark_th = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.dark_th; dehaze_param->result.air_max = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.air_max; dehaze_param->result.air_min = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.air_min; dehaze_param->result.tmax_max = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.tmax_max; dehaze_param->result.tmax_off = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.tmax_off; dehaze_param->result.hist_k = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.hist_k; dehaze_param->result.hist_th_off = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.hist_th_off; dehaze_param->result.hist_min = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.hist_min; dehaze_param->result.hist_gratio = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.hist_gratio; dehaze_param->result.hist_scale = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.hist_scale; dehaze_param->result.enhance_value = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.enhance_value; dehaze_param->result.iir_wt_sigma = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.iir_wt_sigma; dehaze_param->result.iir_sigma = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.iir_sigma; dehaze_param->result.stab_fnum = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.stab_fnum; dehaze_param->result.iir_tmax_sigma = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.iir_tmax_sigma; dehaze_param->result.iir_air_sigma = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.iir_air_sigma; dehaze_param->result.cfg_wt = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.cfg_wt; dehaze_param->result.cfg_air = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.cfg_air; dehaze_param->result.cfg_alpha = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.cfg_alpha; dehaze_param->result.cfg_gratio = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.cfg_gratio; dehaze_param->result.cfg_tmax = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.cfg_tmax; dehaze_param->result.dc_weitcur = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.dc_weitcur; dehaze_param->result.dc_thed = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.dc_thed; dehaze_param->result.sw_dhaz_dc_bf_h0 = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.sw_dhaz_dc_bf_h0; dehaze_param->result.sw_dhaz_dc_bf_h1 = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.sw_dhaz_dc_bf_h1; dehaze_param->result.sw_dhaz_dc_bf_h2 = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.sw_dhaz_dc_bf_h2; dehaze_param->result.sw_dhaz_dc_bf_h3 = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.sw_dhaz_dc_bf_h3; dehaze_param->result.sw_dhaz_dc_bf_h4 = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.sw_dhaz_dc_bf_h4; dehaze_param->result.sw_dhaz_dc_bf_h5 = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.sw_dhaz_dc_bf_h5; dehaze_param->result.air_weitcur = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.air_weitcur; dehaze_param->result.air_thed = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.air_thed; dehaze_param->result.air_bf_h0 = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.air_bf_h0; dehaze_param->result.air_bf_h1 = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.air_bf_h1; dehaze_param->result.air_bf_h2 = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.air_bf_h2; dehaze_param->result.gaus_h0 = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.gaus_h0; dehaze_param->result.gaus_h1 = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.gaus_h1; dehaze_param->result.gaus_h2 = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.gaus_h2; for(int i = 0; i < 6; i++) { dehaze_param->result.conv_t0[i] = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.conv_t0[i]; dehaze_param->result.conv_t1[i] = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.conv_t1[i]; dehaze_param->result.conv_t2[i] = adhaz_rk->adhaz_proc_res_com.AdehzeProcRes.ProcResV20.conv_t2[i]; } } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAsdResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ASD); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAsd* asd_com = shared->procResComb.asd_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else /* * rk_aiq_isp_other_params_v20_t* isp_param = * arams->mIspOtherParams->data().ptr(); */ #endif if (!asd_com) { LOGD_ANALYZER("no asd result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen asd common result int algo_id = (*handle)->getAlgoId(); // gen rk asd result if (algo_id == 0) { RkAiqAlgoProcResAsdInt* asd_rk = (RkAiqAlgoProcResAsdInt*)asd_com; #if 0 // flash test RkAiqAlgoPreResAsdInt* asd_pre_rk = (RkAiqAlgoPreResAsdInt*)shared->preResComb.asd_pre_res; if (asd_pre_rk->asd_result.fl_on) { fl_param->flash_mode = RK_AIQ_FLASH_MODE_TORCH; fl_param->power[0] = 1000; fl_param->strobe = true; } else { fl_param->flash_mode = RK_AIQ_FLASH_MODE_OFF; fl_param->power[0] = 0; fl_param->strobe = false; } #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAcpResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ACP); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAcp* acp_com = shared->procResComb.acp_proc_res; // #ifdef RK_SIMULATOR_HW #if 0 rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else rk_aiq_isp_cp_params_v20_t* cp_param = params->mCpParams->data().ptr(); setResultExpectedEffId(cp_param->frame_id, RK_AIQ_ALGO_TYPE_ACP); #endif if (!acp_com) { LOGD_ANALYZER("no acp result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen acp common result rk_aiq_acp_params_t* isp_cp = &cp_param->result; *isp_cp = acp_com->acp_res; int algo_id = (*handle)->getAlgoId(); // gen rk acp result if (algo_id == 0) { RkAiqAlgoProcResAcpInt* acp_rk = (RkAiqAlgoProcResAcpInt*)acp_com; #ifdef RK_SIMULATOR_HW #else #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAieResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AIE); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAie* aie_com = shared->procResComb.aie_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else rk_aiq_isp_ie_params_v20_t* ie_param = params->mIeParams->data().ptr(); setResultExpectedEffId(ie_param->frame_id, RK_AIQ_ALGO_TYPE_AIE); #endif if (!aie_com) { LOGD_ANALYZER("no aie result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen aie common result rk_aiq_isp_ie_t* isp_ie = &ie_param->result; isp_ie->base = aie_com->params; int algo_id = (*handle)->getAlgoId(); // gen rk aie result if (algo_id == 0) { RkAiqAlgoProcResAieInt* aie_rk = (RkAiqAlgoProcResAieInt*)aie_com; isp_ie->extra = aie_rk->params; #ifdef RK_SIMULATOR_HW #else #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAsharpResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ASHARP); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAsharp* asharp_com = shared->procResComb.asharp_proc_res; if (!asharp_com) { LOGD_ANALYZER("no asharp result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen asharp common result int algo_id = (*handle)->getAlgoId(); // gen rk asharp result if (algo_id == 0) { RkAiqAlgoProcResAsharpInt* asharp_rk = (RkAiqAlgoProcResAsharpInt*)asharp_com; #ifdef RK_SIMULATOR_HW #if 0 rk_aiq_isp_meas_params_v20_t* isp_meas_param = params->mIspMeasParams->data().ptr(); LOGD_ASHARP("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__); memcpy(&isp_meas_param->rkaiq_asharp_proc_res.stSharpParamSelect.rk_sharpen_params_selected_V1, &asharp_rk->stAsharpProcResult.stSharpParamSelect.rk_sharpen_params_selected_V1, sizeof(RKAsharp_Sharp_HW_Params_Select_t)); memcpy(&isp_meas_param->rkaiq_asharp_proc_res.stSharpParamSelect.rk_sharpen_params_selected_V2, &asharp_rk->stAsharpProcResult.stSharpParamSelect.rk_sharpen_params_selected_V2, sizeof(RKAsharp_Sharp_HW_V2_Params_Select_t)); memcpy(&isp_meas_param->rkaiq_asharp_proc_res.stSharpParamSelect.rk_sharpen_params_selected_V3, &asharp_rk->stAsharpProcResult.stSharpParamSelect.rk_sharpen_params_selected_V3, sizeof(RKAsharp_Sharp_HW_V3_Params_Select_t)); memcpy(&isp_meas_param->rkaiq_asharp_proc_res.stEdgefilterParamSelect, &asharp_rk->stAsharpProcResult.stEdgefilterParamSelect, sizeof(RKAsharp_EdgeFilter_Params_Select_t)); LOGD_ASHARP("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__); #endif #else // rk_aiq_ispp_other_params_t* ispp_other_param = // static_cast(params->mIsppOtherParams->data().ptr()); LOGD_ASHARP("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__); rk_aiq_isp_sharpen_params_v20_t *sharpen_params = params->mSharpenParams->data().ptr(); sharpen_params->update_mask |= RKAIQ_ISPP_SHARP_ID; setResultExpectedEffId(sharpen_params->frame_id, RK_AIQ_ALGO_TYPE_ASHARP); memcpy(&sharpen_params->result, &asharp_rk->stAsharpProcResult.stSharpFix, sizeof(rk_aiq_isp_sharpen_t)); rk_aiq_isp_edgeflt_params_v20_t *edgeflt_params = params->mEdgefltParams->data().ptr(); memcpy(&edgeflt_params->result, &asharp_rk->stAsharpProcResult.stEdgefltFix, sizeof(rk_aiq_isp_edgeflt_t)); setResultExpectedEffId(edgeflt_params->frame_id, RK_AIQ_ALGO_TYPE_ASHARP); LOGD_ASHARP("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__); #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspA3dlutResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_A3DLUT); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResA3dlut* a3dlut_com = shared->procResComb.a3dlut_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else rk_aiq_isp_lut3d_params_v20_t* lut3d_param = params->mLut3dParams->data().ptr(); setResultExpectedEffId(lut3d_param->frame_id, RK_AIQ_ALGO_TYPE_A3DLUT); #endif if (!a3dlut_com) { LOGD_ANALYZER("no a3dlut result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen a3dlut common result RkAiqAlgoProcResA3dlut* a3dlut_rk = (RkAiqAlgoProcResA3dlut*)a3dlut_com; lut3d_param->result = a3dlut_rk->lut3d_hw_conf; int algo_id = (*handle)->getAlgoId(); // gen rk a3dlut result if (algo_id == 0) { RkAiqAlgoProcResA3dlutInt* a3dlut_rk_int = (RkAiqAlgoProcResA3dlutInt*)a3dlut_com; #ifdef RK_SIMULATOR_HW #else #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAblcResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ABLC); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAblc* ablc_com = shared->procResComb.ablc_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else #if 0 rk_aiq_isp_other_params_v20_t* isp_param = params->mIspOtherParams->data().ptr(); #else rk_aiq_isp_blc_params_v20_t *blc_param = params->mBlcParams->data().ptr(); #endif #endif if (!ablc_com) { LOGD_ANALYZER("no ablc result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen ablc common result int algo_id = (*handle)->getAlgoId(); // gen rk ablc result if (algo_id == 0) { RkAiqAlgoProcResAblcInt* ablc_rk = (RkAiqAlgoProcResAblcInt*)ablc_com; #if 0 memcpy(&isp_param->blc, &ablc_rk->ablc_proc_res, sizeof(rk_aiq_isp_blc_t)); #else setResultExpectedEffId(blc_param->frame_id, RK_AIQ_ALGO_TYPE_ABLC); memcpy(&blc_param->result, &ablc_rk->ablc_proc_res, sizeof(rk_aiq_isp_blc_t)); #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAccmResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ACCM); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAccm* accm_com = shared->procResComb.accm_proc_res; #if 0 rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else rk_aiq_isp_ccm_params_v20_t* ccm_param = params->mCcmParams->data().ptr(); #endif if (!accm_com) { LOGD_ANALYZER("no accm result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen accm common result RkAiqAlgoProcResAccm* accm_rk = (RkAiqAlgoProcResAccm*)accm_com; setResultExpectedEffId(ccm_param->frame_id, RK_AIQ_ALGO_TYPE_ACCM); ccm_param->result = accm_rk->accm_hw_conf; int algo_id = (*handle)->getAlgoId(); // gen rk accm result if (algo_id == 0) { RkAiqAlgoProcResAccmInt* accm_rk_int = (RkAiqAlgoProcResAccmInt*)accm_com; } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAcgcResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ACGC); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAcgc* acgc_com = shared->procResComb.acgc_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else rk_aiq_isp_cgc_params_v20_t* cgc_param = params->mCgcParams->data().ptr(); setResultExpectedEffId(cgc_param->frame_id, RK_AIQ_ALGO_TYPE_ACGC); #endif if (!acgc_com) { LOGD_ANALYZER("no acgc result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen acgc common result int algo_id = (*handle)->getAlgoId(); // gen rk acgc result if (algo_id == 0) { RkAiqAlgoProcResAcgcInt* acgc_rk = (RkAiqAlgoProcResAcgcInt*)acgc_com; #ifdef RK_SIMULATOR_HW #else #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAdebayerResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ADEBAYER); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAdebayer* adebayer_com = shared->procResComb.adebayer_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else #if 0 rk_aiq_isp_other_params_v20_t* isp_param = params->mIspOtherParams->data().ptr(); #else rk_aiq_isp_debayer_params_v20_t* debayer_param = params->mDebayerParams->data().ptr(); #endif #endif if (!adebayer_com) { LOGD_ANALYZER("no adebayer result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen adebayer common result int algo_id = (*handle)->getAlgoId(); // gen rk adebayer result if (algo_id == 0) { RkAiqAlgoProcResAdebayerInt* adebayer_rk = (RkAiqAlgoProcResAdebayerInt*)adebayer_com; setResultExpectedEffId(debayer_param->frame_id, RK_AIQ_ALGO_TYPE_ADEBAYER); memcpy(&debayer_param->result, &adebayer_rk->debayerRes.config, sizeof(AdebayerConfig_t)); } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAdpccResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ADPCC); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAdpcc* adpcc_com = shared->procResComb.adpcc_proc_res; rk_aiq_isp_dpcc_params_v20_t *dpcc_param = params->mDpccParams->data().ptr(); #if 0 /* TODO: xuhf */ SmartPtr exp_param = params->mExposureParams->data(); #endif if (!adpcc_com) { LOGD_ANALYZER("no adpcc result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen adpcc common result int algo_id = (*handle)->getAlgoId(); #if 0 // gen rk adpcc result exp_param->SensorDpccInfo.enable = adpcc_com->SenDpccRes.enable; exp_param->SensorDpccInfo.cur_single_dpcc = adpcc_com->SenDpccRes.cur_single_dpcc; exp_param->SensorDpccInfo.cur_multiple_dpcc = adpcc_com->SenDpccRes.cur_multiple_dpcc; exp_param->SensorDpccInfo.total_dpcc = adpcc_com->SenDpccRes.total_dpcc; #endif if (algo_id == 0) { RkAiqAlgoProcResAdpccInt* adpcc_rk = (RkAiqAlgoProcResAdpccInt*)adpcc_com; LOGD_ADPCC("oyyf: %s:%d output dpcc param start\n", __FUNCTION__, __LINE__); #if 0 memcpy(&isp_param->dpcc, &adpcc_rk->stAdpccProcResult, sizeof(rk_aiq_isp_dpcc_t)); #else setResultExpectedEffId(dpcc_param->frame_id, RK_AIQ_ALGO_TYPE_ADPCC); memcpy(&dpcc_param->result, &adpcc_rk->stAdpccProcResult, sizeof(rk_aiq_isp_dpcc_t)); #endif LOGD_ADPCC("oyyf: %s:%d output dpcc param end\n", __FUNCTION__, __LINE__); } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAfecResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AFEC); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAfec* afec_com = shared->procResComb.afec_proc_res; // #ifdef RK_SIMULATOR_HW #if 0 if (!afec_com || !params->mIsppMeasParams.ptr()) { LOGD_ANALYZER("no afec result"); return XCAM_RETURN_NO_ERROR; } rk_aiq_ispp_meas_params_t* ispp_param = params->mIsppMeasParams->data().ptr(); #else if (!afec_com) { LOGD_ANALYZER("no afec result"); return XCAM_RETURN_NO_ERROR; } rk_aiq_isp_fec_params_v20_t *fec_params = params->mFecParams->data().ptr(); #endif if (fec_params->result.usage == ISPP_MODULE_FEC_ST) { LOGD_ANALYZER("afec not update because EIS enabled"); return XCAM_RETURN_NO_ERROR; } // TODO: gen afec common result int algo_id = (*handle)->getAlgoId(); // gen rk afec result if (algo_id == 0) { RkAiqAlgoProcResAfecInt* afec_rk = (RkAiqAlgoProcResAfecInt*)afec_com; setResultExpectedEffId(fec_params->frame_id, RK_AIQ_ALGO_TYPE_AFEC); if (afec_rk->afec_result.update) { fec_params->update_mask |= RKAIQ_ISPP_FEC_ID; fec_params->result.fec_en = afec_rk->afec_result.sw_fec_en; if (fec_params->result.fec_en) { fec_params->result.crop_en = afec_rk->afec_result.crop_en; fec_params->result.crop_width = afec_rk->afec_result.crop_width; fec_params->result.crop_height = afec_rk->afec_result.crop_height; fec_params->result.mesh_density = afec_rk->afec_result.mesh_density; fec_params->result.mesh_size = afec_rk->afec_result.mesh_size; fec_params->result.mesh_buf_fd = afec_rk->afec_result.mesh_buf_fd; //memcpy(fec_params->result.sw_mesh_xi, afec_rk->afec_result.meshxi, sizeof(fec_params->result.sw_mesh_xi)); //memcpy(fec_params->result.sw_mesh_xf, afec_rk->afec_result.meshxf, sizeof(fec_params->result.sw_mesh_xf)); //memcpy(fec_params->result.sw_mesh_yi, afec_rk->afec_result.meshyi, sizeof(fec_params->result.sw_mesh_yi)); //memcpy(fec_params->result.sw_mesh_yf, afec_rk->afec_result.meshyf, sizeof(fec_params->result.sw_mesh_yf)); } } else { fec_params->update_mask &= ~RKAIQ_ISPP_FEC_ID; } } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAgammaResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AGAMMA); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAgamma* agamma_com = shared->procResComb.agamma_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else rk_aiq_isp_agamma_params_v20_t* agamma_param = params->mAgammaParams->data().ptr(); #endif if (!agamma_com) { LOGD_ANALYZER("no agamma result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen agamma common result RkAiqAlgoProcResAgamma* agamma_rk = (RkAiqAlgoProcResAgamma*)agamma_com; setResultExpectedEffId(agamma_param->frame_id, RK_AIQ_ALGO_TYPE_AGAMMA); agamma_param->result = agamma_rk->agamma_proc_res; int algo_id = (*handle)->getAlgoId(); // gen rk agamma result if (algo_id == 0) { RkAiqAlgoProcResAgammaInt* agamma_rk = (RkAiqAlgoProcResAgammaInt*)agamma_com; } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAdegammaResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ADEGAMMA); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAdegamma* adegamma_com = shared->procResComb.adegamma_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else rk_aiq_isp_adegamma_params_v20_t* degamma_param = params->mAdegammaParams->data().ptr(); #endif if (!adegamma_com) { LOGD_ANALYZER("no adegamma result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen agamma common result RkAiqAlgoProcResAdegamma* adegamma_rk = (RkAiqAlgoProcResAdegamma*)adegamma_com; setResultExpectedEffId(degamma_param->frame_id, RK_AIQ_ALGO_TYPE_ADEGAMMA); degamma_param->result = adegamma_rk->adegamma_proc_res; int algo_id = (*handle)->getAlgoId(); // gen rk adegamma result if (algo_id == 0) { RkAiqAlgoProcResAdegammaInt* adegamma_rk = (RkAiqAlgoProcResAdegammaInt*)adegamma_com; } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAgicResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AGIC); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAgic* agic_com = shared->procResComb.agic_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else #if 0 rk_aiq_isp_other_params_v20_t* isp_param = params->mIspOtherParams->data().ptr(); #else rk_aiq_isp_gic_params_v20_t* gic_param = params->mGicParams->data().ptr(); #endif #endif if (!agic_com) { LOGD_ANALYZER("no agic result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen agic common result int algo_id = (*handle)->getAlgoId(); // gen rk agic result if (algo_id == 0) { RkAiqAlgoProcResAgicInt* agic_rk = (RkAiqAlgoProcResAgicInt*)agic_com; setResultExpectedEffId(gic_param->frame_id, RK_AIQ_ALGO_TYPE_AGIC); memcpy(&gic_param->result, &agic_rk->gicRes, sizeof(AgicProcResult_t)); } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAldchResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ALDCH); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAldch* aldch_com = shared->procResComb.aldch_proc_res; #if 0 // #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else rk_aiq_isp_ldch_params_v20_t* ldch_param = params->mLdchParams->data().ptr(); #endif if (!aldch_com) { LOGD_ANALYZER("no aldch result"); return XCAM_RETURN_NO_ERROR; } RkAiqAlgoProcResAldchInt* aldch_rk = (RkAiqAlgoProcResAldchInt*)aldch_com; setResultExpectedEffId(ldch_param->frame_id, RK_AIQ_ALGO_TYPE_ALDCH); if (aldch_rk->ldch_result.update) { ldch_param->update_mask |= RKAIQ_ISP_LDCH_ID; ldch_param->result.ldch_en = aldch_rk->ldch_result.sw_ldch_en; if (ldch_param->result.ldch_en) { ldch_param->result.lut_h_size = aldch_rk->ldch_result.lut_h_size; ldch_param->result.lut_v_size = aldch_rk->ldch_result.lut_v_size; ldch_param->result.lut_size = aldch_rk->ldch_result.lut_map_size; ldch_param->result.lut_mem_fd = aldch_rk->ldch_result.lut_mapxy_buf_fd; } } else { ldch_param->update_mask &= ~RKAIQ_ISP_LDCH_ID; } int algo_id = (*handle)->getAlgoId(); // gen rk aldch result if (algo_id == 0) { RkAiqAlgoProcResAldchInt* aldch_rk = (RkAiqAlgoProcResAldchInt*)aldch_com; } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAlscResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ALSC); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAlsc* alsc_com = shared->procResComb.alsc_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else #if 0 rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else rk_aiq_isp_lsc_params_v20_t* lsc_param = params->mLscParams->data().ptr(); #endif #endif if (!alsc_com) { LOGD_ANALYZER("no alsc result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen alsc common result RkAiqAlgoProcResAlsc* alsc_rk = (RkAiqAlgoProcResAlsc*)alsc_com; setResultExpectedEffId(lsc_param->frame_id, RK_AIQ_ALGO_TYPE_ALSC); lsc_param->result = alsc_rk->alsc_hw_conf; if(mAlogsComSharedParams.sns_mirror) { for(int i = 0; i < LSC_DATA_TBL_V_SIZE; i++) { for(int j = 0; j < LSC_DATA_TBL_H_SIZE; j++) { SWAP(unsigned short, lsc_param->result.r_data_tbl[i * LSC_DATA_TBL_H_SIZE + j], lsc_param->result.r_data_tbl[i * LSC_DATA_TBL_H_SIZE + (LSC_DATA_TBL_H_SIZE - 1 - j)]); SWAP(unsigned short, lsc_param->result.gr_data_tbl[i * LSC_DATA_TBL_H_SIZE + j], lsc_param->result.gr_data_tbl[i * LSC_DATA_TBL_H_SIZE + (LSC_DATA_TBL_H_SIZE - 1 - j)]); SWAP(unsigned short, lsc_param->result.gb_data_tbl[i * LSC_DATA_TBL_H_SIZE + j], lsc_param->result.gb_data_tbl[i * LSC_DATA_TBL_H_SIZE + (LSC_DATA_TBL_H_SIZE - 1 - j)]); SWAP(unsigned short, lsc_param->result.b_data_tbl[i * LSC_DATA_TBL_H_SIZE + j], lsc_param->result.b_data_tbl[i * LSC_DATA_TBL_H_SIZE + (LSC_DATA_TBL_H_SIZE - 1 - j)]); } } } if(mAlogsComSharedParams.sns_flip) { for(int i = 0; i < LSC_DATA_TBL_V_SIZE; i++) { for(int j = 0; j < LSC_DATA_TBL_H_SIZE; j++) { SWAP(unsigned short, lsc_param->result.r_data_tbl[i * LSC_DATA_TBL_H_SIZE + j], lsc_param->result.r_data_tbl[(LSC_DATA_TBL_V_SIZE - 1 - i)*LSC_DATA_TBL_H_SIZE + j]); SWAP(unsigned short, lsc_param->result.gr_data_tbl[i * LSC_DATA_TBL_H_SIZE + j], lsc_param->result.gr_data_tbl[(LSC_DATA_TBL_V_SIZE - 1 - i)*LSC_DATA_TBL_H_SIZE + j]); SWAP(unsigned short, lsc_param->result.gb_data_tbl[i * LSC_DATA_TBL_H_SIZE + j], lsc_param->result.gb_data_tbl[(LSC_DATA_TBL_V_SIZE - 1 - i)*LSC_DATA_TBL_H_SIZE + j]); SWAP(unsigned short, lsc_param->result.b_data_tbl[i * LSC_DATA_TBL_H_SIZE + j], lsc_param->result.b_data_tbl[(LSC_DATA_TBL_V_SIZE - 1 - i)*LSC_DATA_TBL_H_SIZE + j]); } } } int algo_id = (*handle)->getAlgoId(); // gen rk alsc result if (algo_id == 0) { RkAiqAlgoProcResAlscInt* alsc_rk_int = (RkAiqAlgoProcResAlscInt*)alsc_com; } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAorbResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AORB); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAorb* aorb_com = shared->procResComb.aorb_proc_res; if (!aorb_com) { LOGE_ANALYZER("no aorb result"); return XCAM_RETURN_NO_ERROR; } int algo_id = (*handle)->getAlgoId(); // gen rk aorb result if (algo_id == 0) { RkAiqAlgoProcResAorbInt* aorb_rk = (RkAiqAlgoProcResAorbInt*)aorb_com; rk_aiq_isp_orb_params_v20_t *orb_params = params->mOrbParams->data().ptr(); if (orb_params != nullptr) { setResultExpectedEffId(orb_params->frame_id, RK_AIQ_ALGO_TYPE_AORB); if (aorb_rk->aorb_meas.update) { orb_params->update_mask |= RKAIQ_ISPP_ORB_ID; orb_params->result.orb_en = aorb_rk->aorb_meas.orb_en; if (orb_params->result.orb_en) { orb_params->result.limit_value = aorb_rk->aorb_meas.limit_value; orb_params->result.max_feature = aorb_rk->aorb_meas.max_feature; } } else { orb_params->update_mask &= ~RKAIQ_ISPP_ORB_ID; } } } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAeisResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AEIS); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAeis* aeis_com = shared->procResComb.aeis_proc_res; #ifdef RK_SIMULATOR_HW if (!aeis_com) { LOGD_ANALYZER("no aeis result"); return XCAM_RETURN_NO_ERROR; } #else if (!aeis_com) { LOGD_ANALYZER("no aeis result"); return XCAM_RETURN_NO_ERROR; } rk_aiq_isp_fec_params_v20_t *fec_params = params->mFecParams->data().ptr(); #endif int algo_id = (*handle)->getAlgoId(); if (algo_id == 0) { RkAiqAlgoProcResAeisInt* aeis_rk = (RkAiqAlgoProcResAeisInt*)aeis_com; if (aeis_rk->update) { fec_params->update_mask |= ISPP_MODULE_FEC_ST; fec_params->result.fec_en = aeis_rk->fec_en; fec_params->result.usage = ISPP_MODULE_FEC_ST; if (fec_params->result.fec_en) { #if 1 if (1) { #else if (aeis_rk->fd >= 0) { #endif fec_params->result.config = true; fec_params->result.frame_id = aeis_rk->frame_id; fec_params->frame_id = aeis_rk->frame_id; fec_params->result.mesh_density = aeis_rk->mesh_density; fec_params->result.mesh_size = aeis_rk->mesh_size; fec_params->result.mesh_buf_fd = aeis_rk->fd; fec_params->result.img_buf_index = aeis_rk->img_buf_index; fec_params->result.img_buf_size = aeis_rk->img_size; } else { fec_params->result.config = false; } } else { fec_params->update_mask &= ~ISPP_MODULE_FEC_ST; } } LOGD_AEIS("eis update %d, id %d, fec: en %d, config %d, fd %d, idx %d", aeis_rk->update, fec_params->result.frame_id, fec_params->result.fec_en, fec_params->result.config, fec_params->result.mesh_buf_fd, fec_params->result.img_buf_index); } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAr2yResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AR2Y); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAr2y* ar2y_com = shared->procResComb.ar2y_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else /* * rk_aiq_isp_other_params_v20_t* isp_param = * params->mIspOtherParams->data().ptr(); */ #endif if (!ar2y_com) { LOGD_ANALYZER("no ar2y result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen ar2y common result int algo_id = (*handle)->getAlgoId(); // gen rk ar2y result if (algo_id == 0) { RkAiqAlgoProcResAr2yInt* ar2y_rk = (RkAiqAlgoProcResAr2yInt*)ar2y_com; #ifdef RK_SIMULATOR_HW #else #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAwdrResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AWDR); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAwdr* awdr_com = shared->procResComb.awdr_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else rk_aiq_isp_wdr_params_v20_t* wdr_param = params->mWdrParams->data().ptr(); setResultExpectedEffId(wdr_param->frame_id, RK_AIQ_ALGO_TYPE_AWDR); #endif if (!awdr_com) { LOGD_ANALYZER("no awdr result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen awdr common result int algo_id = (*handle)->getAlgoId(); // gen rk awdr result if (algo_id == 0) { RkAiqAlgoProcResAwdrInt* awdr_rk = (RkAiqAlgoProcResAwdrInt*)awdr_com; #ifdef RK_SIMULATOR_HW #else #endif } EXIT_ANALYZER_FUNCTION(); return ret; } #if 0 XCamReturn RkAiqCore::genIspAdrcResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; RkAiqAlgosGroupShared_t* shared = nullptr; int groupId = getGroupId(RK_AIQ_ALGO_TYPE_ADRC); if (groupId >= 0) { if (getGroupSharedParams(groupId, shared) != XCAM_RETURN_NO_ERROR) return XCAM_RETURN_BYPASS; } else return XCAM_RETURN_BYPASS; RkAiqAlgoProcResAdrc* adrc_com = shared->procResComb.adrc_proc_res; rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); if (!adrc_com) { LOGD_ANALYZER("no adrc result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen ahdr common result SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ADRC); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } int algo_id = (*handle)->getAlgoId(); // gen rk ahdr result if (algo_id == 0) { RkAiqAlgoProcResAdrcInt* ahdr_rk = (RkAiqAlgoProcResAdrcInt*)adrc_com; isp_param->drc.DrcProcRes.sw_drc_offset_pow2 = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_offset_pow2; isp_param->drc.DrcProcRes.sw_drc_compres_scl = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_compres_scl; isp_param->drc.DrcProcRes.sw_drc_position = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_position; isp_param->drc.DrcProcRes.sw_drc_delta_scalein = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_delta_scalein; isp_param->drc.DrcProcRes.sw_drc_hpdetail_ratio = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_hpdetail_ratio; isp_param->drc.DrcProcRes.sw_drc_lpdetail_ratio = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_lpdetail_ratio; isp_param->drc.DrcProcRes.sw_drc_weicur_pix = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_weicur_pix; isp_param->drc.DrcProcRes.sw_drc_weipre_frame = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_weipre_frame; isp_param->drc.DrcProcRes.sw_drc_force_sgm_inv0 = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_force_sgm_inv0; isp_param->drc.DrcProcRes.sw_drc_motion_scl = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_motion_scl; isp_param->drc.DrcProcRes.sw_drc_edge_scl = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_edge_scl; isp_param->drc.DrcProcRes.sw_drc_space_sgm_inv1 = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_space_sgm_inv1; isp_param->drc.DrcProcRes.sw_drc_space_sgm_inv0 = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_range_sgm_inv1; isp_param->drc.DrcProcRes.sw_drc_range_sgm_inv1 = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_range_sgm_inv0; isp_param->drc.DrcProcRes.sw_drc_range_sgm_inv0 = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_space_sgm_inv0; isp_param->drc.DrcProcRes.sw_drc_weig_maxl = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_weig_maxl; isp_param->drc.DrcProcRes.sw_drc_weig_bilat = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_weig_bilat; isp_param->drc.DrcProcRes.sw_drc_iir_weight = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_iir_weight; isp_param->drc.DrcProcRes.sw_drc_min_ogain = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_min_ogain; for(int i = 0; i < 17; i++) { isp_param->drc.DrcProcRes.sw_drc_gain_y[i] = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_gain_y[i]; isp_param->drc.DrcProcRes.sw_drc_compres_y[i] = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_compres_y[i]; isp_param->drc.DrcProcRes.sw_drc_scale_y[i] = ahdr_rk->AdrcProcRes.DrcProcRes.sw_drc_scale_y[i]; } isp_param->drc.isHdrGlobalTmo = ahdr_rk->AdrcProcRes.isHdrGlobalTmo; isp_param->drc.bTmoEn = ahdr_rk->AdrcProcRes.bTmoEn; isp_param->drc.isLinearTmo = ahdr_rk->AdrcProcRes.isLinearTmo; LOGE("sw_drc_offset_pow2 %d", isp_param->drc.DrcProcRes.sw_drc_offset_pow2); LOGE("sw_drc_compres_scl %d", isp_param->drc.DrcProcRes.sw_drc_compres_scl); LOGE("sw_drc_position %d", isp_param->drc.DrcProcRes.sw_drc_position); LOGE("sw_drc_delta_scalein %d", isp_param->drc.DrcProcRes.sw_drc_delta_scalein); LOGE("sw_drc_hpdetail_ratio %d", isp_param->drc.DrcProcRes.sw_drc_hpdetail_ratio); LOGE("sw_drc_lpdetail_ratio %d", isp_param->drc.DrcProcRes.sw_drc_lpdetail_ratio); LOGE("sw_drc_weicur_pix %d", isp_param->drc.DrcProcRes.sw_drc_weicur_pix); } EXIT_ANALYZER_FUNCTION(); return ret; } #endif XCamReturn RkAiqCore::genIspAmdResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AMD); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAmd* amd_com = shared->procResComb.amd_proc_res; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_param = params->mIspMeasParams->data().ptr(); #else rk_aiq_isp_md_params_v20_t* md_param = params->mMdParams->data().ptr(); setResultExpectedEffId(md_param->frame_id, RK_AIQ_ALGO_TYPE_AMD); #endif if (!amd_com) { LOGD_ANALYZER("no amd result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen amd common result md_param->result = amd_com->amd_proc_res; int algo_id = (*handle)->getAlgoId(); // gen rk amd result if (algo_id == 0) { RkAiqAlgoProcResAmdInt* amd_rk = (RkAiqAlgoProcResAmdInt*)amd_com; #ifdef RK_SIMULATOR_HW #else #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspArawnrResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ARAWNR); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResArawnr* arawnr_com = shared->procResComb.arawnr_proc_res; if (!arawnr_com) { LOGD_ANALYZER("no asharp result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen asharp common result int algo_id = (*handle)->getAlgoId(); // gen rk asharp result if (algo_id == 0) { RkAiqAlgoProcResArawnrInt* arawnr_rk = (RkAiqAlgoProcResArawnrInt*)arawnr_com; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_meas_param = static_cast(params->mIspMeasParams->data().ptr()); LOGD_ASHARP("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__); memcpy(&isp_param->rkaiq_anr_proc_res.stBayernrParamSelect, &arawnr_rk->stArawnrProcResult.stSelect, sizeof(RK_Bayernr_Params_Select_V1_t)); LOGD_ASHARP("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__); #else if (params->mRawnrParams.ptr()) { rk_aiq_isp_rawnr_params_v20_t* rawnr_param = params->mRawnrParams->data().ptr(); LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__); setResultExpectedEffId(rawnr_param->frame_id, RK_AIQ_ALGO_TYPE_ARAWNR); memcpy(&rawnr_param->result, &arawnr_rk->stArawnrProcResult.stFix, sizeof(RK_Bayernr_Fix_V1_t)); } LOGD_ASHARP("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__); #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAynrResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AYNR); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAynr* aynr_com = shared->procResComb.aynr_proc_res; if (!aynr_com) { LOGD_ANALYZER("no asharp result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen asharp common result int algo_id = (*handle)->getAlgoId(); // gen rk asharp result if (algo_id == 0) { RkAiqAlgoProcResAynrInt* aynr_rk = (RkAiqAlgoProcResAynrInt*)aynr_com; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_meas_param = static_cast(params->mIspMeasParams->data().ptr()); LOGD_ASHARP("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__); memcpy(&isp_param->rkaiq_anr_proc_res.stYnrParamSelect, &aynr_rk->stAynrProcResult.stSelect, sizeof(RK_YNR_Params_V1_Select_t)); LOGD_ASHARP("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__); #else if (params->mYnrParams.ptr()) { rk_aiq_isp_ynr_params_v20_t* ynr_param = params->mYnrParams->data().ptr(); LOGD_ANR("oyyf: %s:%d output ispp param start\n", __FUNCTION__, __LINE__); setResultExpectedEffId(ynr_param->frame_id, RK_AIQ_ALGO_TYPE_AYNR); memcpy(&ynr_param->result, &aynr_rk->stAynrProcResult.stFix, sizeof(RK_YNR_Fix_V1_t)); } LOGD_ASHARP("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__); #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAcnrResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ACNR); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAcnr* acnr_com = shared->procResComb.acnr_proc_res; if (!acnr_com) { LOGD_ANALYZER("no asharp result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen asharp common result int algo_id = (*handle)->getAlgoId(); // gen rk asharp result if (algo_id == 0) { RkAiqAlgoProcResAcnrInt* acnr_rk = (RkAiqAlgoProcResAcnrInt*)acnr_com; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_meas_param = static_cast(params->mIspMeasParams->data().ptr()); LOGD_ASHARP("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__); memcpy(&isp_param->rkaiq_anr_proc_res.stUvnrParamSelect, &acnr_rk->stAuvnrProcResult.stSelect, sizeof(RK_UVNR_Params_V1_Select_t)); LOGD_ASHARP("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__); #else if (params->mUvnrParams.ptr()) { rk_aiq_isp_uvnr_params_v20_t* cnr_param = params->mUvnrParams->data().ptr(); LOGD_ANR("oyyf: %s:%d output ispp param start\n", __FUNCTION__, __LINE__); setResultExpectedEffId(cnr_param->frame_id, RK_AIQ_ALGO_TYPE_ACNR); cnr_param->update_mask |= RKAIQ_ISPP_NR_ID; memcpy(&cnr_param->result, &acnr_rk->stAuvnrProcResult.stFix, sizeof(RK_UVNR_Fix_V1_t)); } LOGD_ASHARP("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__); #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAmfnrResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AMFNR); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAmfnr* amfnr_com = shared->procResComb.amfnr_proc_res; if (!amfnr_com) { LOGD_ANALYZER("no asharp result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen asharp common result int algo_id = (*handle)->getAlgoId(); // gen rk asharp result if (algo_id == 0) { RkAiqAlgoProcResAmfnrInt* amfnr_rk = (RkAiqAlgoProcResAmfnrInt*)amfnr_com; #ifdef RK_SIMULATOR_HW rk_aiq_isp_meas_params_v20_t* isp_meas_param = static_cast(params->mIspMeasParams->data().ptr()); LOGD_ASHARP("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__); memcpy(&isp_param->rkaiq_anr_proc_res.stMfnrParamSelect, &amfnr_rk->stAmfnrProcResult.stSelect, sizeof(RK_MFNR_Params_V1_Select_t)); LOGD_ASHARP("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__); #else if (params->mTnrParams.ptr()) { rk_aiq_isp_tnr_params_v20_t* tnr_param = params->mTnrParams->data().ptr(); LOGD_ANR("oyyf: %s:%d output ispp param start\n", __FUNCTION__, __LINE__); setResultExpectedEffId(tnr_param->frame_id, RK_AIQ_ALGO_TYPE_AMFNR); tnr_param->update_mask |= RKAIQ_ISPP_TNR_ID; memcpy(&tnr_param->result, &amfnr_rk->stAmfnrProcResult.stFix, sizeof(RK_MFNR_Fix_V1_t)); } LOGD_ASHARP("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__); #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::genIspAgainResult(RkAiqFullParams* params) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr* handle = getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AGAIN); if (handle == nullptr) { return XCAM_RETURN_BYPASS; } RkAiqCore::RkAiqAlgosGroupShared_t* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)((*handle)->getGroupShared()); RkAiqAlgoProcResAgain* again_com = shared->procResComb.again_proc_res; if (!again_com) { LOGD_ANALYZER("no asharp result"); return XCAM_RETURN_NO_ERROR; } // TODO: gen asharp common result int algo_id = (*handle)->getAlgoId(); // gen rk asharp result if (algo_id == 0) { RkAiqAlgoProcResAgainInt* again_rk = (RkAiqAlgoProcResAgainInt*)again_com; #ifdef RK_SIMULATOR_HW #else if (params->mGainParams.ptr()) { rk_aiq_isp_gain_params_v20_t* gain_param = params->mGainParams->data().ptr(); setResultExpectedEffId(gain_param ->frame_id, RK_AIQ_ALGO_TYPE_AGAIN); LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__); memcpy(&gain_param->result, &again_rk->stAgainProcResult.stFix, sizeof(RK_GAIN_Fix_V1_t)); } LOGD_ASHARP("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__); #endif } EXIT_ANALYZER_FUNCTION(); return ret; } XCamReturn RkAiqCore::pushStats(SmartPtr &buffer) { ENTER_ANALYZER_FUNCTION(); XCAM_ASSERT(buffer.ptr()); mRkAiqCoreTh->push_stats(buffer); EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::pushEvts(SmartPtr &evts) { ENTER_ANALYZER_FUNCTION(); XCAM_ASSERT(evts.ptr()); if (evts->evt_code == V4L2_EVENT_FRAME_SYNC) mRkAiqCoreEvtsTh->push_evts(evts); EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } const RkAiqHandle* RkAiqCore::getAiqAlgoHandle(const int algo_type) { SmartPtr* handlePtr = getCurAlgoTypeHandle(algo_type); if (handlePtr == nullptr) { return NULL; } return (*handlePtr).ptr(); } SmartPtr* RkAiqCore::getCurAlgoTypeHandle(int algo_type) { if (mCurAlgoHandleMaps.count(algo_type) > 0) return &mCurAlgoHandleMaps.at(algo_type); LOGE("can't find algo handle %d", algo_type); return NULL; } std::map>* RkAiqCore::getAlgoTypeHandleMap(int algo_type) { if (mAlgoHandleMaps.count(algo_type) > 0) return &mAlgoHandleMaps.at(algo_type); LOGE("can't find algo map %d", algo_type); return NULL; } void RkAiqCore::addDefaultAlgos(const struct RkAiqAlgoDesCommExt* algoDes) { map> algoMap; for (int i = 0; i < RK_AIQ_ALGO_TYPE_MAX; i++) { mAlogsComSharedParams.ctxCfigs[i].calib = const_cast(mAlogsComSharedParams.calib); mAlogsComSharedParams.ctxCfigs[i].calibv2 = const_cast(mAlogsComSharedParams.calibv2); mAlogsComSharedParams.ctxCfigs[i].cfg_com.isp_hw_version = mIspHwVer; } for (size_t i = 0; algoDes[i].des != NULL; i++) { int algo_type = algoDes[i].des->type; // enable only the specified algorithm modules if (!(1 << algo_type & mCustomEnAlgosMask)) continue; int32_t grpMask = 1ULL << algoDes[i].group; mAlogsComSharedParams.ctxCfigs[algo_type].calib = const_cast(mAlogsComSharedParams.calib); mAlogsComSharedParams.ctxCfigs[algo_type].calibv2 = const_cast(mAlogsComSharedParams.calibv2); mAlogsComSharedParams.ctxCfigs[algo_type].cfg_com.module_hw_version = algoDes[i].module_hw_ver; mAlgoTypeToGrpMaskMap[algo_type] = grpMask; bool isExist = false; for(auto it = mAlogsGroupList.begin();it != mAlogsGroupList.end();it++){ if (*it == algoDes[i].group) isExist = true; } if (!isExist) { mAlogsGroupList.push_back(algoDes[i].group); auto groupId = algoDes[i].group; mAlogsGroupSharedParamsMap[grpMask] = new RkAiqAlgosGroupShared_t; mAlogsGroupSharedParamsMap[grpMask]->reset(); mAlogsGroupSharedParamsMap[grpMask]->groupId = algoDes[i].group; mAlogsGroupSharedParamsMap[grpMask]->frameId = 0; mAlogsGroupSharedParamsMap[grpMask]->ispStats = NULL; } algoMap[0] = newAlgoHandle(algoDes[i].des, false, algoDes[i].algo_ver); if (!algoMap[0].ptr()) { LOGE_ANALYZER("new algo_type %d handle failed", algo_type); continue; } algoMap[0]->setGroupId(grpMask); algoMap[0]->setGroupShared(mAlogsGroupSharedParamsMap[grpMask]); mAlgoHandleMaps[algo_type] = algoMap; mCurIspAlgoHandleList.push_back(algoMap[0]); mCurAlgoHandleMaps[algo_type] = algoMap[0]; enableAlgo(algo_type, 0, true); algoMap.clear(); } } SmartPtr RkAiqCore::newAlgoHandle(RkAiqAlgoDesComm* algo, bool generic, int version) { #define NEW_ALGO_HANDLE(lc, BC) \ if (algo->type == RK_AIQ_ALGO_TYPE_##BC) { \ if (generic) { \ if (version == 0) \ return new RkAiq##lc##Handle(algo, this); \ } else { \ if (version == 0) \ return new RkAiq##lc##HandleInt(algo, this); \ }\ }\ NEW_ALGO_HANDLE(Ae, AE); NEW_ALGO_HANDLE(Awb, AWB); NEW_ALGO_HANDLE(Af, AF); NEW_ALGO_HANDLE(Amerge, AMERGE); NEW_ALGO_HANDLE(Atmo, ATMO); NEW_ALGO_HANDLE(Anr, ANR); NEW_ALGO_HANDLE(Adhaz, ADHAZ); NEW_ALGO_HANDLE(Asd, ASD); NEW_ALGO_HANDLE(Acp, ACP); NEW_ALGO_HANDLE(Asharp, ASHARP); NEW_ALGO_HANDLE(A3dlut, A3DLUT); NEW_ALGO_HANDLE(Ablc, ABLC); NEW_ALGO_HANDLE(Accm, ACCM); NEW_ALGO_HANDLE(Acgc, ACGC); NEW_ALGO_HANDLE(Adebayer, ADEBAYER); NEW_ALGO_HANDLE(Adpcc, ADPCC); NEW_ALGO_HANDLE(Afec, AFEC); NEW_ALGO_HANDLE(Agamma, AGAMMA); NEW_ALGO_HANDLE(Agic, AGIC); NEW_ALGO_HANDLE(Aie, AIE); NEW_ALGO_HANDLE(Aldch, ALDCH); NEW_ALGO_HANDLE(Alsc, ALSC); NEW_ALGO_HANDLE(Aorb, AORB); NEW_ALGO_HANDLE(Ar2y, AR2Y); NEW_ALGO_HANDLE(Awdr, AWDR); NEW_ALGO_HANDLE(Arawnr, ARAWNR); NEW_ALGO_HANDLE(Amfnr, AMFNR); NEW_ALGO_HANDLE(Aynr, AYNR); NEW_ALGO_HANDLE(Acnr, ACNR); NEW_ALGO_HANDLE(Adrc, ADRC); NEW_ALGO_HANDLE(Adegamma, ADEGAMMA); NEW_ALGO_HANDLE(Aeis, AEIS); NEW_ALGO_HANDLE(Amd, AMD); NEW_ALGO_HANDLE(Again, AGAIN); return NULL; } XCamReturn RkAiqCore::addAlgo(RkAiqAlgoDesComm& algo) { ENTER_ANALYZER_FUNCTION(); std::map>* algo_map = getAlgoTypeHandleMap(algo.type); if (!algo_map) { LOGE_ANALYZER("do not support this algo type %d !", algo.type); return XCAM_RETURN_ERROR_FAILED; } // TODO, check if exist befor insert ? std::map>::reverse_iterator rit = algo_map->rbegin(); algo.id = rit->first + 1; int i = 0; const struct RkAiqAlgoDesCommExt* def_des = NULL; while (mAlgosDesArray[i].des != NULL) { if (mAlgosDesArray[i].des->type == algo.type) { def_des = &mAlgosDesArray[i]; break; } i++; } // add to map SmartPtr new_hdl = newAlgoHandle(&algo, true, def_des->algo_ver); new_hdl->setEnable(false); (*algo_map)[algo.id] = new_hdl; EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::enableAlgo(int algoType, int id, bool enable) { ENTER_ANALYZER_FUNCTION(); // get current algotype handle, get id SmartPtr* cur_algo_hdl = getCurAlgoTypeHandle(algoType); if (!cur_algo_hdl) { LOGE_ANALYZER("can't find current type %d algo", algoType); return XCAM_RETURN_ERROR_FAILED; } std::map>* algo_map = getAlgoTypeHandleMap(algoType); NULL_RETURN_RET(algo_map, XCAM_RETURN_ERROR_FAILED); std::map>::iterator it = algo_map->find(id); bool switch_algo = false; if (it == algo_map->end()) { LOGE_ANALYZER("can't find type id <%d, %d> algo", algoType, id); return XCAM_RETURN_ERROR_FAILED; } it->second->setEnable(enable); /* WARNING: * Be careful when use SmartPtr = SmartPtr * if RkAiqxxxHandle is derived from multiple RkAiqHandle, * the ptr of RkAiqxxxHandle and RkAiqHandle IS NOT the same * (RkAiqHandle ptr = RkAiqxxxHandle ptr + offset), but seams like * SmartPtr do not deal with this correctly. */ if (enable) { SmartLock locker (mApiMutex); while (mSafeEnableAlgo != true) mApiMutexCond.wait(mApiMutex); if ((*cur_algo_hdl).ptr() && (*cur_algo_hdl).ptr() != it->second.ptr()) { (*cur_algo_hdl)->setEnable(false); switch_algo = true; } *cur_algo_hdl = it->second; for (auto& algo : mCurIspAlgoHandleList) { if (algo->getAlgoType() == algoType) algo = it->second; } for (auto& algo : mCurIsppAlgoHandleList) { if (algo->getAlgoType() == algoType) algo = it->second; } if (switch_algo && (mState >= RK_AIQ_CORE_STATE_PREPARED)) (*cur_algo_hdl)->prepare(); } EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::rmAlgo(int algoType, int id) { ENTER_ANALYZER_FUNCTION(); // can't remove default algos if (id == 0) return XCAM_RETURN_NO_ERROR; SmartPtr* cur_algo_hdl = getCurAlgoTypeHandle(algoType); if (!cur_algo_hdl) { LOGE_ANALYZER("can't find current type %d algo", algoType); return XCAM_RETURN_ERROR_FAILED; } std::map>* algo_map = getAlgoTypeHandleMap(algoType); NULL_RETURN_RET(algo_map, XCAM_RETURN_ERROR_FAILED); std::map>::iterator it = algo_map->find(id); if (it == algo_map->end()) { LOGE_ANALYZER("can't find type id <%d, %d> algo", algoType, id); return XCAM_RETURN_ERROR_FAILED; } // if it's the current algo handle, clear it if ((*cur_algo_hdl).ptr() == it->second.ptr()) { (*cur_algo_hdl).release(); for (auto& algo : mCurIspAlgoHandleList) { if (algo->getAlgoType() == algoType) algo.release(); } for (auto& algo : mCurIsppAlgoHandleList) { if (algo->getAlgoType() == algoType) algo.release(); } } algo_map->erase(it); EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } bool RkAiqCore::getAxlibStatus(int algoType, int id) { std::map>* algo_map = getAlgoTypeHandleMap(algoType); NULL_RETURN_RET(algo_map, false); std::map>::iterator it = algo_map->find(id); if (it == algo_map->end()) { LOGE_ANALYZER("can't find type id <%d, %d> algo", algoType, id); return false; } LOGD_ANALYZER("algo type id <%d,%d> status %s", algoType, id, it->second->getEnable() ? "enable" : "disable"); return it->second->getEnable(); } const RkAiqAlgoContext* RkAiqCore::getEnabledAxlibCtx(const int algo_type) { if (algo_type <= RK_AIQ_ALGO_TYPE_NONE || algo_type >= RK_AIQ_ALGO_TYPE_MAX) return NULL; SmartPtr* algo_handle = getCurAlgoTypeHandle(algo_type); if (algo_handle == nullptr) { return NULL; } if ((*algo_handle).ptr()) return (*algo_handle)->getAlgoCtx(); else return NULL; } void RkAiqCore::copyIspStats(SmartPtr& aecStat, SmartPtr& awbStat, SmartPtr& afStat, rk_aiq_isp_stats_t* to) { if (aecStat.ptr()) { to->aec_stats = aecStat->data()->aec_stats; to->frame_id = aecStat->data()->frame_id; } to->awb_hw_ver = 0; if (awbStat.ptr()) to->awb_stats_v200 = awbStat->data()->awb_stats; if (afStat.ptr()) to->af_stats = afStat->data()->af_stats; } void RkAiqCore::cacheIspStatsToList(SmartPtr& aecStat, SmartPtr& awbStat, SmartPtr& afStat) { SmartLock locker (ispStatsListMutex); SmartPtr stats = NULL; if (mAiqStatsPool->has_free_items()) { stats = mAiqStatsPool->get_item(); } else { if(mAiqStatsCachedList.empty()) { LOGW_ANALYZER("no free or cached stats, user may hold all stats buf !"); return ; } stats = mAiqStatsCachedList.front(); mAiqStatsCachedList.pop_front(); } copyIspStats(aecStat, awbStat, afStat, &stats->data()->result); mAiqStatsCachedList.push_back(stats); mIspStatsCond.broadcast (); } XCamReturn RkAiqCore::get3AStatsFromCachedList(rk_aiq_isp_stats_t **stats, int timeout_ms) { SmartLock locker (ispStatsListMutex); int code = 0; while (mState != RK_AIQ_CORE_STATE_STOPED && mAiqStatsCachedList.empty() && code == 0) { if (timeout_ms < 0) code = mIspStatsCond.wait(ispStatsListMutex); else code = mIspStatsCond.timedwait(ispStatsListMutex, timeout_ms * 1000); } if (mState == RK_AIQ_CORE_STATE_STOPED) { *stats = NULL; return XCAM_RETURN_NO_ERROR; } if (mAiqStatsCachedList.empty()) { if (code == ETIMEDOUT) { *stats = NULL; return XCAM_RETURN_ERROR_TIMEOUT; } else { *stats = NULL; return XCAM_RETURN_ERROR_FAILED; } } SmartPtr stats_proxy = mAiqStatsCachedList.front(); mAiqStatsCachedList.pop_front(); *stats = &stats_proxy->data()->result; mAiqStatsOutMap[*stats] = stats_proxy; stats_proxy.release(); return XCAM_RETURN_NO_ERROR; } void RkAiqCore::release3AStatsRef(rk_aiq_isp_stats_t *stats) { SmartLock locker (ispStatsListMutex); std::map>::iterator it; it = mAiqStatsOutMap.find(stats); if (it != mAiqStatsOutMap.end()) { mAiqStatsOutMap.erase(it); } } XCamReturn RkAiqCore::get3AStatsFromCachedList(rk_aiq_isp_stats_t &stats) { SmartLock locker (ispStatsListMutex); if(!mAiqStatsCachedList.empty()) { SmartPtr stats_proxy = mAiqStatsCachedList.front(); mAiqStatsCachedList.pop_front(); stats = stats_proxy->data()->result; stats_proxy.release(); return XCAM_RETURN_NO_ERROR; } else { return XCAM_RETURN_ERROR_FAILED; } } XCamReturn RkAiqCore::analyze(const SmartPtr &buffer) { XCamReturn ret = XCAM_RETURN_NO_ERROR; { SmartLock locker (mApiMutex); mSafeEnableAlgo = false; } if (!firstStatsReceived) { firstStatsReceived = true; mState = RK_AIQ_CORE_STATE_RUNNING; } switch (buffer->_buf_type) { case ISP_POLL_3A_STATS: { SmartPtr aecStat = NULL; SmartPtr awbStat = NULL; SmartPtr afStat = NULL; handleIspStats(buffer); handleAecStats(buffer, aecStat); handleAwbStats(buffer, awbStat); handleAfStats(buffer, afStat); cacheIspStatsToList(aecStat, awbStat, afStat); handleAtmoStats(buffer); handleAdehazeStats(buffer); } break; case ISPP_POLL_TNR_STATS: break; case ISPP_POLL_NR_STATS: handleOrbStats(buffer); break; case ISP_POLL_SP: { SmartPtr msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ISP_POLL_SP_OK, buffer->get_sequence(), buffer); post_message(msg); break; } case ISP_GAIN: { SmartPtr msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ISP_GAIN_OK, buffer->get_sequence(), buffer); post_message(msg); break; } case ISPP_GAIN_KG: { SmartPtr msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ISPP_GAIN_KG_OK, buffer->get_sequence(), buffer); post_message(msg); break; } case ISPP_GAIN_WR: { SmartPtr msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ISPP_GAIN_WR_OK, buffer->get_sequence(), buffer); post_message(msg); break; } case ISP_NR_IMG: { SmartPtr msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_NR_IMG_OK, buffer->get_sequence(), buffer); post_message(msg); break; } case ISP_POLL_TX: { SmartPtr msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ISP_POLL_TX_OK, buffer->get_sequence(), buffer); post_message(msg); break; } defalut: LOGW_ANALYZER("don't know buffer type: 0x%x!", buffer->_buf_type); break; } return ret; } XCamReturn RkAiqCore::events_analyze(const SmartPtr &evts) { XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr preExpParams = nullptr; SmartPtr curExpParams = nullptr; const SmartPtr isp20Evts = evts.dynamic_cast_ptr(); uint32_t sequence = isp20Evts->sequence; if (sequence == 0) return ret; uint32_t id = 0, maxId = 0; if (sequence > 0) id = mLastAnalyzedId + 1 > sequence ? mLastAnalyzedId + 1 : sequence; maxId = sequence + isp20Evts->expDelay; LOGD_ANALYZER("sequence(%d), expDelay(%d), id(%d), maxId(%d)", isp20Evts->sequence, isp20Evts->expDelay, id, maxId); while (id <= maxId) { if (isp20Evts->getExpInfoParams(preExpParams, id > 0 ? id - 1 : 0 ) < 0) { LOGE_ANALYZER("id(%d) get pre exp failed!", id); break; } if (isp20Evts->getExpInfoParams(curExpParams, id) < 0) { LOGE_ANALYZER("id(%d) get exp failed!", id); break; } SmartPtr sofInfo = NULL; if (mAiqSofInfoWrapperPool->has_free_items()) { sofInfo = mAiqSofInfoWrapperPool->get_item(); } else { LOGE_ANALYZER("no free item for sofInfo!"); return XCAM_RETURN_BYPASS; } sofInfo->data()->sequence = id; sofInfo->data()->preExp = preExpParams; sofInfo->data()->curExp = curExpParams; sofInfo->data()->sof = isp20Evts->getSofTimeStamp(); sofInfo->setId(id); sofInfo->setType(RK_AIQ_SHARED_TYPE_SOF_INFO); SmartPtr msg = new RkAiqCoreExpMsg(XCAM_MESSAGE_SOF_INFO_OK, id, sofInfo); post_message(msg); mLastAnalyzedId = id; id++; LOGD_ANALYZER("analyze the id(%d), sequence(%d), mLastAnalyzedId(%d)", id, sequence, mLastAnalyzedId); } return ret; } XCamReturn RkAiqCore::preProcess(enum rk_aiq_core_analyze_type_e type) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; std::list& algo_list = mRkAiqCoreGroupManager->getGroupAlgoList(type); for (auto algo : algo_list) { SmartPtr* algoHdl = getCurAlgoTypeHandle(algo); if (algoHdl && (*algoHdl)->getEnable()) { ret = (*algoHdl)->updateConfig(true); RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d updateConfig failed", algo); ret = (*algoHdl)->preProcess(); RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d processing failed", algo); } } EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::processing(enum rk_aiq_core_analyze_type_e type) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; std::list& algo_list = mRkAiqCoreGroupManager->getGroupAlgoList(type); for (auto algo : algo_list) { SmartPtr* algoHdl = getCurAlgoTypeHandle(algo); if (algoHdl && (*algoHdl)->getEnable()) { ret = (*algoHdl)->processing(); RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d processing failed", algo); } } EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::postProcess(enum rk_aiq_core_analyze_type_e type) { ENTER_ANALYZER_FUNCTION(); XCamReturn ret = XCAM_RETURN_NO_ERROR; std::list& algo_list = mRkAiqCoreGroupManager->getGroupAlgoList(type); for (auto algo : algo_list) { SmartPtr* algoHdl = getCurAlgoTypeHandle(algo); if (algoHdl && (*algoHdl)->getEnable()) { ret = (*algoHdl)->postProcess(); RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d postProcess failed", algo); } } EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::setHwInfos(struct RkAiqHwInfo &hw_info) { ENTER_ANALYZER_FUNCTION(); mHwInfo = hw_info; EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::setCpsLtCfg(rk_aiq_cpsl_cfg_t &cfg) { ENTER_ANALYZER_FUNCTION(); if (mState < RK_AIQ_CORE_STATE_INITED) { LOGE_ANALYZER("should call afer init"); return XCAM_RETURN_ERROR_FAILED; } if (mCpslCap.modes_num == 0) return XCAM_RETURN_ERROR_PARAM; int i = 0; for (; i < mCpslCap.modes_num; i++) { if (mCpslCap.supported_modes[i] == cfg.mode) break; } if (i == mCpslCap.modes_num) { return XCAM_RETURN_ERROR_PARAM; } if (cfg.mode == RK_AIQ_OP_MODE_AUTO) { mAlogsComSharedParams.cpslCfg.u.a = cfg.u.a; } else if (cfg.mode == RK_AIQ_OP_MODE_MANUAL) { mAlogsComSharedParams.cpslCfg.u.m = cfg.u.m; } else { return XCAM_RETURN_ERROR_PARAM; } mAlogsComSharedParams.cpslCfg.mode = cfg.mode; for (i = 0; i < mCpslCap.lght_src_num; i++) { if (mCpslCap.supported_lght_src[i] == cfg.lght_src) break; } if (i == mCpslCap.lght_src_num) { return XCAM_RETURN_ERROR_PARAM; } mAlogsComSharedParams.cpslCfg = cfg; LOGD("set cpsl: mode %d", cfg.mode); EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::getCpsLtInfo(rk_aiq_cpsl_info_t &info) { ENTER_ANALYZER_FUNCTION(); if (mState < RK_AIQ_CORE_STATE_INITED) { LOGE_ANALYZER("should call afer init"); return XCAM_RETURN_ERROR_FAILED; } info.mode = mAlogsComSharedParams.cpslCfg.mode; if (info.mode == RK_AIQ_OP_MODE_MANUAL) { info.on = mAlogsComSharedParams.cpslCfg.u.m.on; info.strength_led = mAlogsComSharedParams.cpslCfg.u.m.strength_led; info.strength_ir = mAlogsComSharedParams.cpslCfg.u.m.strength_ir; } else { info.on = mCurCpslOn; info.gray = mAlogsComSharedParams.gray_mode; } info.lght_src = mAlogsComSharedParams.cpslCfg.lght_src; EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::queryCpsLtCap(rk_aiq_cpsl_cap_t &cap) { ENTER_ANALYZER_FUNCTION(); if (mHwInfo.fl_supported || mHwInfo.irc_supported) { cap.supported_modes[0] = RK_AIQ_OP_MODE_AUTO; cap.supported_modes[1] = RK_AIQ_OP_MODE_MANUAL; cap.modes_num = 2; } else { cap.modes_num = 0; } cap.lght_src_num = 0; if (mHwInfo.fl_supported) { cap.supported_lght_src[0] = RK_AIQ_CPSLS_LED; cap.lght_src_num++; } if (mHwInfo.irc_supported) { cap.supported_lght_src[cap.lght_src_num] = RK_AIQ_CPSLS_IR; cap.lght_src_num++; } if (cap.lght_src_num > 1) { cap.supported_lght_src[cap.lght_src_num] = RK_AIQ_CPSLS_MIX; cap.lght_src_num++; } cap.strength_led.min = 0; cap.strength_led.max = 100; if (!mHwInfo.fl_strth_adj) cap.strength_led.step = 100; else cap.strength_led.step = 1; cap.strength_ir.min = 0; cap.strength_ir.max = 100; if (!mHwInfo.fl_ir_strth_adj) cap.strength_ir.step = 100; else cap.strength_ir.step = 1; cap.sensitivity.min = 0; cap.sensitivity.max = 100; cap.sensitivity.step = 1; LOGI("cpsl cap: light_src_num %d, led_step %f, ir_step %f", cap.lght_src_num, cap.strength_led.step, cap.strength_ir.step); EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::genCpslResult(RkAiqFullParams* params) { rk_aiq_cpsl_cfg_t* cpsl_cfg = &mAlogsComSharedParams.cpslCfg; if (cpsl_cfg->mode == RK_AIQ_OP_MODE_INVALID) return XCAM_RETURN_NO_ERROR; if (mAiqCpslParamsPool->has_free_items()) { params->mCpslParams = mAiqCpslParamsPool->get_item(); } else { LOGW_ANALYZER("no free cpsl params buffer!"); return XCAM_RETURN_NO_ERROR; } RKAiqCpslInfoWrapper_t* cpsl_param = params->mCpslParams->data().ptr(); //xcam_mem_clear(*cpsl_param); LOGD_ANALYZER("cpsl mode %d, light src %d", cpsl_cfg->mode, cpsl_cfg->lght_src); bool cpsl_on = false; bool need_update = false; if (cpsl_cfg->mode == RK_AIQ_OP_MODE_MANUAL) { if ((mCurCpslOn != cpsl_cfg->u.m.on) || (fabs(mStrthLed - cpsl_cfg->u.m.strength_led) > EPSINON) || (fabs(mStrthIr - cpsl_cfg->u.m.strength_ir) > EPSINON)) { need_update = true; cpsl_on = cpsl_cfg->u.m.on; cpsl_param->fl.power[0] = cpsl_cfg->u.m.strength_led / 100.0f; cpsl_param->fl_ir.power[0] = cpsl_cfg->u.m.strength_ir / 100.0f; } } else { RkAiqAlgosGroupShared_t* shared = nullptr; int groupId = getGroupId(RK_AIQ_ALGO_TYPE_ASD); if (groupId >= 0) { if (getGroupSharedParams(groupId, shared) != XCAM_RETURN_NO_ERROR) return XCAM_RETURN_BYPASS; } else return XCAM_RETURN_BYPASS; RkAiqAlgoPreResAsdInt* asd_pre_rk = (RkAiqAlgoPreResAsdInt*)shared->preResComb.asd_pre_res; if (asd_pre_rk) { asd_preprocess_result_t* asd_result = &asd_pre_rk->asd_result; if (mCurCpslOn != asd_result->cpsl_on) { need_update = true; cpsl_on = asd_result->cpsl_on; } } cpsl_param->fl.power[0] = 1.0f; cpsl_param->fl_ir.power[0] = 1.0f; } // need to init cpsl status, cause the cpsl driver state // may be not correct if (mState == RK_AIQ_CORE_STATE_INITED) need_update = true; if (need_update) { if (cpsl_cfg->lght_src & RK_AIQ_CPSLS_LED) { cpsl_param->update_fl = true; if (cpsl_on) cpsl_param->fl.flash_mode = RK_AIQ_FLASH_MODE_TORCH; else cpsl_param->fl.flash_mode = RK_AIQ_FLASH_MODE_OFF; if (cpsl_on ) { cpsl_param->fl.strobe = true; mAlogsComSharedParams.fill_light_on = true; } else { cpsl_param->fl.strobe = false; mAlogsComSharedParams.fill_light_on = false; } LOGD_ANALYZER("cpsl fl mode %d, strength %f, strobe %d", cpsl_param->fl.flash_mode, cpsl_param->fl.power[0], cpsl_param->fl.strobe); } if (cpsl_cfg->lght_src & RK_AIQ_CPSLS_IR) { cpsl_param->update_ir = true; if (cpsl_on) { cpsl_param->ir.irc_on = true; cpsl_param->fl_ir.flash_mode = RK_AIQ_FLASH_MODE_TORCH; cpsl_param->fl_ir.strobe = true; mAlogsComSharedParams.fill_light_on = true; } else { cpsl_param->ir.irc_on = false; cpsl_param->fl_ir.flash_mode = RK_AIQ_FLASH_MODE_OFF; cpsl_param->fl_ir.strobe = false; mAlogsComSharedParams.fill_light_on = false; } LOGD_ANALYZER("cpsl irc on %d, fl_ir: mode %d, strength %f, strobe %d", cpsl_param->ir.irc_on, cpsl_param->fl_ir.flash_mode, cpsl_param->fl_ir.power[0], cpsl_param->fl_ir.strobe); } if (mGrayMode == RK_AIQ_GRAY_MODE_CPSL) { if (mAlogsComSharedParams.fill_light_on && cpsl_cfg->gray_on) { mAlogsComSharedParams.gray_mode = true; } else mAlogsComSharedParams.gray_mode = false; } else { /* no mutex lock protection for gray_mode with setGrayMode, * so need set again here */ if (mGrayMode == RK_AIQ_GRAY_MODE_OFF) mAlogsComSharedParams.gray_mode = false; else if (mGrayMode == RK_AIQ_GRAY_MODE_ON) mAlogsComSharedParams.gray_mode = true; } mCurCpslOn = cpsl_on; mStrthLed = cpsl_cfg->u.m.strength_led; mStrthIr = cpsl_cfg->u.m.strength_ir; } else { cpsl_param->update_ir = false; cpsl_param->update_fl = false; } return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::setGrayMode(rk_aiq_gray_mode_t mode) { LOGD_ANALYZER("%s: gray mode %d", __FUNCTION__, mode); if (mAlogsComSharedParams.is_bw_sensor) { LOGE_ANALYZER("%s: not support for black&white sensor", __FUNCTION__); return XCAM_RETURN_ERROR_PARAM; } CalibDbV2_ColorAsGrey_t *colorAsGrey = (CalibDbV2_ColorAsGrey_t*)CALIBDBV2_GET_MODULE_PTR((void*)(mAlogsComSharedParams.calibv2), colorAsGrey); if (colorAsGrey->param.enable) { LOGE_ANALYZER("%s: not support,since color_as_grey is enabled in xml", __FUNCTION__); return XCAM_RETURN_ERROR_PARAM; } mGrayMode = mode; if (mode == RK_AIQ_GRAY_MODE_OFF) mAlogsComSharedParams.gray_mode = false; else if (mode == RK_AIQ_GRAY_MODE_ON) mAlogsComSharedParams.gray_mode = true; else if (mode == RK_AIQ_GRAY_MODE_CPSL) ; // do nothing else LOGE_ANALYZER("%s: gray mode %d error", __FUNCTION__, mode); return XCAM_RETURN_NO_ERROR; } rk_aiq_gray_mode_t RkAiqCore::getGrayMode() { LOGD_ANALYZER("%s: gray mode %d", __FUNCTION__, mGrayMode); return mGrayMode; } void RkAiqCore::setSensorFlip(bool mirror, bool flip) { mAlogsComSharedParams.sns_mirror = mirror; mAlogsComSharedParams.sns_flip = flip; } XCamReturn RkAiqCore::setCalib(const CamCalibDbContext_t* aiqCalib) { ENTER_ANALYZER_FUNCTION(); if (mState != RK_AIQ_CORE_STATE_STOPED) { LOGE_ANALYZER("wrong state %d\n", mState); return XCAM_RETURN_ERROR_ANALYZER; } /* TODO: xuhf WARNING */ mAlogsComSharedParams.calib = aiqCalib; mAlogsComSharedParams.conf_type = RK_AIQ_ALGO_CONFTYPE_UPDATECALIB; EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::setCalib(const CamCalibDbV2Context_t* aiqCalib) { ENTER_ANALYZER_FUNCTION(); if (mState != RK_AIQ_CORE_STATE_STOPED) { LOGE_ANALYZER("wrong state %d\n", mState); return XCAM_RETURN_ERROR_ANALYZER; } /* TODO: xuhf WARNING */ mAlogsComSharedParams.calibv2 = aiqCalib; mAlogsComSharedParams.conf_type = RK_AIQ_ALGO_CONFTYPE_UPDATECALIB; EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::calibTuning(const CamCalibDbV2Context_t* aiqCalib, ModuleNameList& change_name_list) { ENTER_ANALYZER_FUNCTION(); if (!aiqCalib || !change_name_list) { LOGE_ANALYZER("invalied tuning param\n"); return XCAM_RETURN_ERROR_PARAM; } // Fill new calib to the AlogsSharedParams /* TODO: xuhf WARNING */ mAlogsComSharedParams.calibv2 = aiqCalib; mAlogsComSharedParams.conf_type = RK_AIQ_ALGO_CONFTYPE_UPDATECALIB; std::for_each(std::begin(*change_name_list), std::end(*change_name_list), [this](const std::string& name) { if (!name.compare(0, 4, "cpsl", 0, 4)) { initCpsl(); } else if (!name.compare(0, 11, "colorAsGrey", 0, 11)) { setGrayMode(mGrayMode); } }); AlgoList change_list = std::make_shared>(); std::transform( change_name_list->begin(), change_name_list->end(), std::back_inserter(*change_list), [](const std::string name) { return RkAiqCalibDbV2::string2algostype(name.c_str()); }); change_list->sort(); change_list->unique(); // Call prepare of the Alog handle annd notify update param list::iterator it; for(it = change_list->begin(); it != change_list->end(); it++) { auto algo_handle = getCurAlgoTypeHandle(*it); if (algo_handle) { (*algo_handle)->updateConfig(true); (*algo_handle)->prepare(); } } EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::setMemsSensorIntf(const rk_aiq_mems_sensor_intf_t* intf) { if (mState != RK_AIQ_CORE_STATE_INITED) { LOGE_ANALYZER("set MEMS sensor intf in wrong aiq state %d !", mState); return XCAM_RETURN_ERROR_FAILED; } mMemsSensorIntf = intf; return XCAM_RETURN_NO_ERROR; } const rk_aiq_mems_sensor_intf_t* RkAiqCore::getMemsSensorIntf() { return mMemsSensorIntf; } void RkAiqCore::post_message (SmartPtr &msg) { //mRkAiqCoreMsgTh->push_msg(msg); mRkAiqCoreGroupManager->handleMessage(msg); } XCamReturn RkAiqCore::handle_message (const SmartPtr &msg) { //return mRkAiqCoreGroupManager->handleMessage(msg); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::otherGroupAnalye(uint32_t id, const SmartPtr &msg) { ENTER_ANALYZER_FUNCTION(); SmartPtr fullParam; uint32_t sequence = msg->msg->data()->sequence; uint64_t grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_OTHER); RkAiqAlgosGroupShared_t *shared = mAlogsGroupSharedParamsMap[grpMask]; shared->frameId = msg->msg->data()->sequence; shared->preExp = msg->msg->data()->preExp->data()->aecExpInfo; shared->curExp = msg->msg->data()->curExp->data()->aecExpInfo; LOGI_ANALYZER("%s, start analyzing id(%d)", __FUNCTION__, shared->frameId); fullParam = analyzeInternal(RK_AIQ_CORE_ANALYZE_OTHER); if (fullParam.ptr() && mCb) { mCb->rkAiqCalcDone(fullParam); } EXIT_ANALYZER_FUNCTION(); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::aeGroupAnalyze(uint32_t id, XCamVideoBuffer* aecStatsBuf) { uint32_t frameId = id; SmartPtr fullParam; uint64_t grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_AE); RkAiqAlgosGroupShared_t *shared = mAlogsGroupSharedParamsMap[grpMask]; shared->frameId = frameId; shared->aecStatsBuf = aecStatsBuf; LOGI_ANALYZER("%s, start analyzing id(%d)", __FUNCTION__, shared->frameId); fullParam = analyzeInternal(RK_AIQ_CORE_ANALYZE_AE); if (fullParam.ptr() && mCb) { mCb->rkAiqCalcDone(fullParam); } return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::awbGroupAnalyze(int32_t id, XCamVideoBuffer* aePreRes, XCamVideoBuffer* awbStatsBuf) { uint32_t frameId = id; SmartPtr fullParam; uint64_t grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_AWB); RkAiqAlgosGroupShared_t *shared = mAlogsGroupSharedParamsMap[grpMask]; shared->frameId = frameId; shared->awbStatsBuf = awbStatsBuf; shared->res_comb.ae_pre_res = aePreRes; LOGI_ANALYZER("%s, start analyzing id(%d)", __FUNCTION__, shared->frameId); fullParam = analyzeInternal(RK_AIQ_CORE_ANALYZE_AWB); if (fullParam.ptr() && mCb) { mCb->rkAiqCalcDone(fullParam); } return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::measGroupAnalyze(uint32_t id, const SmartPtr &msg, XCamVideoBuffer* aePreRes) { SmartPtr fullParam; uint64_t grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_MEAS); RkAiqAlgosGroupShared_t *shared = mAlogsGroupSharedParamsMap[grpMask]; shared->frameId = id; shared->ispStats = msg->msg->data().ptr(); shared->res_comb.ae_pre_res = aePreRes; LOGI_ANALYZER("%s, start analyzing id(%d)", __FUNCTION__, shared->frameId); fullParam = analyzeInternal(RK_AIQ_CORE_ANALYZE_MEAS); if (fullParam.ptr() && mCb) { mCb->rkAiqCalcDone(fullParam); } return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::amdGroupAnalyze(uint32_t id, const SmartPtr &expMsg, XCamVideoBuffer* sp, XCamVideoBuffer* ispGain) { uint32_t frameId = sp->frame_id; SmartPtr fullParam; uint64_t grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_AMD); RkAiqAlgosGroupShared_t *shared = mAlogsGroupSharedParamsMap[grpMask]; shared->frameId = frameId; shared->sp = sp; shared->ispGain = ispGain; shared->curExp = expMsg->msg->data()->curExp->data()->aecExpInfo; LOGD_ANALYZER("%s, start analyzing id(%d)", __FUNCTION__, shared->frameId); fullParam = analyzeInternal(RK_AIQ_CORE_ANALYZE_AMD); if (fullParam.ptr() && mCb) { mCb->rkAiqCalcDone(fullParam); } return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::lscGroupAnalyze(uint32_t id, const SmartPtr &expMsg, XCamVideoBuffer* awbProcRes, XCamVideoBuffer* tx) { uint32_t frameId = expMsg->frame_id; SmartPtr fullParam; uint64_t grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_LSC); RkAiqAlgosGroupShared_t *shared = mAlogsGroupSharedParamsMap[grpMask]; shared->frameId = frameId; shared->tx = tx; shared->res_comb.awb_proc_res = awbProcRes; shared->curExp = expMsg->msg->data()->curExp->data()->aecExpInfo; LOGD_ANALYZER("%s, start analyzing id(%d)", __FUNCTION__, shared->frameId); fullParam = analyzeInternal(RK_AIQ_CORE_ANALYZE_LSC); if (fullParam.ptr() && mCb) { mCb->rkAiqCalcDone(fullParam); } tx->unref(tx); awbProcRes->unref(awbProcRes); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::thumbnailsGroupAnalyze(rkaiq_image_source_t &thumbnailsSrc) { uint32_t frameId = thumbnailsSrc.frame_id; if (mThumbnailsService.ptr()) mThumbnailsService->OnFrameEvent(thumbnailsSrc); thumbnailsSrc.image_source->unref(thumbnailsSrc.image_source); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::mfnrGroupAnalyze(uint32_t id, const SmartPtr &expMsg, XCamVideoBuffer* ispGain, XCamVideoBuffer* kgGain, rk_aiq_amd_params_t &amdParams) { uint32_t frameId = expMsg->frame_id; SmartPtr fullParam; uint64_t grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_AMFNR); RkAiqAlgosGroupShared_t *shared = mAlogsGroupSharedParamsMap[grpMask]; shared->frameId = frameId; shared->ispGain = ispGain; shared->kgGain = kgGain; // shared->amdResParams = amdParams; shared->curExp = expMsg->msg->data()->curExp->data()->aecExpInfo; LOGD_ANALYZER("%s, start analyzing id(%d)", __FUNCTION__, shared->frameId); fullParam = analyzeInternal(RK_AIQ_CORE_ANALYZE_AMFNR); if (fullParam.ptr() && mCb) { mCb->rkAiqCalcDone(fullParam); } return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::ynrGroupAnalyze(uint32_t id, const SmartPtr &expMsg, XCamVideoBuffer* ispGain, XCamVideoBuffer* wrGain, rk_aiq_amd_params_t &amdParams) { uint32_t frameId = expMsg->frame_id; SmartPtr fullParam; uint64_t grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_AYNR); RkAiqAlgosGroupShared_t *shared = mAlogsGroupSharedParamsMap[grpMask]; shared->frameId = frameId; shared->ispGain = ispGain; shared->wrGain = wrGain; // shared->amdResParams = amdParams; shared->curExp = expMsg->msg->data()->curExp->data()->aecExpInfo; LOGD_ANALYZER("%s, start analyzing id(%d)", __FUNCTION__, shared->frameId); fullParam = analyzeInternal(RK_AIQ_CORE_ANALYZE_AYNR); if (fullParam.ptr() && mCb) { mCb->rkAiqCalcDone(fullParam); } return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::grp0Analyze(grp0AnalyzerInParams_t &inParams) { SmartPtr fullParam; uint64_t grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_GRP0); RkAiqAlgosGroupShared_t *shared = mAlogsGroupSharedParamsMap[grpMask]; shared->frameId = inParams.id; shared->aecStatsBuf = inParams.aecStatsBuf; shared->awbStatsBuf = inParams.awbStatsBuf; shared->afStatsBuf = inParams.afStatsBuf; shared->res_comb.ae_pre_res = inParams.aePreRes; shared->res_comb.ae_proc_res = inParams.aeProcRes; shared->curExp = inParams.sofInfoMsg->msg->data()->curExp->data()->aecExpInfo; LOGI_ANALYZER("%s, start analyzing id(%d)", __FUNCTION__, shared->frameId); fullParam = analyzeInternal(RK_AIQ_CORE_ANALYZE_GRP0); if (fullParam.ptr() && mCb) { mCb->rkAiqCalcDone(fullParam); } return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::grp1Analyze(grp1AnalyzerInParams_t &inParams) { SmartPtr fullParam; uint64_t grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_GRP1); RkAiqAlgosGroupShared_t *shared = mAlogsGroupSharedParamsMap[grpMask]; shared->frameId = inParams.id; shared->aecStatsBuf = inParams.aecStatsBuf; shared->awbStatsBuf = inParams.awbStatsBuf; shared->afStatsBuf = inParams.afStatsBuf; shared->res_comb.ae_pre_res = inParams.aePreRes; shared->res_comb.awb_proc_res = inParams.awbProcRes; shared->curExp = inParams.sofInfoMsg->msg->data()->curExp->data()->aecExpInfo; LOGI_ANALYZER("%s, start analyzing id(%d)", __FUNCTION__, shared->frameId); fullParam = analyzeInternal(RK_AIQ_CORE_ANALYZE_GRP1); if (fullParam.ptr() && mCb) { mCb->rkAiqCalcDone(fullParam); } return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::afAnalyze(afAnalyzerInParams_t &inParams) { SmartPtr fullParam; uint64_t grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_AF); RkAiqAlgosGroupShared_t *shared = mAlogsGroupSharedParamsMap[grpMask]; shared->frameId = inParams.id; shared->aecStatsBuf = inParams.aecStatsBuf; shared->afStatsBuf = inParams.afStatsBuf; shared->res_comb.ae_pre_res = inParams.aePreRes; shared->res_comb.ae_proc_res = inParams.aeProcRes; shared->curExp = inParams.expInfo->msg->data()->curExp->data()->aecExpInfo; LOGI_ANALYZER("%s, start analyzing id(%d)", __FUNCTION__, shared->frameId); fullParam = analyzeInternal(RK_AIQ_CORE_ANALYZE_AF); if (fullParam.ptr() && mCb) { mCb->rkAiqCalcDone(fullParam); } return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::eisGroupAnalyze(uint32_t id, const SmartPtr& expMsg, XCamVideoBuffer* orbStats, XCamVideoBuffer* nrImg) { uint32_t frameId = orbStats->frame_id; SmartPtr fullParam; RkAiqAlgosGroupShared_t* shared = mAlogsGroupSharedParamsMap[RK_AIQ_CORE_ANALYZE_EIS]; shared->frameId = frameId; shared->orbStats = orbStats; shared->nrImg = nrImg; shared->sof = expMsg->msg->data()->sof; shared->curExp = expMsg->msg->data()->curExp->data()->aecExpInfo; LOGD_ANALYZER("%s, start analyzing id(%d)", __FUNCTION__, shared->frameId); fullParam = analyzeInternal(RK_AIQ_CORE_ANALYZE_EIS); if (fullParam.ptr() && mCb) { if (fullParam->data()->mFecParams.ptr()) { rk_aiq_isp_fec_params_v20_t* fec_params = fullParam->data()->mFecParams->data().ptr(); if (fec_params->update_mask != 0) { mCb->rkAiqCalcDone(fullParam); } } } if (orbStats != nullptr) orbStats->unref(orbStats); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::orbGroupAnalyze(uint32_t id, XCamVideoBuffer* orbStats) { uint32_t frameId = orbStats->frame_id; SmartPtr fullParam; RkAiqAlgosGroupShared_t *shared = mAlogsGroupSharedParamsMap[RK_AIQ_CORE_ANALYZE_ORB]; shared->frameId = frameId; shared->orbStats = orbStats; LOGD_ANALYZER("%s, start analyzing id(%d)", __FUNCTION__, shared->frameId); fullParam = analyzeInternal(RK_AIQ_CORE_ANALYZE_ORB); if (fullParam.ptr() && mCb) { mCb->rkAiqCalcDone(fullParam); } if (orbStats != nullptr) orbStats->unref(orbStats); return XCAM_RETURN_NO_ERROR; } void RkAiqCore::newAiqParamsPool() { for (auto algoHdl : mCurIspAlgoHandleList) { if (algoHdl.ptr() && algoHdl->getEnable()) { switch (algoHdl->getAlgoType()) { case RK_AIQ_ALGO_TYPE_AE: mAiqExpParamsPool = new RkAiqExpParamsPool("RkAiqExpParams", MAX_AEC_EFFECT_FNUM * 4); mAiqIrisParamsPool = new RkAiqIrisParamsPool("RkAiqIrisParams", 4); mAiqIspAecParamsPool = new RkAiqIspAecParamsPool("RkAiqIspAecParams", RkAiqCore::DEFAULT_POOL_SIZE); mAiqIspHistParamsPool = new RkAiqIspHistParamsPool("RkAiqIspHistParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AWB: mAiqIspAwbParamsPool = new RkAiqIspAwbParamsPool("RkAiqIspAwbParams", RkAiqCore::DEFAULT_POOL_SIZE); mAiqIspAwbGainParamsPool = new RkAiqIspAwbGainParamsPool("RkAiqIspAwbGainParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AF: mAiqFocusParamsPool = new RkAiqFocusParamsPool("RkAiqFocusParams", 4); mAiqIspAfParamsPool = new RkAiqIspAfParamsPool("RkAiqIspAfParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ADPCC: mAiqIspDpccParamsPool = new RkAiqIspDpccParamsPool("RkAiqIspDpccParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AMERGE: mAiqIspMergeParamsPool = new RkAiqIspMergeParamsPool("RkAiqIspMergeParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ATMO: mAiqIspTmoParamsPool = new RkAiqIspTmoParamsPool("RkAiqIspTmoParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ACCM: mAiqIspCcmParamsPool = new RkAiqIspCcmParamsPool("RkAiqIspCcmParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ALSC: mAiqIspLscParamsPool = new RkAiqIspLscParamsPool("RkAiqIspLscParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ABLC: mAiqIspBlcParamsPool = new RkAiqIspBlcParamsPool("RkAiqIspBlcParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ARAWNR: mAiqIspRawnrParamsPool = new RkAiqIspRawnrParamsPool("RkAiqIspRawnrParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AGIC: mAiqIspGicParamsPool = new RkAiqIspGicParamsPool("RkAiqIspGicParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ADEBAYER: mAiqIspDebayerParamsPool = new RkAiqIspDebayerParamsPool("RkAiqIspDebayerParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ALDCH: mAiqIspLdchParamsPool = new RkAiqIspLdchParamsPool("RkAiqIspLdchParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_A3DLUT: mAiqIspLut3dParamsPool = new RkAiqIspLut3dParamsPool("RkAiqIspLut3dParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ADHAZ: mAiqIspDehazeParamsPool = new RkAiqIspDehazeParamsPool("RkAiqIspDehazeParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AGAMMA: mAiqIspAgammaParamsPool = new RkAiqIspAgammaParamsPool("RkAiqIspAgammaParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ADEGAMMA: mAiqIspAdegammaParamsPool = new RkAiqIspAdegammaParamsPool("RkAiqIspAdegammaParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AWDR: mAiqIspWdrParamsPool = new RkAiqIspWdrParamsPool("RkAiqIspWdrParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AR2Y: mAiqIspCsmParamsPool = new RkAiqIspCsmParamsPool("RkAiqIspCsmParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ACGC: mAiqIspCgcParamsPool = new RkAiqIspCgcParamsPool("RkAiqIspCgcParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AGAIN: mAiqIspGainParamsPool = new RkAiqIspGainParamsPool("RkAiqIspGainParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ACP: mAiqIspCpParamsPool = new RkAiqIspCpParamsPool("RkAiqIspCpParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AIE: mAiqIspIeParamsPool = new RkAiqIspIeParamsPool("RkAiqIspIeParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AMD: mAiqIspMdParamsPool = new RkAiqIspMdParamsPool("RkAiqIspMdParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AMFNR: mAiqIspTnrParamsPool = new RkAiqIspTnrParamsPool("RkAiqIspTnrParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AYNR: mAiqIspYnrParamsPool = new RkAiqIspYnrParamsPool("RkAiqIspYnrParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ACNR: mAiqIspUvnrParamsPool = new RkAiqIspUvnrParamsPool("RkAiqIspUvnrParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_ASHARP: mAiqIspSharpenParamsPool = new RkAiqIspSharpenParamsPool("RkAiqIspSharpenParams", RkAiqCore::DEFAULT_POOL_SIZE); mAiqIspEdgefltParamsPool = new RkAiqIspEdgefltParamsPool("RkAiqIspEdgefltParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AORB: mAiqIspOrbParamsPool = new RkAiqIspOrbParamsPool("RkAiqIspOrbParams", RkAiqCore::DEFAULT_POOL_SIZE); break; case RK_AIQ_ALGO_TYPE_AFEC: case RK_AIQ_ALGO_TYPE_AEIS: mAiqIspFecParamsPool = new RkAiqIspFecParamsPool("RkAiqIspFecParams", RkAiqCore::DEFAULT_POOL_SIZE); break; default: break; } } } } void RkAiqCore::onThumbnailsResult(const rkaiq_thumbnails_t& thumbnail) { LOGV_ANALYZER("Callback thumbnail : id:%d, type:%d, 1/%dx1/%d, %dx%d", thumbnail.frame_id, thumbnail.config.stream_type, thumbnail.config.width_intfactor, thumbnail.config.height_intfactor, thumbnail.buffer->info.width, thumbnail.buffer->info.height); #if 0 thumbnail.buffer->ref(thumbnail.buffer); if (thumbnail.frame_id == 1) { char* ptr = reinterpret_cast(thumbnail.buffer->map(thumbnail.buffer)); size_t size = thumbnail.buffer->info.size; std::string path = "/data/thumbnails_"; path.append(std::to_string(thumbnail.frame_id)); path.append("_"); path.append(std::to_string(thumbnail.buffer->info.width)); path.append("x"); path.append(std::to_string(thumbnail.buffer->info.height)); path.append(".yuv"); std::ofstream ofs(path, std::ios::binary); ofs.write(ptr, size); thumbnail.buffer->unmap(thumbnail.buffer); } thumbnail.buffer->unref(thumbnail.buffer); #endif } int32_t RkAiqCore::getGroupId(RkAiqAlgoType_t type) { auto mapIter = mAlgoTypeToGrpMaskMap.find(type); if (mapIter != mAlgoTypeToGrpMaskMap.end()) { return mapIter->second; } else { LOGW_ANALYZER("don't find the group id of module(0x%x)", type); return XCAM_RETURN_ERROR_FAILED; } } XCamReturn RkAiqCore::getGroupSharedParams(int32_t groupId, RkAiqAlgosGroupShared_t* &shared) { auto mapIter = mAlogsGroupSharedParamsMap.find(groupId); if (mapIter != mAlogsGroupSharedParamsMap.end()) { shared = mapIter->second; } else { LOGE_ANALYZER("don't find the group shared params of group(0x%x)", groupId); return XCAM_RETURN_ERROR_FAILED; } return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::handleIspStats(const SmartPtr &buffer) { XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr ispStatsInt = NULL; if (mAiqIspStatsIntPool->has_free_items()) { ispStatsInt = mAiqIspStatsIntPool->get_item(); } else { LOGE_ANALYZER("no free ispStatsInt!"); return XCAM_RETURN_BYPASS; } ret = mTranslator->translateIspStats(buffer, ispStatsInt); if (ret) { LOGE_ANALYZER("translate isp stats failed!"); return XCAM_RETURN_BYPASS; } uint32_t id = buffer->get_sequence(); SmartPtr msg = new RkAiqCoreIspStatsMsg(XCAM_MESSAGE_ISP_STATS_OK, id, ispStatsInt); post_message(msg); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::handleAecStats(const SmartPtr &buffer, SmartPtr& aecStat_ret) { XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr aecStats = NULL; if (mAiqAecStatsPool->has_free_items()) { aecStats = mAiqAecStatsPool->get_item(); } else { LOGE_ANALYZER("no free aecStats buffer!"); return XCAM_RETURN_BYPASS; } ret = mTranslator->translateAecStats(buffer, aecStats); if (ret < 0) { LOGE_ANALYZER("translate aec stats failed!"); return XCAM_RETURN_BYPASS; } aecStat_ret = aecStats; uint32_t id = buffer->get_sequence(); SmartPtr msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_AEC_STATS_OK, id, aecStats); post_message(msg); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::handleAwbStats(const SmartPtr &buffer, SmartPtr& awbStat_ret) { XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr awbStats = NULL; if (mAiqAwbStatsPool->has_free_items()) { awbStats = mAiqAwbStatsPool->get_item(); } else { LOGE_ANALYZER("no free awbStats buffer!"); return XCAM_RETURN_BYPASS; } ret = mTranslator->translateAwbStats(buffer, awbStats); if (ret < 0) { LOGE_ANALYZER("translate awb stats failed!"); return XCAM_RETURN_BYPASS; } awbStat_ret = awbStats; uint32_t id = buffer->get_sequence(); SmartPtr msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_AWB_STATS_OK, id, awbStats); post_message(msg); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::handleAfStats(const SmartPtr &buffer, SmartPtr& afStat_ret) { XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr afStats = NULL; if (mAiqAfStatsPool->has_free_items()) { afStats = mAiqAfStatsPool->get_item(); } else { LOGE_ANALYZER("no free afStats buffer!"); return XCAM_RETURN_BYPASS; } ret = mTranslator->translateAfStats(buffer, afStats); if (ret < 0) { LOGE_ANALYZER("translate af stats failed!"); return XCAM_RETURN_BYPASS; } afStat_ret = afStats; uint32_t id = buffer->get_sequence(); SmartPtr msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_AF_STATS_OK, id, afStats); post_message(msg); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::handleAtmoStats(const SmartPtr &buffer) { XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr atmoStats = NULL; if (mAiqAtmoStatsPool->has_free_items()) { atmoStats = mAiqAtmoStatsPool->get_item(); } else { LOGE_ANALYZER("no free atmoStats buffer!"); return XCAM_RETURN_BYPASS; } ret = mTranslator->translateAtmoStats(buffer, atmoStats); if (ret < 0) { LOGE_ANALYZER("translate tmo stats failed!"); return XCAM_RETURN_BYPASS; } uint32_t id = buffer->get_sequence(); SmartPtr msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ATMO_STATS_OK, id, atmoStats); post_message(msg); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::handleAdehazeStats(const SmartPtr &buffer) { XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr adehazeStats = NULL; if (mAiqAdehazeStatsPool->has_free_items()) { adehazeStats = mAiqAdehazeStatsPool->get_item(); } else { LOGE_ANALYZER("no free adehazeStats buffer!"); return XCAM_RETURN_BYPASS; } ret = mTranslator->translateAdehazeStats(buffer, adehazeStats); if (ret < 0) { LOGE_ANALYZER("translate dehaze stats failed!"); return XCAM_RETURN_BYPASS; } uint32_t id = buffer->get_sequence(); SmartPtr msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ADEHAZE_STATS_OK, id, adehazeStats); post_message(msg); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::handleOrbStats(const SmartPtr &buffer) { XCamReturn ret = XCAM_RETURN_NO_ERROR; SmartPtr orbStats = NULL; if (mAiqOrbStatsIntPool->has_free_items()) { orbStats = mAiqOrbStatsIntPool->get_item(); } else { LOGE_ANALYZER("no free orbStats!"); return XCAM_RETURN_BYPASS; } ret = mTranslator->translateOrbStats(buffer, orbStats); if (ret) return XCAM_RETURN_BYPASS; uint32_t id = buffer->get_sequence(); orbStats->setId(id); orbStats->setType(RK_AIQ_SHARED_TYPE_ORB_STATS); SmartPtr msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ORB_STATS_OK, id, orbStats); post_message(msg); return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::set_sp_resolution(int &width, int &height, int &aligned_w, int &aligned_h) { mSpWidth = width; mSpHeight = height; mSpAlignedWidth = aligned_w; mSpAlignedHeight = aligned_h; return XCAM_RETURN_NO_ERROR; } XCamReturn RkAiqCore::newAiqGroupAnayzer() { mRkAiqCoreGroupManager = new RkAiqAnalyzeGroupManager(this); mRkAiqCoreGroupManager->parseAlgoGroup(mAlgosDesArray); return XCAM_RETURN_NO_ERROR; } } //namespace RkCam