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 "RkAiqAorbHandle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAorbHandleInt);
23
init()24 void RkAiqAorbHandleInt::init() {
25 ENTER_ANALYZER_FUNCTION();
26
27 RkAiqHandle::deInit();
28 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAorb());
29 mPreInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPreAorb());
30 mPreOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPreResAorb());
31 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAorb());
32 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAorb());
33 mPostInParam = (RkAiqAlgoCom*)(new RkAiqAlgoPostAorb());
34 mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAorb());
35
36 EXIT_ANALYZER_FUNCTION();
37 }
38
prepare()39 XCamReturn RkAiqAorbHandleInt::prepare() {
40 ENTER_ANALYZER_FUNCTION();
41
42 XCamReturn ret = XCAM_RETURN_NO_ERROR;
43
44 ret = RkAiqHandle::prepare();
45 RKAIQCORE_CHECK_RET(ret, "aorb handle prepare failed");
46
47 RkAiqAlgoConfigAorb* aorb_config_int = (RkAiqAlgoConfigAorb*)mConfig;
48 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
49
50 CalibDbV2_Orb_t* orb =
51 (CalibDbV2_Orb_t*)CALIBDBV2_GET_MODULE_PTR((void*)(sharedCom->calibv2), orb);
52 if (orb) {
53 aorb_config_int->orb_calib_cfg.param.orb_en = orb->param.orb_en;
54 }
55
56 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
57 ret = des->prepare(mConfig);
58 RKAIQCORE_CHECK_RET(ret, "aorb algo prepare failed");
59
60 EXIT_ANALYZER_FUNCTION();
61 return XCAM_RETURN_NO_ERROR;
62 }
63
preProcess()64 XCamReturn RkAiqAorbHandleInt::preProcess() { return XCAM_RETURN_NO_ERROR; }
65
processing()66 XCamReturn RkAiqAorbHandleInt::processing() {
67 ENTER_ANALYZER_FUNCTION();
68
69 XCamReturn ret = XCAM_RETURN_NO_ERROR;
70
71 RkAiqAlgoProcAorb* aorb_proc_int = (RkAiqAlgoProcAorb*)mProcInParam;
72 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
73 auto* shared = (RkAiqCore::RkAiqAlgosGroupShared_t*)getGroupShared();
74 if (!shared) return XCAM_RETURN_BYPASS;
75
76 aorb_proc_int->orb_stats_buf = shared->orbStats;
77
78 ret = RkAiqHandle::processing();
79 if (ret) {
80 RKAIQCORE_CHECK_RET(ret, "aorb handle processing failed");
81 }
82
83 if (!shared->orbStats && !sharedCom->init) {
84 LOGE_AORB("no orb stats, ignore!");
85 return XCAM_RETURN_BYPASS;
86 }
87
88 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
89 ret = des->processing(mProcInParam, mProcOutParam);
90 RKAIQCORE_CHECK_RET(ret, "aorb algo processing failed");
91
92 EXIT_ANALYZER_FUNCTION();
93 return ret;
94 }
95
postProcess()96 XCamReturn RkAiqAorbHandleInt::postProcess() { return XCAM_RETURN_NO_ERROR; }
97
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)98 XCamReturn RkAiqAorbHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
99 ENTER_ANALYZER_FUNCTION();
100
101 XCamReturn ret = XCAM_RETURN_NO_ERROR;
102 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
103 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
104 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
105 RkAiqAlgoProcResAorb* aorb_com = (RkAiqAlgoProcResAorb*)mProcOutParam;
106
107 if (!aorb_com) {
108 LOGE_ANALYZER("no aorb result");
109 return XCAM_RETURN_NO_ERROR;
110 }
111
112 if (!this->getAlgoId()) {
113 RkAiqAlgoProcResAorb* aorb_rk = (RkAiqAlgoProcResAorb*)aorb_com;
114 rk_aiq_isp_orb_params_v20_t* orb_params = params->mOrbParams->data().ptr();
115 if (orb_params != nullptr) {
116 if (sharedCom->init) {
117 orb_params->frame_id = 0;
118 } else {
119 orb_params->frame_id = shared->frameId;
120 }
121 if (aorb_rk->aorb_meas.update) {
122 orb_params->update_mask |= RKAIQ_ISPP_ORB_ID;
123 orb_params->result.orb_en = aorb_rk->aorb_meas.orb_en;
124 if (orb_params->result.orb_en) {
125 orb_params->result.limit_value = aorb_rk->aorb_meas.limit_value;
126 orb_params->result.max_feature = aorb_rk->aorb_meas.max_feature;
127 }
128 } else {
129 orb_params->update_mask &= ~RKAIQ_ISPP_ORB_ID;
130 }
131 }
132 }
133
134 cur_params->mOrbParams = params->mOrbParams;
135
136 EXIT_ANALYZER_FUNCTION();
137
138 return ret;
139 }
140
141 } // namespace RkCam
142