1 /*
2 * Copyright (c) 2019-2022 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 #include "RkAiqAgainHandle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAgainHandleInt);
23
init()24 void RkAiqAgainHandleInt::init() {
25 ENTER_ANALYZER_FUNCTION();
26
27 RkAiqHandle::deInit();
28 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAgain());
29 mPreInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPreAgain());
30 mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAgain());
31 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAgain());
32 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAgain());
33 mPostInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPostAgain());
34 mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAgain());
35
36 EXIT_ANALYZER_FUNCTION();
37 }
38
updateConfig(bool needSync)39 XCamReturn RkAiqAgainHandleInt::updateConfig(bool needSync) {
40 ENTER_ANALYZER_FUNCTION();
41
42 XCamReturn ret = XCAM_RETURN_NO_ERROR;
43 if (needSync) mCfgMutex.lock();
44
45 if (needSync) mCfgMutex.unlock();
46
47 EXIT_ANALYZER_FUNCTION();
48 return ret;
49 }
50
prepare()51 XCamReturn RkAiqAgainHandleInt::prepare() {
52 ENTER_ANALYZER_FUNCTION();
53
54 XCamReturn ret = XCAM_RETURN_NO_ERROR;
55
56 ret = RkAiqHandle::prepare();
57 RKAIQCORE_CHECK_RET(ret, "again handle prepare failed");
58
59 RkAiqAlgoConfigAgain* again_config_int = (RkAiqAlgoConfigAgain*)mConfig;
60 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
61 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
62 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
63
64 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
65 ret = des->prepare(mConfig);
66 RKAIQCORE_CHECK_RET(ret, "again algo prepare failed");
67
68 EXIT_ANALYZER_FUNCTION();
69 return XCAM_RETURN_NO_ERROR;
70 }
71
preProcess()72 XCamReturn RkAiqAgainHandleInt::preProcess() {
73 ENTER_ANALYZER_FUNCTION();
74
75 XCamReturn ret = XCAM_RETURN_NO_ERROR;
76
77 RkAiqAlgoPreAgain* again_pre_int = (RkAiqAlgoPreAgain*)mPreInParam;
78 RkAiqAlgoPreResAgain* again_pre_res_int = (RkAiqAlgoPreResAgain*)mPreOutParam;
79
80 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
81 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
82 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
83
84 ret = RkAiqHandle::preProcess();
85 if (ret) {
86 RKAIQCORE_CHECK_RET(ret, "again handle preProcess failed");
87 }
88
89 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
90 ret = des->pre_process(mPreInParam, mPreOutParam);
91 RKAIQCORE_CHECK_RET(ret, "again algo pre_process failed");
92
93 EXIT_ANALYZER_FUNCTION();
94 return XCAM_RETURN_NO_ERROR;
95 }
96
processing()97 XCamReturn RkAiqAgainHandleInt::processing() {
98 ENTER_ANALYZER_FUNCTION();
99
100 XCamReturn ret = XCAM_RETURN_NO_ERROR;
101
102 RkAiqAlgoProcAgain* again_proc_int = (RkAiqAlgoProcAgain*)mProcInParam;
103 RkAiqAlgoProcResAgain* again_proc_res_int = (RkAiqAlgoProcResAgain*)mProcOutParam;
104
105 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
106 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
107 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
108
109 again_proc_res_int->stAgainProcResult.stFix = &shared->fullParams->mGainParams->data()->result;
110
111 ret = RkAiqHandle::processing();
112 if (ret) {
113 RKAIQCORE_CHECK_RET(ret, "again handle processing failed");
114 }
115
116 // TODO: fill procParam
117 again_proc_int->iso = sharedCom->iso;
118 again_proc_int->hdr_mode = sharedCom->working_mode;
119
120 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
121 ret = des->processing(mProcInParam, mProcOutParam);
122 RKAIQCORE_CHECK_RET(ret, "again algo processing failed");
123
124 EXIT_ANALYZER_FUNCTION();
125 return ret;
126 }
127
postProcess()128 XCamReturn RkAiqAgainHandleInt::postProcess() {
129 ENTER_ANALYZER_FUNCTION();
130
131 XCamReturn ret = XCAM_RETURN_NO_ERROR;
132
133 RkAiqAlgoPostAgain* again_post_int = (RkAiqAlgoPostAgain*)mPostInParam;
134 RkAiqAlgoPostResAgain* again_post_res_int = (RkAiqAlgoPostResAgain*)mPostOutParam;
135
136 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
137 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
138 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
139
140 ret = RkAiqHandle::postProcess();
141 if (ret) {
142 RKAIQCORE_CHECK_RET(ret, "auvnr handle postProcess failed");
143 return ret;
144 }
145
146 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
147 ret = des->post_process(mPostInParam, mPostOutParam);
148 RKAIQCORE_CHECK_RET(ret, "auvnr algo post_process failed");
149
150 EXIT_ANALYZER_FUNCTION();
151 return ret;
152 }
153
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)154 XCamReturn RkAiqAgainHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
155 ENTER_ANALYZER_FUNCTION();
156
157 XCamReturn ret = XCAM_RETURN_NO_ERROR;
158 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
159 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
160 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
161 RkAiqAlgoProcResAgain* again_com = (RkAiqAlgoProcResAgain*)mProcOutParam;
162
163 if (!again_com) {
164 LOGD_ANALYZER("no asharp result");
165 return XCAM_RETURN_NO_ERROR;
166 }
167
168 if (!this->getAlgoId()) {
169 RkAiqAlgoProcResAgain* again_rk = (RkAiqAlgoProcResAgain*)again_com;
170
171 if (params->mGainParams.ptr()) {
172 rk_aiq_isp_gain_params_v20_t* gain_param = params->mGainParams->data().ptr();
173 if (sharedCom->init) {
174 gain_param->frame_id = 0;
175 } else {
176 gain_param->frame_id = shared->frameId;
177 }
178
179 if (again_com->res_com.cfg_update) {
180 mSyncFlag = shared->frameId;
181 gain_param->sync_flag = mSyncFlag;
182 // copy from algo result
183 // set as the latest result
184 cur_params->mGainParams = gain_param->mGainParams;
185 gain_param->is_update = true;
186 LOGD_ANR("[%d] params from algo", mSyncFlag);
187 } else if (mSyncFlag != gain_param->sync_flag) {
188 gain_param->sync_flag = mSyncFlag;
189 // copy from latest result
190 if (cur_params->mGainParams.ptr()) {
191 gain_param->result = cur_params->mGainParams->data()->result;
192 gain_param->is_update = true;
193 } else {
194 LOGE_ANR("no latest params !");
195 gain_param->is_update = false;
196 }
197 LOGD_ANR("[%d] params from latest [%d]", shared->frameId, mSyncFlag);
198 } else {
199 // do nothing, result in buf needn't update
200 gain_param->is_update = false;
201 LOGD_ANR("[%d] params needn't update", shared->frameId);
202 }
203 LOGD_ANR("oyyf: %s:%d output isp param start\n", __FUNCTION__, __LINE__);
204 }
205 LOGD_ANR("oyyf: %s:%d output isp param end \n", __FUNCTION__, __LINE__);
206 }
207
208 EXIT_ANALYZER_FUNCTION();
209
210 return ret;
211 }
212
213 } // namespace RkCam
214