1 /* 2 * RkAiqCamGroupManager.h 3 * 4 * Copyright (c) 2021 Rockchip Corporation 5 * 6 * Licensed under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 * 18 */ 19 20 #ifndef _RK_AIQ_CAM_GROUP_MANAGER_H_ 21 #define _RK_AIQ_CAM_GROUP_MANAGER_H_ 22 23 #include "rk_aiq_algo_camgroup_types.h" 24 #include "xcore/smartptr.h" 25 #include "xcore/safe_list.h" 26 #include "common/rk_aiq_pool.h" 27 #include "aiq_core/MessageBus.h" 28 #include "aiq_core/RkAiqCamgroupHandle.h" 29 #include "aiq_core/RkAiqCore.h" 30 #include "rk_aiq.h" 31 32 using namespace XCam; 33 namespace RkCam { 34 35 class RkAiqManager; 36 class RkAiqCore; 37 38 typedef struct rk_aiq_singlecam_result_s { 39 rk_aiq_singlecam_3a_result_t _3aResults; 40 SmartPtr<RkAiqFullParamsProxy> _fullIspParam; rk_aiq_singlecam_result_srk_aiq_singlecam_result_s41 rk_aiq_singlecam_result_s () { 42 memset(&_3aResults, 0, sizeof(_3aResults)); 43 } resetrk_aiq_singlecam_result_s44 void reset() { 45 XCamVideoBuffer* stats_buf = _3aResults.awb._awbStats; 46 if (stats_buf) 47 stats_buf->unref(stats_buf); 48 49 stats_buf = _3aResults.awb._awbProcRes; 50 if (stats_buf) 51 stats_buf->unref(stats_buf); 52 53 stats_buf = _3aResults.aec._aecStats; 54 if (stats_buf) 55 stats_buf->unref(stats_buf); 56 57 stats_buf = _3aResults.aec._aePreRes; 58 if (stats_buf) 59 stats_buf->unref(stats_buf); 60 61 memset(&_3aResults, 0, sizeof(_3aResults)); 62 _fullIspParam = NULL; 63 } 64 } rk_aiq_singlecam_result_t; 65 66 typedef struct rk_aiq_singlecam_result_status_s { 67 rk_aiq_singlecam_result_t _singleCamResults; 68 uint64_t _validAlgoResBits; 69 uint64_t _validCoreMsgsBits; 70 bool _ready; resetrk_aiq_singlecam_result_status_s71 void reset() { 72 _validAlgoResBits = 0; 73 _validCoreMsgsBits = 0; 74 _ready = false; 75 _singleCamResults.reset(); 76 } 77 } rk_aiq_singlecam_result_status_t; 78 79 typedef struct rk_aiq_groupcam_result_s { 80 rk_aiq_singlecam_result_status_t _singleCamResultsStatus[RK_AIQ_CAM_GROUP_MAX_CAMS]; 81 uint8_t _validCamResBits; 82 uint32_t _frameId; 83 bool _ready; 84 uint32_t _refCnt; resetrk_aiq_groupcam_result_s85 void reset() { 86 _validCamResBits = 0; 87 _ready = false; 88 _frameId = -1; 89 _refCnt = 0; 90 for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) 91 _singleCamResultsStatus[i].reset(); 92 } 93 } rk_aiq_groupcam_result_t; 94 95 typedef struct rk_aiq_groupcam_sofsync_s { 96 SmartPtr<VideoBuffer> _singleCamSofEvt[RK_AIQ_CAM_GROUP_MAX_CAMS]; 97 uint8_t _validCamSofSyncBits; rk_aiq_groupcam_sofsync_srk_aiq_groupcam_sofsync_s98 rk_aiq_groupcam_sofsync_s() { 99 _validCamSofSyncBits = 0; 100 } 101 uint32_t _refCnt; resetrk_aiq_groupcam_sofsync_s102 void reset() { 103 _validCamSofSyncBits = 0; 104 _refCnt = 0; 105 for (int i = 0; i < RK_AIQ_CAM_GROUP_MAX_CAMS; i++) 106 _singleCamSofEvt[i] = NULL; 107 } 108 } rk_aiq_groupcam_sofsync_t; 109 110 class RkAiqCamGroupManager; 111 class RkAiqCamGroupReprocTh 112 : public Thread { 113 public: RkAiqCamGroupReprocTh(RkAiqCamGroupManager * camGroupManager)114 RkAiqCamGroupReprocTh(RkAiqCamGroupManager* camGroupManager) 115 : Thread("RkAiqCamGroupReprocTh") 116 , mCamGroupManager(camGroupManager) {}; ~RkAiqCamGroupReprocTh()117 ~RkAiqCamGroupReprocTh() { 118 }; 119 triger_stop()120 void triger_stop() { 121 mMsgQueue.pause_pop (); 122 }; 123 triger_start()124 void triger_start() { 125 mMsgQueue.clear (); 126 mMsgQueue.resume_pop (); 127 }; 128 typedef struct rk_aiq_groupcam_result_wrapper_s { rk_aiq_groupcam_result_wrapper_srk_aiq_groupcam_result_wrapper_s129 rk_aiq_groupcam_result_wrapper_s(rk_aiq_groupcam_result_t* gc_result) 130 :_gc_result(gc_result){}; 131 rk_aiq_groupcam_result_t* _gc_result; 132 } rk_aiq_groupcam_result_wrapper_t; 133 bool sendFrame(rk_aiq_groupcam_result_t* gc_result); 134 135 protected: 136 //virtual bool started (); stopped()137 virtual void stopped () { 138 mMsgQueue.clear (); 139 }; 140 virtual bool loop (); 141 private: 142 RkAiqCamGroupManager* mCamGroupManager; 143 SafeList<rk_aiq_groupcam_result_wrapper_t> mMsgQueue; 144 }; 145 146 typedef std::shared_ptr<std::list<std::string>> ModuleNameList; 147 class RkAiqCamgroupHandle; 148 class RkAiqCamGroupManager 149 { 150 friend class RkAiqCamGroupReprocTh; 151 friend class RkAiqCamgroupHandle; 152 /* normal processing */ 153 // add cam's AIQ ctx to cam group 154 // receive group cam's awb,ae stats 155 // receive group cam's awb,ae pre/proc results 156 // receive group cam's genIspxxx results 157 // running group algos, and replace the params 158 // send all cam's params to hwi 159 /* special for init params */ 160 // called only once 161 public: 162 RkAiqCamGroupManager(); 163 virtual ~RkAiqCamGroupManager(); 164 165 // folowing called by single RkAiq 166 void processAiqCoreMsgs(RkAiqCore* src, RkAiqCoreVdBufMsg& msg); 167 void RelayAiqCoreResults(RkAiqCore* src, SmartPtr<RkAiqFullParamsProxy> &results); 168 XCamReturn sofSync(RkAiqManager* aiqManager, SmartPtr<VideoBuffer>& sof_evt); 169 170 XCamReturn setCamgroupCalib(CamCalibDbCamgroup_t* camgroup_calib); 171 // rk_aiq_camgroup_ctx_t setContainerCtx(void * group_ctx)172 void setContainerCtx(void* group_ctx) { 173 mGroupCtx = group_ctx; 174 }; getContainerCtx()175 void* getContainerCtx() { 176 return mGroupCtx; 177 }; 178 // called after single cam aiq init 179 XCamReturn init(); 180 // called only once 181 XCamReturn deInit(); 182 // start analyze thread 183 XCamReturn start(); 184 // stop analyze thread 185 XCamReturn stop(); 186 // called before start(), get initial settings 187 XCamReturn prepare(); 188 // if called, prepare should be re-called 189 XCamReturn bind(RkAiqManager* ctx); 190 XCamReturn unbind(int camId); isRunningState()191 bool isRunningState() { 192 return mState == CAMGROUP_MANAGER_STARTED; 193 } 194 XCamReturn addAlgo(RkAiqAlgoDesComm& algo); 195 XCamReturn enableAlgo(int algoType, int id, bool enable); 196 XCamReturn rmAlgo(int algoType, int id); 197 bool getAxlibStatus(int algoType, int id); 198 RkAiqAlgoContext* getEnabledAxlibCtx(const int algo_type); 199 RkAiqAlgoContext* getAxlibCtx(const int algo_type, const int lib_id); 200 RkAiqCamgroupHandle* getAiqCamgroupHandle(const int algo_type, const int lib_id); 201 XCamReturn calibTuning(const CamCalibDbV2Context_t* aiqCalib, ModuleNameList& change_name_list); 202 XCamReturn updateCalibDb(const CamCalibDbV2Context_t* newCalibDb); 203 XCamReturn rePrepare(); 204 205 void setVicapReady(rk_aiq_hwevt_t* hwevt); 206 bool isAllVicapReady(); 207 protected: 208 const struct RkAiqAlgoDesCommExt* mGroupAlgosDesArray; 209 /* key: camId*/ 210 std::map<uint8_t, RkAiqManager*> mBindAiqsMap; 211 /* key: frameId */ 212 std::map<uint32_t, rk_aiq_groupcam_result_t*> mCamGroupResMap; 213 /* key: frameId */ 214 std::map<uint32_t, rk_aiq_groupcam_sofsync_t*> mCamGroupSofsyncMap; 215 Mutex mCamGroupResMutex; 216 SmartPtr<RkAiqCamGroupReprocTh> mCamGroupReprocTh; 217 /* */ 218 Mutex mCamGroupApiSyncMutex; 219 Mutex mSofMutex; 220 uint64_t mRequiredMsgsMask; 221 uint64_t mRequiredAlgoResMask; 222 uint8_t mRequiredCamsResMask; 223 uint8_t mVicapReadyMask; 224 AlgoCtxInstanceCfgCamGroup mGroupAlgoCtxCfg; 225 // mDefAlgoHandleList and mDefAlgoHandleMap only contain default handlers(id == 0), 226 // default handlers will be treated as root handler, and custom handlers as children. 227 // Custom handlers located in mAlgoHandleMaps and nexthdl of default handlers. 228 // ordered algo list 229 std::list<SmartPtr<RkAiqCamgroupHandle>> mDefAlgoHandleList; 230 // key: algo type 231 // for fast access 232 std::map<int, SmartPtr<RkAiqCamgroupHandle>> mDefAlgoHandleMap; 233 234 // key1: algo type 235 // key2: algo id 236 std::map<int, std::map<int, SmartPtr<RkAiqCamgroupHandle>>> mAlgoHandleMaps; 237 // status transition 238 /* Typical transitions: 239 * CURRENT_STATE NEXT_STATE OPERATION 240 * CAMGROUP_MANAGER_INVALID -> CAMGROUP_MANAGER_BINDED bind 241 * CAMGROUP_MANAGER_BINDED-> CAMGROUP_MANAGER_INITED init 242 * CAMGROUP_MANAGER_INITED -> CAMGROUP_MANAGER_PREPARED prepare 243 * CAMGROUP_MANAGER_PREPARED -> CAMGROUP_MANAGER_STARTED start 244 * CAMGROUP_MANAGER_STARTED -> CAMGROUP_MANAGER_PREPARED stop 245 * CAMGROUP_MANAGER_PREPARED-> CAMGROUP_MANAGER_UNBINDED unbind 246 * CAMGROUP_MANAGER_UNBINDED -> CAMGROUP_MANAGER_INVALID deinit 247 * 248 * Others: 249 * CAMGROUP_MANAGER_BINDED-> CAMGROUP_MANAGER_UNBINDED unbind 250 * CAMGROUP_MANAGER_INITED -> CAMGROUP_MANAGER_UNBINDED unbind 251 * CAMGROUP_MANAGER_PREPARED -> CAMGROUP_MANAGER_UNBINDED unbind 252 */ 253 enum camgroup_manager_state_e { 254 CAMGROUP_MANAGER_INVALID, 255 CAMGROUP_MANAGER_BINDED, 256 CAMGROUP_MANAGER_UNBINDED, 257 CAMGROUP_MANAGER_INITED, 258 CAMGROUP_MANAGER_PREPARED, 259 CAMGROUP_MANAGER_STARTED, 260 }; 261 int mState; 262 bool mInit; 263 CamCalibDbCamgroup_t* mCamgroupCalib; 264 uint32_t mClearedSofId; 265 uint32_t mClearedResultId; 266 267 protected: 268 XCamReturn reProcess(rk_aiq_groupcam_result_t* gc_res); 269 rk_aiq_groupcam_result_t* getGroupCamResult(uint32_t frameId, bool query_ready = true); 270 rk_aiq_groupcam_sofsync_t* getGroupCamSofsync(uint32_t frameId, bool query_ready = true); 271 void setSingleCamStatusReady(rk_aiq_singlecam_result_status_t* status, rk_aiq_groupcam_result_t* gc_result); 272 void relayToHwi(rk_aiq_groupcam_result_t* gc_res); 273 void clearGroupCamResult(uint32_t frameId); 274 void clearGroupCamResult_Locked(uint32_t frameId); 275 void putGroupCamResult(rk_aiq_groupcam_result_t* gc_res); 276 void clearGroupCamSofsync(uint32_t frameId); 277 void clearGroupCamSofsync_Locked(uint32_t frameId); 278 void putGroupCamSofsync(rk_aiq_groupcam_sofsync_t* syncSof); 279 void addDefaultAlgos(const struct RkAiqAlgoDesCommExt* algoDes); 280 virtual SmartPtr<RkAiqCamgroupHandle> newAlgoHandle(RkAiqAlgoDesComm* algo, int hw_ver); 281 SmartPtr<RkAiqCamgroupHandle> getDefAlgoTypeHandle(int algo_type); 282 XCamReturn syncSingleCamResultWithMaster(rk_aiq_groupcam_result_t* gc_res); 283 std::map<int, SmartPtr<RkAiqCamgroupHandle>>* getAlgoTypeHandleMap(int algo_type); 284 void* mGroupCtx; 285 private: 286 CamCalibDbV2Context_t mCalibv2; 287 bool needReprepare; 288 XCam::Mutex _update_mutex; 289 XCam::Cond _update_done_cond; 290 std::atomic<bool> _sync_sof_running; 291 }; 292 293 } //namespace 294 295 #endif 296