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 "RkAiqAwbV32Handle.h"
17
18 #include "RkAiqCore.h"
19
20 namespace RkCam {
21
22 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAwbV32HandleInt);
23
updateConfig(bool needSync)24 XCamReturn RkAiqAwbV32HandleInt::updateConfig(bool needSync) {
25 ENTER_ANALYZER_FUNCTION();
26
27 XCamReturn ret = XCAM_RETURN_NO_ERROR;
28 #ifndef DISABLE_HANDLE_ATTRIB
29 if (needSync) mCfgMutex.lock();
30 // if something changed
31 if (updateWbV32Attr) {
32 mCurWbV32Attr = mNewWbV32Attr;
33 rk_aiq_uapiV2_awbV32_SetAttrib(mAlgoCtx, mCurWbV32Attr, false);
34 updateWbV32Attr = false;
35 sendSignal(mCurWbV32Attr.sync.sync_mode);
36 }
37 if (updateWbOpModeAttr) {
38 mCurWbOpModeAttr = mNewWbOpModeAttr;
39 rk_aiq_uapiV2_awb_SetMwbMode(mAlgoCtx, mCurWbOpModeAttr.mode, false);
40 updateWbOpModeAttr = false;
41 sendSignal(mCurWbOpModeAttr.sync.sync_mode);
42 }
43 if (updateWbMwbAttr) {
44 mCurWbMwbAttr = mNewWbMwbAttr;
45 rk_aiq_uapiV2_awb_SetMwbAttrib(mAlgoCtx, mCurWbMwbAttr, false);
46 updateWbMwbAttr = false;
47 sendSignal(mCurWbMwbAttr.sync.sync_mode);
48 }
49 if (updateWbAwbWbGainOffsetAttr) {
50 mCurWbAwbWbGainOffsetAttr = mNewWbAwbWbGainOffsetAttr;
51 rk_aiq_uapiV2_awb_SetAwbGainOffset(mAlgoCtx, mCurWbAwbWbGainOffsetAttr.gainOffset, false);
52 updateWbAwbWbGainOffsetAttr = false;
53 sendSignal(mCurWbAwbWbGainOffsetAttr.sync.sync_mode);
54 }
55 if (updateWbV32AwbMultiWindowAttr) {
56 mCurWbV32AwbMultiWindowAttr = mNewWbV32AwbMultiWindowAttr;
57 rk_aiq_uapiV2_awbV32_SetAwbMultiwindow(mAlgoCtx, mCurWbV32AwbMultiWindowAttr, false);
58 updateWbV32AwbMultiWindowAttr = false;
59 sendSignal(mCurWbV32AwbMultiWindowAttr.sync.sync_mode);
60 }
61 if (updateWriteAwbInputAttr) {
62 mCurWriteAwbInputAttr = mNewWriteAwbInputAttr;
63 rk_aiq_uapiV2_awb_WriteInput(mAlgoCtx, mCurWriteAwbInputAttr, false);
64 updateWriteAwbInputAttr = false;
65 sendSignal(mCurWriteAwbInputAttr.sync.sync_mode);
66 }
67 if (updateFFWbgainAttr) {
68 mCurFFWbgainAttr = mNewFFWbgainAttr;
69 rk_aiq_uapiV2_awb_SetFstFrWbgain(mAlgoCtx, mCurFFWbgainAttr.wggain, false);
70 updateFFWbgainAttr = false;
71 sendSignal(mCurFFWbgainAttr.sync.sync_mode);
72 }
73 if (needSync) mCfgMutex.unlock();
74 #endif
75
76 EXIT_ANALYZER_FUNCTION();
77 return ret;
78 }
setWbV32AwbMultiWindowAttrib(rk_aiq_uapiV2_wbV32_awb_mulWindow_t att)79 XCamReturn RkAiqAwbV32HandleInt::setWbV32AwbMultiWindowAttrib(rk_aiq_uapiV2_wbV32_awb_mulWindow_t att) {
80 ENTER_ANALYZER_FUNCTION();
81
82 XCamReturn ret = XCAM_RETURN_NO_ERROR;
83 mCfgMutex.lock();
84
85 #ifdef DISABLE_HANDLE_ATTRIB
86 ret = rk_aiq_uapiV2_awbV32_SetAwbMultiwindow(mAlgoCtx, att, false);
87 #else
88 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
89 // if something changed, set att to mNewAtt, and
90 // the new params will be effective later when updateConfig
91 // called by RkAiqCore
92 bool isChanged = false;
93 if (att.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
94 memcmp(&mNewWbV32AwbMultiWindowAttr, &att, sizeof(att)))
95 isChanged = true;
96 else if (att.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
97 memcmp(&mCurWbV32AwbMultiWindowAttr, &att, sizeof(att)))
98 isChanged = true;
99
100 // if something changed
101 if (isChanged) {
102 mNewWbV32AwbMultiWindowAttr = att;
103 updateWbV32AwbMultiWindowAttr = true;
104 waitSignal(att.sync.sync_mode);
105 }
106 #endif
107
108 mCfgMutex.unlock();
109
110 EXIT_ANALYZER_FUNCTION();
111 return ret;
112 }
113
getWbV32AwbMultiWindowAttrib(rk_aiq_uapiV2_wbV32_awb_mulWindow_t * att)114 XCamReturn RkAiqAwbV32HandleInt::getWbV32AwbMultiWindowAttrib(rk_aiq_uapiV2_wbV32_awb_mulWindow_t* att) {
115 ENTER_ANALYZER_FUNCTION();
116
117 XCamReturn ret = XCAM_RETURN_NO_ERROR;
118
119 #ifdef DISABLE_HANDLE_ATTRIB
120 mCfgMutex.lock();
121 rk_aiq_uapiV2_awbV32_GetAwbMultiwindow(mAlgoCtx, att);
122 att->sync.done = true;
123 mCfgMutex.unlock();
124 #else
125 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
126 mCfgMutex.lock();
127 rk_aiq_uapiV2_awbV32_GetAwbMultiwindow(mAlgoCtx, att);
128 att->sync.done = true;
129 mCfgMutex.unlock();
130 } else {
131 if (updateWbV32AwbMultiWindowAttr) {
132 memcpy(att, &mNewWbV32AwbMultiWindowAttr, sizeof(mNewWbV32AwbMultiWindowAttr));
133 att->sync.done = false;
134 } else {
135 mCfgMutex.lock();
136 rk_aiq_uapiV2_awbV32_GetAwbMultiwindow(mAlgoCtx, att);
137 mCfgMutex.unlock();
138 att->sync.sync_mode = mNewWbV32AwbMultiWindowAttr.sync.sync_mode;
139 att->sync.done = true;
140 }
141 }
142 #endif
143 EXIT_ANALYZER_FUNCTION();
144 return ret;
145 }
146
setWbV32Attrib(rk_aiq_uapiV2_wbV32_attrib_t att)147 XCamReturn RkAiqAwbV32HandleInt::setWbV32Attrib(rk_aiq_uapiV2_wbV32_attrib_t att) {
148 ENTER_ANALYZER_FUNCTION();
149
150 XCamReturn ret = XCAM_RETURN_NO_ERROR;
151 mCfgMutex.lock();
152
153 #ifdef DISABLE_HANDLE_ATTRIB
154 ret = rk_aiq_uapiV2_awbV32_SetAttrib(mAlgoCtx, att, false);
155 #else
156 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
157 // if something changed, set att to mNewAtt, and
158 // the new params will be effective later when updateConfig
159 // called by RkAiqCore
160 bool isChanged = false;
161 if (att.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
162 memcmp(&mNewWbV32Attr, &att, sizeof(att)))
163 isChanged = true;
164 else if (att.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
165 memcmp(&mCurWbV32Attr, &att, sizeof(att)))
166 isChanged = true;
167
168 // if something changed
169 if (isChanged) {
170 mNewWbV32Attr = att;
171 updateWbV32Attr = true;
172 waitSignal(att.sync.sync_mode);
173 }
174 #endif
175
176 mCfgMutex.unlock();
177
178 EXIT_ANALYZER_FUNCTION();
179 return ret;
180 }
181
getWbV32Attrib(rk_aiq_uapiV2_wbV32_attrib_t * att)182 XCamReturn RkAiqAwbV32HandleInt::getWbV32Attrib(rk_aiq_uapiV2_wbV32_attrib_t* att) {
183 ENTER_ANALYZER_FUNCTION();
184
185 XCamReturn ret = XCAM_RETURN_NO_ERROR;
186
187 #ifdef DISABLE_HANDLE_ATTRIB
188 mCfgMutex.lock();
189 rk_aiq_uapiV2_awbV32_GetAttrib(mAlgoCtx, att);
190 att->sync.done = true;
191 mCfgMutex.unlock();
192 #else
193 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
194 mCfgMutex.lock();
195 rk_aiq_uapiV2_awbV32_GetAttrib(mAlgoCtx, att);
196 att->sync.done = true;
197 mCfgMutex.unlock();
198 } else {
199 if (updateWbV32Attr) {
200 memcpy(att, &mNewWbV32Attr, sizeof(mNewWbV32Attr));
201 att->sync.done = false;
202 } else {
203 mCfgMutex.lock();
204 rk_aiq_uapiV2_awbV32_GetAttrib(mAlgoCtx, att);
205 mCfgMutex.unlock();
206 att->sync.sync_mode = mNewWbV32Attr.sync.sync_mode;
207 att->sync.done = true;
208 }
209 }
210 #endif
211
212 EXIT_ANALYZER_FUNCTION();
213 return ret;
214 }
writeAwbIn(rk_aiq_uapiV2_awb_wrtIn_attr_t att)215 XCamReturn RkAiqAwbV32HandleInt::writeAwbIn(rk_aiq_uapiV2_awb_wrtIn_attr_t att) {
216 ENTER_ANALYZER_FUNCTION();
217
218 XCamReturn ret = XCAM_RETURN_NO_ERROR;
219 mCfgMutex.lock();
220
221 #ifdef DISABLE_HANDLE_ATTRIB
222 ret = rk_aiq_uapiV2_awb_WriteInput(mAlgoCtx, att, false);
223 #else
224 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
225 // if something changed, set att to mNewAtt, and
226 // the new params will be effective later when updateConfig
227 // called by RkAiqCore
228 bool isChanged = false;
229 if (att.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
230 memcmp(&mNewWriteAwbInputAttr, &att, sizeof(att)))
231 isChanged = true;
232 else if (att.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
233 memcmp(&mCurWriteAwbInputAttr, &att, sizeof(att)))
234 isChanged = true;
235
236 // if something changed
237 if (isChanged) {
238 mNewWriteAwbInputAttr = att;
239 updateWriteAwbInputAttr = true;
240 waitSignal(att.sync.sync_mode);
241 }
242 #endif
243
244 mCfgMutex.unlock();
245
246 EXIT_ANALYZER_FUNCTION();
247 return ret;
248 }
249
250
251 } // namespace RkCam
252