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
17 #include "RkAiqAmdHandle.h"
18
19 #include "RkAiqCore.h"
20 #include "common/media_buffer/media_buffer.h"
21
22 namespace RkCam {
23
24 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAmdHandleInt);
25
prepare()26 XCamReturn RkAiqAmdHandleInt::prepare() {
27 ENTER_ANALYZER_FUNCTION();
28
29 XCamReturn ret = XCAM_RETURN_NO_ERROR;
30
31 ret = RkAiqHandle::prepare();
32 RKAIQCORE_CHECK_RET(ret, "amd handle prepare failed");
33
34 RkAiqAlgoConfigAmd* amd_config_int = (RkAiqAlgoConfigAmd*)mConfig;
35 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
36 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
37 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
38
39 amd_config_int->spWidth = sharedCom->spWidth;
40 amd_config_int->spHeight = sharedCom->spHeight;
41 amd_config_int->spAlignedW = sharedCom->spAlignedWidth;
42 amd_config_int->spAlignedH = sharedCom->spAlignedHeight;
43
44 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
45 ret = des->prepare(mConfig);
46 RKAIQCORE_CHECK_RET(ret, "amd algo prepare failed");
47
48 EXIT_ANALYZER_FUNCTION();
49 return XCAM_RETURN_NO_ERROR;
50 }
51
init()52 void RkAiqAmdHandleInt::init() {
53 ENTER_ANALYZER_FUNCTION();
54
55 RkAiqHandle::deInit();
56 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAmd());
57 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAmd());
58 // mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAmd());
59
60 EXIT_ANALYZER_FUNCTION();
61 }
62
updateConfig(bool needSync)63 XCamReturn RkAiqAmdHandleInt::updateConfig(bool needSync) { return XCAM_RETURN_NO_ERROR; }
64
preProcess()65 XCamReturn RkAiqAmdHandleInt::preProcess() {
66 ENTER_ANALYZER_FUNCTION();
67
68 XCamReturn ret = XCAM_RETURN_NO_ERROR;
69 #if 0
70 RkAiqAlgoPreAmd* amd_pre_int = (RkAiqAlgoPreAmd*)mPreInParam;
71 RkAiqAlgoPreResAmd* amd_pre_res_int = (RkAiqAlgoPreResAmd*)mPreOutParam;
72 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
73 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
74 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
75
76 ret = RkAiqHandle::preProcess();
77 if (ret) {
78 RKAIQCORE_CHECK_RET(ret, "amd handle preProcess failed");
79 }
80
81 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
82 ret = des->pre_process(mPreInParam, mPreOutParam);
83 RKAIQCORE_CHECK_RET(ret, "amd algo pre_process failed");
84
85 EXIT_ANALYZER_FUNCTION();
86 #endif
87 return XCAM_RETURN_NO_ERROR;
88 }
89
processing()90 XCamReturn RkAiqAmdHandleInt::processing() {
91 ENTER_ANALYZER_FUNCTION();
92
93 XCamReturn ret = XCAM_RETURN_NO_ERROR;
94
95 RkAiqAlgoProcAmd* amd_proc_int = (RkAiqAlgoProcAmd*)mProcInParam;
96
97 mProcResShared = new RkAiqAlgoProcResAmdIntShared();
98 if (!mProcResShared.ptr()) {
99 LOGE("new amd mProcOutParam failed, bypass!");
100 return XCAM_RETURN_BYPASS;
101 }
102 RkAiqAlgoProcResAmd* amd_proc_res_int = &mProcResShared->result;
103
104 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
105 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
106 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
107
108 ret = RkAiqHandle::processing();
109 if (ret) {
110 RKAIQCORE_CHECK_RET(ret, "amd handle processing failed");
111 }
112
113 memset(&amd_proc_res_int->amd_proc_res, 0,
114 sizeof(amd_proc_res_int->amd_proc_res));
115 amd_proc_int->stats.spImage = shared->sp;
116 amd_proc_int->stats.ispGain = shared->ispGain;
117 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
118 ret = des->processing(mProcInParam, (RkAiqAlgoResCom*)amd_proc_res_int);
119 RKAIQCORE_CHECK_RET(ret, "amd algo processing failed");
120
121 MediaBuffer_t* mbuf = amd_proc_res_int->amd_proc_res.st_ratio;
122 if (mbuf) {
123 MotionBufMetaData_t* metadata = (MotionBufMetaData_t*)mbuf->pMetaData;
124 mProcResShared->set_sequence(shared->frameId);
125 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_AMD_PROC_RES_OK, metadata->frame_id, mProcResShared);
126 mAiqCore->post_message(msg);
127 }
128
129 EXIT_ANALYZER_FUNCTION();
130 return ret;
131 }
132
postProcess()133 XCamReturn RkAiqAmdHandleInt::postProcess() {
134 ENTER_ANALYZER_FUNCTION();
135
136 XCamReturn ret = XCAM_RETURN_NO_ERROR;
137 #if 0
138 RkAiqAlgoPostAmd* amd_post_int = (RkAiqAlgoPostAmd*)mPostInParam;
139 RkAiqAlgoPostResAmd* amd_post_res_int = (RkAiqAlgoPostResAmd*)mPostOutParam;
140 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
141 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
142 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
143
144 ret = RkAiqHandle::postProcess();
145 if (ret) {
146 RKAIQCORE_CHECK_RET(ret, "amd handle postProcess failed");
147 return ret;
148 }
149
150 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
151 ret = des->post_process(mPostInParam, mPostOutParam);
152 RKAIQCORE_CHECK_RET(ret, "amd algo post_process failed");
153
154 EXIT_ANALYZER_FUNCTION();
155 #endif
156 return ret;
157 }
158
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)159 XCamReturn RkAiqAmdHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
160 ENTER_ANALYZER_FUNCTION();
161
162 XCamReturn ret = XCAM_RETURN_NO_ERROR;
163 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
164 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
165 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
166 RkAiqAlgoProcResAmd* amd_com = &mProcResShared->result;
167
168 rk_aiq_isp_md_params_v20_t* md_param = params->mMdParams->data().ptr();
169 if (sharedCom->init) {
170 md_param->frame_id = 0;
171 } else {
172 md_param->frame_id = shared->frameId;
173 }
174
175 if (!amd_com) {
176 LOGD_ANALYZER("no amd result");
177 return XCAM_RETURN_NO_ERROR;
178 }
179
180 md_param->result = amd_com->amd_proc_res;
181
182 if (!this->getAlgoId()) {
183 RkAiqAlgoProcResAmd* amd_rk = (RkAiqAlgoProcResAmd*)amd_com;
184 }
185
186 cur_params->mMdParams = params->mMdParams;
187
188 EXIT_ANALYZER_FUNCTION();
189
190 return ret;
191 }
192
193 } // namespace RkCam
194