1 /*
2 * RkAiqHandle.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 "RkAiqHandle.h"
21
22 #include "RkAiqCore.h"
23
24 namespace RkCam {
25
26 RkAiqHandleFactory::map_type* RkAiqHandleFactory::map;
27
RkAiqHandle(RkAiqAlgoDesComm * des,RkAiqCore * aiqCore)28 RkAiqHandle::RkAiqHandle(RkAiqAlgoDesComm* des, RkAiqCore* aiqCore)
29 : mDes(des), mAiqCore(aiqCore), mEnable(true), mReConfig(false) {
30 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
31 mDes->create_context(&mAlgoCtx, (const _AlgoCtxInstanceCfg*)(&sharedCom->ctxCfigs[des->type]));
32 mConfig = NULL;
33 mPreInParam = NULL;
34 mPreOutParam = NULL;
35 mProcInParam = NULL;
36 mProcOutParam = NULL;
37 mPostInParam = NULL;
38 mPostOutParam = NULL;
39 updateAtt = false;
40 mNextHdl = NULL;
41 mParentHdl = NULL;
42 mIsMulRun = false;
43 mPostShared = true;
44 mSyncFlag = (uint32_t)(-1);
45 }
46
~RkAiqHandle()47 RkAiqHandle::~RkAiqHandle() {
48 if (mDes) mDes->destroy_context(mAlgoCtx);
49 }
50
configInparamsCom(RkAiqAlgoCom * com,int type)51 XCamReturn RkAiqHandle::configInparamsCom(RkAiqAlgoCom* com, int type) {
52 ENTER_ANALYZER_FUNCTION();
53
54 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
55 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
56 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
57 xcam_mem_clear(*com);
58
59 if (type == RKAIQ_CONFIG_COM_PREPARE) {
60 com->ctx = mAlgoCtx;
61 com->frame_id = shared->frameId;
62 com->u.prepare.working_mode = sharedCom->working_mode;
63 com->u.prepare.sns_op_width = sharedCom->snsDes.isp_acq_width;
64 com->u.prepare.sns_op_height = sharedCom->snsDes.isp_acq_height;
65 com->u.prepare.conf_type = sharedCom->conf_type;
66 #ifdef RKAIQ_ENABLE_PARSER_V1
67 com->u.prepare.calib = (CamCalibDbContext_t*)(sharedCom->calib);
68 #endif
69 com->u.prepare.calibv2 = (CamCalibDbV2Context_t*)(sharedCom->calibv2);
70 } else {
71 com->ctx = mAlgoCtx;
72 com->frame_id = shared->frameId;
73 com->u.proc.init = sharedCom->init;
74 com->u.proc.iso = sharedCom->iso;
75 com->u.proc.fill_light_on = sharedCom->fill_light_on;
76 com->u.proc.gray_mode = sharedCom->gray_mode;
77 com->u.proc.is_bw_sensor = sharedCom->is_bw_sensor;
78 com->u.proc.preExp = &shared->preExp;
79 com->u.proc.curExp = &shared->curExp;
80 com->u.proc.nxtExp = &shared->nxtExp;
81 com->u.proc.res_comb = &shared->res_comb;
82 }
83 EXIT_ANALYZER_FUNCTION();
84
85 return XCAM_RETURN_NO_ERROR;
86 }
87
prepare()88 XCamReturn RkAiqHandle::prepare() {
89 ENTER_ANALYZER_FUNCTION();
90
91 XCamReturn ret = XCAM_RETURN_NO_ERROR;
92
93 if (mConfig == NULL) init();
94 // build common configs
95 RkAiqAlgoCom* cfgParam = mConfig;
96 configInparamsCom(cfgParam, RKAIQ_CONFIG_COM_PREPARE);
97
98 EXIT_ANALYZER_FUNCTION();
99
100 return XCAM_RETURN_NO_ERROR;
101 }
102
preProcess()103 XCamReturn RkAiqHandle::preProcess() {
104 ENTER_ANALYZER_FUNCTION();
105
106 XCamReturn ret = XCAM_RETURN_NO_ERROR;
107 RkAiqAlgoCom* preParam = mPreInParam;
108
109 configInparamsCom(preParam, RKAIQ_CONFIG_COM_PRE);
110
111 EXIT_ANALYZER_FUNCTION();
112
113 return XCAM_RETURN_NO_ERROR;
114 }
115
processing()116 XCamReturn RkAiqHandle::processing() {
117 ENTER_ANALYZER_FUNCTION();
118
119 XCamReturn ret = XCAM_RETURN_NO_ERROR;
120 RkAiqAlgoCom* procParam = mProcInParam;
121
122 configInparamsCom(procParam, RKAIQ_CONFIG_COM_PROC);
123
124 EXIT_ANALYZER_FUNCTION();
125
126 return XCAM_RETURN_NO_ERROR;
127 }
128
postProcess()129 XCamReturn RkAiqHandle::postProcess() {
130 ENTER_ANALYZER_FUNCTION();
131
132 XCamReturn ret = XCAM_RETURN_NO_ERROR;
133 RkAiqAlgoCom* postParam = mPostInParam;
134
135 configInparamsCom(postParam, RKAIQ_CONFIG_COM_POST);
136
137 EXIT_ANALYZER_FUNCTION();
138
139 return XCAM_RETURN_NO_ERROR;
140 }
141
deInit()142 void RkAiqHandle::deInit() {
143 ENTER_ANALYZER_FUNCTION();
144
145 #define RKAIQ_DELLET(a) \
146 if (a) { \
147 delete a; \
148 a = NULL; \
149 }
150
151 RKAIQ_DELLET(mConfig);
152 RKAIQ_DELLET(mPreInParam);
153 RKAIQ_DELLET(mPreOutParam);
154 RKAIQ_DELLET(mProcInParam);
155 RKAIQ_DELLET(mProcOutParam);
156 RKAIQ_DELLET(mPostInParam);
157 RKAIQ_DELLET(mPostOutParam);
158
159 EXIT_ANALYZER_FUNCTION();
160 }
161
162 void
waitSignal(rk_aiq_uapi_mode_sync_e sync_mode)163 RkAiqHandle::waitSignal(rk_aiq_uapi_mode_sync_e sync_mode)
164 {
165 if (mAiqCore->isRunningState()) {
166 if (sync_mode == RK_AIQ_UAPI_MODE_ASYNC)
167 return;
168
169 mUpdateCond.timedwait(mCfgMutex, 100000);
170 } else {
171 updateConfig(false);
172 }
173 }
174
175 void
sendSignal(rk_aiq_uapi_mode_sync_e sync_mode)176 RkAiqHandle::sendSignal(rk_aiq_uapi_mode_sync_e sync_mode)
177 {
178 if (sync_mode == RK_AIQ_UAPI_MODE_ASYNC)
179 return;
180
181 if (mAiqCore->isRunningState())
182 mUpdateCond.signal();
183 }
184
185
186
187 } // namespace RkCam
188