1 /* 2 * Copyright (c) 2019 Rockchip Corporation 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 * 16 */ 17 18 #ifndef _CAM_HW_ISP20_PARAMS_H_ 19 #define _CAM_HW_ISP20_PARAMS_H_ 20 21 #include "rk_aiq_pool.h" 22 #include "rkisp2-config.h" 23 #include "rkispp-config.h" 24 25 namespace RkCam { 26 27 #define ISP20PARAM_SUBM (0x2) 28 29 #define DISABLE_PARAMS_ASSEMBLER 30 31 typedef struct AntiTmoFlicker_s { 32 int preFrameNum; 33 bool FirstChange; 34 int FirstChangeNum; 35 bool FirstChangeDone; 36 int FirstChangeDoneNum; 37 } AntiTmoFlicker_t; 38 39 40 enum params_type { 41 ISP_PARAMS, 42 ISPP_PARAMS, 43 }; 44 45 #ifndef DISABLE_PARAMS_ASSEMBLER 46 class IspParamsAssembler { 47 public: 48 explicit IspParamsAssembler(const char* name); 49 virtual ~IspParamsAssembler(); 50 void addReadyCondition(uint32_t cond); 51 void rmReadyCondition(uint32_t cond); 52 XCamReturn queue(cam3aResultList& results); 53 XCamReturn queue(SmartPtr<cam3aResult>& result); 54 XCamReturn deQueOne(cam3aResultList& results, uint32_t& frame_id); 55 void forceReady(uint32_t frame_id); 56 bool ready(); 57 void reset(); 58 XCamReturn start(); 59 void stop(); setCamPhyId(int phyId)60 void setCamPhyId(int phyId) { 61 mCamPhyId = phyId; 62 } 63 protected: 64 int mCamPhyId; 65 private: 66 XCAM_DEAD_COPY(IspParamsAssembler); 67 XCamReturn queue_locked(SmartPtr<cam3aResult>& result); 68 void reset_locked(); 69 typedef struct { 70 bool ready; 71 uint64_t flags; 72 cam3aResultList params; 73 } params_t; 74 // <frameId, result lists> 75 std::map<uint32_t, params_t> mParamsMap; 76 Mutex mParamsMutex; 77 uint32_t mLatestReadyFrmId; 78 uint64_t mReadyMask; 79 uint32_t mReadyNums; 80 std::string mName; 81 // <result_type, maskId> 82 std::map<uint32_t, uint64_t> mCondMaskMap; 83 uint8_t mCondNum; 84 static uint32_t MAX_PENDING_PARAMS; 85 cam3aResultList mInitParamsList; 86 bool started; 87 }; 88 #endif 89 90 class Isp20Params { 91 public: Isp20Params()92 explicit Isp20Params() : _last_pp_module_init_ens(0) 93 , _force_isp_module_ens(0) 94 , _force_ispp_module_ens(0) 95 , _force_module_flags(0) 96 { AntiTmoFlicker.preFrameNum = 0; 97 AntiTmoFlicker.FirstChange = false; 98 AntiTmoFlicker.FirstChangeNum = 0; 99 AntiTmoFlicker.FirstChangeDone = false; 100 AntiTmoFlicker.FirstChangeDoneNum = 0; 101 _working_mode = RK_AIQ_WORKING_MODE_ISP_HDR3; 102 }; ~Isp20Params()103 virtual ~Isp20Params() {}; setCamPhyId(int phyId)104 virtual void setCamPhyId(int phyId) { 105 _CamPhyId = phyId; 106 } 107 108 virtual XCamReturn checkIsp20Params(struct isp2x_isp_params_cfg& isp_cfg); 109 void set_working_mode(int mode); 110 void setModuleStatus(rk_aiq_module_id_t mId, bool en); 111 void getModuleStatus(rk_aiq_module_id_t mId, bool& en); 112 void hdrtmoGetLumaInfo(rk_aiq_luma_params_t * Next, rk_aiq_luma_params_t *Cur, 113 s32 frameNum, s32 PixelNumBlock, float blc, float *luma); 114 void hdrtmoGetAeInfo(RKAiqAecExpInfo_t* Next, RKAiqAecExpInfo_t* Cur, s32 frameNum, float* expo); 115 s32 hdrtmoPredictK(float* luma, float* expo, s32 frameNum, PredictKPara_t *TmoPara); 116 bool hdrtmoSceneStable(uint32_t frameId, int IIRMAX, int IIR, int SetWeight, s32 frameNum, float *LumaDeviation, float StableThr); 117 #if 0 118 void forceOverwriteAiqIsppCfg(struct rkispp_params_cfg& pp_cfg, 119 SmartPtr<RkAiqIspParamsProxy> aiq_meas_results, 120 SmartPtr<RkAiqIspParamsProxy> aiq_other_results); 121 void forceOverwriteAiqIspCfg(struct isp2x_isp_params_cfg& isp_cfg, 122 SmartPtr<RkAiqIspParamsProxy> aiq_results, 123 SmartPtr<RkAiqIspParamsProxy> aiq_other_results); 124 #endif 125 template<typename T> 126 XCamReturn merge_results(cam3aResultList &results, T &isp_cfg); 127 XCamReturn get_tnr_cfg_params(cam3aResultList &results, struct rkispp_params_tnrcfg &tnr_cfg); 128 //XCamReturn get_nr_cfg_params(cam3aResultList &results, struct rkispp_params_nrcfg &nr_cfg); 129 XCamReturn get_fec_cfg_params(cam3aResultList &results, struct rkispp_params_feccfg &fec_cfg); 130 virtual XCamReturn merge_isp_results(cam3aResultList &results, void* isp_cfg, bool is_multi_isp = false); 131 protected: 132 XCAM_DEAD_COPY(Isp20Params); 133 134 template<class T> 135 void convertAiqAeToIsp20Params(T& isp_cfg, 136 const rk_aiq_isp_aec_meas_t& aec_meas); 137 template<class T> 138 void convertAiqHistToIsp20Params(T& isp_cfg, 139 const rk_aiq_isp_hist_meas_t& hist_meas); 140 #if RKAIQ_HAVE_AWB_V20 141 template<class T> 142 void convertAiqAwbToIsp20Params(T& isp_cfg, 143 const rk_aiq_awb_stat_cfg_v200_t& awb_meas, 144 bool awb_cfg_udpate); 145 #endif 146 template<class T> 147 void convertAiqAwbGainToIsp20Params(T& isp_cfg, 148 const rk_aiq_wb_gain_t& awb_gain, const rk_aiq_isp_blc_t &blc, 149 bool awb_gain_update); 150 #if RKAIQ_HAVE_MERGE_V10 151 template<class T> 152 void convertAiqMergeToIsp20Params(T& isp_cfg, 153 const rk_aiq_isp_merge_t& amerge_data); 154 #endif 155 template<class T> 156 void convertAiqTmoToIsp20Params(T& isp_cfg, 157 const rk_aiq_isp_tmo_t& atmo_data); 158 #if RKAIQ_HAVE_DEHAZE_V10 159 template<class T> 160 void convertAiqAdehazeToIsp20Params(T& isp_cfg, 161 const rk_aiq_isp_dehaze_t& dhaze); 162 #endif 163 #if RKAIQ_HAVE_GAMMA_V10 164 template<class T> 165 void convertAiqAgammaToIsp20Params(T& isp_cfg, 166 const AgammaProcRes_t& gamma_out_cfg); 167 #endif 168 template<class T> 169 void convertAiqAdegammaToIsp20Params(T& isp_cfg, 170 const AdegammaProcRes_t& degamma_cfg); 171 template<class T> 172 void convertAiqAdemosaicToIsp20Params(T& isp_cfg, rk_aiq_isp_debayer_t &demosaic); 173 174 template<class T> 175 void convertAiqLscToIsp20Params(T& isp_cfg, 176 const rk_aiq_lsc_cfg_t& lsc); 177 template<class T> 178 void convertAiqBlcToIsp20Params(T& isp_cfg, rk_aiq_isp_blc_t &blc); 179 180 template<class T> 181 void convertAiqDpccToIsp20Params(T& isp_cfg, rk_aiq_isp_dpcc_t &dpcc); 182 #if RKAIQ_HAVE_CCM_V1 183 template<class T> 184 void convertAiqCcmToIsp20Params(T& isp_cfg, 185 const rk_aiq_ccm_cfg_t& ccm); 186 #endif 187 #if RKAIQ_HAVE_3DLUT_V1 188 template<class T> 189 void convertAiqA3dlutToIsp20Params(T& isp_cfg, 190 const rk_aiq_lut3d_cfg_t& lut3d_cfg); 191 #endif 192 #if RKAIQ_HAVE_ACP_V10 193 template<class T> 194 void convertAiqCpToIsp20Params(T& isp_cfg, 195 const rk_aiq_acp_params_t& lut3d_cfg); 196 #endif 197 #if RKAIQ_HAVE_AIE_V10 198 template<class T> 199 void convertAiqIeToIsp20Params(T& isp_cfg, 200 const rk_aiq_isp_ie_t& ie_cfg); 201 #endif 202 203 #if RKAIQ_HAVE_ANR_V1 204 template<class T> 205 void convertAiqRawnrToIsp20Params(T& isp_cfg, 206 rk_aiq_isp_rawnr_t& rawnr); 207 template<typename T> 208 void convertAiqTnrToIsp20Params(T& pp_cfg, 209 rk_aiq_isp_tnr_t& tnr); 210 template<typename T> 211 void convertAiqUvnrToIsp20Params(T& pp_cfg, 212 rk_aiq_isp_uvnr_t& uvnr); 213 template<typename T> 214 void convertAiqYnrToIsp20Params(T& pp_cfg, 215 rk_aiq_isp_ynr_t& ynr); 216 template<typename T> 217 void convertAiqSharpenToIsp20Params(T& pp_cfg, 218 rk_aiq_isp_sharpen_t& sharp, rk_aiq_isp_edgeflt_t& edgeflt); 219 #endif 220 #if RKAIQ_HAVE_AF_V20 || RKAIQ_ONLY_AF_STATS_V20 221 template<class T> 222 void convertAiqAfToIsp20Params(T& isp_cfg, 223 const rk_aiq_isp_af_meas_t& af_data, bool af_cfg_udpate); 224 #endif 225 template<class T> 226 void convertAiqGainToIsp20Params(T& isp_cfg, 227 rk_aiq_isp_gain_t& gain); 228 template<class T> 229 void convertAiqAldchToIsp20Params(T& isp_cfg, 230 const rk_aiq_isp_ldch_t& ldch_cfg); 231 template<typename T> 232 void convertAiqFecToIsp20Params(T& pp_cfg, 233 rk_aiq_isp_fec_t& fec); 234 template<class T> 235 void convertAiqGicToIsp20Params(T& isp_cfg, 236 const rk_aiq_isp_gic_t& gic_cfg); 237 template<typename T> 238 void convertAiqOrbToIsp20Params(T& pp_cfg, 239 rk_aiq_isp_orb_t& orb); 240 bool getModuleForceFlag(int module_id); 241 void setModuleForceFlagInverse(int module_id); 242 bool getModuleForceEn(int module_id); 243 void updateIspModuleForceEns(u64 module_ens); 244 void updateIsppModuleForceEns(u32 module_ens); 245 uint32_t _last_pp_module_init_ens; 246 u64 _force_isp_module_ens; 247 u32 _force_ispp_module_ens; 248 u64 _force_module_flags; 249 int _working_mode; 250 int _CamPhyId; 251 AntiTmoFlicker_t AntiTmoFlicker; 252 Mutex _mutex; 253 254 virtual bool convert3aResultsToIspCfg(SmartPtr<cam3aResult> &result, void* isp_cfg_p, bool is_multi_isp = false); 255 SmartPtr<cam3aResult> get_3a_result (cam3aResultList &results, int32_t type); 256 // std::map<int, std::list<SmartPtr<cam3aResult>>> _cam3aConfig; 257 cam3aResult* mBlcResult{NULL}; 258 cam3aResult* mAwbParams{NULL}; 259 cam3aResult* mAfParams{NULL}; 260 bool _lsc_en{false}; 261 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE) 262 struct isp32_isp_meas_cfg mLatestMeasCfg; 263 struct isp32_bls_cfg mLatestBlsCfg; 264 struct isp32_awb_gain_cfg mLatestWbGainCfg; 265 #endif 266 }; 267 } 268 #endif 269