1 /* 2 * Copyright (c) 2019-2021 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_CORE_H_ 17 #define _RK_AIQ_CORE_H_ 18 19 #include <bitset> 20 #include <memory> 21 22 #include "ICamHw.h" 23 #include "MessageBus.h" 24 #include "RkAiqCalibDb.h" 25 #include "RkAiqCalibDbTypes.h" 26 #include "RkAiqCalibDbV2.h" 27 #include "RkAiqCalibDbV2Helper.h" 28 #include "RkAiqCamProfiles.h" 29 #include "RkAiqHandle.h" 30 #include "RkAiqResourceTranslator.h" 31 #include "common/panorama_stitchingApp.h" 32 #include "rk_aiq.h" 33 #include "rk_aiq_algo_types.h" 34 #include "rk_aiq_pool.h" 35 #include "rk_aiq_types.h" 36 #include "safe_list.h" 37 #include "smartptr.h" 38 #include "video_buffer.h" 39 #include "xcam_log.h" 40 #include "xcam_thread.h" 41 42 using namespace XCam; 43 namespace RkCam { 44 45 #define RKAIQCORE_CHECK_RET(ret, format, ...) \ 46 do { \ 47 if (ret < 0) { \ 48 LOGE_ANALYZER(format, ##__VA_ARGS__); \ 49 return ret; \ 50 } else if (ret == XCAM_RETURN_BYPASS) { \ 51 LOGW_ANALYZER(format, ##__VA_ARGS__); \ 52 return ret; \ 53 } \ 54 } while (0) 55 56 #define RKAIQCORE_CHECK_RET_NULL(ret, format, ...) \ 57 do { \ 58 if ((ret) < 0) { \ 59 LOGE_ANALYZER(format, ##__VA_ARGS__); \ 60 return NULL; \ 61 } else if ((ret) == XCAM_RETURN_BYPASS) { \ 62 LOGW_ANALYZER("bypass !", __FUNCTION__, __LINE__); \ 63 } \ 64 } while (0) 65 66 #define RKAIQCORE_CHECK_BYPASS(ret, format, ...) \ 67 do { \ 68 if ((ret) < 0) { \ 69 LOGE_ANALYZER(format, ##__VA_ARGS__); \ 70 return ret; \ 71 } else if ((ret) == XCAM_RETURN_BYPASS) { \ 72 LOGW_ANALYZER("bypass !", __FUNCTION__, __LINE__); \ 73 } \ 74 } while (0) 75 76 template <typename StandardMsg> 77 class RkAiqCoreMsg 78 : public XCamMessage 79 { 80 public: RkAiqCoreMsg(XCamMessageType msg_id,uint32_t id,const SmartPtr<StandardMsg> & message)81 RkAiqCoreMsg(XCamMessageType msg_id, uint32_t id, const SmartPtr<StandardMsg> &message) 82 : XCamMessage(msg_id, id) 83 , msg(message) 84 {}; RkAiqCoreMsg()85 RkAiqCoreMsg() {}; ~RkAiqCoreMsg()86 virtual ~RkAiqCoreMsg() {}; 87 88 SmartPtr<StandardMsg> msg; 89 90 private: 91 //XCAM_DEAD_COPY (RkAiqCoreMsg); 92 }; 93 94 typedef RkAiqCoreMsg<VideoBuffer> RkAiqCoreVdBufMsg; 95 96 class RkAiqCore; 97 class MessageThread; 98 class RkAiqAnalyzerGroup; 99 class RkAiqAnalyzeGroupManager; 100 101 class RkAiqAnalyzerCb { 102 public: RkAiqAnalyzerCb()103 explicit RkAiqAnalyzerCb() {}; ~RkAiqAnalyzerCb()104 virtual ~RkAiqAnalyzerCb() {}; 105 virtual void rkAiqCalcDone(SmartPtr<RkAiqFullParamsProxy> &results) = 0; 106 virtual void rkAiqCalcFailed(const char* msg) = 0; 107 private: 108 XCAM_DEAD_COPY (RkAiqAnalyzerCb); 109 }; 110 111 class RkAiqCoreThread 112 : public Thread { 113 public: RkAiqCoreThread(RkAiqCore * rkAiqCore)114 RkAiqCoreThread(RkAiqCore* rkAiqCore) 115 : Thread("RkAiqCoreThread") 116 , mRkAiqCore(rkAiqCore) {}; ~RkAiqCoreThread()117 ~RkAiqCoreThread() { 118 mStatsQueue.clear (); 119 }; 120 triger_stop()121 void triger_stop() { 122 mStatsQueue.pause_pop (); 123 }; 124 triger_start()125 void triger_start() { 126 mStatsQueue.clear (); 127 mStatsQueue.resume_pop (); 128 }; 129 push_stats(const SmartPtr<VideoBuffer> & buffer)130 bool push_stats (const SmartPtr<VideoBuffer> &buffer) { 131 mStatsQueue.push (buffer); 132 return true; 133 }; 134 135 protected: 136 //virtual bool started (); stopped()137 virtual void stopped () { 138 mStatsQueue.clear (); 139 }; 140 virtual bool loop (); 141 private: 142 RkAiqCore* mRkAiqCore; 143 SafeList<VideoBuffer> mStatsQueue; 144 }; 145 146 class RkAiqCoreEvtsThread 147 : public Thread { 148 public: RkAiqCoreEvtsThread(RkAiqCore * rkAiqCore)149 RkAiqCoreEvtsThread(RkAiqCore* rkAiqCore) 150 : Thread("RkAiqCoreEvtsThread") 151 , mRkAiqCore(rkAiqCore) {}; ~RkAiqCoreEvtsThread()152 ~RkAiqCoreEvtsThread() { 153 mEvtsQueue.clear (); 154 }; 155 triger_stop()156 void triger_stop() { 157 mEvtsQueue.pause_pop (); 158 }; 159 triger_start()160 void triger_start() { 161 mEvtsQueue.clear (); 162 mEvtsQueue.resume_pop (); 163 }; 164 push_evts(const SmartPtr<ispHwEvt_t> & buffer)165 bool push_evts (const SmartPtr<ispHwEvt_t> &buffer) { 166 mEvtsQueue.push (buffer); 167 return true; 168 }; 169 170 protected: 171 //virtual bool started (); stopped()172 virtual void stopped () { 173 mEvtsQueue.clear (); 174 }; 175 virtual bool loop (); 176 private: 177 RkAiqCore* mRkAiqCore; 178 SafeList<ispHwEvt_t> mEvtsQueue; 179 }; 180 181 struct RkAiqHwInfo { 182 bool fl_supported; // led flash 183 bool fl_strth_adj; // led streng_adjust 184 bool irc_supported; // ir flash & ir cutter 185 bool fl_ir_strth_adj; // ir streng_adjust 186 bool lens_supported; 187 bool is_multi_isp_mode; 188 uint16_t multi_isp_extended_pixel; 189 enum RK_PS_SrcOverlapPosition module_rotation; 190 }; 191 192 #ifdef RKAIQ_ENABLE_CAMGROUP 193 class RkAiqCamGroupManager; 194 #endif 195 196 class RkAiqCore 197 : public rk_aiq_share_ptr_ops_t 198 { 199 friend class RkAiqCoreThread; 200 friend class RkAiqCoreEvtsThread; 201 friend class MessageThread; 202 friend class RkAiqAnalyzeGroup; 203 friend class RkAiqAnalyzeGroupManager; 204 205 #ifdef RKAIQ_ENABLE_CAMGROUP 206 friend class RkAiqCamGroupManager; 207 #endif 208 209 public: 210 RkAiqCore() = delete; 211 explicit RkAiqCore(int isp_hw_ver); 212 virtual ~RkAiqCore(); 213 setAnalyzeResultCb(RkAiqAnalyzerCb * callback)214 bool setAnalyzeResultCb(RkAiqAnalyzerCb* callback) { 215 mCb = callback; 216 return true; 217 } 218 219 #ifdef RKAIQ_ENABLE_CAMGROUP 220 void setCamGroupManager(RkAiqCamGroupManager* cam_group_manager); 221 #endif 222 // called only once 223 XCamReturn init(const char* sns_ent_name, const CamCalibDbContext_t* aiqCalib, 224 const CamCalibDbV2Context_t* aiqCalibv2 = nullptr); 225 // called only once 226 XCamReturn deInit(); 227 // start analyze thread 228 XCamReturn start(); 229 // stop analyze thread 230 XCamReturn stop(); 231 // called before start(), get initial settings 232 virtual XCamReturn prepare(const rk_aiq_exposure_sensor_descriptor* sensor_des, 233 int mode); 234 // should called befor prepare notifyIspStreamMode(rk_isp_stream_mode_t mode)235 void notifyIspStreamMode(rk_isp_stream_mode_t mode) { 236 if (mode == RK_ISP_STREAM_MODE_ONLNIE) { 237 mIspOnline = true; 238 } else if (mode == RK_ISP_STREAM_MODE_OFFLNIE) { 239 mIspOnline = false; 240 } else { 241 mIspOnline = false; 242 } 243 } 244 // could be called after prepare() or start() 245 // if called between prepare() start(), can get 246 // initial settings getAiqFullParams()247 SmartPtr<RkAiqFullParamsProxy>& getAiqFullParams() { 248 return mAiqCurParams; 249 }; 250 XCamReturn pushStats(SmartPtr<VideoBuffer> &buffer); 251 XCamReturn pushEvts(SmartPtr<ispHwEvt_t> &evts); 252 XCamReturn addAlgo(RkAiqAlgoDesComm& algo); 253 XCamReturn enableAlgo(int algoType, int id, bool enable); 254 XCamReturn rmAlgo(int algoType, int id); 255 bool getAxlibStatus(int algoType, int id); 256 RkAiqAlgoContext* getEnabledAxlibCtx(const int algo_type); 257 RkAiqAlgoContext* getAxlibCtx(const int algo_type, const int lib_id); 258 RkAiqHandle* getAiqAlgoHandle(const int algo_type); 259 XCamReturn get3AStatsFromCachedList(rk_aiq_isp_stats_t &stats); 260 XCamReturn get3AStatsFromCachedList(rk_aiq_isp_stats_t **stats, int timeout_ms); 261 void release3AStatsRef(rk_aiq_isp_stats_t *stats); 262 #if RKAIQ_HAVE_ASD_V10 263 XCamReturn setCpsLtCfg(rk_aiq_cpsl_cfg_t &cfg); 264 XCamReturn getCpsLtInfo(rk_aiq_cpsl_info_t &info); 265 XCamReturn queryCpsLtCap(rk_aiq_cpsl_cap_t &cap); 266 #endif 267 XCamReturn setHwInfos(struct RkAiqHwInfo &hw_info); 268 XCamReturn setGrayMode(rk_aiq_gray_mode_t mode); 269 rk_aiq_gray_mode_t getGrayMode(); 270 void setSensorFlip(bool mirror, bool flip); setResrcPath(const char * rp)271 void setResrcPath(const char* rp) { 272 if (mAlogsComSharedParams.resourcePath) { 273 xcam_free((void*)(mAlogsComSharedParams.resourcePath)); 274 mAlogsComSharedParams.resourcePath = NULL; 275 } 276 if (rp) 277 mAlogsComSharedParams.resourcePath = strdup(rp); 278 }; isRunningState()279 bool isRunningState() { 280 return mState == RK_AIQ_CORE_STATE_RUNNING; 281 } setShareMemOps(isp_drv_share_mem_ops_t * mem_ops)282 void setShareMemOps(isp_drv_share_mem_ops_t *mem_ops) { 283 mShareMemOps = mem_ops; 284 } 285 #ifdef RKAIQ_ENABLE_PARSER_V1 286 XCamReturn setCalib(const CamCalibDbContext_t* aiqCalib); 287 #endif 288 XCamReturn setCalib(const CamCalibDbV2Context_t* aiqCalib); 289 XCamReturn events_analyze(const SmartPtr<ispHwEvt_t> &evts); 290 XCamReturn calibTuning(const CamCalibDbV2Context_t* aiqCalib, 291 ModuleNameList& change_list); 292 XCamReturn setMemsSensorIntf(const rk_aiq_mems_sensor_intf_t* intf); 293 const rk_aiq_mems_sensor_intf_t* getMemsSensorIntf(); 294 XCamReturn set_sp_resolution(int &width, int &height, int &aligned_w, int &aligned_h); 295 setMulCamConc(bool cc)296 void setMulCamConc(bool cc) { 297 mAlogsComSharedParams.is_multi_sensor = cc; 298 }; setCamPhyId(int phyId)299 void setCamPhyId(int phyId) { 300 mAlogsComSharedParams.mCamPhyId = phyId; 301 mTranslator->setCamPhyId(phyId); 302 } getCamPhyId()303 int getCamPhyId() { 304 return mAlogsComSharedParams.mCamPhyId; 305 } 306 307 #if RKAIQ_HAVE_PDAF 308 XCamReturn set_pdaf_support(bool support); 309 bool get_pdaf_support(); 310 #endif 311 312 public: 313 // following vars shared by all algo handlers 314 typedef struct RkAiqAlgosComShared_s { 315 #ifdef RKAIQ_ENABLE_PARSER_V1 316 const CamCalibDbContext_t* calib; 317 #endif 318 const CamCalibDbV2Context_t* calibv2; 319 rk_aiq_exposure_sensor_descriptor snsDes; 320 int64_t sof; 321 int working_mode; 322 uint16_t multi_isp_extended_pixels; 323 bool is_multi_isp_mode; 324 bool fill_light_on; 325 bool gray_mode; 326 bool init; 327 bool reConfig; 328 bool is_bw_sensor; 329 bool is_multi_sensor; 330 uint32_t hardware_version; 331 int iso; 332 AlgoCtxInstanceCfg ctxCfigs[RK_AIQ_ALGO_TYPE_MAX]; 333 rk_aiq_cpsl_cfg_t cpslCfg; 334 int conf_type; 335 const char* resourcePath; 336 bool sns_mirror; 337 bool sns_flip; 338 int spWidth; 339 int spHeight; 340 int spAlignedWidth; 341 int spAlignedHeight; 342 int mCamPhyId; 343 resetRkAiqAlgosComShared_s344 void reset() { 345 xcam_mem_clear(ctxCfigs); 346 xcam_mem_clear(cpslCfg); 347 xcam_mem_clear(snsDes); 348 #ifdef RKAIQ_ENABLE_PARSER_V1 349 calib = NULL; 350 #endif 351 calibv2 = NULL; 352 sof = -1; 353 working_mode = 0; 354 is_multi_sensor = 0; 355 init = false; 356 reConfig = false; 357 hardware_version = 0; 358 iso = 0; 359 fill_light_on = false; 360 gray_mode = false; 361 is_bw_sensor = false; 362 resourcePath = NULL; 363 sns_mirror = false; 364 sns_flip = false; 365 conf_type = RK_AIQ_ALGO_CONFTYPE_INIT; 366 mCamPhyId = -1; 367 multi_isp_extended_pixels = 0; 368 is_multi_isp_mode = false; 369 snsDes.otp_lsc = nullptr; 370 } 371 } RkAiqAlgosComShared_t; 372 373 // following vars shared among itself by algo handlers 374 typedef struct RkAiqAlgosGroupShared_s { 375 int32_t groupId; 376 uint32_t frameId; 377 int64_t sof; 378 XCamVideoBuffer* ispStats; 379 RKAiqAecExpInfo_t preExp; 380 RKAiqAecExpInfo_t curExp; 381 RKAiqAecExpInfo_t nxtExp; 382 rk_aiq_amd_params_t amdResParams; 383 RkAiqAecStats* aecStatsBuf; 384 RkAiqAwbStats* awbStatsBuf; 385 RkAiqAfStats* afStatsBuf; 386 RkAiqAdehazeStats* adehazeStatsBuf; 387 XCamVideoBuffer* sp; 388 XCamVideoBuffer* ispGain; 389 XCamVideoBuffer* kgGain; 390 XCamVideoBuffer* wrGain; 391 XCamVideoBuffer* tx; 392 XCamVideoBuffer* orbStats; 393 XCamVideoBuffer* nrImg; 394 RkAiqPdafStats* pdafStatsBuf; 395 RkAiqResComb res_comb; 396 rk_aiq_scale_raw_info_t scaleRawInfo; 397 RkAiqFullParams* fullParams; resetRkAiqAlgosGroupShared_s398 void reset() { 399 frameId = -1; 400 sof = 0; 401 xcam_mem_clear(res_comb); 402 xcam_mem_clear(amdResParams); 403 xcam_mem_clear(preExp); 404 xcam_mem_clear(curExp); 405 xcam_mem_clear(nxtExp); 406 xcam_mem_clear(scaleRawInfo); 407 ispStats = nullptr; 408 sp = nullptr; 409 ispGain = nullptr; 410 kgGain = nullptr; 411 wrGain = nullptr; 412 tx = nullptr; 413 aecStatsBuf = nullptr; 414 awbStatsBuf = nullptr; 415 afStatsBuf = nullptr; 416 adehazeStatsBuf = nullptr; 417 orbStats = nullptr; 418 nrImg = nullptr; 419 pdafStatsBuf = nullptr; 420 fullParams = nullptr; 421 } 422 } RkAiqAlgosGroupShared_t; 423 RkAiqAlgosComShared_t mAlogsComSharedParams; 424 // key: group type 425 std::map<int32_t, RkAiqAlgosGroupShared_t *> mAlogsGroupSharedParamsMap; 426 427 // key: algo type 428 std::map<int32_t, uint64_t> mAlgoTypeToGrpMaskMap; 429 430 isp_drv_share_mem_ops_t *mShareMemOps; 431 432 void post_message (RkAiqCoreVdBufMsg& msg); 433 int32_t getGroupId(RkAiqAlgoType_t type); 434 XCamReturn getGroupSharedParams(uint64_t groupId, RkAiqAlgosGroupShared_t* &shared); getInitDisAlgosMask()435 uint64_t getInitDisAlgosMask() { 436 return mInitDisAlgosMask; 437 } 438 // TODO(Cody): Just AF use it, should it be public ? 439 SmartPtr<RkAiqHandle>* getCurAlgoTypeHandle(int algo_type); 440 #if RKAIQ_HAVE_ASD_V10 441 virtual XCamReturn genCpslResult(RkAiqFullParams* params, RkAiqAlgoPreResAsd* asd_pre_rk); 442 #endif 443 444 XCamReturn updateCalib(enum rk_aiq_core_analyze_type_e type); 445 XCamReturn updateCalibDbBrutal(CamCalibDbV2Context_t* aiqCalib); 446 void setDelayCnts(int8_t delayCnts); 447 void setVicapScaleFlag(bool mode); setTbInfo(rk_aiq_tb_info_t & info)448 void setTbInfo(rk_aiq_tb_info_t& info) { 449 mTbInfo = info; 450 } 451 getTbInfo(void)452 rk_aiq_tb_info_t* getTbInfo(void) { 453 return &mTbInfo; 454 } 455 456 void syncVicapScaleMode(); 457 458 protected: 459 // in analyzer thread 460 XCamReturn analyze(const SmartPtr<VideoBuffer> &buffer); 461 SmartPtr<RkAiqFullParamsProxy> analyzeInternal(enum rk_aiq_core_analyze_type_e type); 462 XCamReturn freeSharebuf(uint64_t grpId); 463 XCamReturn prepare(enum rk_aiq_core_analyze_type_e type); 464 XCamReturn preProcess(enum rk_aiq_core_analyze_type_e type); 465 XCamReturn processing(enum rk_aiq_core_analyze_type_e type); 466 XCamReturn postProcess(enum rk_aiq_core_analyze_type_e type); 467 std::map<int, SmartPtr<RkAiqHandle>>* getAlgoTypeHandleMap(int algo_type); 468 void addDefaultAlgos(const struct RkAiqAlgoDesCommExt* algoDes); 469 virtual SmartPtr<RkAiqHandle> newAlgoHandle(RkAiqAlgoDesComm* algo, int hw_ver, int handle_ver); 470 virtual void copyIspStats(SmartPtr<RkAiqAecStatsProxy>& aecStat, 471 SmartPtr<RkAiqAwbStatsProxy>& awbStat, 472 SmartPtr<RkAiqAfStatsProxy>& afStat, 473 rk_aiq_isp_stats_t* to); 474 void cacheIspStatsToList(SmartPtr<RkAiqAecStatsProxy>& aecStat, 475 SmartPtr<RkAiqAwbStatsProxy>& awbStat, 476 SmartPtr<RkAiqAfStatsProxy>& afStat); 477 #if RKAIQ_HAVE_ASD_V10 478 void initCpsl(); 479 #endif 480 481 protected: 482 enum rk_aiq_core_state_e { 483 RK_AIQ_CORE_STATE_INVALID, 484 RK_AIQ_CORE_STATE_INITED, 485 RK_AIQ_CORE_STATE_PREPARED, 486 RK_AIQ_CORE_STATE_STARTED, 487 RK_AIQ_CORE_STATE_RUNNING, 488 RK_AIQ_CORE_STATE_STOPED, 489 }; 490 SmartPtr<RkAiqCoreThread> mRkAiqCoreTh; 491 #if defined(ISP_HW_V20) 492 SmartPtr<RkAiqCoreThread> mRkAiqCorePpTh; 493 #endif 494 SmartPtr<RkAiqCoreEvtsThread> mRkAiqCoreEvtsTh; 495 int mState; 496 RkAiqAnalyzerCb* mCb; 497 bool mHasPp; 498 bool mIspOnline; 499 bool mIsSingleThread; 500 // key1: algo type 501 // key2: algo id 502 // contains default handlers and custom handlers 503 std::map<int, map<int, SmartPtr<RkAiqHandle>>> mAlgoHandleMaps; 504 // key: algo type 505 // mCurAlgoHandleMaps and mCurIspAlgoHandleList only contain default handlers(id == 0), 506 // default handlers will be treated as root handler, and custom handlers as children. 507 // Custom handlers located in mAlgoHandleMaps and nexthdl of default handlers. 508 std::map<int, SmartPtr<RkAiqHandle>> mCurAlgoHandleMaps; 509 // ordered algo list 510 std::list<SmartPtr<RkAiqHandle>> mCurIspAlgoHandleList; 511 512 SmartPtr<RkAiqFullParamsPool> mAiqParamsPool; 513 SmartPtr<RkAiqFullParamsProxy> mAiqCurParams; 514 SmartPtr<RkAiqExpParamsPool> mAiqExpParamsPool; 515 SmartPtr<RkAiqIrisParamsPool> mAiqIrisParamsPool; 516 SmartPtr<RkAiqFocusParamsPool> mAiqFocusParamsPool; 517 SmartPtr<RkAiqCpslParamsPool> mAiqCpslParamsPool; 518 #if 1 519 SmartPtr<RkAiqIspAecParamsPool> mAiqIspAecParamsPool; 520 SmartPtr<RkAiqIspHistParamsPool> mAiqIspHistParamsPool; 521 SmartPtr<RkAiqIspAwbParamsPool> mAiqIspAwbParamsPool; 522 SmartPtr<RkAiqIspAwbGainParamsPool> mAiqIspAwbGainParamsPool; 523 SmartPtr<RkAiqIspAfParamsPool> mAiqIspAfParamsPool; 524 SmartPtr<RkAiqIspDpccParamsPool> mAiqIspDpccParamsPool; 525 // SmartPtr<RkAiqIspHdrParamsPool> mAiqIspHdrParamsPool; 526 SmartPtr<RkAiqIspMergeParamsPool> mAiqIspMergeParamsPool; 527 SmartPtr<RkAiqIspTmoParamsPool> mAiqIspTmoParamsPool; 528 SmartPtr<RkAiqIspCcmParamsPool> mAiqIspCcmParamsPool; 529 SmartPtr<RkAiqIspLscParamsPool> mAiqIspLscParamsPool; 530 SmartPtr<RkAiqIspBlcParamsPool> mAiqIspBlcParamsPool; 531 SmartPtr<RkAiqIspRawnrParamsPool> mAiqIspRawnrParamsPool; 532 SmartPtr<RkAiqIspGicParamsPool> mAiqIspGicParamsPool; 533 SmartPtr<RkAiqIspDebayerParamsPool> mAiqIspDebayerParamsPool; 534 SmartPtr<RkAiqIspLdchParamsPool> mAiqIspLdchParamsPool; 535 SmartPtr<RkAiqIspLut3dParamsPool> mAiqIspLut3dParamsPool; 536 SmartPtr<RkAiqIspDehazeParamsPool> mAiqIspDehazeParamsPool; 537 SmartPtr<RkAiqIspAgammaParamsPool> mAiqIspAgammaParamsPool; 538 SmartPtr<RkAiqIspAdegammaParamsPool> mAiqIspAdegammaParamsPool; 539 SmartPtr<RkAiqIspWdrParamsPool> mAiqIspWdrParamsPool; 540 SmartPtr<RkAiqIspCsmParamsPool> mAiqIspCsmParamsPool; 541 SmartPtr<RkAiqIspCgcParamsPool> mAiqIspCgcParamsPool; 542 SmartPtr<RkAiqIspConv422ParamsPool> mAiqIspConv422ParamsPool; 543 SmartPtr<RkAiqIspYuvconvParamsPool> mAiqIspYuvconvParamsPool; 544 SmartPtr<RkAiqIspGainParamsPool> mAiqIspGainParamsPool; 545 SmartPtr<RkAiqIspCpParamsPool> mAiqIspCpParamsPool; 546 SmartPtr<RkAiqIspIeParamsPool> mAiqIspIeParamsPool; 547 SmartPtr<RkAiqIspMotionParamsPool> mAiqIspMotionParamsPool; 548 SmartPtr<RkAiqIspMdParamsPool> mAiqIspMdParamsPool; 549 550 SmartPtr<RkAiqIspTnrParamsPool> mAiqIspTnrParamsPool; 551 SmartPtr<RkAiqIspYnrParamsPool> mAiqIspYnrParamsPool; 552 SmartPtr<RkAiqIspUvnrParamsPool> mAiqIspUvnrParamsPool; 553 SmartPtr<RkAiqIspSharpenParamsPool> mAiqIspSharpenParamsPool; 554 SmartPtr<RkAiqIspEdgefltParamsPool> mAiqIspEdgefltParamsPool; 555 SmartPtr<RkAiqIspFecParamsPool> mAiqIspFecParamsPool; 556 SmartPtr<RkAiqIspOrbParamsPool> mAiqIspOrbParamsPool; 557 558 // TODO: change full params to list 559 // V21 differential modules 560 SmartPtr<RkAiqIspAwbParamsPoolV21> mAiqIspAwbV21ParamsPool; 561 SmartPtr<RkAiqIspDrcParamsPool> mAiqIspDrcParamsPool; 562 SmartPtr<RkAiqIspBlcParamsPoolV21> mAiqIspBlcV21ParamsPool; 563 SmartPtr<RkAiqIspBaynrParamsPoolV21> mAiqIspBaynrV21ParamsPool; 564 SmartPtr<RkAiqIspBa3dParamsPoolV21> mAiqIspBa3dV21ParamsPool; 565 SmartPtr<RkAiqIspYnrParamsPoolV21> mAiqIspYnrV21ParamsPool; 566 SmartPtr<RkAiqIspCnrParamsPoolV21> mAiqIspCnrV21ParamsPool; 567 SmartPtr<RkAiqIspSharpenParamsPoolV21> mAiqIspSharpenV21ParamsPool; 568 569 // V30 570 SmartPtr<RkAiqIspAwbParamsPoolV3x> mAiqIspAwbV3xParamsPool; 571 SmartPtr<RkAiqIspAfParamsPoolV3x> mAiqIspAfV3xParamsPool; 572 SmartPtr<RkAiqIspCacParamsPoolV3x> mAiqIspCacV3xParamsPool; 573 SmartPtr<RkAiqIspGainParamsPoolV3x> mAiqIspGainV3xParamsPool; 574 SmartPtr<RkAiqIspBaynrParamsPoolV3x> mAiqIspBaynrV3xParamsPool; 575 SmartPtr<RkAiqIspBa3dParamsPoolV3x> mAiqIspBa3dV3xParamsPool; 576 SmartPtr<RkAiqIspYnrParamsPoolV3x> mAiqIspYnrV3xParamsPool; 577 SmartPtr<RkAiqIspCnrParamsPoolV3x> mAiqIspCnrV3xParamsPool; 578 SmartPtr<RkAiqIspSharpenParamsPoolV3x> mAiqIspSharpenV3xParamsPool; 579 SmartPtr<RkAiqIspTnrParamsPoolV3x> mAiqIspTnrV3xParamsPool; 580 581 // V32 582 SmartPtr<RkAiqIspBlcParamsPoolV32> mAiqIspBlcV32ParamsPool; 583 SmartPtr<RkAiqIspBaynrParamsPoolV32> mAiqIspBaynrV32ParamsPool; 584 SmartPtr<RkAiqIspCacParamsPoolV32> mAiqIspCacV32ParamsPool; 585 SmartPtr<RkAiqIspDebayerParamsPoolV32> mAiqIspDebayerV32ParamsPool; 586 SmartPtr<RkAiqIspCcmParamsPoolV32> mAiqIspCcmV32ParamsPool; 587 SmartPtr<RkAiqIspLdchParamsPoolV32> mAiqIspLdchV32ParamsPool; 588 SmartPtr<RkAiqIspYnrParamsPoolV32> mAiqIspYnrV32ParamsPool; 589 SmartPtr<RkAiqIspCnrParamsPoolV32> mAiqIspCnrV32ParamsPool; 590 SmartPtr<RkAiqIspSharpParamsPoolV32> mAiqIspSharpV32ParamsPool; 591 SmartPtr<RkAiqIspAwbParamsPoolV32> mAiqIspAwbV32ParamsPool; 592 SmartPtr<RkAiqIspAfParamsPoolV32> mAiqIspAfV32ParamsPool; 593 SmartPtr<RkAiqIspTnrParamsPoolV32> mAiqIspTnrV32ParamsPool; 594 SmartPtr<RkAiqIspAwbGainParamsPoolV32> mAiqIspAwbGainV32ParamsPool; 595 596 SmartPtr<RkAiqIspAfParamsPoolV32Lite> mAiqIspAfV32LiteParamsPool; 597 598 SmartPtr<RkAiqIspAfdParamsPool> mAiqIspAfdParamsPool; 599 600 #endif 601 static uint16_t DEFAULT_POOL_SIZE; 602 XCam::Cond mIspStatsCond; 603 Mutex ispStatsListMutex; 604 struct RkAiqHwInfo mHwInfo; 605 rk_aiq_cpsl_cap_t mCpslCap; 606 bool mCurCpslOn; 607 float mStrthLed; 608 float mStrthIr; 609 rk_aiq_gray_mode_t mGrayMode; 610 bool firstStatsReceived; 611 typedef SharedItemPool<rk_aiq_isp_stats_wrapper_t> RkAiqStatsPool; 612 typedef SharedItemProxy<rk_aiq_isp_stats_wrapper_t> RkAiqStatsProxy; 613 SmartPtr<RkAiqStatsPool> mAiqStatsPool; 614 std::list<SmartPtr<RkAiqStatsProxy>> mAiqStatsCachedList; 615 std::map<rk_aiq_isp_stats_t*, SmartPtr<RkAiqStatsProxy>> mAiqStatsOutMap; 616 617 /* isp/ispp resource pool */ 618 SmartPtr<RkAiqSofInfoWrapperPool> mAiqSofInfoWrapperPool; 619 SmartPtr<RkAiqIspStatsIntPool> mAiqIspStatsIntPool; 620 SmartPtr<RkAiqAecStatsPool> mAiqAecStatsPool; 621 SmartPtr<RkAiqAwbStatsPool> mAiqAwbStatsPool; 622 SmartPtr<RkAiqAtmoStatsPool> mAiqAtmoStatsPool; 623 SmartPtr<RkAiqAdehazeStatsPool> mAiqAdehazeStatsPool; 624 SmartPtr<RkAiqAfStatsPool> mAiqAfStatsPool; 625 SmartPtr<RkAiqOrbStatsPool> mAiqOrbStatsIntPool; 626 #if RKAIQ_HAVE_PDAF 627 SmartPtr<RkAiqPdafStatsPool> mAiqPdafStatsPool; 628 #endif 629 630 const struct RkAiqAlgoDesCommExt* mAlgosDesArray; 631 Mutex mApiMutex; 632 XCam::Cond mApiMutexCond; 633 bool mSafeEnableAlgo; 634 int mIspHwVer; 635 const rk_aiq_mems_sensor_intf_t *mMemsSensorIntf; 636 637 // messageBus: receive and distribute all kinds of messagess 638 virtual XCamReturn handle_message (const SmartPtr<XCamMessage> &msg); 639 640 // the group manager handle the messages from MessageBus 641 XCamReturn newAiqGroupAnayzer(); 642 SmartPtr<RkAiqAnalyzeGroupManager> mRkAiqCoreGroupManager; 643 644 XCamReturn thumbnailsGroupAnalyze(rkaiq_image_source_t &thumbnailsSrc); 645 XCamReturn groupAnalyze(uint64_t grpId, const RkAiqAlgosGroupShared_t* shared); 646 647 virtual void newAiqParamsPool(); 648 #if RKAIQ_HAVE_PDAF 649 void newPdafStatsPool(); 650 void delPdafStatsPool(); 651 #endif 652 XCamReturn getAiqParamsBuffer(RkAiqFullParams* aiqParams, int type, uint32_t frame_id); 653 //void getThumbCfgForStreams(); 654 //void setThumbCfgFromStreams(); 655 void onThumbnailsResult(const rkaiq_thumbnails_t& thumbnail); 656 657 XCamReturn handleIspStats(const SmartPtr<VideoBuffer>& buffer, 658 const SmartPtr<RkAiqAecStatsProxy>& aecStat, 659 const SmartPtr<RkAiqAwbStatsProxy>& awbStat, 660 const SmartPtr<RkAiqAfStatsProxy>& afStat, 661 const SmartPtr<RkAiqAtmoStatsProxy>& tmoStat, 662 const SmartPtr<RkAiqAdehazeStatsProxy>& dehazeStat); 663 XCamReturn handleAecStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAecStatsProxy>& aecStat); 664 XCamReturn handleAwbStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAwbStatsProxy>& awbStat); 665 XCamReturn handleAfStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAfStatsProxy>& afStat); 666 XCamReturn handleAtmoStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAtmoStatsProxy>& tmoStat); 667 XCamReturn handleAdehazeStats(const SmartPtr<VideoBuffer> &buffer, SmartPtr<RkAiqAdehazeStatsProxy>& dehazeStat); 668 XCamReturn handleOrbStats(const SmartPtr<VideoBuffer> &buffer); 669 XCamReturn handlePdafStats(const SmartPtr<VideoBuffer> &buffer); grpId2GrpMask(uint32_t grpId)670 inline uint64_t grpId2GrpMask(uint32_t grpId) { 671 return grpId == RK_AIQ_CORE_ANALYZE_ALL ? (uint64_t)grpId : (1ULL << grpId); 672 } 673 XCamReturn handleVicapScaleBufs(const SmartPtr<VideoBuffer> &buffer); 674 675 std::bitset<RK_AIQ_ALGO_TYPE_MAX> getReqAlgoResMask(int algoType); 676 void setReqAlgoResMask(int algoType, bool req); 677 678 bool isGroupAlgo(int algoType); 679 void getDummyAlgoRes(int type, uint32_t frame_id); 680 681 SmartPtr<IRkAiqResourceTranslator> mTranslator; 682 uint32_t mLastAnalyzedId; 683 #ifdef RKAIQ_ENABLE_CAMGROUP 684 RkAiqCamGroupManager* mCamGroupCoreManager; 685 #endif 686 std::bitset<RK_AIQ_ALGO_TYPE_MAX> mAllReqAlgoResMask{0}; 687 688 private: 689 #if defined(RKAIQ_HAVE_THUMBNAILS) 690 SmartPtr<ThumbnailsService> mThumbnailsService; 691 #endif 692 int mSpWidth; 693 int mSpHeight; 694 int mSpAlignedWidth; 695 int mSpAlignedHeight; 696 uint64_t mInitDisAlgosMask; 697 // update calib for each group 698 XCam::Mutex _update_mutex; 699 XCam::Cond _update_done_cond; 700 XCamReturn notifyUpdate(uint64_t mask); 701 XCamReturn waitUpdateDone(); 702 uint64_t groupUpdateMask; 703 rk_aiq_tb_info_t mTbInfo; 704 705 bool mPdafSupport{false}; 706 int64_t mFrmInterval = 30000LL; 707 int64_t mSofTime = 0LL; 708 int64_t mAfStatsTime; 709 int64_t mPdafStatsTime; 710 uint32_t mAfStatsFrmId; 711 SmartPtr<RkAiqAfStatsProxy> mAfStats; 712 SmartPtr<RkAiqPdafStatsProxy> mPdafStats; 713 CamProfiles mProfiles; 714 SmartPtr<RkAiqVicapRawBuf_t> mVicapBufs; 715 bool mIsEnableVicap{false}; 716 int mScaleRatio{32}; 717 typedef struct { 718 SmartPtr<RkAiqFullParamsProxy> proxy; 719 uint64_t groupMasks; 720 bool ready; 721 } pending_params_t; 722 // key: frame_id 723 std::map<uint32_t, pending_params_t> mFullParamsPendingMap; 724 uint64_t mFullParamReqGroupsMasks{0}; 725 XCam::Mutex _mFullParam_mutex; 726 uint32_t mLatestParamsDoneId {0}; 727 uint32_t mLatestEvtsId {0}; 728 uint32_t mLatestStatsId {0}; 729 }; 730 731 } 732 733 #endif //_RK_AIQ_CORE_H_ 734