1 /*
2 * RkAiqCamgroupHandle.h
3 *
4 * Copyright (c) 2019-2021 Rockchip Eletronics Co., Ltd.
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 #include "RkAiqCamgroupHandle.h"
21 #include "RkAiqCamGroupManager.h"
22 #include "RkAiqManager.h"
23 #include "aiq_core/RkAiqCore.h"
24
25 namespace RkCam {
26
RkAiqCamgroupHandle(RkAiqAlgoDesComm * des,RkAiqCamGroupManager * camGroupMg)27 RkAiqCamgroupHandle::RkAiqCamgroupHandle(RkAiqAlgoDesComm* des, RkAiqCamGroupManager* camGroupMg)
28 : mDes(des), mGroupMg(camGroupMg), mEnable(true) {
29 mDes->create_context(&mAlgoCtx, (const _AlgoCtxInstanceCfg*)(&mGroupMg->mGroupAlgoCtxCfg));
30 mConfig = NULL;
31 mProcInParam = NULL;
32 mProcOutParam = NULL;
33 updateAtt = false;
34 mNextHdl = NULL;
35 mParentHdl = NULL;
36 mAiqCore = NULL;
37 }
38
~RkAiqCamgroupHandle()39 RkAiqCamgroupHandle::~RkAiqCamgroupHandle() {
40 if (mDes) mDes->destroy_context(mAlgoCtx);
41 deInit();
42 }
43
init()44 void RkAiqCamgroupHandle::init() {
45 ENTER_ANALYZER_FUNCTION();
46 deInit();
47 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoCamGroupPrepare());
48 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoCamGroupProcIn());
49 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoCamGroupProcOut());
50
51 EXIT_ANALYZER_FUNCTION();
52 }
53
prepare(RkAiqCore * aiqCore)54 XCamReturn RkAiqCamgroupHandle::prepare(RkAiqCore* aiqCore) {
55 ENTER_ANALYZER_FUNCTION();
56
57 XCamReturn ret = XCAM_RETURN_NO_ERROR;
58
59 mAiqCore = aiqCore;
60
61 if (mConfig == NULL) init();
62
63 // assume all single cam runs same algos
64
65 RkAiqAlgoCamGroupPrepare* prepareCfg = (RkAiqAlgoCamGroupPrepare*)mConfig ;
66
67 RkAiqAlgoComCamGroup* gcom = &prepareCfg->gcom;
68 RkAiqAlgoCom *com = &gcom->com;
69 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
70
71 prepareCfg->camIdArrayLen = mGroupMg->mBindAiqsMap.size();
72
73 LOGD_CAMGROUP("camgroup: prepare: relay init params ...");
74 int i = 0;
75 for (auto it : mGroupMg->mBindAiqsMap) {
76 prepareCfg->camIdArray[i++] = it.first;
77 }
78
79 prepareCfg->aec.LinePeriodsPerField =
80 (float)sharedCom->snsDes.frame_length_lines;
81 prepareCfg->aec.PixelClockFreqMHZ =
82 (float)sharedCom->snsDes.pixel_clock_freq_mhz;
83 prepareCfg->aec.PixelPeriodsPerLine =
84 (float)sharedCom->snsDes.line_length_pck;
85 prepareCfg->s_calibv2 = mGroupMg->mGroupAlgoCtxCfg.s_calibv2;
86
87 prepareCfg->pCamgroupCalib = mGroupMg->mCamgroupCalib;
88 prepareCfg->aec.nr_switch = sharedCom->snsDes.nr_switch;
89
90 LOGD_CAMGROUP("camgroup: prepare: prepare algos ...");
91
92 com->ctx = mAlgoCtx;
93 com->frame_id = 0;
94 com->u.prepare.working_mode = sharedCom->working_mode;
95 com->u.prepare.sns_op_width = sharedCom->snsDes.isp_acq_width;
96 com->u.prepare.sns_op_height = sharedCom->snsDes.isp_acq_height;
97 com->u.prepare.conf_type = sharedCom->conf_type;
98 com->u.prepare.calibv2 =
99 const_cast<CamCalibDbV2Context_t*>(prepareCfg->s_calibv2);
100 if (mDes->type == RK_AIQ_ALGO_TYPE_AWB) {
101 mCfgMutex.lock();
102 ret = ((RkAiqAlgoDescription*)mDes)->prepare(com);
103 mCfgMutex.unlock();
104 }
105 else {
106 ret = ((RkAiqAlgoDescription*)mDes)->prepare(com);
107 }
108
109 if (ret) {
110 LOGE("algo %d prepare failed !", mDes->type);
111 return ret;
112 }
113
114 EXIT_ANALYZER_FUNCTION();
115
116 return XCAM_RETURN_NO_ERROR;
117 }
118
processing(rk_aiq_singlecam_3a_result_t ** params_res_array)119 XCamReturn RkAiqCamgroupHandle::processing(rk_aiq_singlecam_3a_result_t** params_res_array) {
120 ENTER_ANALYZER_FUNCTION();
121
122 XCamReturn ret = XCAM_RETURN_NO_ERROR;
123
124 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
125
126 RkAiqAlgoCamGroupProcIn* procIn =
127 (RkAiqAlgoCamGroupProcIn*)mProcInParam;
128 RkAiqAlgoCamGroupProcOut* procOut =
129 (RkAiqAlgoCamGroupProcOut*)mProcOutParam;
130
131 memset(procIn, 0, sizeof(RkAiqAlgoCamGroupProcIn));
132 memset(procOut, 0, sizeof(RkAiqAlgoCamGroupProcOut));
133
134 RkAiqAlgoComCamGroup* gcom = &procIn->gcom;
135 RkAiqAlgoCom *com = &gcom->com;
136
137 procIn->arraySize = mGroupMg->mBindAiqsMap.size();
138 procOut->arraySize = mGroupMg->mBindAiqsMap.size();
139
140 procIn->camgroupParmasArray = params_res_array;
141 procOut->camgroupParmasArray = params_res_array;
142 procIn->_gray_mode = sharedCom->gray_mode;
143 procIn->working_mode = sharedCom->working_mode;
144 procIn->_is_bw_sensor = sharedCom->is_bw_sensor;
145 procIn->_offset_is_update =
146 (char*)(&((rk_aiq_isp_params_t<int> *)0)->result) - (char*)(&((rk_aiq_isp_params_t<int>*)0)->is_update);
147
148 com->ctx = mAlgoCtx;
149 com->frame_id = params_res_array[0]->_frameId;
150 // TODO: remove init info ? algo can maintain the state itself
151 com->u.proc.init = mGroupMg->mInit;
152 ret = ((RkAiqAlgoDescription*)mDes)->processing((const RkAiqAlgoCom*)procIn,
153 (RkAiqAlgoResCom*)procOut);
154 if (ret) {
155 LOGW_CAMGROUP("group algo %d proc error !", mDes->type);
156 return ret;
157 }
158
159 EXIT_ANALYZER_FUNCTION();
160
161 return XCAM_RETURN_NO_ERROR;
162 }
163
deInit()164 void RkAiqCamgroupHandle::deInit() {
165 ENTER_ANALYZER_FUNCTION();
166
167 #define RKAIQ_DELLET(a) \
168 if (a) { \
169 delete a; \
170 a = NULL; \
171 }
172
173 RKAIQ_DELLET(mConfig);
174 RKAIQ_DELLET(mProcInParam);
175 RKAIQ_DELLET(mProcOutParam);
176
177 EXIT_ANALYZER_FUNCTION();
178 }
179
180 void
waitSignal(rk_aiq_uapi_mode_sync_e sync_mode)181 RkAiqCamgroupHandle::waitSignal(rk_aiq_uapi_mode_sync_e sync_mode)
182 {
183 if (mGroupMg->isRunningState()) {
184 if (sync_mode == RK_AIQ_UAPI_MODE_ASYNC)
185 return;
186
187 mUpdateCond.timedwait(mCfgMutex, 100000);
188 } else {
189 updateConfig(false);
190 }
191 }
192
193 void
sendSignal(rk_aiq_uapi_mode_sync_e sync_mode)194 RkAiqCamgroupHandle::sendSignal(rk_aiq_uapi_mode_sync_e sync_mode)
195 {
196 if (sync_mode == RK_AIQ_UAPI_MODE_ASYNC)
197 return;
198
199 if (mGroupMg->isRunningState())
200 mUpdateCond.signal();
201 }
202
203 } // namespace RkCam
204