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 "RkAiqAwdrHandle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAwdrHandleInt);
23
prepare()24 XCamReturn RkAiqAwdrHandleInt::prepare() {
25 ENTER_ANALYZER_FUNCTION();
26
27 XCamReturn ret = XCAM_RETURN_NO_ERROR;
28
29 ret = RkAiqHandle::prepare();
30 RKAIQCORE_CHECK_RET(ret, "awdr handle prepare failed");
31
32 RkAiqAlgoConfigAwdr* awdr_config_int = (RkAiqAlgoConfigAwdr*)mConfig;
33 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
34 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
35
36 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
37 ret = des->prepare(mConfig);
38 RKAIQCORE_CHECK_RET(ret, "awdr algo prepare failed");
39
40 EXIT_ANALYZER_FUNCTION();
41 return XCAM_RETURN_NO_ERROR;
42 }
43
init()44 void RkAiqAwdrHandleInt::init() {
45 ENTER_ANALYZER_FUNCTION();
46
47 RkAiqHandle::deInit();
48 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAwdr());
49 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAwdr());
50 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAwdr());
51
52 EXIT_ANALYZER_FUNCTION();
53 }
54
preProcess()55 XCamReturn RkAiqAwdrHandleInt::preProcess() {
56 ENTER_ANALYZER_FUNCTION();
57
58 XCamReturn ret = XCAM_RETURN_NO_ERROR;
59 #if 0
60 RkAiqAlgoPreAwdr* awdr_pre_int = (RkAiqAlgoPreAwdr*)mPreInParam;
61 RkAiqAlgoPreResAwdr* awdr_pre_res_int = (RkAiqAlgoPreResAwdr*)mPreOutParam;
62 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
63 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
64 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
65
66 ret = RkAiqHandle::preProcess();
67 if (ret) {
68 RKAIQCORE_CHECK_RET(ret, "awdr handle preProcess failed");
69 }
70
71 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
72 ret = des->pre_process(mPreInParam, mPreOutParam);
73 RKAIQCORE_CHECK_RET(ret, "awdr algo pre_process failed");
74
75 EXIT_ANALYZER_FUNCTION();
76 #endif
77 return XCAM_RETURN_NO_ERROR;
78 }
79
processing()80 XCamReturn RkAiqAwdrHandleInt::processing() {
81 ENTER_ANALYZER_FUNCTION();
82
83 XCamReturn ret = XCAM_RETURN_NO_ERROR;
84
85 RkAiqAlgoProcAwdr* awdr_proc_int = (RkAiqAlgoProcAwdr*)mProcInParam;
86 RkAiqAlgoProcResAwdr* awdr_proc_res_int = (RkAiqAlgoProcResAwdr*)mProcOutParam;
87 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
88 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
89 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
90
91 ret = RkAiqHandle::processing();
92 if (ret) {
93 RKAIQCORE_CHECK_RET(ret, "awdr handle processing failed");
94 }
95
96 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
97 ret = des->processing(mProcInParam, mProcOutParam);
98 RKAIQCORE_CHECK_RET(ret, "awdr algo processing failed");
99
100 EXIT_ANALYZER_FUNCTION();
101 return ret;
102 }
103
postProcess()104 XCamReturn RkAiqAwdrHandleInt::postProcess() {
105 ENTER_ANALYZER_FUNCTION();
106
107 XCamReturn ret = XCAM_RETURN_NO_ERROR;
108 #if 0
109 RkAiqAlgoPostAwdr* awdr_post_int = (RkAiqAlgoPostAwdr*)mPostInParam;
110 RkAiqAlgoPostResAwdr* awdr_post_res_int = (RkAiqAlgoPostResAwdr*)mPostOutParam;
111 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
112 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
113 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
114
115 ret = RkAiqHandle::postProcess();
116 if (ret) {
117 RKAIQCORE_CHECK_RET(ret, "awdr handle postProcess failed");
118 return ret;
119 }
120
121 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
122 ret = des->post_process(mPostInParam, mPostOutParam);
123 RKAIQCORE_CHECK_RET(ret, "awdr algo post_process failed");
124
125 EXIT_ANALYZER_FUNCTION();
126 #endif
127 return ret;
128 }
129
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)130 XCamReturn RkAiqAwdrHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
131 ENTER_ANALYZER_FUNCTION();
132
133 XCamReturn ret = XCAM_RETURN_NO_ERROR;
134 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
135 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
136 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
137 RkAiqAlgoProcResAwdr* awdr_com = (RkAiqAlgoProcResAwdr*)mProcOutParam;
138 rk_aiq_isp_wdr_params_v20_t* wdr_param = params->mWdrParams->data().ptr();
139
140 if (sharedCom->init) {
141 wdr_param->frame_id = 0;
142 } else {
143 wdr_param->frame_id = shared->frameId;
144 }
145
146 if (!awdr_com) {
147 LOGD_ANALYZER("no awdr result");
148 return XCAM_RETURN_NO_ERROR;
149 }
150
151 if (!this->getAlgoId()) {
152 RkAiqAlgoProcResAwdr* awdr_rk = (RkAiqAlgoProcResAwdr*)awdr_com;
153 }
154
155 cur_params->mWdrParams = params->mWdrParams;
156
157 EXIT_ANALYZER_FUNCTION();
158
159 return ret;
160 }
161
162 } // namespace RkCam
163