1 /* 2 * Copyright (c) 2019-2022 Rockchip Eletronics Co., Ltd. 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 #ifndef _RK_AIQ_CAMGROUP_HANDLE_INT_V3_H_ 17 #define _RK_AIQ_CAMGROUP_HANDLE_INT_V3_H_ 18 19 #include "RkAiqCamgroupHandle.h" 20 #include "ae/rk_aiq_uapi_ae_int.h" 21 #include "awb/rk_aiq_uapiv2_camgroup_awb_int.h" 22 #include "accm/rk_aiq_uapi_accm_int.h" 23 #include "a3dlut/rk_aiq_uapi_a3dlut_int.h" 24 #include "agamma/rk_aiq_uapi_agamma_int.h" 25 #include "amerge/rk_aiq_uapi_amerge_int.h" 26 #include "adrc/rk_aiq_uapi_adrc_int.h" 27 #include "adehaze/rk_aiq_uapi_adehaze_int.h" 28 #include "algo_camgroup_handlers/RkAiqCamGroupAgicHandle.h" 29 #include "aynr3/rk_aiq_uapi_aynr_int_v3.h" 30 #include "acnr2/rk_aiq_uapi_acnr_int_v2.h" 31 #include "abayer2dnr2/rk_aiq_uapi_abayer2dnr_int_v2.h" 32 #include "ablc/rk_aiq_uapi_ablc_int.h" 33 #include "aldch/rk_aiq_uapi_aldch_int.h" 34 #include "algos/aldch/rk_aiq_uapi_aldch_v21_int.h" 35 #include "adebayer/rk_aiq_uapi_adebayer_int.h" 36 #include "alsc/rk_aiq_uapi_alsc_int.h" 37 #include "adpcc/rk_aiq_uapi_adpcc_int.h" 38 39 #include "abayertnr2/rk_aiq_uapi_abayertnr_int_v2.h" 40 #include "asharp4/rk_aiq_uapi_asharp_int_v4.h" 41 42 #include "ablcV32/rk_aiq_uapi_ablc_int_v32.h" 43 #include "aynrV22/rk_aiq_uapi_aynr_int_v22.h" 44 #include "acnrV30/rk_aiq_uapi_acnr_int_v30.h" 45 #include "abayer2dnrV23/rk_aiq_uapi_abayer2dnr_int_v23.h" 46 #include "abayertnrV23/rk_aiq_uapi_abayertnr_int_v23.h" 47 #include "asharpV33/rk_aiq_uapi_asharp_int_v33.h" 48 49 using namespace XCam; 50 51 namespace RkCam { 52 // ae 53 class RkAiqCamGroupAeHandleInt: 54 public RkAiqCamgroupHandle { 55 56 public: RkAiqCamGroupAeHandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)57 explicit RkAiqCamGroupAeHandleInt(RkAiqAlgoDesComm* des, RkAiqCamGroupManager* camGroupMg) 58 : RkAiqCamgroupHandle(des, camGroupMg) { 59 memset(&mCurExpSwAttrV2, 0, sizeof(Uapi_ExpSwAttrV2_t)); 60 memset(&mNewExpSwAttrV2, 0, sizeof(Uapi_ExpSwAttrV2_t)); 61 memset(&mCurLinExpAttrV2, 0, sizeof(Uapi_LinExpAttrV2_t)); 62 memset(&mNewLinExpAttrV2, 0, sizeof(Uapi_LinExpAttrV2_t)); 63 memset(&mCurHdrExpAttrV2, 0, sizeof(Uapi_HdrExpAttrV2_t)); 64 memset(&mNewHdrExpAttrV2, 0, sizeof(Uapi_HdrExpAttrV2_t)); 65 66 memset(&mCurLinAeRouteAttr, 0, sizeof(Uapi_LinAeRouteAttr_t)); 67 memset(&mNewLinAeRouteAttr, 0, sizeof(Uapi_LinAeRouteAttr_t)); 68 memset(&mCurHdrAeRouteAttr, 0, sizeof(Uapi_HdrAeRouteAttr_t)); 69 memset(&mNewHdrAeRouteAttr, 0, sizeof(Uapi_HdrAeRouteAttr_t)); 70 memset(&mCurAecSyncTestAttr, 0, sizeof(Uapi_AecSyncTest_t)); 71 memset(&mNewAecSyncTestAttr, 0, sizeof(Uapi_AecSyncTest_t)); 72 73 updateExpSwAttrV2 = false; 74 updateLinExpAttrV2 = false; 75 updateHdrExpAttrV2 = false; 76 updateLinAeRouteAttr = false; 77 updateHdrAeRouteAttr = false; 78 updateSyncTestAttr = false; 79 80 }; ~RkAiqCamGroupAeHandleInt()81 virtual ~RkAiqCamGroupAeHandleInt() { 82 RkAiqCamgroupHandle::deInit(); 83 }; 84 virtual XCamReturn updateConfig(bool needSync); 85 86 // TODO: calibv2 87 XCamReturn setExpSwAttr(Uapi_ExpSwAttrV2_t ExpSwAttr); 88 XCamReturn getExpSwAttr(Uapi_ExpSwAttrV2_t* pExpSwAttr); 89 XCamReturn setLinExpAttr(Uapi_LinExpAttrV2_t LinExpAttr); 90 XCamReturn getLinExpAttr(Uapi_LinExpAttrV2_t* pLinExpAttr); 91 XCamReturn setHdrExpAttr(Uapi_HdrExpAttrV2_t HdrExpAttr); 92 XCamReturn getHdrExpAttr (Uapi_HdrExpAttrV2_t* pHdrExpAttr); 93 94 XCamReturn setLinAeRouteAttr(Uapi_LinAeRouteAttr_t LinAeRouteAttr); 95 XCamReturn getLinAeRouteAttr(Uapi_LinAeRouteAttr_t* pLinAeRouteAttr); 96 XCamReturn setHdrAeRouteAttr(Uapi_HdrAeRouteAttr_t HdrAeRouteAttr); 97 XCamReturn getHdrAeRouteAttr(Uapi_HdrAeRouteAttr_t* pHdrAeRouteAttr); 98 99 100 XCamReturn setSyncTestAttr(Uapi_AecSyncTest_t SyncTestAttr); 101 XCamReturn getSyncTestAttr (Uapi_AecSyncTest_t* pSyncTestAttr); 102 XCamReturn queryExpInfo(Uapi_ExpQueryInfo_t* pExpQueryInfo); 103 104 protected: 105 106 private: 107 108 // TODO: calibv2 109 Uapi_ExpSwAttrV2_t mCurExpSwAttrV2; 110 Uapi_ExpSwAttrV2_t mNewExpSwAttrV2; 111 Uapi_LinExpAttrV2_t mCurLinExpAttrV2; 112 Uapi_LinExpAttrV2_t mNewLinExpAttrV2; 113 Uapi_HdrExpAttrV2_t mCurHdrExpAttrV2; 114 Uapi_HdrExpAttrV2_t mNewHdrExpAttrV2; 115 116 Uapi_LinAeRouteAttr_t mCurLinAeRouteAttr; 117 Uapi_LinAeRouteAttr_t mNewLinAeRouteAttr; 118 Uapi_HdrAeRouteAttr_t mCurHdrAeRouteAttr; 119 Uapi_HdrAeRouteAttr_t mNewHdrAeRouteAttr; 120 Uapi_AecSyncTest_t mCurAecSyncTestAttr; 121 Uapi_AecSyncTest_t mNewAecSyncTestAttr; 122 123 mutable std::atomic<bool> updateExpSwAttrV2; 124 mutable std::atomic<bool> updateLinExpAttrV2; 125 mutable std::atomic<bool> updateHdrExpAttrV2; 126 127 mutable std::atomic<bool> updateLinAeRouteAttr; 128 mutable std::atomic<bool> updateHdrAeRouteAttr; 129 mutable std::atomic<bool> updateSyncTestAttr; 130 }; 131 132 // awb 133 class RkAiqCamGroupAwbHandleInt: 134 public RkAiqCamgroupHandle { 135 136 public: RkAiqCamGroupAwbHandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)137 explicit RkAiqCamGroupAwbHandleInt(RkAiqAlgoDesComm* des, 138 RkAiqCamGroupManager* camGroupMg) 139 : RkAiqCamgroupHandle(des, camGroupMg) { 140 memset(&mCurWbV21Attr, 0, sizeof(mCurWbV21Attr)); 141 memset(&mCurWbOpModeAttr, 0, sizeof(mCurWbOpModeAttr)); 142 mCurWbOpModeAttr.mode = RK_AIQ_WB_MODE_MAX; 143 memset(&mCurWbMwbAttr, 0, sizeof(mCurWbMwbAttr)); 144 memset(&mCurWbAwbAttr, 0, sizeof(mCurWbAwbAttr)); 145 memset(&mCurWbAwbWbGainAdjustAttr, 0, sizeof(mCurWbAwbWbGainAdjustAttr)); 146 memset(&mCurWbAwbWbGainOffsetAttr, 0, sizeof(mCurWbAwbWbGainOffsetAttr)); 147 memset(&mCurWbAwbMultiWindowAttr, 0, sizeof(mCurWbAwbMultiWindowAttr)); 148 memset(&mNewWbV21Attr, 0, sizeof(mNewWbV21Attr)); 149 memset(&mNewWbOpModeAttr, 0, sizeof(mNewWbOpModeAttr)); 150 mNewWbOpModeAttr.mode = RK_AIQ_WB_MODE_MAX; 151 memset(&mNewWbMwbAttr, 0, sizeof(mNewWbMwbAttr)); 152 memset(&mNewWbAwbAttr, 0, sizeof(mNewWbAwbAttr)); 153 memset(&mNewWbAwbWbGainAdjustAttr, 0, sizeof(mNewWbAwbWbGainAdjustAttr)); 154 memset(&mNewWbAwbWbGainOffsetAttr, 0, sizeof(mNewWbAwbWbGainOffsetAttr)); 155 memset(&mNewWbAwbMultiWindowAttr, 0, sizeof(mNewWbAwbMultiWindowAttr)); 156 updateWbV21Attr = false; 157 updateWbOpModeAttr = false; 158 updateWbMwbAttr = false; 159 updateWbAwbAttr = false; 160 updateWbAwbWbGainAdjustAttr = false; 161 updateWbAwbWbGainOffsetAttr = false; 162 updateWbAwbMultiWindowAttr = false; 163 // isp32 164 memset(&mCurWbV32Attr, 0, sizeof(rk_aiq_uapiV2_wbV32_attrib_t)); 165 memset(&mNewWbV32Attr, 0, sizeof(rk_aiq_uapiV2_wbV32_attrib_t)); 166 memset(&mCurWbV32AwbMultiWindowAttr, 0, sizeof(rk_aiq_uapiV2_wbV32_awb_mulWindow_t)); 167 memset(&mNewWbV32AwbMultiWindowAttr, 0, sizeof(rk_aiq_uapiV2_wbV32_awb_mulWindow_t)); 168 updateWbV32Attr = false; 169 updateWbV32AwbMultiWindowAttr = false; 170 }; ~RkAiqCamGroupAwbHandleInt()171 virtual ~RkAiqCamGroupAwbHandleInt() { 172 // free wbGainAdjust.lutAll from rk_aiq_uapiV2_awb_GetAwbGainAdjust in rk_aiq_uapiv2_awb_int.cpp 173 for(int i = 0; i < mNewWbV21Attr.stAuto.wbGainAdjust.lutAll_len; i++) { 174 if(mNewWbV21Attr.stAuto.wbGainAdjust.lutAll[i].cri_lut_out) { 175 free(mNewWbV21Attr.stAuto.wbGainAdjust.lutAll[i].cri_lut_out); 176 mNewWbV21Attr.stAuto.wbGainAdjust.lutAll[i].cri_lut_out = NULL; 177 } 178 if(mNewWbV21Attr.stAuto.wbGainAdjust.lutAll[i].ct_lut_out) { 179 free(mNewWbV21Attr.stAuto.wbGainAdjust.lutAll[i].ct_lut_out); 180 mNewWbV21Attr.stAuto.wbGainAdjust.lutAll[i].ct_lut_out = NULL; 181 } 182 } 183 if (mNewWbV21Attr.stAuto.wbGainAdjust.lutAll) { 184 free(mNewWbV21Attr.stAuto.wbGainAdjust.lutAll); 185 mNewWbV21Attr.stAuto.wbGainAdjust.lutAll = NULL; 186 } 187 188 RkAiqCamgroupHandle::deInit(); 189 }; 190 virtual XCamReturn updateConfig(bool needSync); 191 192 XCamReturn setWbV21Attrib(rk_aiq_uapiV2_wbV21_attrib_t att); 193 XCamReturn getWbV21Attrib(rk_aiq_uapiV2_wbV21_attrib_t *att); 194 XCamReturn getCct(rk_aiq_wb_cct_t *cct); 195 XCamReturn queryWBInfo(rk_aiq_wb_querry_info_t *wb_querry_info ); 196 XCamReturn lock(); 197 XCamReturn unlock(); 198 XCamReturn setWbOpModeAttrib(rk_aiq_uapiV2_wb_opMode_t att); 199 XCamReturn getWbOpModeAttrib(rk_aiq_uapiV2_wb_opMode_t *att); 200 XCamReturn setMwbAttrib(rk_aiq_wb_mwb_attrib_t att); 201 XCamReturn getMwbAttrib(rk_aiq_wb_mwb_attrib_t *att); 202 XCamReturn setWbAwbWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t att); 203 XCamReturn getWbAwbWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t *att); 204 XCamReturn setWbAwbWbGainOffsetAttrib(rk_aiq_uapiV2_wb_awb_wbGainOffset_t att); 205 XCamReturn getWbAwbWbGainOffsetAttrib(rk_aiq_uapiV2_wb_awb_wbGainOffset_t *att); 206 XCamReturn setWbAwbMultiWindowAttrib(rk_aiq_uapiV2_wb_awb_mulWindow_t att); 207 XCamReturn getWbAwbMultiWindowAttrib(rk_aiq_uapiV2_wb_awb_mulWindow_t *att); 208 XCamReturn getAlgoStat(rk_tool_awb_stat_res_full_t *awb_stat_algo); 209 XCamReturn getStrategyResult(rk_tool_awb_strategy_result_t *awb_strategy_result); 210 //isp32 211 XCamReturn setWbV32Attrib(rk_aiq_uapiV2_wbV32_attrib_t att); 212 XCamReturn getWbV32Attrib(rk_aiq_uapiV2_wbV32_attrib_t* att); 213 XCamReturn setWbV32AwbMultiWindowAttrib(rk_aiq_uapiV2_wbV32_awb_mulWindow_t att); 214 XCamReturn getWbV32AwbMultiWindowAttrib(rk_aiq_uapiV2_wbV32_awb_mulWindow_t* att); 215 protected: 216 217 private: 218 // TODO 219 rk_aiq_uapiV2_wbV21_attrib_t mCurWbV21Attr; 220 rk_aiq_uapiV2_wbV21_attrib_t mNewWbV21Attr; 221 rk_aiq_uapiV2_wb_opMode_t mCurWbOpModeAttr; 222 rk_aiq_uapiV2_wb_opMode_t mNewWbOpModeAttr; 223 rk_aiq_wb_mwb_attrib_t mCurWbMwbAttr; 224 rk_aiq_wb_mwb_attrib_t mNewWbMwbAttr; 225 rk_aiq_uapiV2_wbV20_awb_attrib_t mCurWbAwbAttr; 226 rk_aiq_uapiV2_wbV20_awb_attrib_t mNewWbAwbAttr; 227 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t mCurWbAwbWbGainAdjustAttr; 228 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t mNewWbAwbWbGainAdjustAttr; 229 rk_aiq_uapiV2_wb_awb_wbGainOffset_t mCurWbAwbWbGainOffsetAttr; 230 rk_aiq_uapiV2_wb_awb_wbGainOffset_t mNewWbAwbWbGainOffsetAttr; 231 rk_aiq_uapiV2_wb_awb_mulWindow_t mCurWbAwbMultiWindowAttr; 232 rk_aiq_uapiV2_wb_awb_mulWindow_t mNewWbAwbMultiWindowAttr; 233 mutable std::atomic<bool> updateWbV21Attr; 234 mutable std::atomic<bool> updateWbOpModeAttr; 235 mutable std::atomic<bool> updateWbMwbAttr; 236 mutable std::atomic<bool> updateWbAwbAttr; 237 mutable std::atomic<bool> updateWbAwbWbGainAdjustAttr; 238 mutable std::atomic<bool> updateWbAwbWbGainOffsetAttr; 239 mutable std::atomic<bool> updateWbAwbMultiWindowAttr; 240 241 // isp32 242 rk_aiq_uapiV2_wbV32_attrib_t mCurWbV32Attr; 243 rk_aiq_uapiV2_wbV32_attrib_t mNewWbV32Attr; 244 mutable std::atomic<bool> updateWbV32Attr; 245 rk_aiq_uapiV2_wbV32_awb_mulWindow_t mCurWbV32AwbMultiWindowAttr; 246 rk_aiq_uapiV2_wbV32_awb_mulWindow_t mNewWbV32AwbMultiWindowAttr; 247 mutable std::atomic<bool> updateWbV32AwbMultiWindowAttr; 248 }; 249 250 // accm 251 class RkAiqCamGroupAccmHandleInt: 252 public RkAiqCamgroupHandle { 253 public: RkAiqCamGroupAccmHandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)254 explicit RkAiqCamGroupAccmHandleInt(RkAiqAlgoDesComm* des, 255 RkAiqCamGroupManager* camGroupMg) 256 : RkAiqCamgroupHandle(des, camGroupMg) { 257 #if RKAIQ_HAVE_CCM_V1 258 memset(&mCurAtt, 0, sizeof(rk_aiq_ccm_attrib_t)); 259 memset(&mNewAtt, 0, sizeof(rk_aiq_ccm_attrib_t)); 260 #endif 261 #if RKAIQ_HAVE_CCM_V2 262 memset(&mCurAttV2, 0, sizeof(rk_aiq_ccm_v2_attrib_t)); 263 memset(&mNewAttV2, 0, sizeof(rk_aiq_ccm_v2_attrib_t)); 264 #endif 265 }; ~RkAiqCamGroupAccmHandleInt()266 virtual ~RkAiqCamGroupAccmHandleInt() { 267 RkAiqCamgroupHandle::deInit(); 268 }; 269 virtual XCamReturn updateConfig(bool needSync); 270 // TODO add algo specific methords, this is a sample 271 #if RKAIQ_HAVE_CCM_V1 272 XCamReturn setAttrib(const rk_aiq_ccm_attrib_t* att); 273 XCamReturn getAttrib(rk_aiq_ccm_attrib_t *att); 274 #endif 275 #if RKAIQ_HAVE_CCM_V2 276 XCamReturn setAttribV2(const rk_aiq_ccm_v2_attrib_t* att); 277 XCamReturn getAttribV2(rk_aiq_ccm_v2_attrib_t *att); 278 #endif 279 XCamReturn queryCcmInfo(rk_aiq_ccm_querry_info_t* ccm_querry_info); 280 281 protected: 282 283 private: 284 // TODO 285 #if RKAIQ_HAVE_CCM_V1 286 rk_aiq_ccm_attrib_t mCurAtt; 287 rk_aiq_ccm_attrib_t mNewAtt; 288 #endif 289 #if RKAIQ_HAVE_CCM_V2 290 rk_aiq_ccm_v2_attrib_t mCurAttV2; 291 rk_aiq_ccm_v2_attrib_t mNewAttV2; 292 #endif 293 }; 294 295 // a3dlut 296 class RkAiqCamGroupA3dlutHandleInt: 297 public RkAiqCamgroupHandle { 298 public: RkAiqCamGroupA3dlutHandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)299 explicit RkAiqCamGroupA3dlutHandleInt(RkAiqAlgoDesComm* des, 300 RkAiqCamGroupManager* camGroupMg) 301 : RkAiqCamgroupHandle(des, camGroupMg) { 302 memset(&mCurAtt, 0, sizeof(rk_aiq_lut3d_attrib_t)); 303 memset(&mNewAtt, 0, sizeof(rk_aiq_lut3d_attrib_t)); 304 }; ~RkAiqCamGroupA3dlutHandleInt()305 virtual ~RkAiqCamGroupA3dlutHandleInt() { 306 RkAiqCamgroupHandle::deInit(); 307 }; 308 virtual XCamReturn updateConfig(bool needSync); 309 // TODO add algo specific methords, this is a sample 310 XCamReturn setAttrib(const rk_aiq_lut3d_attrib_t* att); 311 XCamReturn getAttrib(rk_aiq_lut3d_attrib_t *att); 312 XCamReturn query3dlutInfo(rk_aiq_lut3d_querry_info_t* lut3d_querry_info); 313 314 protected: 315 316 private: 317 // TODO 318 rk_aiq_lut3d_attrib_t mCurAtt; 319 rk_aiq_lut3d_attrib_t mNewAtt; 320 }; 321 322 // agamma 323 class RkAiqCamGroupAgammaHandleInt: 324 virtual public RkAiqCamgroupHandle { 325 public: RkAiqCamGroupAgammaHandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)326 explicit RkAiqCamGroupAgammaHandleInt(RkAiqAlgoDesComm* des, 327 RkAiqCamGroupManager* camGroupMg) 328 : RkAiqCamgroupHandle(des, camGroupMg) { 329 #if RKAIQ_HAVE_GAMMA_V10 330 memset(&mCurAttV10, 0, sizeof(rk_aiq_gamma_v10_attr_t)); 331 memset(&mNewAttV10, 0, sizeof(rk_aiq_gamma_v10_attr_t)); 332 #endif 333 #if RKAIQ_HAVE_GAMMA_V11 334 memset(&mCurAttV11, 0, sizeof(rk_aiq_gamma_v11_attr_t)); 335 memset(&mNewAttV11, 0, sizeof(rk_aiq_gamma_v11_attr_t)); 336 #endif 337 }; ~RkAiqCamGroupAgammaHandleInt()338 virtual ~RkAiqCamGroupAgammaHandleInt() { 339 RkAiqCamgroupHandle::deInit(); 340 }; 341 virtual XCamReturn updateConfig(bool needSync); 342 #if RKAIQ_HAVE_GAMMA_V10 343 XCamReturn setAttribV10(const rk_aiq_gamma_v10_attr_t* att); 344 XCamReturn getAttribV10(rk_aiq_gamma_v10_attr_t* att); 345 #endif 346 #if RKAIQ_HAVE_GAMMA_V11 347 XCamReturn setAttribV11(const rk_aiq_gamma_v11_attr_t* att); 348 XCamReturn getAttribV11(rk_aiq_gamma_v11_attr_t* att); 349 #endif 350 protected: 351 private: 352 #if RKAIQ_HAVE_GAMMA_V10 353 rk_aiq_gamma_v10_attr_t mCurAttV10; 354 rk_aiq_gamma_v10_attr_t mNewAttV10; 355 #endif 356 #if RKAIQ_HAVE_GAMMA_V11 357 rk_aiq_gamma_v11_attr_t mCurAttV11; 358 rk_aiq_gamma_v11_attr_t mNewAttV11; 359 #endif 360 }; 361 362 // amerge 363 class RkAiqCamGroupAmergeHandleInt: 364 virtual public RkAiqCamgroupHandle { 365 public: RkAiqCamGroupAmergeHandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)366 explicit RkAiqCamGroupAmergeHandleInt(RkAiqAlgoDesComm* des, 367 RkAiqCamGroupManager* camGroupMg) 368 : RkAiqCamgroupHandle(des, camGroupMg) { 369 #if RKAIQ_HAVE_MERGE_V10 370 memset(&mCurAttV10, 0, sizeof(mergeAttrV10_t)); 371 memset(&mNewAttV10, 0, sizeof(mergeAttrV10_t)); 372 #endif 373 #if RKAIQ_HAVE_MERGE_V11 374 memset(&mCurAttV11, 0, sizeof(mergeAttrV11_t)); 375 memset(&mNewAttV11, 0, sizeof(mergeAttrV11_t)); 376 #endif 377 #if RKAIQ_HAVE_MERGE_V12 378 memset(&mCurAttV12, 0, sizeof(mergeAttrV12_t)); 379 memset(&mNewAttV12, 0, sizeof(mergeAttrV12_t)); 380 #endif 381 }; ~RkAiqCamGroupAmergeHandleInt()382 virtual ~RkAiqCamGroupAmergeHandleInt() { 383 RkAiqCamgroupHandle::deInit(); 384 }; 385 virtual XCamReturn updateConfig(bool needSync); 386 // TODO add algo specific methords, this is a sample 387 #if RKAIQ_HAVE_MERGE_V10 388 XCamReturn setAttribV10(const mergeAttrV10_t* att); 389 XCamReturn getAttribV10(mergeAttrV10_t* att); 390 #endif 391 #if RKAIQ_HAVE_MERGE_V11 392 XCamReturn setAttribV11(const mergeAttrV11_t* att); 393 XCamReturn getAttribV11(mergeAttrV11_t* att); 394 #endif 395 #if RKAIQ_HAVE_MERGE_V12 396 XCamReturn setAttribV12(const mergeAttrV12_t* att); 397 XCamReturn getAttribV12(mergeAttrV12_t* att); 398 #endif 399 400 protected: 401 private: 402 // TODO 403 #if RKAIQ_HAVE_MERGE_V10 404 mergeAttrV10_t mCurAttV10; 405 mergeAttrV10_t mNewAttV10; 406 #endif 407 #if RKAIQ_HAVE_MERGE_V11 408 mergeAttrV11_t mCurAttV11; 409 mergeAttrV11_t mNewAttV11; 410 #endif 411 #if RKAIQ_HAVE_MERGE_V12 412 mergeAttrV12_t mCurAttV12; 413 mergeAttrV12_t mNewAttV12; 414 #endif 415 }; 416 417 // adrc 418 class RkAiqCamGroupAdrcHandleInt: 419 virtual public RkAiqCamgroupHandle { 420 public: RkAiqCamGroupAdrcHandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)421 explicit RkAiqCamGroupAdrcHandleInt(RkAiqAlgoDesComm* des, 422 RkAiqCamGroupManager* camGroupMg) 423 : RkAiqCamgroupHandle(des, camGroupMg) { 424 #if RKAIQ_HAVE_DRC_V10 425 memset(&mCurAttV10, 0, sizeof(drcAttrV10_t)); 426 memset(&mNewAttV10, 0, sizeof(drcAttrV10_t)); 427 #endif 428 #if RKAIQ_HAVE_DRC_V11 429 memset(&mCurAttV11, 0, sizeof(drcAttrV11_t)); 430 memset(&mNewAttV11, 0, sizeof(drcAttrV11_t)); 431 #endif 432 #if RKAIQ_HAVE_DRC_V12 433 memset(&mCurAttV12, 0, sizeof(drcAttrV12_t)); 434 memset(&mNewAttV12, 0, sizeof(drcAttrV12_t)); 435 #endif 436 #if RKAIQ_HAVE_DRC_V12_LITE 437 memset(&mCurAttV12Lite, 0, sizeof(drcAttrV12Lite_t)); 438 memset(&mNewAttV12Lite, 0, sizeof(drcAttrV12Lite_t)); 439 #endif 440 }; ~RkAiqCamGroupAdrcHandleInt()441 virtual ~RkAiqCamGroupAdrcHandleInt() { 442 RkAiqCamgroupHandle::deInit(); 443 }; 444 virtual XCamReturn updateConfig(bool needSync); 445 // TODO add algo specific methords, this is a sample 446 #if RKAIQ_HAVE_DRC_V10 447 XCamReturn setAttribV10(const drcAttrV10_t* att); 448 XCamReturn getAttribV10(drcAttrV10_t* att); 449 #endif 450 #if RKAIQ_HAVE_DRC_V11 451 XCamReturn setAttribV11(const drcAttrV11_t* att); 452 XCamReturn getAttribV11(drcAttrV11_t* att); 453 #endif 454 #if RKAIQ_HAVE_DRC_V12 455 XCamReturn setAttribV12(const drcAttrV12_t* att); 456 XCamReturn getAttribV12(drcAttrV12_t* att); 457 #endif 458 #if RKAIQ_HAVE_DRC_V12_LITE 459 XCamReturn setAttribV12Lite(const drcAttrV12Lite_t* att); 460 XCamReturn getAttribV12Lite(drcAttrV12Lite_t* att); 461 #endif 462 463 protected: 464 private: 465 // TODO 466 #if RKAIQ_HAVE_DRC_V10 467 drcAttrV10_t mCurAttV10; 468 drcAttrV10_t mNewAttV10; 469 #endif 470 #if RKAIQ_HAVE_DRC_V11 471 drcAttrV11_t mCurAttV11; 472 drcAttrV11_t mNewAttV11; 473 #endif 474 #if RKAIQ_HAVE_DRC_V12 475 drcAttrV12_t mCurAttV12; 476 drcAttrV12_t mNewAttV12; 477 #endif 478 #if RKAIQ_HAVE_DRC_V12_LITE 479 drcAttrV12Lite_t mCurAttV12Lite; 480 drcAttrV12Lite_t mNewAttV12Lite; 481 #endif 482 }; 483 484 // adehaze 485 class RkAiqCamGroupAdehazeHandleInt : virtual public RkAiqCamgroupHandle { 486 public: RkAiqCamGroupAdehazeHandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)487 explicit RkAiqCamGroupAdehazeHandleInt(RkAiqAlgoDesComm* des, RkAiqCamGroupManager* camGroupMg) 488 : RkAiqCamgroupHandle(des, camGroupMg) { 489 #if RKAIQ_HAVE_DEHAZE_V10 490 memset(&mCurAttV10, 0, sizeof(adehaze_sw_v10_t)); 491 memset(&mNewAttV10, 0, sizeof(adehaze_sw_v10_t)); 492 #endif 493 #if RKAIQ_HAVE_DEHAZE_V11 || RKAIQ_HAVE_DEHAZE_V11_DUO 494 memset(&mCurAttV11, 0, sizeof(adehaze_sw_v11_t)); 495 memset(&mNewAttV11, 0, sizeof(adehaze_sw_v11_t)); 496 #endif 497 #if RKAIQ_HAVE_DEHAZE_V12 498 memset(&mCurAttV12, 0, sizeof(adehaze_sw_v12_t)); 499 memset(&mNewAttV12, 0, sizeof(adehaze_sw_v12_t)); 500 #endif 501 }; ~RkAiqCamGroupAdehazeHandleInt()502 virtual ~RkAiqCamGroupAdehazeHandleInt() { 503 RkAiqCamgroupHandle::deInit(); 504 }; 505 virtual XCamReturn updateConfig(bool needSync); 506 #if RKAIQ_HAVE_DEHAZE_V10 507 XCamReturn setAttribV10(const adehaze_sw_v10_t* att); 508 XCamReturn getAttribV10(adehaze_sw_v10_t* att); 509 #endif 510 #if RKAIQ_HAVE_DEHAZE_V11 || RKAIQ_HAVE_DEHAZE_V11_DUO 511 XCamReturn setAttribV11(const adehaze_sw_v11_t* att); 512 XCamReturn getAttribV11(adehaze_sw_v11_t* att); 513 #endif 514 #if RKAIQ_HAVE_DEHAZE_V12 515 XCamReturn setAttribV12(const adehaze_sw_v12_t* att); 516 XCamReturn getAttribV12(adehaze_sw_v12_t* att); 517 #endif 518 protected: 519 private: 520 // TODO 521 #if RKAIQ_HAVE_DEHAZE_V10 522 adehaze_sw_v10_t mCurAttV10; 523 adehaze_sw_v10_t mNewAttV10; 524 #endif 525 #if RKAIQ_HAVE_DEHAZE_V11 || RKAIQ_HAVE_DEHAZE_V11_DUO 526 adehaze_sw_v11_t mCurAttV11; 527 adehaze_sw_v11_t mNewAttV11; 528 #endif 529 #if RKAIQ_HAVE_DEHAZE_V12 530 adehaze_sw_v12_t mCurAttV12; 531 adehaze_sw_v12_t mNewAttV12; 532 #endif 533 }; 534 535 // aynr 536 #if RKAIQ_HAVE_YNR_V3 537 538 class RkAiqCamGroupAynrV3HandleInt: 539 public RkAiqCamgroupHandle { 540 public: RkAiqCamGroupAynrV3HandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)541 explicit RkAiqCamGroupAynrV3HandleInt(RkAiqAlgoDesComm* des, 542 RkAiqCamGroupManager* camGroupMg) 543 : RkAiqCamgroupHandle(des, camGroupMg) { 544 updateAtt = false; 545 updateStrength = false; 546 memset(&mCurStrength, 0x00, sizeof(mCurStrength)); 547 mCurStrength.percent = 1.0; 548 memset(&mNewStrength, 0x00, sizeof(mNewStrength)); 549 mNewStrength.percent = 1.0; 550 memset(&mCurAtt, 0x00, sizeof(mCurAtt)); 551 memset(&mNewAtt, 0x00, sizeof(mNewAtt)); 552 }; ~RkAiqCamGroupAynrV3HandleInt()553 virtual ~RkAiqCamGroupAynrV3HandleInt() { 554 RkAiqCamgroupHandle::deInit(); 555 }; 556 virtual XCamReturn updateConfig(bool needSync); 557 XCamReturn setAttrib(rk_aiq_ynr_attrib_v3_t *att); 558 XCamReturn getAttrib(rk_aiq_ynr_attrib_v3_t *att); 559 XCamReturn setStrength(rk_aiq_ynr_strength_v3_t *pStrength); 560 XCamReturn getStrength(rk_aiq_ynr_strength_v3_t *pStrength); 561 XCamReturn getInfo(rk_aiq_ynr_info_v3_t *pInfo); 562 563 protected: 564 565 private: 566 567 rk_aiq_ynr_attrib_v3_t mCurAtt; 568 rk_aiq_ynr_attrib_v3_t mNewAtt; 569 rk_aiq_ynr_strength_v3_t mCurStrength; 570 rk_aiq_ynr_strength_v3_t mNewStrength; 571 mutable std::atomic<bool> updateStrength; 572 }; 573 #endif 574 575 // acnr v2 576 #if RKAIQ_HAVE_CNR_V2 577 578 class RkAiqCamGroupAcnrV2HandleInt: 579 virtual public RkAiqCamgroupHandle { 580 public: RkAiqCamGroupAcnrV2HandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)581 explicit RkAiqCamGroupAcnrV2HandleInt(RkAiqAlgoDesComm* des, 582 RkAiqCamGroupManager* camGroupMg) 583 : RkAiqCamgroupHandle(des, camGroupMg) { 584 updateStrength = false; 585 updateAtt = false; 586 memset(&mCurStrength, 0x00, sizeof(mCurStrength)); 587 mCurStrength.percent = 1.0; 588 memset(&mNewStrength, 0x00, sizeof(mNewStrength)); 589 mNewStrength.percent = 1.0; 590 memset(&mCurAtt, 0x00, sizeof(mCurAtt)); 591 memset(&mNewAtt, 0x00, sizeof(mNewAtt)); 592 }; ~RkAiqCamGroupAcnrV2HandleInt()593 virtual ~RkAiqCamGroupAcnrV2HandleInt() { 594 RkAiqCamgroupHandle::deInit(); 595 }; 596 virtual XCamReturn updateConfig(bool needSync); 597 XCamReturn setAttrib(rk_aiq_cnr_attrib_v2_t *att); 598 XCamReturn getAttrib(rk_aiq_cnr_attrib_v2_t *att); 599 XCamReturn setStrength(rk_aiq_cnr_strength_v2_t *pStrength); 600 XCamReturn getStrength(rk_aiq_cnr_strength_v2_t *pStrength); 601 XCamReturn getInfo(rk_aiq_cnr_info_v2_t *pInfo); 602 protected: 603 604 private: 605 // TODO 606 rk_aiq_cnr_attrib_v2_t mCurAtt; 607 rk_aiq_cnr_attrib_v2_t mNewAtt; 608 rk_aiq_cnr_strength_v2_t mCurStrength; 609 rk_aiq_cnr_strength_v2_t mNewStrength; 610 mutable std::atomic<bool> updateStrength; 611 }; 612 #endif 613 614 // aynr v2 615 #if RKAIQ_HAVE_BAYER2DNR_V2 616 617 class RkAiqCamGroupAbayer2dnrV2HandleInt: 618 virtual public RkAiqCamgroupHandle { 619 public: RkAiqCamGroupAbayer2dnrV2HandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)620 explicit RkAiqCamGroupAbayer2dnrV2HandleInt(RkAiqAlgoDesComm* des, 621 RkAiqCamGroupManager* camGroupMg) 622 : RkAiqCamgroupHandle(des, camGroupMg) { 623 updateStrength = false; 624 updateAtt = false; 625 memset(&mCurStrength, 0x00, sizeof(mCurStrength)); 626 memset(&mNewStrength, 0x00, sizeof(mNewStrength)); 627 mCurStrength.percent = 1.0; 628 mNewStrength.percent = 1.0; 629 memset(&mCurAtt, 0x00, sizeof(mCurAtt)); 630 memset(&mNewAtt, 0x00, sizeof(mNewAtt)); 631 632 }; ~RkAiqCamGroupAbayer2dnrV2HandleInt()633 virtual ~RkAiqCamGroupAbayer2dnrV2HandleInt() { 634 RkAiqCamgroupHandle::deInit(); 635 }; 636 virtual XCamReturn updateConfig(bool needSync); 637 XCamReturn setAttrib(rk_aiq_bayer2dnr_attrib_v2_t *att); 638 XCamReturn getAttrib(rk_aiq_bayer2dnr_attrib_v2_t *att); 639 XCamReturn setStrength(rk_aiq_bayer2dnr_strength_v2_t *pStrength); 640 XCamReturn getStrength(rk_aiq_bayer2dnr_strength_v2_t *pStrength); 641 XCamReturn getInfo(rk_aiq_bayer2dnr_info_v2_t *pInfo); 642 protected: 643 644 private: 645 // TODO 646 rk_aiq_bayer2dnr_attrib_v2_t mCurAtt; 647 rk_aiq_bayer2dnr_attrib_v2_t mNewAtt; 648 rk_aiq_bayer2dnr_strength_v2_t mCurStrength; 649 rk_aiq_bayer2dnr_strength_v2_t mNewStrength; 650 mutable std::atomic<bool> updateStrength; 651 }; 652 #endif 653 654 // ablc 655 #if RKAIQ_HAVE_BLC_V1 656 657 class RkAiqCamGroupAblcHandleInt: 658 public RkAiqCamgroupHandle { 659 public: RkAiqCamGroupAblcHandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)660 explicit RkAiqCamGroupAblcHandleInt(RkAiqAlgoDesComm* des, 661 RkAiqCamGroupManager* camGroupMg) 662 : RkAiqCamgroupHandle(des, camGroupMg) { 663 updateAtt = false; 664 memset(&mCurAtt, 0x00, sizeof(mCurAtt)); 665 memset(&mNewAtt, 0x00, sizeof(mNewAtt)); 666 667 }; ~RkAiqCamGroupAblcHandleInt()668 virtual ~RkAiqCamGroupAblcHandleInt() { 669 RkAiqCamgroupHandle::deInit(); 670 }; 671 virtual XCamReturn updateConfig(bool needSync); 672 XCamReturn setAttrib(const rk_aiq_blc_attrib_t *att); 673 XCamReturn getAttrib(rk_aiq_blc_attrib_t *att); 674 XCamReturn getInfo(rk_aiq_ablc_info_t *pInfo); 675 protected: 676 677 private: 678 679 rk_aiq_blc_attrib_t mCurAtt; 680 rk_aiq_blc_attrib_t mNewAtt; 681 }; 682 #endif 683 684 // asharp 685 #if RKAIQ_HAVE_SHARP_V4 686 687 class RkAiqCamGroupAsharpV4HandleInt: 688 public RkAiqCamgroupHandle { 689 public: RkAiqCamGroupAsharpV4HandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)690 explicit RkAiqCamGroupAsharpV4HandleInt(RkAiqAlgoDesComm* des, RkAiqCamGroupManager* camGroupMg) 691 : RkAiqCamgroupHandle(des, camGroupMg) { 692 updateAtt = false; 693 updateStrength = false; 694 memset(&mCurStrength, 0x00, sizeof(mCurStrength)); 695 mCurStrength.percent = 1.0; 696 memset(&mNewStrength, 0x00, sizeof(mNewStrength)); 697 mNewStrength.percent = 1.0; 698 memset(&mCurAtt, 0x00, sizeof(mCurAtt)); 699 memset(&mNewAtt, 0x00, sizeof(mNewAtt)); 700 }; ~RkAiqCamGroupAsharpV4HandleInt()701 virtual ~RkAiqCamGroupAsharpV4HandleInt() { 702 RkAiqCamgroupHandle::deInit(); 703 }; 704 virtual XCamReturn updateConfig(bool needSync); 705 // TODO add algo specific methords, this is a sample 706 XCamReturn setAttrib(rk_aiq_sharp_attrib_v4_t *att); 707 XCamReturn getAttrib(rk_aiq_sharp_attrib_v4_t *att); 708 XCamReturn setStrength(rk_aiq_sharp_strength_v4_t *pStrength); 709 XCamReturn getStrength(rk_aiq_sharp_strength_v4_t *pStrength); 710 XCamReturn getInfo(rk_aiq_sharp_info_v4_t *pInfo); 711 712 protected: 713 714 private: 715 716 rk_aiq_sharp_attrib_v4_t mCurAtt; 717 rk_aiq_sharp_attrib_v4_t mNewAtt; 718 rk_aiq_sharp_strength_v4_t mCurStrength; 719 rk_aiq_sharp_strength_v4_t mNewStrength; 720 mutable std::atomic<bool> updateStrength; 721 }; 722 #endif 723 724 #if RKAIQ_HAVE_BAYERTNR_V2 725 726 class RkAiqCamGroupAbayertnrV2HandleInt: 727 public RkAiqCamgroupHandle { 728 public: RkAiqCamGroupAbayertnrV2HandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)729 explicit RkAiqCamGroupAbayertnrV2HandleInt(RkAiqAlgoDesComm* des, 730 RkAiqCamGroupManager* camGroupMg) 731 : RkAiqCamgroupHandle(des, camGroupMg) { 732 updateAtt = false; 733 updateStrength = false; 734 memset(&mCurStrength, 0x00, sizeof(mCurStrength)); 735 mCurStrength.percent = 1.0; 736 memset(&mNewStrength, 0x00, sizeof(mNewStrength)); 737 mNewStrength.percent = 1.0; 738 memset(&mCurAtt, 0x00, sizeof(mCurAtt)); 739 memset(&mNewAtt, 0x00, sizeof(mNewAtt)); 740 }; ~RkAiqCamGroupAbayertnrV2HandleInt()741 virtual ~RkAiqCamGroupAbayertnrV2HandleInt() { 742 RkAiqCamgroupHandle::deInit(); 743 }; 744 virtual XCamReturn updateConfig(bool needSync); 745 // TODO add algo specific methords, this is a sample 746 XCamReturn setAttrib(rk_aiq_bayertnr_attrib_v2_t *att); 747 XCamReturn getAttrib(rk_aiq_bayertnr_attrib_v2_t *att); 748 XCamReturn setStrength(rk_aiq_bayertnr_strength_v2_t *pStrength); 749 XCamReturn getStrength(rk_aiq_bayertnr_strength_v2_t *pStrength); 750 XCamReturn getInfo(rk_aiq_bayertnr_info_v2_t *pInfo); 751 752 protected: 753 754 private: 755 756 rk_aiq_bayertnr_attrib_v2_t mCurAtt; 757 rk_aiq_bayertnr_attrib_v2_t mNewAtt; 758 rk_aiq_bayertnr_strength_v2_t mCurStrength; 759 rk_aiq_bayertnr_strength_v2_t mNewStrength; 760 mutable std::atomic<bool> updateStrength; 761 }; 762 #endif 763 764 // aldch 765 class RkAiqCamGroupAldchHandleInt: 766 public RkAiqCamgroupHandle { 767 public: RkAiqCamGroupAldchHandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)768 explicit RkAiqCamGroupAldchHandleInt(RkAiqAlgoDesComm* des, RkAiqCamGroupManager* camGroupMg) 769 : RkAiqCamgroupHandle(des, camGroupMg) { 770 memset(&mCurAtt, 0, sizeof(mCurAtt)); 771 memset(&mNewAtt, 0, sizeof(mNewAtt)); 772 }; ~RkAiqCamGroupAldchHandleInt()773 virtual ~RkAiqCamGroupAldchHandleInt() { 774 RkAiqCamgroupHandle::deInit(); 775 }; 776 virtual XCamReturn updateConfig(bool needSync); 777 // TODO add algo specific methords, this is a sample 778 #if (RKAIQ_HAVE_LDCH_V21) 779 XCamReturn setAttrib(const rk_aiq_ldch_v21_attrib_t* att); 780 XCamReturn getAttrib(rk_aiq_ldch_v21_attrib_t* att); 781 #else 782 XCamReturn setAttrib(const rk_aiq_ldch_attrib_t* att); 783 XCamReturn getAttrib(rk_aiq_ldch_attrib_t *att); 784 #endif 785 786 protected: 787 788 private: 789 // TODO 790 #if (RKAIQ_HAVE_LDCH_V21) 791 rk_aiq_ldch_v21_attrib_t mCurAtt; 792 rk_aiq_ldch_v21_attrib_t mNewAtt; 793 #else 794 rk_aiq_ldch_attrib_t mCurAtt; 795 rk_aiq_ldch_attrib_t mNewAtt; 796 #endif 797 }; 798 799 // adebayer 800 class RkAiqCamGroupAdebayerHandleInt: 801 public RkAiqCamgroupHandle { 802 public: RkAiqCamGroupAdebayerHandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)803 explicit RkAiqCamGroupAdebayerHandleInt(RkAiqAlgoDesComm* des, RkAiqCamGroupManager* camGroupMg) 804 : RkAiqCamgroupHandle(des, camGroupMg) { 805 #if RKAIQ_HAVE_DEBAYER_V1 806 memset(&mCurAtt, 0, sizeof(mCurAtt)); 807 memset(&mNewAtt, 0, sizeof(mNewAtt)); 808 #endif 809 #if RKAIQ_HAVE_DEBAYER_V2 810 memset(&mCurAttV2, 0, sizeof(mCurAttV2)); 811 memset(&mNewAttV2, 0, sizeof(mNewAttV2)); 812 #endif 813 #if RKAIQ_HAVE_DEBAYER_V2_LITE 814 memset(&mCurAttV2Lite, 0, sizeof(mCurAttV2Lite)); 815 memset(&mNewAttV2Lite, 0, sizeof(mNewAttV2Lite)); 816 #endif 817 818 }; ~RkAiqCamGroupAdebayerHandleInt()819 virtual ~RkAiqCamGroupAdebayerHandleInt() { 820 RkAiqCamgroupHandle::deInit(); 821 }; 822 virtual XCamReturn updateConfig(bool needSync); 823 // TODO add algo specific methords, this is a sample 824 #if RKAIQ_HAVE_DEBAYER_V1 825 XCamReturn setAttrib(adebayer_attrib_t att); 826 XCamReturn getAttrib(adebayer_attrib_t *att); 827 #endif 828 #if RKAIQ_HAVE_DEBAYER_V2 829 XCamReturn setAttribV2(adebayer_v2_attrib_t att); 830 XCamReturn getAttribV2(adebayer_v2_attrib_t* att); 831 #endif 832 #if RKAIQ_HAVE_DEBAYER_V2_LITE 833 XCamReturn setAttribV2(adebayer_v2lite_attrib_t att); 834 XCamReturn getAttribV2(adebayer_v2lite_attrib_t* att); 835 #endif 836 837 protected: 838 839 private: 840 // TODO 841 #if RKAIQ_HAVE_DEBAYER_V1 842 adebayer_attrib_t mCurAtt; 843 adebayer_attrib_t mNewAtt; 844 #endif 845 846 #if RKAIQ_HAVE_DEBAYER_V2 847 adebayer_v2_attrib_t mCurAttV2; 848 adebayer_v2_attrib_t mNewAttV2; 849 #endif 850 #if RKAIQ_HAVE_DEBAYER_V2_LITE 851 adebayer_v2lite_attrib_t mCurAttV2Lite; 852 adebayer_v2lite_attrib_t mNewAttV2Lite; 853 #endif 854 855 }; 856 857 // lsc 858 class RkAiqCamGroupAlscHandleInt: 859 public RkAiqCamgroupHandle { 860 public: RkAiqCamGroupAlscHandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)861 explicit RkAiqCamGroupAlscHandleInt(RkAiqAlgoDesComm* des, RkAiqCamGroupManager* camGroupMg) 862 : RkAiqCamgroupHandle(des, camGroupMg) { 863 memset(&mCurAtt, 0, sizeof(rk_aiq_lsc_attrib_t)); 864 memset(&mNewAtt, 0, sizeof(rk_aiq_lsc_attrib_t)); 865 }; ~RkAiqCamGroupAlscHandleInt()866 virtual ~RkAiqCamGroupAlscHandleInt() { 867 RkAiqCamgroupHandle::deInit(); 868 }; 869 virtual XCamReturn updateConfig(bool needSync); 870 XCamReturn setAttrib(rk_aiq_lsc_attrib_t att); 871 XCamReturn getAttrib(rk_aiq_lsc_attrib_t* att); 872 XCamReturn queryLscInfo(rk_aiq_lsc_querry_info_t* lsc_querry_info); 873 874 protected: 875 876 private: 877 // TODO 878 rk_aiq_lsc_attrib_t mCurAtt; 879 rk_aiq_lsc_attrib_t mNewAtt; 880 }; 881 882 // dpcc 883 class RkAiqCamGroupAdpccHandleInt: 884 public RkAiqCamgroupHandle { 885 public: RkAiqCamGroupAdpccHandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)886 explicit RkAiqCamGroupAdpccHandleInt(RkAiqAlgoDesComm* des, RkAiqCamGroupManager* camGroupMg) 887 : RkAiqCamgroupHandle(des, camGroupMg) { 888 memset(&mCurAtt, 0, sizeof(rk_aiq_dpcc_attrib_V20_t)); 889 memset(&mNewAtt, 0, sizeof(rk_aiq_dpcc_attrib_V20_t)); 890 }; ~RkAiqCamGroupAdpccHandleInt()891 virtual ~RkAiqCamGroupAdpccHandleInt() { 892 RkAiqCamgroupHandle::deInit(); 893 }; 894 virtual XCamReturn updateConfig(bool needSync); 895 XCamReturn setAttrib(rk_aiq_dpcc_attrib_V20_t att); 896 XCamReturn getAttrib(rk_aiq_dpcc_attrib_V20_t* att); 897 898 protected: 899 900 private: 901 rk_aiq_dpcc_attrib_V20_t mCurAtt; 902 rk_aiq_dpcc_attrib_V20_t mNewAtt; 903 }; 904 905 #if RKAIQ_HAVE_GAIN_V2 906 907 class RkAiqCamGroupAgainV2HandleInt: 908 virtual public RkAiqCamgroupHandle { 909 public: RkAiqCamGroupAgainV2HandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)910 explicit RkAiqCamGroupAgainV2HandleInt(RkAiqAlgoDesComm* des, 911 RkAiqCamGroupManager* camGroupMg) 912 : RkAiqCamgroupHandle(des, camGroupMg) { 913 updateAtt = false; 914 memset(&mCurAtt, 0x00, sizeof(mCurAtt)); 915 memset(&mNewAtt, 0x00, sizeof(mNewAtt)); 916 917 }; ~RkAiqCamGroupAgainV2HandleInt()918 virtual ~RkAiqCamGroupAgainV2HandleInt() { 919 RkAiqCamgroupHandle::deInit(); 920 }; 921 virtual XCamReturn updateConfig(bool needSync); 922 XCamReturn setAttrib(const rk_aiq_gain_attrib_v2_t *att); 923 XCamReturn getAttrib(rk_aiq_gain_attrib_v2_t *att); 924 XCamReturn getInfo(rk_aiq_gain_info_v2_t *pInfo); 925 private: 926 // TODO 927 rk_aiq_gain_attrib_v2_t mCurAtt; 928 rk_aiq_gain_attrib_v2_t mNewAtt; 929 930 }; 931 #endif 932 933 934 // aynr 935 #if RKAIQ_HAVE_YNR_V22 936 937 class RkAiqCamGroupAynrV22HandleInt: 938 public RkAiqCamgroupHandle { 939 public: RkAiqCamGroupAynrV22HandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)940 explicit RkAiqCamGroupAynrV22HandleInt(RkAiqAlgoDesComm* des, 941 RkAiqCamGroupManager* camGroupMg) 942 : RkAiqCamgroupHandle(des, camGroupMg) { 943 updateAtt = false; 944 updateStrength = false; 945 memset(&mCurStrength, 0x00, sizeof(mCurStrength)); 946 mCurStrength.percent = 1.0; 947 memset(&mNewStrength, 0x00, sizeof(mNewStrength)); 948 mNewStrength.percent = 1.0; 949 memset(&mCurAtt, 0x00, sizeof(mCurAtt)); 950 memset(&mNewAtt, 0x00, sizeof(mNewAtt)); 951 }; ~RkAiqCamGroupAynrV22HandleInt()952 virtual ~RkAiqCamGroupAynrV22HandleInt() { 953 RkAiqCamgroupHandle::deInit(); 954 }; 955 virtual XCamReturn updateConfig(bool needSync); 956 XCamReturn setAttrib(const rk_aiq_ynr_attrib_v22_t *att); 957 XCamReturn getAttrib(rk_aiq_ynr_attrib_v22_t *att); 958 XCamReturn setStrength(const rk_aiq_ynr_strength_v22_t *pStrength); 959 XCamReturn getStrength(rk_aiq_ynr_strength_v22_t *pStrength); 960 XCamReturn getInfo(rk_aiq_ynr_info_v22_t *pInfo); 961 protected: 962 963 private: 964 965 rk_aiq_ynr_attrib_v22_t mCurAtt; 966 rk_aiq_ynr_attrib_v22_t mNewAtt; 967 rk_aiq_ynr_strength_v22_t mCurStrength; 968 rk_aiq_ynr_strength_v22_t mNewStrength; 969 mutable std::atomic<bool> updateStrength; 970 }; 971 #endif 972 973 // acnr v2 974 #if (RKAIQ_HAVE_CNR_V30 || RKAIQ_HAVE_CNR_V30_LITE) 975 976 class RkAiqCamGroupAcnrV30HandleInt: 977 virtual public RkAiqCamgroupHandle { 978 public: RkAiqCamGroupAcnrV30HandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)979 explicit RkAiqCamGroupAcnrV30HandleInt(RkAiqAlgoDesComm* des, 980 RkAiqCamGroupManager* camGroupMg) 981 : RkAiqCamgroupHandle(des, camGroupMg) { 982 updateStrength = false; 983 updateAtt = false; 984 memset(&mCurStrength, 0x00, sizeof(mCurStrength)); 985 mCurStrength.percent = 1.0; 986 memset(&mNewStrength, 0x00, sizeof(mNewStrength)); 987 mNewStrength.percent = 1.0; 988 memset(&mCurAtt, 0x00, sizeof(mCurAtt)); 989 memset(&mNewAtt, 0x00, sizeof(mNewAtt)); 990 }; ~RkAiqCamGroupAcnrV30HandleInt()991 virtual ~RkAiqCamGroupAcnrV30HandleInt() { 992 RkAiqCamgroupHandle::deInit(); 993 }; 994 virtual XCamReturn updateConfig(bool needSync); 995 XCamReturn setAttrib(const rk_aiq_cnr_attrib_v30_t *att); 996 XCamReturn getAttrib(rk_aiq_cnr_attrib_v30_t *att); 997 XCamReturn setStrength(const rk_aiq_cnr_strength_v30_t *pStrength); 998 XCamReturn getStrength(rk_aiq_cnr_strength_v30_t *pStrength); 999 XCamReturn getInfo(rk_aiq_cnr_info_v30_t *pInfo); 1000 protected: 1001 1002 private: 1003 // TODO 1004 rk_aiq_cnr_attrib_v30_t mCurAtt; 1005 rk_aiq_cnr_attrib_v30_t mNewAtt; 1006 rk_aiq_cnr_strength_v30_t mCurStrength; 1007 rk_aiq_cnr_strength_v30_t mNewStrength; 1008 mutable std::atomic<bool> updateStrength; 1009 }; 1010 #endif 1011 1012 1013 // aynr v2 1014 #if RKAIQ_HAVE_BAYER2DNR_V23 1015 1016 class RkAiqCamGroupAbayer2dnrV23HandleInt: 1017 virtual public RkAiqCamgroupHandle { 1018 public: RkAiqCamGroupAbayer2dnrV23HandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)1019 explicit RkAiqCamGroupAbayer2dnrV23HandleInt(RkAiqAlgoDesComm* des, 1020 RkAiqCamGroupManager* camGroupMg) 1021 : RkAiqCamgroupHandle(des, camGroupMg) { 1022 updateStrength = false; 1023 updateAtt = false; 1024 memset(&mCurStrength, 0x00, sizeof(mCurStrength)); 1025 memset(&mNewStrength, 0x00, sizeof(mNewStrength)); 1026 mCurStrength.percent = 1.0; 1027 mNewStrength.percent = 1.0; 1028 memset(&mCurAtt, 0x00, sizeof(mCurAtt)); 1029 memset(&mNewAtt, 0x00, sizeof(mNewAtt)); 1030 1031 }; ~RkAiqCamGroupAbayer2dnrV23HandleInt()1032 virtual ~RkAiqCamGroupAbayer2dnrV23HandleInt() { 1033 RkAiqCamgroupHandle::deInit(); 1034 }; 1035 virtual XCamReturn updateConfig(bool needSync); 1036 XCamReturn setAttrib(const rk_aiq_bayer2dnr_attrib_v23_t *att); 1037 XCamReturn getAttrib(rk_aiq_bayer2dnr_attrib_v23_t *att); 1038 XCamReturn setStrength(const rk_aiq_bayer2dnr_strength_v23_t *pStrength); 1039 XCamReturn getStrength(rk_aiq_bayer2dnr_strength_v23_t *pStrength); 1040 XCamReturn getInfo(rk_aiq_bayer2dnr_info_v23_t *pInfo); 1041 protected: 1042 1043 private: 1044 // TODO 1045 rk_aiq_bayer2dnr_attrib_v23_t mCurAtt; 1046 rk_aiq_bayer2dnr_attrib_v23_t mNewAtt; 1047 rk_aiq_bayer2dnr_strength_v23_t mCurStrength; 1048 rk_aiq_bayer2dnr_strength_v23_t mNewStrength; 1049 mutable std::atomic<bool> updateStrength; 1050 }; 1051 #endif 1052 1053 1054 // ablc 1055 #if RKAIQ_HAVE_BLC_V32 1056 1057 class RkAiqCamGroupAblcV32HandleInt: 1058 public RkAiqCamgroupHandle { 1059 public: RkAiqCamGroupAblcV32HandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)1060 explicit RkAiqCamGroupAblcV32HandleInt(RkAiqAlgoDesComm* des, 1061 RkAiqCamGroupManager* camGroupMg) 1062 : RkAiqCamgroupHandle(des, camGroupMg) { 1063 updateAtt = false; 1064 memset(&mCurAtt, 0x00, sizeof(mCurAtt)); 1065 memset(&mNewAtt, 0x00, sizeof(mNewAtt)); 1066 1067 }; ~RkAiqCamGroupAblcV32HandleInt()1068 virtual ~RkAiqCamGroupAblcV32HandleInt() { 1069 RkAiqCamgroupHandle::deInit(); 1070 }; 1071 virtual XCamReturn updateConfig(bool needSync); 1072 XCamReturn setAttrib(const rk_aiq_blc_attrib_V32_t *att); 1073 XCamReturn getAttrib(rk_aiq_blc_attrib_V32_t *att); 1074 XCamReturn getInfo(rk_aiq_blc_info_v32_t* pInfo); 1075 protected: 1076 1077 private: 1078 1079 rk_aiq_blc_attrib_V32_t mCurAtt; 1080 rk_aiq_blc_attrib_V32_t mNewAtt; 1081 }; 1082 #endif 1083 1084 #if (RKAIQ_HAVE_BAYERTNR_V23 || RKAIQ_HAVE_BAYERTNR_V23_LITE) 1085 1086 class RkAiqCamGroupAbayertnrV23HandleInt: 1087 public RkAiqCamgroupHandle { 1088 public: RkAiqCamGroupAbayertnrV23HandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)1089 explicit RkAiqCamGroupAbayertnrV23HandleInt(RkAiqAlgoDesComm* des, 1090 RkAiqCamGroupManager* camGroupMg) 1091 : RkAiqCamgroupHandle(des, camGroupMg) { 1092 updateAtt = false; 1093 updateStrength = false; 1094 updateAttLite = false; 1095 memset(&mCurStrength, 0x00, sizeof(mCurStrength)); 1096 mCurStrength.percent = 1.0; 1097 memset(&mNewStrength, 0x00, sizeof(mNewStrength)); 1098 mNewStrength.percent = 1.0; 1099 memset(&mCurAtt, 0x00, sizeof(mCurAtt)); 1100 memset(&mNewAtt, 0x00, sizeof(mNewAtt)); 1101 memset(&mCurAttLite, 0x00, sizeof(mCurAttLite)); 1102 memset(&mNewAttLite, 0x00, sizeof(mNewAttLite)); 1103 }; ~RkAiqCamGroupAbayertnrV23HandleInt()1104 virtual ~RkAiqCamGroupAbayertnrV23HandleInt() { 1105 RkAiqCamgroupHandle::deInit(); 1106 }; 1107 virtual XCamReturn updateConfig(bool needSync); 1108 // TODO add algo specific methords, this is a sample 1109 XCamReturn setAttrib(const rk_aiq_bayertnr_attrib_v23_t *att); 1110 XCamReturn getAttrib(rk_aiq_bayertnr_attrib_v23_t *att); 1111 XCamReturn setAttribLite(const rk_aiq_bayertnr_attrib_v23L_t* att); 1112 XCamReturn getAttribLite(rk_aiq_bayertnr_attrib_v23L_t* att); 1113 XCamReturn setStrength(const rk_aiq_bayertnr_strength_v23_t *pStrength); 1114 XCamReturn getStrength(rk_aiq_bayertnr_strength_v23_t *pStrength); 1115 XCamReturn getInfo(rk_aiq_bayertnr_info_v23_t *pInfo); 1116 1117 protected: 1118 1119 private: 1120 1121 rk_aiq_bayertnr_attrib_v23_t mCurAtt; 1122 rk_aiq_bayertnr_attrib_v23_t mNewAtt; 1123 rk_aiq_bayertnr_strength_v23_t mCurStrength; 1124 rk_aiq_bayertnr_strength_v23_t mNewStrength; 1125 mutable std::atomic<bool> updateStrength; 1126 rk_aiq_bayertnr_attrib_v23L_t mCurAttLite; 1127 rk_aiq_bayertnr_attrib_v23L_t mNewAttLite; 1128 mutable std::atomic<bool> updateAttLite; 1129 }; 1130 #endif 1131 1132 // asharp 1133 #if (RKAIQ_HAVE_SHARP_V33 || RKAIQ_HAVE_SHARP_V33_LITE) 1134 1135 class RkAiqCamGroupAsharpV33HandleInt: 1136 public RkAiqCamgroupHandle { 1137 public: RkAiqCamGroupAsharpV33HandleInt(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)1138 explicit RkAiqCamGroupAsharpV33HandleInt(RkAiqAlgoDesComm* des, RkAiqCamGroupManager* camGroupMg) 1139 : RkAiqCamgroupHandle(des, camGroupMg) { 1140 updateAtt = false; 1141 updateStrength = false; 1142 updateAttLite = false; 1143 memset(&mCurStrength, 0x00, sizeof(mCurStrength)); 1144 mCurStrength.percent = 1.0; 1145 memset(&mNewStrength, 0x00, sizeof(mNewStrength)); 1146 mNewStrength.percent = 1.0; 1147 memset(&mCurAtt, 0x00, sizeof(mCurAtt)); 1148 memset(&mNewAtt, 0x00, sizeof(mNewAtt)); 1149 memset(&mCurAttLite, 0x00, sizeof(mCurAttLite)); 1150 memset(&mNewAttLite, 0x00, sizeof(mNewAttLite)); 1151 }; ~RkAiqCamGroupAsharpV33HandleInt()1152 virtual ~RkAiqCamGroupAsharpV33HandleInt() { 1153 RkAiqCamgroupHandle::deInit(); 1154 }; 1155 virtual XCamReturn updateConfig(bool needSync); 1156 // TODO add algo specific methords, this is a sample 1157 XCamReturn setAttrib(const rk_aiq_sharp_attrib_v33_t *att); 1158 XCamReturn getAttrib(rk_aiq_sharp_attrib_v33_t *att); 1159 XCamReturn setAttribLite(const rk_aiq_sharp_attrib_v33LT_t* att); 1160 XCamReturn getAttribLite(rk_aiq_sharp_attrib_v33LT_t* att); 1161 XCamReturn setStrength(const rk_aiq_sharp_strength_v33_t *pStrength); 1162 XCamReturn getStrength(rk_aiq_sharp_strength_v33_t *pStrength); 1163 XCamReturn getInfo(rk_aiq_sharp_info_v33_t *pStrength); 1164 1165 protected: 1166 1167 private: 1168 1169 rk_aiq_sharp_attrib_v33_t mCurAtt; 1170 rk_aiq_sharp_attrib_v33_t mNewAtt; 1171 rk_aiq_sharp_strength_v33_t mCurStrength; 1172 rk_aiq_sharp_strength_v33_t mNewStrength; 1173 mutable std::atomic<bool> updateStrength; 1174 rk_aiq_sharp_attrib_v33LT_t mCurAttLite; 1175 rk_aiq_sharp_attrib_v33LT_t mNewAttLite; 1176 mutable std::atomic<bool> updateAttLite; 1177 }; 1178 #endif 1179 } 1180 1181 #endif 1182