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 _RK_AIQ_MANAGER_H_ 19 #define _RK_AIQ_MANAGER_H_ 20 21 #include "ICamHw.h" 22 #include "RkAiqCore.h" 23 #include "RkAiqCalibDb.h" 24 #include "RkAiqCalibDbV2.h" 25 #include "RkLumaCore.h" 26 #include "rk_aiq.h" 27 #include <memory> 28 #include <list> 29 30 namespace RkCam { 31 32 class RkAiqManager; 33 34 class RkAiqMngCmdThread 35 : public Thread { 36 public: RkAiqMngCmdThread(RkAiqManager * aiqMng)37 RkAiqMngCmdThread(RkAiqManager* aiqMng) 38 : Thread("RkAiqMngCmdThread") 39 , mAiqMng(aiqMng) {}; ~RkAiqMngCmdThread()40 ~RkAiqMngCmdThread() {}; 41 triger_stop()42 void triger_stop() { 43 mAiqCmdQueue.pause_pop (); 44 }; 45 triger_start()46 void triger_start() { 47 mAiqCmdQueue.resume_pop (); 48 }; 49 50 enum MSG_CMD { 51 MSG_CMD_SW_WORKING_MODE 52 }; 53 54 typedef struct message_s { 55 int cmd; 56 union { 57 struct { 58 rk_aiq_working_mode_t mode; 59 } sw_wk_mode; 60 } data; 61 bool sync; 62 SmartPtr<Mutex> mutex; 63 SmartPtr<XCam::Cond> cond; 64 } msg_t; 65 send_cmd(SmartPtr<msg_t> msg)66 bool send_cmd(SmartPtr<msg_t> msg) { 67 bool ret = true; 68 if (msg->sync) { 69 msg->mutex = new Mutex(); 70 msg->cond = new XCam::Cond(); 71 SmartLock lock (*msg->mutex.ptr()); 72 ret = mAiqCmdQueue.push(msg); 73 msg->cond->wait(*msg->mutex.ptr()); 74 } else { 75 ret = mAiqCmdQueue.push(msg); 76 } 77 78 return ret; 79 }; 80 81 protected: stopped()82 virtual void stopped () { 83 mAiqCmdQueue.clear (); 84 }; 85 86 virtual bool loop (); 87 88 private: 89 RkAiqManager* mAiqMng; 90 SafeList<msg_t> mAiqCmdQueue; 91 }; 92 93 class RkAiqRstApplyThread 94 : public Thread { 95 public: RkAiqRstApplyThread(RkAiqManager * aiqMng)96 RkAiqRstApplyThread(RkAiqManager* aiqMng) 97 : Thread("RkAiqRstApplyThread") 98 , mAiqMng(aiqMng) {}; ~RkAiqRstApplyThread()99 ~RkAiqRstApplyThread() {}; 100 triger_stop()101 void triger_stop() { 102 mAiqRstQueue.pause_pop (); 103 }; 104 triger_start()105 void triger_start() { 106 mAiqRstQueue.clear (); 107 mAiqRstQueue.resume_pop (); 108 }; 109 push_results(SmartPtr<RkAiqFullParamsProxy> aiqRst)110 bool push_results (SmartPtr<RkAiqFullParamsProxy> aiqRst) { 111 return mAiqRstQueue.push(aiqRst); 112 }; 113 114 protected: stopped()115 virtual void stopped () { 116 mAiqRstQueue.clear (); 117 }; 118 119 virtual bool loop (); 120 121 private: 122 RkAiqManager* mAiqMng; 123 SafeList<RkAiqFullParamsProxy> mAiqRstQueue; 124 }; 125 126 class RkAiqManager 127 :/* public IspStatsListener 128 , public IsppStatsListener 129 , public IspLumaListener 130 , public IspEvtsListener 131 ,*/ public HwResListener 132 , public RkAiqAnalyzerCb 133 , public RkLumaAnalyzerCb { 134 friend RkAiqRstApplyThread; 135 friend RkAiqMngCmdThread; 136 #ifdef RKAIQ_ENABLE_CAMGROUP 137 friend class RkAiqCamGroupManager; 138 #endif 139 public: 140 explicit RkAiqManager(const char* sns_ent_name, 141 rk_aiq_error_cb err_cb, 142 rk_aiq_metas_cb metas_cb); 143 virtual ~RkAiqManager(); setHwEvtCb(rk_aiq_hwevt_cb hwevt_cb,void * evt_cb_ctx)144 void setHwEvtCb(rk_aiq_hwevt_cb hwevt_cb, void* evt_cb_ctx) { 145 mHwEvtCbCtx = evt_cb_ctx; 146 mHwEvtCb = hwevt_cb; 147 }; setTbInfo(rk_aiq_tb_info_t & info)148 void setTbInfo(rk_aiq_tb_info_t& info) { 149 mTbInfo = info; 150 } 151 void setCamHw(SmartPtr<ICamHw>& camhw); setCamPhyId(int phyId)152 void setCamPhyId(int phyId) {mCamPhyId = phyId;} getCamPhyId()153 int getCamPhyId() { return mCamPhyId;} 154 void setAnalyzer(SmartPtr<RkAiqCore> analyzer); 155 #ifdef RKAIQ_ENABLE_PARSER_V1 156 void setAiqCalibDb(const CamCalibDbContext_t* calibDb); 157 #endif 158 void setAiqCalibDb(const CamCalibDbV2Context_t* calibDb); 159 void unsetTuningCalibDb(); 160 #if defined(ISP_HW_V20) 161 void setLumaAnalyzer(SmartPtr<RkLumaCore> analyzer); 162 #endif 163 XCamReturn init(); 164 XCamReturn prepare(uint32_t width, uint32_t height, rk_aiq_working_mode_t mode); 165 XCamReturn start(); 166 XCamReturn stop(bool keep_ext_hw_st = false); 167 XCamReturn deInit(); 168 XCamReturn updateCalibDb(const CamCalibDbV2Context_t* newCalibDb); 169 #if 0 170 // from IsppStatsListener 171 XCamReturn isppStatsCb(SmartPtr<VideoBuffer>& isppStats); 172 // from IspLumaListener 173 XCamReturn ispLumaCb(SmartPtr<VideoBuffer>& ispLuma); 174 // from IspStatsListener 175 XCamReturn ispStatsCb(SmartPtr<VideoBuffer>& ispStats); 176 // from IspEvtsListener 177 XCamReturn ispEvtsCb(ispHwEvt_t* evt); 178 #endif 179 XCamReturn hwResCb(SmartPtr<VideoBuffer>& hwres); 180 XCamReturn syncSofEvt(SmartPtr<VideoBuffer>& hwres); 181 // from RkAiqAnalyzerCb 182 void rkAiqCalcDone(SmartPtr<RkAiqFullParamsProxy>& results); 183 void rkAiqCalcFailed(const char* msg); 184 // from RkLumaAnalyzerCb 185 void rkLumaCalcDone(rk_aiq_luma_params_t luma_params); 186 void rkLumaCalcFailed(const char* msg); 187 XCamReturn setModuleCtl(rk_aiq_module_id_t mId, bool mod_en); 188 XCamReturn getModuleCtl(rk_aiq_module_id_t mId, bool& mod_en); 189 XCamReturn enqueueRawBuffer(void *rawdata, bool sync); 190 XCamReturn enqueueRawFile(const char *path); 191 XCamReturn registRawdataCb(void (*callback)(void *)); 192 XCamReturn rawdataPrepare(rk_aiq_raw_prop_t prop); 193 XCamReturn setSharpFbcRotation(rk_aiq_rotation_t rot); 194 XCamReturn setMirrorFlip(bool mirror, bool flip, int skip_frm_cnt); 195 XCamReturn getMirrorFlip(bool& mirror, bool& flip); 196 void setDefMirrorFlip(); 197 XCamReturn swWorkingModeDyn_msg(rk_aiq_working_mode_t mode); 198 void setMulCamConc(bool cc); 199 CamCalibDbV2Context_t* getCurrentCalibDBV2(void); 200 XCamReturn calibTuning(CamCalibDbV2Context_t* aiqCalib, 201 ModuleNameList& change_list); 202 #ifdef RKAIQ_ENABLE_CAMGROUP setCamGroupManager(RkAiqCamGroupManager * cam_group_manager,bool isMain)203 void setCamGroupManager(RkAiqCamGroupManager* cam_group_manager, bool isMain) { 204 mCamGroupCoreManager = cam_group_manager; 205 mIsMain = isMain; 206 } 207 #endif getWorkingMode()208 rk_aiq_working_mode_t getWorkingMode() { 209 return mWorkingMode; 210 } 211 uint32_t sensor_output_width; 212 uint32_t sensor_output_height; 213 protected: 214 XCamReturn applyAnalyzerResult(SmartPtr<RkAiqFullParamsProxy>& results, bool ignoreIsUpdate = false); 215 XCamReturn swWorkingModeDyn(rk_aiq_working_mode_t mode); 216 private: 217 enum aiq_state_e { 218 AIQ_STATE_INVALID, 219 AIQ_STATE_INITED, 220 AIQ_STATE_PREPARED, 221 AIQ_STATE_STARTED, 222 AIQ_STATE_STOPED, 223 }; 224 XCAM_DEAD_COPY (RkAiqManager); 225 private: 226 SmartPtr<ICamHw> mCamHw; 227 SmartPtr<RkAiqCore> mRkAiqAnalyzer; 228 SmartPtr<RkAiqRstApplyThread> mAiqRstAppTh; 229 SmartPtr<RkAiqMngCmdThread> mAiqMngCmdTh; 230 #if defined(ISP_HW_V20) 231 SmartPtr<RkLumaCore> mRkLumaAnalyzer; 232 #endif 233 rk_aiq_error_cb mErrCb; 234 rk_aiq_metas_cb mMetasCb; 235 rk_aiq_hwevt_cb mHwEvtCb; 236 void* mHwEvtCbCtx; 237 const char* mSnsEntName; 238 rk_aiq_tb_info_t mTbInfo; 239 #ifdef RKAIQ_ENABLE_PARSER_V1 240 const CamCalibDbContext_t* mCalibDb; 241 #endif 242 CamCalibDbV2Context_t* mCalibDbV2; 243 CamCalibDbV2Context_t* tuningCalib; 244 rk_aiq_working_mode_t mWorkingMode; 245 rk_aiq_working_mode_t mOldWkModeForGray; 246 bool mWkSwitching; 247 uint32_t mWidth; 248 uint32_t mHeight; 249 int _state; 250 bool mCurMirror; 251 bool mCurFlip; 252 SmartPtr<RkAiqCpslParamsProxy> mDleayCpslParams; 253 int mDelayCpslApplyFrmNum; 254 int mCamPhyId; 255 #ifdef RKAIQ_ENABLE_CAMGROUP 256 RkAiqCamGroupManager* mCamGroupCoreManager; 257 #endif 258 bool mIsMain; 259 int mTBStatsCnt {0}; 260 }; 261 262 } //namespace RkCam 263 264 #endif //_RK_AIQ_MANAGER_H_ 265