/*
|
* Copyright (c) 2019-2021 Rockchip Eletronics Co., Ltd.
|
*
|
* 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 <iostream>
|
#include <fstream>
|
#include <unordered_map>
|
|
#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 "acsm/rk_aiq_algo_acsm_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"
|
#include "asharp3/rk_aiq_asharp_algo_itf_v3.h"
|
#include "aynr2/rk_aiq_aynr_algo_itf_v2.h"
|
#include "acnr/rk_aiq_acnr_algo_itf_v1.h"
|
#include "arawnr2/rk_aiq_abayernr_algo_itf_v2.h"
|
#include "asharp4/rk_aiq_asharp_algo_itf_v4.h"
|
#include "aynr3/rk_aiq_aynr_algo_itf_v3.h"
|
#include "acnr2/rk_aiq_acnr_algo_itf_v2.h"
|
#include "abayer2dnr2/rk_aiq_abayer2dnr_algo_itf_v2.h"
|
#include "abayertnr2/rk_aiq_abayertnr_algo_itf_v2.h"
|
#include "again2/rk_aiq_again_algo_itf_v2.h"
|
#include "acac/rk_aiq_algo_acac_itf.h"
|
|
#ifdef RK_SIMULATOR_HW
|
#include "simulator/isp20_hw_simulator.h"
|
#else
|
#include "isp20/Isp20Evts.h"
|
#include "isp20/Isp20StatsBuffer.h"
|
#include "common/rkisp2-config.h"
|
#include "isp20/rkispp-config.h"
|
#include "common/rkisp21-config.h"
|
#endif
|
#include <fcntl.h>
|
#include <unistd.h>
|
#include "SPStreamProcUnit.h"
|
#include "PdafStreamProcUnit.h"
|
// #include "MessageBus.h"
|
#include "RkAiqResourceTranslatorV21.h"
|
#include "RkAiqResourceTranslatorV3x.h"
|
#include "RkAiqAnalyzeGroupManager.h"
|
#ifdef RKAIQ_ENABLE_CAMGROUP
|
#include "RkAiqCamGroupManager.h"
|
#endif
|
#include "RkAiqCustomAeHandle.h"
|
#include "RkAiqCustomAwbHandle.h"
|
|
namespace RkCam {
|
|
std::string AlgoTypeToString(RkAiqAlgoType_t type) {
|
static std::unordered_map<uint32_t, std::string> str_map = {
|
// clang-format off
|
{ RK_AIQ_ALGO_TYPE_AE, "Ae" },
|
{ RK_AIQ_ALGO_TYPE_AWB, "Awb" },
|
{ RK_AIQ_ALGO_TYPE_AF, "Af" },
|
{ RK_AIQ_ALGO_TYPE_ABLC, "Ablc" },
|
{ RK_AIQ_ALGO_TYPE_ADPCC, "Adpcc" },
|
{ RK_AIQ_ALGO_TYPE_AMERGE, "Amerge" },
|
{ RK_AIQ_ALGO_TYPE_ATMO, "Atmo" },
|
{ RK_AIQ_ALGO_TYPE_ANR, "Anr" },
|
{ RK_AIQ_ALGO_TYPE_ALSC, "Alsc" },
|
{ RK_AIQ_ALGO_TYPE_AGIC, "Agic" },
|
{ RK_AIQ_ALGO_TYPE_ADEBAYER, "Adebayer" },
|
{ RK_AIQ_ALGO_TYPE_ACCM, "Accm" },
|
{ RK_AIQ_ALGO_TYPE_AGAMMA, "Agamma" },
|
{ RK_AIQ_ALGO_TYPE_AWDR, "Awdr" },
|
{ RK_AIQ_ALGO_TYPE_ADHAZ, "Adhaz" },
|
{ RK_AIQ_ALGO_TYPE_A3DLUT, "A3dlut" },
|
{ RK_AIQ_ALGO_TYPE_ALDCH, "Aldch" },
|
{ RK_AIQ_ALGO_TYPE_ACSM, "Acsm" },
|
{ RK_AIQ_ALGO_TYPE_ACP, "Acp" },
|
{ RK_AIQ_ALGO_TYPE_AIE, "Aie" },
|
{ RK_AIQ_ALGO_TYPE_ASHARP, "Asharp" },
|
{ RK_AIQ_ALGO_TYPE_AORB, "Aorb" },
|
{ RK_AIQ_ALGO_TYPE_ACGC, "Acgc" },
|
{ RK_AIQ_ALGO_TYPE_ASD, "Asd" },
|
{ RK_AIQ_ALGO_TYPE_ADRC, "Adrc" },
|
{ RK_AIQ_ALGO_TYPE_ADEGAMMA, "Adegamma" },
|
#if defined(ISP_HW_V30)
|
{ RK_AIQ_ALGO_TYPE_ARAWNR, "Abayer2dnr"},
|
{ RK_AIQ_ALGO_TYPE_AMFNR, "Abayertnr" },
|
#else
|
{ RK_AIQ_ALGO_TYPE_ARAWNR, "Arawnr" },
|
{ RK_AIQ_ALGO_TYPE_AMFNR, "Amfnr" },
|
#endif
|
{ RK_AIQ_ALGO_TYPE_AYNR, "Aynr" },
|
{ RK_AIQ_ALGO_TYPE_ACNR, "Acnr" },
|
{ RK_AIQ_ALGO_TYPE_AEIS, "Aeis" },
|
{ RK_AIQ_ALGO_TYPE_AFEC, "Afec" },
|
{ RK_AIQ_ALGO_TYPE_AMD, "Amd" },
|
{ RK_AIQ_ALGO_TYPE_AGAIN, "Again" },
|
{ RK_AIQ_ALGO_TYPE_ACAC, "Acac" },
|
// clang-format oon
|
};
|
|
return str_map[uint32_t(type)];
|
}
|
|
#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_SOF_INFO_OK, 0 },
|
[1] = {XCAM_MESSAGE_AE_PRE_RES_OK, 0},
|
[2] = {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[] = {
|
// clang-format off
|
{ &g_RkIspAlgoDescAe.common, RK_AIQ_CORE_ANALYZE_AE, 0, 0, 0, aeGrpConds },
|
{ &g_RkIspAlgoDescAwb.common, RK_AIQ_CORE_ANALYZE_AWB, 0, 0, 0, awbGrpConds },
|
{ &g_RkIspAlgoDescAf.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, 0, measGrpConds },
|
{ &g_RkIspAlgoDescAblc.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAdegamma.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAdpcc.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, 0, measGrpConds },
|
{ &g_RkIspAlgoDescAmerge.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, 0, measGrpConds },
|
{ &g_RkIspAlgoDescAtmo.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, 0, measGrpConds },
|
#if ANR_NO_SEPERATE_MARCO
|
{ &g_RkIspAlgoDescAnr.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, 0, measGrpConds },
|
#else
|
#if 0
|
{ &g_RkIspAlgoDescArawnr.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, 0, measGrpConds },
|
{ &g_RkIspAlgoDescAynr.common, RK_AIQ_CORE_ANALYZE_AYNR, 0, 0, 0, aynrGrpConds },
|
{ &g_RkIspAlgoDescAcnr.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, 0, measGrpConds },
|
{ &g_RkIspAlgoDescAmfnr.common, RK_AIQ_CORE_ANALYZE_AMFNR, 0, 0, 0, amfnrGrpConds },
|
{ &g_RkIspAlgoDescAgain.common, RK_AIQ_CORE_ANALYZE_AMFNR, 0, 0, 0, amfnrGrpConds },
|
#else
|
{ &g_RkIspAlgoDescArawnr.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, 0, measGrpConds },
|
{ &g_RkIspAlgoDescAynr.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAcnr.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAmfnr.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAgain.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
#endif
|
#endif
|
{ &g_RkIspAlgoDescAlsc.common, RK_AIQ_CORE_ANALYZE_LSC, 0, 0, 0, lscGrpConds },
|
{ &g_RkIspAlgoDescAgic.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAdebayer.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAccm.common, RK_AIQ_CORE_ANALYZE_MEAS, 0, 0, 0, measGrpConds },
|
{ &g_RkIspAlgoDescAgamma.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAwdr.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAdhaz.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescA3dlut.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAldch.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAcsm.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAcp.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAie.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAsharp.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAorb.common, RK_AIQ_CORE_ANALYZE_ORB, 0, 0, 0, orbGrpConds },
|
{ &g_RkIspAlgoDescAcgc.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAsd.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
//{ &g_RkIspAlgoDescAfec.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpConds },
|
{ &g_RkIspAlgoDescAeis.common, RK_AIQ_CORE_ANALYZE_EIS, 0, 0, 0, eisGrpConds },
|
#if 0
|
{ &g_RkIspAlgoDescAmd.common, RK_AIQ_CORE_ANALYZE_AMD, 0, 0, 0, amdGrpConds },
|
#endif
|
{ NULL, RK_AIQ_CORE_ANALYZE_ALL, 0, 0, 0, {0} },
|
// clang-format on
|
};
|
|
static RkAiqGrpCondition_t aeGrpCondV21[] = {
|
[0] = { XCAM_MESSAGE_AEC_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT },
|
};
|
static RkAiqGrpConditions_t aeGrpCondsV21 = { grp_conds_array_info(aeGrpCondV21) };
|
|
static RkAiqGrpCondition_t afGrpCondV21[] = {
|
[0] = { XCAM_MESSAGE_SOF_INFO_OK, 0 },
|
[1] = { XCAM_MESSAGE_AE_PRE_RES_OK, 0 },
|
[2] = { XCAM_MESSAGE_AE_PROC_RES_OK, 0 },
|
[3] = { XCAM_MESSAGE_AF_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT },
|
[4] = { XCAM_MESSAGE_AEC_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT },
|
[5] = { XCAM_MESSAGE_PDAF_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT },
|
};
|
static RkAiqGrpConditions_t afGrpCondsV21 = { grp_conds_array_info(afGrpCondV21) };
|
|
static RkAiqGrpCondition_t otherGrpCondV21[] = {
|
[0] = { XCAM_MESSAGE_SOF_INFO_OK, 0 },
|
};
|
static RkAiqGrpConditions_t otherGrpCondsV21 = { grp_conds_array_info(otherGrpCondV21) };
|
|
static RkAiqGrpCondition_t grp0Cond[] = {
|
[0] = { XCAM_MESSAGE_SOF_INFO_OK, 0 },
|
[1] = { XCAM_MESSAGE_AE_PRE_RES_OK, 0 },
|
[2] = { XCAM_MESSAGE_AE_PROC_RES_OK, 0 },
|
[3] = { XCAM_MESSAGE_AEC_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT },
|
[4] = { XCAM_MESSAGE_AWB_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT },
|
};
|
static RkAiqGrpConditions_t grp0Conds = { grp_conds_array_info(grp0Cond) };
|
|
static RkAiqGrpCondition_t grp1Cond[] = {
|
[0] = { XCAM_MESSAGE_SOF_INFO_OK, 0 },
|
[1] = { XCAM_MESSAGE_AWB_PROC_RES_OK, 0 },
|
};
|
static RkAiqGrpConditions_t grp1Conds = { grp_conds_array_info(grp1Cond) };
|
|
static struct RkAiqAlgoDesCommExt g_default_3a_des_v21[] = {
|
// clang-format off
|
{ &g_RkIspAlgoDescAe.common, RK_AIQ_CORE_ANALYZE_AE, 0, 1, 0, aeGrpCondsV21 },
|
{ &g_RkIspAlgoDescAwb.common, RK_AIQ_CORE_ANALYZE_AWB, 1, 1, 21, awbGrpConds },
|
{ &g_RkIspAlgoDescAdebayer.common, RK_AIQ_CORE_ANALYZE_GRP0, 0, 0, 0, grp0Conds },
|
{ &g_RkIspAlgoDescAgamma.common, RK_AIQ_CORE_ANALYZE_GRP0, 0, 0, 0, grp0Conds },
|
{ &g_RkIspAlgoDescAdegamma.common, RK_AIQ_CORE_ANALYZE_GRP0, 0, 0, 0, grp0Conds },
|
{ &g_RkIspAlgoDescAmerge.common, RK_AIQ_CORE_ANALYZE_GRP0, 0, 0, 0, grp0Conds },
|
{ &g_RkIspAlgoDescAdhaz.common, RK_AIQ_CORE_ANALYZE_GRP0, 0, 1, 0, grp0Conds },
|
{ &g_RkIspAlgoDescArawnrV2.common, RK_AIQ_CORE_ANALYZE_GRP0, 2, 2, 2, grp0Conds },
|
{ &g_RkIspAlgoDescAynrV2.common, RK_AIQ_CORE_ANALYZE_GRP0, 2, 2, 2, grp0Conds },
|
{ &g_RkIspAlgoDescAcnrV1.common, RK_AIQ_CORE_ANALYZE_GRP0, 1, 1, 1, grp0Conds },
|
{ &g_RkIspAlgoDescAsharpV3.common, RK_AIQ_CORE_ANALYZE_GRP0, 3, 3, 3, grp0Conds },
|
{ &g_RkIspAlgoDescAdrc.common, RK_AIQ_CORE_ANALYZE_GRP0, 0, 0, 0, grp0Conds },
|
{ &g_RkIspAlgoDescA3dlut.common, RK_AIQ_CORE_ANALYZE_GRP1, 0, 0, 0, grp1Conds },
|
{ &g_RkIspAlgoDescAlsc.common, RK_AIQ_CORE_ANALYZE_GRP1, 0, 0, 0, grp1Conds },
|
{ &g_RkIspAlgoDescAccm.common, RK_AIQ_CORE_ANALYZE_GRP1, 0, 0, 0, grp1Conds },
|
{ &g_RkIspAlgoDescAcp.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV21 },
|
{ &g_RkIspAlgoDescAie.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV21 },
|
{ &g_RkIspAlgoDescAdpcc.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV21 },
|
{ &g_RkIspAlgoDescAldch.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV21 },
|
{ &g_RkIspAlgoDescAcgc.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV21 },
|
{ &g_RkIspAlgoDescAcsm.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV21 },
|
{ &g_RkIspAlgoDescAf.common, RK_AIQ_CORE_ANALYZE_AF, 0, 0, 0, afGrpCondsV21 },
|
{ &g_RkIspAlgoDescAblc.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV21 },
|
{ &g_RkIspAlgoDescAgic.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 1, 0, otherGrpCondsV21 },
|
{ &g_RkIspAlgoDescAwdr.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV21 },
|
{ &g_RkIspAlgoDescAsd.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV21 },
|
|
{ NULL, RK_AIQ_CORE_ANALYZE_ALL, 0, 0, 0, {0} },
|
// clang-format on
|
};
|
|
static RkAiqGrpCondition_t aeGrpCondV3x[] = {
|
[0] = { XCAM_MESSAGE_AEC_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT },
|
};
|
static RkAiqGrpConditions_t aeGrpCondsV3x = { grp_conds_array_info(aeGrpCondV3x) };
|
|
static RkAiqGrpCondition_t afGrpCondV3x[] = {
|
[0] = { XCAM_MESSAGE_SOF_INFO_OK, 0 },
|
[1] = { XCAM_MESSAGE_AE_PRE_RES_OK, 0 },
|
[2] = { XCAM_MESSAGE_AE_PROC_RES_OK, 0 },
|
[3] = { XCAM_MESSAGE_AF_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT },
|
[4] = { XCAM_MESSAGE_AEC_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT },
|
[5] = { XCAM_MESSAGE_PDAF_STATS_OK, ISP_PARAMS_EFFECT_DELAY_CNT },
|
};
|
static RkAiqGrpConditions_t afGrpCondsV3x = { grp_conds_array_info(afGrpCondV3x) };
|
|
static RkAiqGrpCondition_t otherGrpCondV3x[] = {
|
[0] = { XCAM_MESSAGE_SOF_INFO_OK, 0 },
|
};
|
static RkAiqGrpConditions_t otherGrpCondsV3x = { grp_conds_array_info(otherGrpCondV3x) };
|
|
static struct RkAiqAlgoDesCommExt g_default_3a_des_v3x[] = {
|
// clang-format off
|
{ &g_RkIspAlgoDescAe.common, RK_AIQ_CORE_ANALYZE_AE, 0, 2, 0, aeGrpCondsV3x },
|
{ &g_RkIspAlgoDescAblc.common, RK_AIQ_CORE_ANALYZE_AWB, 0, 0, 0, awbGrpConds },
|
{ &g_RkIspAlgoDescAwb.common, RK_AIQ_CORE_ANALYZE_AWB, 1, 1, 21, awbGrpConds },
|
{ &g_RkIspAlgoDescAdebayer.common, RK_AIQ_CORE_ANALYZE_GRP0, 0, 0, 0, grp0Conds },
|
{ &g_RkIspAlgoDescAgamma.common, RK_AIQ_CORE_ANALYZE_GRP0, 0, 0, 0, grp0Conds },
|
{ &g_RkIspAlgoDescAdegamma.common, RK_AIQ_CORE_ANALYZE_GRP0, 0, 0, 0, grp0Conds },
|
{ &g_RkIspAlgoDescAmerge.common, RK_AIQ_CORE_ANALYZE_GRP0, 0, 0, 0, grp0Conds },
|
{ &g_RkIspAlgoDescAcac.common, RK_AIQ_CORE_ANALYZE_GRP0, 0, 0, 0, grp0Conds },
|
{ &g_RkIspAlgoDescAdhaz.common, RK_AIQ_CORE_ANALYZE_GRP0, 0, 1, 0, grp0Conds },
|
{ &g_RkIspAlgoDescAbayer2dnrV2.common, RK_AIQ_CORE_ANALYZE_GRP0, 2, 2, 2, grp0Conds },
|
{ &g_RkIspAlgoDescAbayertnrV2.common, RK_AIQ_CORE_ANALYZE_GRP0, 2, 2, 2, grp0Conds },
|
{ &g_RkIspAlgoDescAynrV3.common, RK_AIQ_CORE_ANALYZE_GRP0, 3, 3, 3, grp0Conds },
|
{ &g_RkIspAlgoDescAcnrV2.common, RK_AIQ_CORE_ANALYZE_GRP0, 2, 2, 2, grp0Conds },
|
{ &g_RkIspAlgoDescAsharpV4.common, RK_AIQ_CORE_ANALYZE_GRP0, 4, 4, 4, grp0Conds },
|
{ &g_RkIspAlgoDescAdrc.common, RK_AIQ_CORE_ANALYZE_GRP0, 0, 0, 0, grp0Conds },
|
{ &g_RkIspAlgoDescA3dlut.common, RK_AIQ_CORE_ANALYZE_GRP1, 0, 0, 0, grp1Conds },
|
{ &g_RkIspAlgoDescAlsc.common, RK_AIQ_CORE_ANALYZE_GRP1, 0, 0, 0, grp1Conds },
|
{ &g_RkIspAlgoDescAccm.common, RK_AIQ_CORE_ANALYZE_GRP1, 0, 0, 0, grp1Conds },
|
{ &g_RkIspAlgoDescAcp.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV3x },
|
{ &g_RkIspAlgoDescAie.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV3x },
|
{ &g_RkIspAlgoDescAdpcc.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV3x },
|
{ &g_RkIspAlgoDescAldch.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV3x },
|
{ &g_RkIspAlgoDescAcgc.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV3x },
|
{ &g_RkIspAlgoDescAcsm.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV3x },
|
{ &g_RkIspAlgoDescAf.common, RK_AIQ_CORE_ANALYZE_AF, 0, 1, 0, afGrpCondsV3x },
|
{ &g_RkIspAlgoDescAgic.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 1, 0, otherGrpCondsV3x },
|
{ &g_RkIspAlgoDescAwdr.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV3x },
|
{ &g_RkIspAlgoDescAsd.common, RK_AIQ_CORE_ANALYZE_OTHER, 0, 0, 0, otherGrpCondsV3x },
|
{ &g_RkIspAlgoDescAgainV2.common, RK_AIQ_CORE_ANALYZE_GRP0, 2, 2, 2, grp0Conds },
|
{ NULL, RK_AIQ_CORE_ANALYZE_ALL, 0, 0, 0, {0} },
|
// clang-format on
|
};
|
|
|
|
bool
|
RkAiqCoreThread::loop()
|
{
|
ENTER_ANALYZER_FUNCTION();
|
|
const static int32_t timeout = -1;
|
SmartPtr<VideoBuffer> 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<ispHwEvt_t> 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(int isp_hw_ver)
|
: mRkAiqCoreTh(new RkAiqCoreThread(this))
|
, mRkAiqCorePpTh(new RkAiqCoreThread(this))
|
, mRkAiqCoreEvtsTh(new RkAiqCoreEvtsThread(this))
|
, mState(RK_AIQ_CORE_STATE_INVALID)
|
, mCb(NULL)
|
, mIsSingleThread(false)
|
, mAiqParamsPool(new RkAiqFullParamsPool("RkAiqFullParams", 32))
|
, mAiqCpslParamsPool(new RkAiqCpslParamsPool("RkAiqCpslParamsPool", 4))
|
, mAiqStatsPool(new RkAiqStatsPool("RkAiqStatsPool", RkAiqCore::DEFAULT_POOL_SIZE))
|
, mAiqIspStatsIntPool(new RkAiqIspStatsIntPool("RkAiqIspStatsIntPool", RkAiqCore::DEFAULT_POOL_SIZE))
|
, mAiqSofInfoWrapperPool(new RkAiqSofInfoWrapperPool("RkAiqSofPoolWrapper", RkAiqCore::DEFAULT_POOL_SIZE))
|
, mAiqAecStatsPool(nullptr)
|
, mAiqAwbStatsPool(nullptr)
|
, mAiqAtmoStatsPool(nullptr)
|
, mAiqAdehazeStatsPool(nullptr)
|
, mAiqAfStatsPool(nullptr)
|
, mAiqOrbStatsIntPool(nullptr)
|
, mAiqPdafStatsPool(nullptr)
|
, mCustomEnAlgosMask(0xffffffffffffffff)
|
{
|
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<RkAiqFullParams> fullParam = new RkAiqFullParams();
|
mAiqCurParams = new RkAiqFullParamsProxy(fullParam );
|
mIspOnline = false;
|
mIspHwVer = isp_hw_ver;
|
mSafeEnableAlgo = true;
|
mLastAnalyzedId = 0;
|
#ifdef RKAIQ_ENABLE_CAMGROUP
|
mCamGroupCoreManager = NULL;
|
#endif
|
mAllReqAlgoResMask = 0;
|
|
if (mIspHwVer == 0) {
|
mHasPp = true;
|
mAlgosDesArray = g_default_3a_des;
|
mTranslator = new RkAiqResourceTranslator();
|
} else if (mIspHwVer == 1) {
|
mHasPp = false;
|
mAlgosDesArray = g_default_3a_des_v21;
|
mTranslator = new RkAiqResourceTranslatorV21();
|
} else if (mIspHwVer == 3) {
|
mHasPp = false;
|
mAlgosDesArray = g_default_3a_des_v3x;
|
mTranslator = new RkAiqResourceTranslatorV3x();
|
}
|
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 CamCalibDbV2Context_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;
|
}
|
|
#ifdef RKAIQ_ENABLE_PARSER_V1
|
mAlogsComSharedParams.calib = aiqCalib;
|
#endif
|
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 |= 1ULL << algoSwitch->enable_algos[i];
|
}
|
LOGI_ANALYZER("mCustomEnAlgosMask: 0x%x\n", mCustomEnAlgosMask);
|
addDefaultAlgos(mAlgosDesArray);
|
initCpsl();
|
newAiqParamsPool();
|
newAiqGroupAnayzer();
|
newPdafStatsPool();
|
|
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;
|
}
|
|
delPdafStatsPool();
|
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();
|
|
uint64_t deps = mRkAiqCoreGroupManager->getGrpDeps(RK_AIQ_CORE_ANALYZE_AF);
|
if (get_pdaf_support()) {
|
deps |= 1LL << XCAM_MESSAGE_PDAF_STATS_OK;
|
} else {
|
deps &= ~(1LL << XCAM_MESSAGE_PDAF_STATS_OK);
|
}
|
mRkAiqCoreGroupManager->setGrpDeps(RK_AIQ_CORE_ANALYZE_AF, deps);
|
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();
|
|
mRkAiqCoreGroupManager->stop();
|
if (mThumbnailsService.ptr()) {
|
mThumbnailsService->Stop();
|
}
|
|
{
|
SmartLock locker (ispStatsListMutex);
|
mAiqStatsCachedList.clear();
|
mAiqStatsOutMap.clear();
|
mAlogsComSharedParams.conf_type = RK_AIQ_ALGO_CONFTYPE_INIT;
|
mState = RK_AIQ_CORE_STATE_STOPED;
|
firstStatsReceived = false;
|
mLastAnalyzedId = 0;
|
}
|
mIspStatsCond.broadcast ();
|
mSafeEnableAlgo = true;
|
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 (mHwInfo.is_multi_isp_mode) {
|
XCAM_ASSERT((sensor_des->isp_acq_width % 32 == 0));// &&
|
//(sensor_des->isp_acq_height % 16 == 0));
|
uint32_t extended_pixel = mHwInfo.multi_isp_extended_pixel;
|
RkAiqResourceTranslatorV3x* translator = static_cast<RkAiqResourceTranslatorV3x*>(mTranslator.ptr());
|
translator->SetMultiIspMode(true)
|
.SetPicInfo({0, 0, sensor_des->isp_acq_width, sensor_des->isp_acq_height})
|
.SetLeftIspRect(
|
{0, 0, sensor_des->isp_acq_width / 2 + extended_pixel, sensor_des->isp_acq_height})
|
.SetRightIspRect({sensor_des->isp_acq_width / 2 - extended_pixel, 0,
|
sensor_des->isp_acq_width / 2 + extended_pixel,
|
sensor_des->isp_acq_height});
|
RkAiqResourceTranslatorV3x::Rectangle f = translator->GetPicInfo();
|
RkAiqResourceTranslatorV3x::Rectangle l = translator->GetLeftIspRect();
|
RkAiqResourceTranslatorV3x::Rectangle r = translator->GetLeftIspRect();
|
LOGD_ANALYZER(
|
"Set Multi-ISP mode Translator info :"
|
" F: { %u, %u, %u, %u }"
|
" L: { %u, %u, %u, %u }"
|
" R: { %u, %u, %u, %u }",
|
f.x, f.y, f.w, f.h, l.x, l.y, l.w, l.h, r.x, r.y, r.w, r.h);
|
mAlogsComSharedParams.is_multi_isp_mode = mHwInfo.is_multi_isp_mode;
|
mAlogsComSharedParams.multi_isp_extended_pixels = extended_pixel;
|
} else {
|
if (mIspHwVer == 3)
|
static_cast<RkAiqResourceTranslatorV3x*>(mTranslator.ptr())->SetMultiIspMode(false);
|
}
|
|
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) {
|
RkAiqHandle* curHdl = algoHdl.ptr();
|
while (curHdl) {
|
if (curHdl->getEnable()) {
|
/* update user initial params */
|
ret = curHdl->updateConfig(true);
|
RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d update initial user params failed", curHdl->getAlgoType());
|
algoHdl->setReConfig(mState == RK_AIQ_CORE_STATE_STOPED);
|
ret = curHdl->prepare();
|
RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d prepare failed", curHdl->getAlgoType());
|
}
|
curHdl = curHdl->getNextHdl();
|
}
|
}
|
|
|
mAlogsComSharedParams.init = true;
|
analyzeInternal(RK_AIQ_CORE_ANALYZE_ALL);
|
mAlogsComSharedParams.init = false;
|
|
mState = RK_AIQ_CORE_STATE_PREPARED;
|
|
EXIT_ANALYZER_FUNCTION();
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
SmartPtr<RkAiqFullParamsProxy>
|
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();
|
shared->frameId = 0;
|
|
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<RkAiqFullParamsProxy> 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();
|
|
ret = getAiqParamsBuffer(aiqParams, type);
|
RKAIQCORE_CHECK_RET_NULL(ret, "get params failed");
|
|
ret = preProcess(type);
|
RKAIQCORE_CHECK_RET_NULL(ret, "preprocess failed");
|
#if 0
|
// moved to RkAiqAsdHandleInt::genIspResult,
|
// may have module params sync issue
|
if (type == RK_AIQ_CORE_ANALYZE_OTHER) {
|
genCpslResult(aiqParams);
|
}
|
#endif
|
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; \
|
}
|
|
#define NEW_PARAMS_BUFFER_WITH_V(lc, BC, v) \
|
if (mAiqIsp##lc##V##v##ParamsPool->has_free_items()) { \
|
aiqParams->m##lc##V##v##Params = mAiqIsp##lc##V##v##ParamsPool->get_item(); \
|
} else { \
|
LOGE_ANALYZER("no free %s buffer!", #BC); \
|
return XCAM_RETURN_ERROR_MEM; \
|
}
|
|
std::vector<SmartPtr<RkAiqHandle>>& algo_list =
|
mRkAiqCoreGroupManager->getGroupAlgoList(type);
|
|
for (auto& algoHdl : algo_list) {
|
bool get_buffer = false;
|
RkAiqHandle* curHdl = algoHdl.ptr();
|
while (curHdl) {
|
if (curHdl->getEnable()) {
|
get_buffer = true;
|
break;
|
}
|
curHdl = curHdl->getNextHdl();
|
}
|
if (!get_buffer)
|
continue;
|
switch (algoHdl->getAlgoType()) {
|
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:
|
#if defined(ISP_HW_V30)
|
NEW_PARAMS_BUFFER_WITH_V(Awb, awb, 3x);
|
#elif defined(ISP_HW_V21)
|
NEW_PARAMS_BUFFER_WITH_V(Awb, awb, 21);
|
#else
|
NEW_PARAMS_BUFFER(Awb, awb);
|
#endif
|
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;
|
}
|
#if defined(ISP_HW_V30)
|
NEW_PARAMS_BUFFER_WITH_V(Af, af, 3x);
|
#else
|
NEW_PARAMS_BUFFER(Af, af);
|
#endif
|
break;
|
case RK_AIQ_ALGO_TYPE_ABLC:
|
#if defined(ISP_HW_V30) || defined(ISP_HW_V21)
|
NEW_PARAMS_BUFFER_WITH_V(Blc, blc, 21);
|
#else
|
NEW_PARAMS_BUFFER(Blc, blc);
|
#endif
|
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_ACSM:
|
NEW_PARAMS_BUFFER(Csm, csm);
|
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:
|
NEW_PARAMS_BUFFER(Drc, drc);
|
break;
|
case RK_AIQ_ALGO_TYPE_ADEGAMMA:
|
NEW_PARAMS_BUFFER(Adegamma, adegamma);
|
break;
|
case RK_AIQ_ALGO_TYPE_ARAWNR:
|
#if defined(ISP_HW_V30)
|
NEW_PARAMS_BUFFER_WITH_V(Baynr, baynr, 3x);
|
#elif defined(ISP_HW_V21)
|
NEW_PARAMS_BUFFER_WITH_V(Baynr, baynr, 21);
|
#else
|
NEW_PARAMS_BUFFER(Rawnr, rawnr);
|
#endif
|
break;
|
case RK_AIQ_ALGO_TYPE_AMFNR:
|
#if defined(ISP_HW_V30)
|
NEW_PARAMS_BUFFER_WITH_V(Tnr, tnr, 3x);
|
#else
|
NEW_PARAMS_BUFFER(Tnr, tnr);
|
#endif
|
break;
|
case RK_AIQ_ALGO_TYPE_AYNR:
|
#if defined(ISP_HW_V30)
|
NEW_PARAMS_BUFFER_WITH_V(Ynr, ynr, 3x);
|
#elif defined(ISP_HW_V21)
|
NEW_PARAMS_BUFFER_WITH_V(Ynr, ynr, 21);
|
#else
|
NEW_PARAMS_BUFFER(Ynr, ynr);
|
#endif
|
break;
|
case RK_AIQ_ALGO_TYPE_ACNR:
|
#if defined(ISP_HW_V30)
|
NEW_PARAMS_BUFFER_WITH_V(Cnr, cnr, 3x);
|
#elif defined(ISP_HW_V21)
|
NEW_PARAMS_BUFFER_WITH_V(Cnr, cnr, 21);
|
#else
|
NEW_PARAMS_BUFFER(Uvnr, uvnr);
|
#endif
|
break;
|
case RK_AIQ_ALGO_TYPE_ASHARP:
|
#if defined(ISP_HW_V30)
|
NEW_PARAMS_BUFFER_WITH_V(Sharpen, sharpen, 3x);
|
#elif defined(ISP_HW_V21)
|
NEW_PARAMS_BUFFER_WITH_V(Sharpen, sharpen, 21);
|
#else
|
NEW_PARAMS_BUFFER(Sharpen, sharpen);
|
NEW_PARAMS_BUFFER(Edgeflt, edgeflt);
|
#endif
|
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;
|
case RK_AIQ_ALGO_TYPE_AGAIN:
|
#if defined(ISP_HW_V30)
|
NEW_PARAMS_BUFFER_WITH_V(Gain, Gain, 3x);
|
#endif
|
break;
|
case RK_AIQ_ALGO_TYPE_ACAC:
|
NEW_PARAMS_BUFFER_WITH_V(Cac, cac, 3x);
|
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<RkAiqFullParams> curParams = mAiqCurParams->data();
|
|
std::vector<SmartPtr<RkAiqHandle>>& algo_list =
|
mRkAiqCoreGroupManager->getGroupAlgoList(type);
|
|
for (auto& algoHdl : algo_list) {
|
RkAiqHandle* curHdl = algoHdl.ptr();
|
// only last one result of same type algo will take effect
|
while (curHdl) {
|
if (curHdl->getEnable()) curHdl->genIspResult(aiqParams, curParams.ptr());
|
curHdl = curHdl->getNextHdl();
|
}
|
}
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
RkAiqCore::pushStats(SmartPtr<VideoBuffer> &buffer)
|
{
|
ENTER_ANALYZER_FUNCTION();
|
|
XCAM_ASSERT(buffer.ptr());
|
mRkAiqCoreTh->push_stats(buffer);
|
EXIT_ANALYZER_FUNCTION();
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
RkAiqCore::pushEvts(SmartPtr<ispHwEvt_t> &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;
|
}
|
|
RkAiqHandle*
|
RkAiqCore::getAiqAlgoHandle(const int algo_type)
|
{
|
// get defalut algo handle(id == 0)
|
SmartPtr<RkAiqHandle>* handlePtr = getCurAlgoTypeHandle(algo_type);
|
if (handlePtr == nullptr) {
|
return NULL;
|
}
|
|
return (*handlePtr).ptr();
|
}
|
|
SmartPtr<RkAiqHandle>*
|
RkAiqCore::getCurAlgoTypeHandle(int algo_type)
|
{
|
// get defalut algo handle(id == 0)
|
if (mCurAlgoHandleMaps.find(algo_type) != mCurAlgoHandleMaps.end())
|
return &mCurAlgoHandleMaps.at(algo_type);
|
|
LOGE("can't find algo handle %d", algo_type);
|
return NULL;
|
}
|
|
std::map<int, SmartPtr<RkAiqHandle>>*
|
RkAiqCore::getAlgoTypeHandleMap(int algo_type)
|
{
|
if (mAlgoHandleMaps.find(algo_type) != mAlgoHandleMaps.end())
|
return &mAlgoHandleMaps.at(algo_type);
|
|
LOGE("can't find algo map %d", algo_type);
|
return NULL;
|
}
|
|
// add rk default handlers(id == 0), can't be removed
|
void
|
RkAiqCore::addDefaultAlgos(const struct RkAiqAlgoDesCommExt* algoDes)
|
{
|
map<int, SmartPtr<RkAiqHandle>> algoMap;
|
for (int i = 0; i < RK_AIQ_ALGO_TYPE_MAX; i++) {
|
#ifdef RKAIQ_ENABLE_PARSER_V1
|
mAlogsComSharedParams.ctxCfigs[i].calib =
|
const_cast<CamCalibDbContext_t*>(mAlogsComSharedParams.calib);
|
#endif
|
mAlogsComSharedParams.ctxCfigs[i].calibv2 =
|
const_cast<CamCalibDbV2Context_t*>(mAlogsComSharedParams.calibv2);
|
mAlogsComSharedParams.ctxCfigs[i].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 (!((1ULL << algo_type) & mCustomEnAlgosMask))
|
continue;
|
int32_t grpMask = 1ULL << algoDes[i].group;
|
#ifdef RKAIQ_ENABLE_PARSER_V1
|
mAlogsComSharedParams.ctxCfigs[algo_type].calib =
|
const_cast<CamCalibDbContext_t*>(mAlogsComSharedParams.calib);
|
#endif
|
mAlogsComSharedParams.ctxCfigs[algo_type].calibv2 =
|
const_cast<CamCalibDbV2Context_t*>(mAlogsComSharedParams.calibv2);
|
mAlogsComSharedParams.ctxCfigs[algo_type].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, algoDes[i].algo_ver, algoDes[i].handle_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<RkAiqHandle>
|
RkAiqCore::newAlgoHandle(RkAiqAlgoDesComm* algo, int hw_ver, int handle_ver)
|
{
|
std::string className = "RkAiq";
|
className.append(AlgoTypeToString(algo->type));
|
if (handle_ver)
|
className.append("V" + std::to_string(handle_ver));
|
className.append("HandleInt");
|
LOGD_ANALYZER("Creating algorithm: %s, version: %d", className.c_str(), hw_ver);
|
return SmartPtr<RkAiqHandle>(RkAiqHandleFactory::createInstance(className, algo, this));
|
}
|
|
// register custom algos
|
XCamReturn
|
RkAiqCore::addAlgo(RkAiqAlgoDesComm& algo)
|
{
|
ENTER_ANALYZER_FUNCTION();
|
|
std::map<int, SmartPtr<RkAiqHandle>>* 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<int, SmartPtr<RkAiqHandle>>::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++;
|
}
|
|
SmartPtr<RkAiqHandle> new_hdl;
|
if (algo.type == RK_AIQ_ALGO_TYPE_AE)
|
new_hdl = new RkAiqCustomAeHandle(&algo, this);
|
else if (algo.type == RK_AIQ_ALGO_TYPE_AWB)
|
new_hdl = new RkAiqCustomAwbHandle(&algo, this);
|
else {
|
LOGE_ANALYZER("not supported custom algo type: %d ", algo.type);
|
return XCAM_RETURN_ERROR_FAILED;
|
}
|
new_hdl->setEnable(false);
|
new_hdl->setGroupId((*algo_map)[0]->getGroupId());
|
new_hdl->setGroupShared((*algo_map)[0]->getGroupShared());
|
rit->second->setNextHdl(new_hdl.ptr());
|
new_hdl->setParentHdl((*algo_map)[0].ptr());
|
|
(*algo_map)[algo.id] = new_hdl;
|
|
EXIT_ANALYZER_FUNCTION();
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
void
|
RkAiqCore::setReqAlgoResMask(int algoType, bool req)
|
{
|
uint64_t tmp = 0;
|
switch (algoType) {
|
case RK_AIQ_ALGO_TYPE_AE:
|
tmp |= (uint64_t)1 << RESULT_TYPE_EXPOSURE_PARAM;
|
tmp |= (uint64_t)1 << RESULT_TYPE_AEC_PARAM;
|
tmp |= (uint64_t)1 << RESULT_TYPE_HIST_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_AWB:
|
tmp |= (uint64_t)1 << RESULT_TYPE_AWB_PARAM;
|
tmp |= (uint64_t)1 << RESULT_TYPE_AWBGAIN_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_AF:
|
tmp |= (uint64_t)1 << RESULT_TYPE_AF_PARAM;
|
tmp |= (uint64_t)1 << RESULT_TYPE_FOCUS_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ADPCC:
|
tmp |= (uint64_t)1 << RESULT_TYPE_DPCC_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_AMERGE:
|
tmp |= (uint64_t)1 << RESULT_TYPE_MERGE_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ATMO:
|
tmp |= (uint64_t)1 << RESULT_TYPE_TMO_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ACCM:
|
tmp |= (uint64_t)1 << RESULT_TYPE_CCM_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ALSC:
|
tmp |= (uint64_t)1 << RESULT_TYPE_LSC_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ABLC:
|
tmp |= (uint64_t)1 << RESULT_TYPE_BLC_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ARAWNR:
|
tmp |= (uint64_t)1 << RESULT_TYPE_RAWNR_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_AGIC:
|
tmp |= (uint64_t)1 << RESULT_TYPE_GIC_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ADEBAYER:
|
tmp |= (uint64_t)1 << RESULT_TYPE_DEBAYER_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ALDCH:
|
tmp |= (uint64_t)1 << RESULT_TYPE_LDCH_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_A3DLUT:
|
tmp |= (uint64_t)1 << RESULT_TYPE_LUT3D_PARAM ;
|
break;
|
case RK_AIQ_ALGO_TYPE_ADHAZ:
|
tmp |= (uint64_t)1 << RESULT_TYPE_DEHAZE_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_AGAMMA:
|
tmp |= (uint64_t)1 << RESULT_TYPE_AGAMMA_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ADEGAMMA:
|
tmp |= (uint64_t)1 << RESULT_TYPE_ADEGAMMA_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_AWDR:
|
tmp |= (uint64_t)1 << RESULT_TYPE_WDR_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_AGAIN:
|
tmp |= (uint64_t)1 << RESULT_TYPE_GAIN_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ACP:
|
tmp |= (uint64_t)1 << RESULT_TYPE_CP_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ACSM:
|
tmp |= (uint64_t)1 << RESULT_TYPE_CSM_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_AIE:
|
tmp |= (uint64_t)1 << RESULT_TYPE_IE_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_AMD:
|
tmp |= (uint64_t)1 << RESULT_TYPE_MOTION_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_AMFNR:
|
tmp |= (uint64_t)1 << RESULT_TYPE_TNR_PARAM ;
|
break;
|
case RK_AIQ_ALGO_TYPE_AYNR:
|
tmp |= (uint64_t)1 << RESULT_TYPE_YNR_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ACNR:
|
tmp |= (uint64_t)1 << RESULT_TYPE_UVNR_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ASHARP:
|
tmp |= (uint64_t)1 << RESULT_TYPE_SHARPEN_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_AFEC:
|
case RK_AIQ_ALGO_TYPE_AEIS:
|
tmp |= (uint64_t)1 << RESULT_TYPE_FEC_PARAM;
|
break;
|
case RK_AIQ_ALGO_TYPE_ADRC:
|
tmp |= (uint64_t)1 << RESULT_TYPE_DRC_PARAM ;
|
break;
|
case RK_AIQ_ALGO_TYPE_ACAC:
|
tmp |= (uint64_t)1 << RESULT_TYPE_CAC_PARAM ;
|
break;
|
default:
|
break;
|
}
|
|
if (req) {
|
mAllReqAlgoResMask |= tmp;
|
} else {
|
mAllReqAlgoResMask &= ~tmp;
|
}
|
}
|
|
XCamReturn
|
RkAiqCore::enableAlgo(int algoType, int id, bool enable)
|
{
|
ENTER_ANALYZER_FUNCTION();
|
// get default algotype handle, id should be 0
|
SmartPtr<RkAiqHandle>* 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<int, SmartPtr<RkAiqHandle>>* algo_map = getAlgoTypeHandleMap(algoType);
|
NULL_RETURN_RET(algo_map, XCAM_RETURN_ERROR_FAILED);
|
std::map<int, SmartPtr<RkAiqHandle>>::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;
|
}
|
|
SmartLock locker (mApiMutex);
|
while (mSafeEnableAlgo != true)
|
mApiMutexCond.wait(mApiMutex);
|
|
LOGI_ANALYZER("set algo type_id <%d,%d> to %d", algoType, id, enable);
|
|
it->second->setEnable(enable);
|
/* WARNING:
|
* Be careful when use SmartPtr<RkAiqxxxHandle> = SmartPtr<RkAiqHandle>
|
* 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) {
|
if (mState >= RK_AIQ_CORE_STATE_PREPARED)
|
it->second->prepare();
|
}
|
|
int enable_cnt = 0;
|
RkAiqHandle* curHdl = (*cur_algo_hdl).ptr();
|
|
while (curHdl) {
|
if (curHdl->getEnable()) {
|
enable_cnt++;
|
}
|
curHdl = curHdl->getNextHdl();
|
}
|
|
setReqAlgoResMask(algoType, enable_cnt > 0 ? true : false);
|
|
curHdl = (*cur_algo_hdl).ptr();
|
|
while (curHdl) {
|
curHdl->setMulRun(enable_cnt > 1 ? true : false);
|
curHdl = curHdl->getNextHdl();
|
}
|
|
LOGI_ANALYZER("algo type %d enabled count :%d", algoType, enable_cnt);
|
|
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<RkAiqHandle>* 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<int, SmartPtr<RkAiqHandle>>* algo_map = getAlgoTypeHandleMap(algoType);
|
NULL_RETURN_RET(algo_map, XCAM_RETURN_ERROR_FAILED);
|
std::map<int, SmartPtr<RkAiqHandle>>::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;
|
}
|
|
SmartLock locker (mApiMutex);
|
while (mState == RK_AIQ_CORE_STATE_RUNNING && mSafeEnableAlgo != true)
|
mApiMutexCond.wait(mApiMutex);
|
|
RkAiqHandle* rmHdl = it->second.ptr();
|
RkAiqHandle* curHdl = (*cur_algo_hdl).ptr();
|
while (curHdl) {
|
RkAiqHandle* nextHdl = curHdl->getNextHdl();
|
if (nextHdl == rmHdl) {
|
curHdl->setNextHdl(nextHdl->getNextHdl());
|
break;
|
}
|
curHdl = nextHdl;
|
}
|
|
algo_map->erase(it);
|
|
EXIT_ANALYZER_FUNCTION();
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
bool
|
RkAiqCore::getAxlibStatus(int algoType, int id)
|
{
|
std::map<int, SmartPtr<RkAiqHandle>>* algo_map = getAlgoTypeHandleMap(algoType);
|
NULL_RETURN_RET(algo_map, false);
|
std::map<int, SmartPtr<RkAiqHandle>>::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();
|
}
|
|
// get the last enabled ctx of same type
|
RkAiqAlgoContext*
|
RkAiqCore::getEnabledAxlibCtx(const int algo_type)
|
{
|
if (algo_type <= RK_AIQ_ALGO_TYPE_NONE ||
|
algo_type >= RK_AIQ_ALGO_TYPE_MAX)
|
return NULL;
|
|
std::map<int, SmartPtr<RkAiqHandle>>* algo_map = getAlgoTypeHandleMap(algo_type);
|
std::map<int, SmartPtr<RkAiqHandle>>::reverse_iterator rit = algo_map->rbegin();
|
if (rit != algo_map->rend() && rit->second->getEnable())
|
return rit->second->getAlgoCtx();
|
else
|
return NULL;
|
}
|
|
|
RkAiqAlgoContext*
|
RkAiqCore::getAxlibCtx(const int algo_type, const int lib_id)
|
{
|
if (algo_type <= RK_AIQ_ALGO_TYPE_NONE ||
|
algo_type >= RK_AIQ_ALGO_TYPE_MAX)
|
return NULL;
|
|
std::map<int, SmartPtr<RkAiqHandle>>* algo_map = getAlgoTypeHandleMap(algo_type);
|
|
std::map<int, SmartPtr<RkAiqHandle>>::iterator it = algo_map->find(lib_id);
|
|
if (it != algo_map->end()) {
|
return it->second->getAlgoCtx();
|
}
|
|
EXIT_ANALYZER_FUNCTION();
|
|
return NULL;
|
|
}
|
|
void
|
RkAiqCore::copyIspStats(SmartPtr<RkAiqAecStatsProxy>& aecStat,
|
SmartPtr<RkAiqAwbStatsProxy>& awbStat,
|
SmartPtr<RkAiqAfStatsProxy>& afStat,
|
rk_aiq_isp_stats_t* to)
|
{
|
if (aecStat.ptr()) {
|
to->aec_stats = aecStat->data()->aec_stats;
|
to->frame_id = aecStat->data()->frame_id;
|
}
|
if (mIspHwVer == 3) {
|
to->awb_hw_ver = 3;
|
if (awbStat.ptr()) {
|
memcpy(to->awb_stats_v3x.light, awbStat->data()->awb_stats_v3x.light,
|
sizeof(to->awb_stats_v3x.light));
|
#ifdef ISP_HW_V30
|
memcpy(to->awb_stats_v3x.WpNo2, awbStat->data()->awb_stats_v3x.WpNo2,
|
sizeof(to->awb_stats_v3x.WpNo2));
|
#endif
|
memcpy(to->awb_stats_v3x.blockResult, awbStat->data()->awb_stats_v3x.blockResult,
|
sizeof(to->awb_stats_v3x.blockResult));
|
#ifdef ISP_HW_V30
|
memcpy(to->awb_stats_v3x.multiwindowLightResult,
|
awbStat->data()->awb_stats_v3x.multiwindowLightResult,
|
sizeof(to->awb_stats_v3x.multiwindowLightResult));
|
memcpy(to->awb_stats_v3x.excWpRangeResult,
|
awbStat->data()->awb_stats_v3x.excWpRangeResult,
|
sizeof(to->awb_stats_v3x.excWpRangeResult));
|
#endif
|
memcpy(to->awb_stats_v3x.WpNoHist, awbStat->data()->awb_stats_v3x.WpNoHist,
|
sizeof(to->awb_stats_v3x.WpNoHist));
|
}
|
} else if (mIspHwVer == 1) {
|
to->awb_hw_ver = 1;
|
if (awbStat.ptr()) {
|
memcpy(to->awb_stats_v21.light, awbStat->data()->awb_stats_v201.light,
|
sizeof(to->awb_stats_v21.light));
|
memcpy(to->awb_stats_v21.blockResult, awbStat->data()->awb_stats_v201.blockResult,
|
sizeof(to->awb_stats_v21.blockResult));
|
memcpy(to->awb_stats_v21.WpNoHist, awbStat->data()->awb_stats_v201.WpNoHist,
|
sizeof(to->awb_stats_v21.WpNoHist));
|
}
|
} else {
|
to->awb_hw_ver = 0;
|
if (awbStat.ptr()) to->awb_stats_v200 = awbStat->data()->awb_stats;
|
}
|
if (mIspHwVer == 3) {
|
to->af_hw_ver = RKAIQ_AF_HW_V30;
|
if (afStat.ptr()) to->af_stats_v3x = afStat->data()->af_stats_v3x;
|
} else {
|
to->af_hw_ver = RKAIQ_AF_HW_V20;
|
if (afStat.ptr()) to->af_stats = afStat->data()->af_stats;
|
}
|
}
|
|
void
|
RkAiqCore::cacheIspStatsToList(SmartPtr<RkAiqAecStatsProxy>& aecStat,
|
SmartPtr<RkAiqAwbStatsProxy>& awbStat,
|
SmartPtr<RkAiqAfStatsProxy>& afStat)
|
{
|
SmartLock locker (ispStatsListMutex);
|
SmartPtr<RkAiqStatsProxy> 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<RkAiqStatsProxy> 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<rk_aiq_isp_stats_t*, SmartPtr<RkAiqStatsProxy>>::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<RkAiqStatsProxy> 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<VideoBuffer> &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<RkAiqAecStatsProxy> aecStat = NULL;
|
SmartPtr<RkAiqAwbStatsProxy> awbStat = NULL;
|
SmartPtr<RkAiqAfStatsProxy> afStat = NULL;
|
SmartPtr<RkAiqAtmoStatsProxy> tmoStat = NULL;
|
SmartPtr<RkAiqAdehazeStatsProxy> dehazeStat = NULL;
|
handleAecStats(buffer, aecStat);
|
handleAwbStats(buffer, awbStat);
|
handleAfStats(buffer, afStat);
|
handleAtmoStats(buffer, tmoStat);
|
handleAdehazeStats(buffer, dehazeStat);
|
handleIspStats(buffer, aecStat, awbStat, afStat, tmoStat, dehazeStat);
|
cacheIspStatsToList(aecStat, awbStat, afStat);
|
}
|
break;
|
case ISPP_POLL_TNR_STATS:
|
break;
|
case ISPP_POLL_NR_STATS:
|
handleOrbStats(buffer);
|
break;
|
case ISP_POLL_SP:
|
{
|
SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ISP_POLL_SP_OK,
|
buffer->get_sequence(), buffer);
|
post_message(msg);
|
break;
|
}
|
case ISP_GAIN:
|
{
|
SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ISP_GAIN_OK,
|
buffer->get_sequence(), buffer);
|
post_message(msg);
|
break;
|
}
|
case ISPP_GAIN_KG:
|
{
|
SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ISPP_GAIN_KG_OK,
|
buffer->get_sequence(), buffer);
|
post_message(msg);
|
break;
|
}
|
case ISPP_GAIN_WR:
|
{
|
SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ISPP_GAIN_WR_OK,
|
buffer->get_sequence(), buffer);
|
post_message(msg);
|
break;
|
}
|
case ISP_NR_IMG:
|
{
|
SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_NR_IMG_OK,
|
buffer->get_sequence(), buffer);
|
post_message(msg);
|
break;
|
}
|
case ISP_POLL_TX:
|
{
|
SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ISP_POLL_TX_OK,
|
buffer->get_sequence(), buffer);
|
post_message(msg);
|
break;
|
}
|
case ISP_POLL_PDAF_STATS:
|
{
|
handlePdafStats(buffer);
|
break;
|
}
|
defalut:
|
LOGW_ANALYZER("don't know buffer type: 0x%x!", buffer->_buf_type);
|
break;
|
}
|
|
return ret;
|
}
|
|
XCamReturn
|
RkAiqCore::events_analyze(const SmartPtr<ispHwEvt_t> &evts)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
SmartPtr<RkAiqExpParamsProxy> preExpParams = nullptr;
|
SmartPtr<RkAiqExpParamsProxy> curExpParams = nullptr;
|
SmartPtr<RkAiqExpParamsProxy> nxtExpParams = nullptr;
|
|
const SmartPtr<Isp20Evt> isp20Evts =
|
evts.dynamic_cast_ptr<Isp20Evt>();
|
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 - 1;
|
|
LOGD_ANALYZER("camId:%d, sequence(%d), expDelay(%d), id(%d), maxId(%d)",
|
mAlogsComSharedParams.mCamPhyId,
|
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;
|
}
|
if (isp20Evts->getExpInfoParams(nxtExpParams, id + 1) < 0) {
|
LOGE_ANALYZER("id(%d) get exp failed!", id + 1);
|
break;
|
}
|
|
SmartPtr<RkAiqSofInfoWrapperProxy> 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()->nxtExp = nxtExpParams;
|
sofInfo->data()->sof = isp20Evts->getSofTimeStamp();
|
|
|
sofInfo->setId(id);
|
sofInfo->setType(RK_AIQ_SHARED_TYPE_SOF_INFO);
|
|
SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_SOF_INFO_OK, id, sofInfo);
|
post_message(msg);
|
|
mLastAnalyzedId = id;
|
id++;
|
|
LOGD_ANALYZER(">>> Framenum=%d, id=%d, Cur sgain=%f,stime=%f,mgain=%f,mtime=%f,lgain=%f,ltime=%f",
|
isp20Evts->sequence, id, curExpParams->data()->aecExpInfo.HdrExp[0].exp_real_params.analog_gain,
|
curExpParams->data()->aecExpInfo.HdrExp[0].exp_real_params.integration_time,
|
curExpParams->data()->aecExpInfo.HdrExp[1].exp_real_params.analog_gain,
|
curExpParams->data()->aecExpInfo.HdrExp[1].exp_real_params.integration_time,
|
curExpParams->data()->aecExpInfo.HdrExp[2].exp_real_params.analog_gain,
|
curExpParams->data()->aecExpInfo.HdrExp[2].exp_real_params.integration_time);
|
LOGD_ANALYZER(">>> Framenum=%d, id=%d, nxt sgain=%f,stime=%f,mgain=%f,mtime=%f,lgain=%f,ltime=%f",
|
isp20Evts->sequence, id, nxtExpParams->data()->aecExpInfo.HdrExp[0].exp_real_params.analog_gain,
|
nxtExpParams->data()->aecExpInfo.HdrExp[0].exp_real_params.integration_time,
|
nxtExpParams->data()->aecExpInfo.HdrExp[1].exp_real_params.analog_gain,
|
nxtExpParams->data()->aecExpInfo.HdrExp[1].exp_real_params.integration_time,
|
nxtExpParams->data()->aecExpInfo.HdrExp[2].exp_real_params.analog_gain,
|
nxtExpParams->data()->aecExpInfo.HdrExp[2].exp_real_params.integration_time);
|
|
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::vector<SmartPtr<RkAiqHandle>>& algo_list =
|
mRkAiqCoreGroupManager->getGroupAlgoList(type);
|
|
for (auto& algoHdl : algo_list) {
|
RkAiqHandle* curHdl = algoHdl.ptr();
|
while (curHdl) {
|
if (curHdl->getEnable()) {
|
ret = curHdl->updateConfig(true);
|
RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d updateConfig failed", curHdl->getAlgoType());
|
ret = curHdl->preProcess();
|
RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d processing failed", curHdl->getAlgoType());
|
}
|
curHdl = curHdl->getNextHdl();
|
}
|
}
|
|
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::vector<SmartPtr<RkAiqHandle>>& algo_list =
|
mRkAiqCoreGroupManager->getGroupAlgoList(type);
|
|
for (auto& algoHdl : algo_list) {
|
RkAiqHandle* curHdl = algoHdl.ptr();
|
while (curHdl) {
|
if (curHdl->getEnable()) {
|
ret = curHdl->processing();
|
RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d processing failed", curHdl->getAlgoType());
|
}
|
curHdl = curHdl->getNextHdl();
|
}
|
}
|
|
|
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::vector<SmartPtr<RkAiqHandle>>& algo_list =
|
mRkAiqCoreGroupManager->getGroupAlgoList(type);
|
|
for (auto& algoHdl : algo_list) {
|
if (algoHdl.ptr() && algoHdl->getEnable()) {
|
ret = algoHdl->postProcess();
|
RKAIQCORE_CHECK_BYPASS(ret, "algoHdl %d postProcess failed", algoHdl->getAlgoType());
|
}
|
}
|
|
EXIT_ANALYZER_FUNCTION();
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
RkAiqCore::setHwInfos(struct RkAiqHwInfo &hw_info)
|
{
|
ENTER_ANALYZER_FUNCTION();
|
mHwInfo = hw_info;
|
if (mTranslator.ptr())
|
mTranslator->setModuleRot(mHwInfo.module_rotation);
|
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, RkAiqAlgoPreResAsd* asd_pre_rk)
|
{
|
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;
|
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;
|
}
|
|
RkAiqAlgosGroupShared_t* shared = nullptr;
|
int groupId = getGroupId(RK_AIQ_ALGO_TYPE_ASD);
|
if (groupId >= 0) {
|
if (getGroupSharedParams(groupId, shared) == XCAM_RETURN_NO_ERROR) {
|
if (mAlogsComSharedParams.init)
|
cpsl_param->frame_id = 0;
|
else
|
cpsl_param->frame_id = shared->frameId;
|
}
|
}
|
|
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;
|
}
|
|
#ifdef RKAIQ_ENABLE_PARSER_V1
|
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;
|
}
|
#endif
|
|
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::list<RkAiqAlgoType_t>>();
|
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<RkAiqAlgoType_t>::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<XCamMessage> &msg)
|
{
|
mRkAiqCoreGroupManager->handleMessage(msg);
|
#ifdef RKAIQ_ENABLE_CAMGROUP
|
if (mCamGroupCoreManager)
|
mCamGroupCoreManager->processAiqCoreMsgs(this, msg);
|
#endif
|
}
|
|
XCamReturn
|
RkAiqCore::handle_message (const SmartPtr<XCamMessage> &msg)
|
{
|
//return mRkAiqCoreGroupManager->handleMessage(msg);
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn RkAiqCore::groupAnalyze(uint64_t grpId, const RkAiqAlgosGroupShared_t* shared) {
|
ENTER_ANALYZER_FUNCTION();
|
|
SmartPtr<RkAiqFullParamsProxy> fullParam;
|
|
fullParam = analyzeInternal(static_cast<rk_aiq_core_analyze_type_e>(grpId));
|
if (fullParam.ptr()) {
|
#ifdef RKAIQ_ENABLE_CAMGROUP
|
if (mCamGroupCoreManager)
|
mCamGroupCoreManager->RelayAiqCoreResults(this, fullParam);
|
else if (mCb)
|
#else
|
if (mCb)
|
#endif
|
mCb->rkAiqCalcDone(fullParam);
|
}
|
|
EXIT_ANALYZER_FUNCTION();
|
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;
|
}
|
|
void RkAiqCore::newAiqParamsPool()
|
{
|
for (auto& algoHdl : mCurIspAlgoHandleList) {
|
bool alloc_pool = false;
|
RkAiqHandle* curHdl = algoHdl.ptr();
|
while (curHdl) {
|
if (curHdl->getEnable()) {
|
alloc_pool = true;
|
break;
|
}
|
curHdl = curHdl->getNextHdl();
|
}
|
if (alloc_pool) {
|
switch (algoHdl->getAlgoType()) {
|
case RK_AIQ_ALGO_TYPE_AE:
|
if (!mAiqAecStatsPool.ptr())
|
mAiqAecStatsPool = new RkAiqAecStatsPool("RkAiqAecStatsPool", RkAiqCore::DEFAULT_POOL_SIZE);
|
mAiqExpParamsPool =
|
new RkAiqExpParamsPool("RkAiqExpParams", MAX_AEC_EFFECT_FNUM * 4);
|
mAiqIrisParamsPool = new RkAiqIrisParamsPool("RkAiqIrisParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
mAiqIspAecParamsPool =
|
new RkAiqIspAecParamsPool("RkAiqIspAecParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
mAiqIspHistParamsPool =
|
new RkAiqIspHistParamsPool("RkAiqIspHistParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
break;
|
case RK_AIQ_ALGO_TYPE_AWB:
|
if (!mAiqAwbStatsPool.ptr())
|
mAiqAwbStatsPool = new RkAiqAwbStatsPool("RkAiqAwbStatsPool", RkAiqCore::DEFAULT_POOL_SIZE);
|
#if defined(ISP_HW_V30)
|
mAiqIspAwbV3xParamsPool = new RkAiqIspAwbParamsPoolV3x(
|
"RkAiqIspAwbV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#elif defined(ISP_HW_V21)
|
mAiqIspAwbV21ParamsPool = new RkAiqIspAwbParamsPoolV21(
|
"RkAiqIspAwbV21Params", RkAiqCore::DEFAULT_POOL_SIZE);
|
#else
|
mAiqIspAwbParamsPool =
|
new RkAiqIspAwbParamsPool("RkAiqIspAwbParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#endif
|
mAiqIspAwbGainParamsPool = new RkAiqIspAwbGainParamsPool(
|
"RkAiqIspAwbGainParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
break;
|
case RK_AIQ_ALGO_TYPE_AF:
|
if (!mAiqAfStatsPool.ptr())
|
mAiqAfStatsPool = new RkAiqAfStatsPool("RkAiqAfStatsPool", RkAiqCore::DEFAULT_POOL_SIZE);
|
if (!mAiqPdafStatsPool.ptr())
|
mAiqPdafStatsPool = new RkAiqPdafStatsPool("RkAiqPdafStatsPool", RkAiqCore::DEFAULT_POOL_SIZE);
|
mAiqFocusParamsPool = new RkAiqFocusParamsPool("RkAiqFocusParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#if defined(ISP_HW_V30)
|
mAiqIspAfV3xParamsPool =
|
new RkAiqIspAfParamsPoolV3x("RkAiqIspAfParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#else
|
mAiqIspAfParamsPool =
|
new RkAiqIspAfParamsPool("RkAiqIspAfParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#endif
|
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:
|
if (!mAiqAtmoStatsPool.ptr())
|
mAiqAtmoStatsPool = new RkAiqAtmoStatsPool("RkAiqAtmoStatsPool", 10);
|
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:
|
#if defined(ISP_HW_V21) || defined(ISP_HW_V30)
|
mAiqIspBlcV21ParamsPool = new RkAiqIspBlcParamsPoolV21("RkAiqIspBlcParamsV21", RkAiqCore::DEFAULT_POOL_SIZE);
|
#else
|
mAiqIspBlcParamsPool = new RkAiqIspBlcParamsPool("RkAiqIspBlcParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#endif
|
break;
|
case RK_AIQ_ALGO_TYPE_ARAWNR:
|
#if defined(ISP_HW_V30)
|
mAiqIspBaynrV3xParamsPool = new RkAiqIspBaynrParamsPoolV3x("RkAiqIspRawnrParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#elif defined(ISP_HW_V21)
|
mAiqIspBaynrV21ParamsPool = new RkAiqIspBaynrParamsPoolV21("RkAiqIspRawnrParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#else
|
mAiqIspRawnrParamsPool = new RkAiqIspRawnrParamsPool("RkAiqIspRawnrParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#endif
|
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:
|
if (!mAiqAdehazeStatsPool.ptr())
|
mAiqAdehazeStatsPool = new RkAiqAdehazeStatsPool("RkAiqAdehazeStatsPool", RkAiqCore::DEFAULT_POOL_SIZE);
|
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_ACSM:
|
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:
|
#if defined(ISP_HW_V30)
|
mAiqIspGainV3xParamsPool = new RkAiqIspGainParamsPoolV3x("RkAiqIspGainV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#else
|
mAiqIspGainParamsPool = new RkAiqIspGainParamsPool("RkAiqIspGainParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#endif
|
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:
|
#if defined(ISP_HW_V30)
|
mAiqIspTnrV3xParamsPool = new RkAiqIspTnrParamsPoolV3x("RkAiqIspTnrV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#else
|
mAiqIspTnrParamsPool = new RkAiqIspTnrParamsPool("RkAiqIspTnrParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#endif
|
break;
|
case RK_AIQ_ALGO_TYPE_AYNR:
|
#if defined(ISP_HW_V30)
|
mAiqIspYnrV3xParamsPool = new RkAiqIspYnrParamsPoolV3x("RkAiqIspYnrV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#elif defined(ISP_HW_V21)
|
mAiqIspYnrV21ParamsPool = new RkAiqIspYnrParamsPoolV21("RkAiqIspYnrV21Params", RkAiqCore::DEFAULT_POOL_SIZE);
|
#else
|
mAiqIspYnrParamsPool = new RkAiqIspYnrParamsPool("RkAiqIspYnrParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#endif
|
break;
|
case RK_AIQ_ALGO_TYPE_ACNR:
|
#if defined(ISP_HW_V30)
|
mAiqIspCnrV3xParamsPool = new RkAiqIspCnrParamsPoolV3x("RkAiqIspCnrV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#elif defined(ISP_HW_V21)
|
mAiqIspCnrV21ParamsPool = new RkAiqIspCnrParamsPoolV21("RkAiqIspCnrV21Params", RkAiqCore::DEFAULT_POOL_SIZE);
|
#else
|
mAiqIspUvnrParamsPool = new RkAiqIspUvnrParamsPool("RkAiqIspUvnrParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#endif
|
break;
|
case RK_AIQ_ALGO_TYPE_ASHARP:
|
#if defined(ISP_HW_V30)
|
mAiqIspSharpenV3xParamsPool = new RkAiqIspSharpenParamsPoolV3x("RkAiqIspSharpenV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#elif defined(ISP_HW_V21)
|
mAiqIspSharpenV21ParamsPool = new RkAiqIspSharpenParamsPoolV21("RkAiqIspSharpenV21Params", RkAiqCore::DEFAULT_POOL_SIZE);
|
#else
|
mAiqIspSharpenParamsPool = new RkAiqIspSharpenParamsPool("RkAiqIspSharpenParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
mAiqIspEdgefltParamsPool = new RkAiqIspEdgefltParamsPool("RkAiqIspEdgefltParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
#endif
|
break;
|
case RK_AIQ_ALGO_TYPE_AORB:
|
if (!mAiqOrbStatsIntPool.ptr())
|
mAiqOrbStatsIntPool =
|
new RkAiqOrbStatsPool("RkAiqOrbStatsPool", RkAiqCore::DEFAULT_POOL_SIZE);
|
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;
|
case RK_AIQ_ALGO_TYPE_ACAC:
|
mAiqIspCacV3xParamsPool = new RkAiqIspCacParamsPoolV3x("RkAiqIspCacV3xParams", RkAiqCore::DEFAULT_POOL_SIZE);
|
break;
|
case RK_AIQ_ALGO_TYPE_ADRC:
|
mAiqIspDrcParamsPool = new RkAiqIspDrcParamsPool("RkAiqIspDrcParamsPool", RkAiqCore::DEFAULT_POOL_SIZE);
|
default:
|
break;
|
}
|
}
|
}
|
}
|
|
void RkAiqCore::newPdafStatsPool() {
|
const CamCalibDbContext_t* aiqCalib = mAlogsComSharedParams.calibv2;
|
uint32_t max_cnt = mAiqPdafStatsPool->get_free_buffer_size();
|
SmartPtr<RkAiqPdafStatsProxy> pdafStats = NULL;
|
CalibDbV2_Af_Pdaf_t* pdaf;
|
int pd_size;
|
|
if (CHECK_ISP_HW_V30()) {
|
CalibDbV2_AFV30_t* af_v30 =
|
(CalibDbV2_AFV30_t*)(CALIBDBV2_GET_MODULE_PTR((void*)aiqCalib, af_v30));
|
pdaf = &af_v30->TuningPara.pdaf;
|
} else {
|
CalibDbV2_AF_t* af = (CalibDbV2_AF_t*)CALIBDBV2_GET_MODULE_PTR((void*)aiqCalib, af);
|
pdaf = &af->TuningPara.pdaf;
|
}
|
|
pd_size = pdaf->pdWidth * pdaf->pdHeight * sizeof(short);
|
if (pd_size > 0) {
|
for (uint32_t i = 0; i < max_cnt; i++) {
|
pdafStats = mAiqPdafStatsPool->get_item();
|
|
rk_aiq_isp_pdaf_stats_t* pdaf_stats = &pdafStats->data().ptr()->pdaf_stats;
|
pdaf_stats->pdWidth = pdaf->pdWidth;
|
pdaf_stats->pdHeight = pdaf->pdHeight;
|
pdaf_stats->pdLData = (unsigned short*)malloc(pd_size);
|
pdaf_stats->pdRData = (unsigned short*)malloc(pd_size);
|
}
|
} else {
|
for (uint32_t i = 0; i < max_cnt; i++) {
|
pdafStats = mAiqPdafStatsPool->get_item();
|
|
rk_aiq_isp_pdaf_stats_t* pdaf_stats = &pdafStats->data().ptr()->pdaf_stats;
|
pdaf_stats->pdLData = NULL;
|
pdaf_stats->pdRData = NULL;
|
}
|
}
|
}
|
|
void RkAiqCore::delPdafStatsPool() {
|
SmartPtr<RkAiqPdafStatsProxy> pdafStats = NULL;
|
uint32_t max_cnt = mAiqPdafStatsPool->get_free_buffer_size();
|
|
for (uint32_t i = 0; i < max_cnt; i++) {
|
pdafStats = mAiqPdafStatsPool->get_item();
|
|
rk_aiq_isp_pdaf_stats_t* pdaf_stats = &pdafStats->data().ptr()->pdaf_stats;
|
if (pdaf_stats->pdLData) {
|
free(pdaf_stats->pdLData);
|
pdaf_stats->pdLData = NULL;
|
}
|
if (pdaf_stats->pdRData) {
|
free(pdaf_stats->pdRData);
|
pdaf_stats->pdRData = NULL;
|
}
|
}
|
}
|
|
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<char*>(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 {
|
LOGW_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<VideoBuffer>& buffer,
|
const SmartPtr<RkAiqAecStatsProxy>& aecStat,
|
const SmartPtr<RkAiqAwbStatsProxy>& awbStat,
|
const SmartPtr<RkAiqAfStatsProxy>& afStat,
|
const SmartPtr<RkAiqAtmoStatsProxy>& tmoStat,
|
const SmartPtr<RkAiqAdehazeStatsProxy>& dehazeStat) {
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
SmartPtr<RkAiqIspStatsIntProxy> 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, aecStat, awbStat, afStat, tmoStat,
|
dehazeStat);
|
if (ret) {
|
LOGE_ANALYZER("translate isp stats failed!");
|
return XCAM_RETURN_BYPASS;
|
}
|
|
uint32_t id = buffer->get_sequence();
|
SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ISP_STATS_OK,
|
id, ispStatsInt);
|
post_message(msg);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
RkAiqCore::handleAecStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAecStatsProxy>& aecStat_ret)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
SmartPtr<RkAiqAecStatsProxy> aecStats = NULL;
|
|
if (mAiqAecStatsPool.ptr() && mAiqAecStatsPool->has_free_items()) {
|
aecStats = mAiqAecStatsPool->get_item();
|
} else {
|
LOGW_AEC("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<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_AEC_STATS_OK,
|
id, aecStats);
|
post_message(msg);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
RkAiqCore::handleAwbStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAwbStatsProxy>& awbStat_ret)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
SmartPtr<RkAiqAwbStatsProxy> awbStats = NULL;
|
|
if (mAiqAwbStatsPool.ptr() && mAiqAwbStatsPool->has_free_items()) {
|
awbStats = mAiqAwbStatsPool->get_item();
|
} else {
|
LOGW_AWB("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<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_AWB_STATS_OK,
|
id, awbStats);
|
post_message(msg);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
RkAiqCore::handleAfStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAfStatsProxy>& afStat_ret)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
SmartPtr<RkAiqAfStatsProxy> afStats = NULL;
|
|
if (mAiqAfStatsPool.ptr() && mAiqAfStatsPool->has_free_items()) {
|
afStats = mAiqAfStatsPool->get_item();
|
} else {
|
LOGW_AF("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<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_AF_STATS_OK,
|
id, afStats);
|
post_message(msg);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn RkAiqCore::handlePdafStats(const SmartPtr<VideoBuffer>& buffer) {
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
SmartPtr<RkAiqPdafStatsProxy> pdafStats = NULL;
|
bool sns_mirror = mAlogsComSharedParams.sns_mirror;
|
|
if (mAiqPdafStatsPool->has_free_items()) {
|
pdafStats = mAiqPdafStatsPool->get_item();
|
} else {
|
LOGE_ANALYZER("no free afStats buffer!");
|
return XCAM_RETURN_BYPASS;
|
}
|
ret = mTranslator->translatePdafStats(buffer, pdafStats, sns_mirror);
|
if (ret < 0) {
|
LOGE_ANALYZER("translate af stats failed!");
|
return XCAM_RETURN_BYPASS;
|
}
|
|
uint32_t id = buffer->get_sequence();
|
SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_PDAF_STATS_OK, id, pdafStats);
|
post_message(msg);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn RkAiqCore::handleAtmoStats(const SmartPtr<VideoBuffer>& buffer,
|
SmartPtr<RkAiqAtmoStatsProxy>& tmoStat) {
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
|
if (mAiqAtmoStatsPool.ptr() && mAiqAtmoStatsPool->has_free_items()) {
|
tmoStat = mAiqAtmoStatsPool->get_item();
|
} else {
|
LOGW_ATMO("no free atmoStats buffer!");
|
return XCAM_RETURN_BYPASS;
|
}
|
ret = mTranslator->translateAtmoStats(buffer, tmoStat);
|
if (ret < 0) {
|
LOGE_ANALYZER("translate tmo stats failed!");
|
return XCAM_RETURN_BYPASS;
|
}
|
|
uint32_t id = buffer->get_sequence();
|
SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ATMO_STATS_OK,
|
id, tmoStat);
|
post_message(msg);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn RkAiqCore::handleAdehazeStats(const SmartPtr<VideoBuffer>& buffer,
|
SmartPtr<RkAiqAdehazeStatsProxy>& dehazeStat) {
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
|
if (mAiqAdehazeStatsPool.ptr() && mAiqAdehazeStatsPool->has_free_items()) {
|
dehazeStat = mAiqAdehazeStatsPool->get_item();
|
} else {
|
LOGW_ADEHAZE("no free adehazeStats buffer!");
|
return XCAM_RETURN_BYPASS;
|
}
|
ret = mTranslator->translateAdehazeStats(buffer, dehazeStat);
|
if (ret < 0) {
|
LOGE_ANALYZER("translate dehaze stats failed!");
|
return XCAM_RETURN_BYPASS;
|
}
|
|
uint32_t id = buffer->get_sequence();
|
SmartPtr<XCamMessage> msg = new RkAiqCoreVdBufMsg(XCAM_MESSAGE_ADEHAZE_STATS_OK,
|
id, dehazeStat);
|
post_message(msg);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
RkAiqCore::handleOrbStats(const SmartPtr<VideoBuffer> &buffer)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
SmartPtr<RkAiqOrbStatsProxy> orbStats = NULL;
|
if (mAiqOrbStatsIntPool.ptr() && mAiqOrbStatsIntPool->has_free_items()) {
|
orbStats = mAiqOrbStatsIntPool->get_item();
|
} else {
|
LOGW_AORB("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<XCamMessage> 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::set_pdaf_support(bool support)
|
{
|
mPdafSupport = support;
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
bool RkAiqCore::get_pdaf_support()
|
{
|
return mPdafSupport;
|
}
|
|
XCamReturn
|
RkAiqCore::newAiqGroupAnayzer()
|
{
|
mRkAiqCoreGroupManager = new RkAiqAnalyzeGroupManager(this, mIsSingleThread);
|
mRkAiqCoreGroupManager->parseAlgoGroup(mAlgosDesArray);
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
} //namespace RkCam
|
