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 "RkAiqAwbHandle.h"
17
18 #include "RkAiqAblcHandle.h"
19 #include "RkAiqCore.h"
20 #include "awb/rk_aiq_uapiv2_awb_int.h"
21 #include "smart_buffer_priv.h"
22
23 namespace RkCam {
24
25 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAwbHandleInt);
26
init()27 void RkAiqAwbHandleInt::init() {
28 ENTER_ANALYZER_FUNCTION();
29
30 RkAiqHandle::deInit();
31 mConfig = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAwb());
32 mProcInParam = (RkAiqAlgoCom*)(new RkAiqAlgoProcAwb());
33 mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAwb());
34
35 EXIT_ANALYZER_FUNCTION();
36 }
37
updateConfig(bool needSync)38 XCamReturn RkAiqAwbHandleInt::updateConfig(bool needSync) {
39 ENTER_ANALYZER_FUNCTION();
40
41 XCamReturn ret = XCAM_RETURN_NO_ERROR;
42 #ifndef DISABLE_HANDLE_ATTRIB
43 #ifdef RKAIQ_HAVE_AWB_V20
44 if (needSync) mCfgMutex.lock();
45 // if something changed
46 if (updateAtt) {
47 mCurAtt = mNewAtt;
48 rk_aiq_uapi_awb_SetAttrib(mAlgoCtx, mCurAtt, false);
49 updateAtt = false;
50 sendSignal();
51 }
52 if (updateWbV20Attr) {
53 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t wbGainAdjustBK = mCurWbV20Attr.stAuto.wbGainAdjust;
54 mCurWbV20Attr = mNewWbV20Attr;
55 mCurWbV20Attr.stAuto.wbGainAdjust = wbGainAdjustBK;
56 mallocAndCopyWbGainAdjustAttrib(&mCurWbV20Attr.stAuto.wbGainAdjust,&mNewWbV20Attr.stAuto.wbGainAdjust);
57 rk_aiq_uapiV2_awbV20_SetAttrib(mAlgoCtx, mCurWbV20Attr, false);
58 updateWbV20Attr = false;
59 sendSignal();
60 }
61 if (updateWbOpModeAttr) {
62 mCurWbOpModeAttr = mNewWbOpModeAttr;
63 rk_aiq_uapiV2_awb_SetMwbMode(mAlgoCtx, mCurWbOpModeAttr.mode, false);
64 updateWbOpModeAttr = false;
65 sendSignal(mCurWbOpModeAttr.sync.sync_mode);
66 }
67 if (updateWbMwbAttr) {
68 mCurWbMwbAttr = mNewWbMwbAttr;
69 rk_aiq_uapiV2_awb_SetMwbAttrib(mAlgoCtx, mCurWbMwbAttr, false);
70 updateWbMwbAttr = false;
71 sendSignal(mCurWbMwbAttr.sync.sync_mode);
72 }
73 if (updateWbAwbAttr) {
74 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t wbGainAdjustBK = mCurWbAwbAttr.wbGainAdjust;
75 mCurWbAwbAttr = mNewWbAwbAttr;
76 mCurWbAwbAttr.wbGainAdjust = wbGainAdjustBK;
77 mallocAndCopyWbGainAdjustAttrib(&mCurWbAwbAttr.wbGainAdjust,&mNewWbAwbAttr.wbGainAdjust);
78 rk_aiq_uapiV2_awbV20_SetAwbAttrib(mAlgoCtx, mCurWbAwbAttr, false);
79 updateWbAwbAttr = false;
80 sendSignal();
81 }
82 if (updateWbAwbWbGainAdjustAttr) {
83 mallocAndCopyWbGainAdjustAttrib(&mCurWbAwbWbGainAdjustAttr,&mNewWbAwbWbGainAdjustAttr);
84 rk_aiq_uapiV2_awb_SetAwbGainAdjust(mAlgoCtx, mCurWbAwbWbGainAdjustAttr, false);
85 updateWbAwbWbGainAdjustAttr = false;
86 sendSignal(mCurWbAwbWbGainAdjustAttr.sync.sync_mode);
87 }
88 if (updateWbAwbWbGainOffsetAttr) {
89 mCurWbAwbWbGainOffsetAttr = mNewWbAwbWbGainOffsetAttr;
90 rk_aiq_uapiV2_awb_SetAwbGainOffset(mAlgoCtx, mCurWbAwbWbGainOffsetAttr.gainOffset, false);
91 updateWbAwbWbGainOffsetAttr = false;
92 sendSignal(mCurWbAwbWbGainOffsetAttr.sync.sync_mode);
93 }
94 if (updateWbAwbMultiWindowAttr) {
95 mCurWbAwbMultiWindowAttr = mNewWbAwbMultiWindowAttr;
96 rk_aiq_uapiV2_awb_SetAwbMultiwindow(mAlgoCtx, mCurWbAwbMultiWindowAttr.multiWindw, false);
97 updateWbAwbMultiWindowAttr = false;
98 sendSignal(mCurWbAwbMultiWindowAttr.sync.sync_mode);
99 }
100 if (updateFFWbgainAttr) {
101 mCurFFWbgainAttr = mNewFFWbgainAttr;
102 rk_aiq_uapiV2_awb_SetFstFrWbgain(mAlgoCtx, mCurFFWbgainAttr.wggain, false);
103 updateFFWbgainAttr = false;
104 sendSignal(mCurFFWbgainAttr.sync.sync_mode);
105 }
106 if (needSync) mCfgMutex.unlock();
107 #endif
108 #endif
109 EXIT_ANALYZER_FUNCTION();
110 return ret;
111 }
112
setAttrib(rk_aiq_wb_attrib_t att)113 XCamReturn RkAiqAwbHandleInt::setAttrib(rk_aiq_wb_attrib_t att) {
114 ENTER_ANALYZER_FUNCTION();
115
116 XCamReturn ret = XCAM_RETURN_NO_ERROR;
117 mCfgMutex.lock();
118 #ifdef DISABLE_HANDLE_ATTRIB
119 ret = rk_aiq_uapi_awb_SetAttrib(mAlgoCtx, att, false);
120 #else
121 // TODO
122 // check if there is different between att & mCurAtt
123 // if something changed, set att to mNewAtt, and
124 // the new params will be effective later when updateConfig
125 // called by RkAiqCore
126
127 // if something changed
128 if (0 != memcmp(&mCurAtt, &att, sizeof(rk_aiq_wb_attrib_t))) {
129 mNewAtt = att;
130 updateAtt = true;
131 waitSignal();
132 }
133 #endif
134
135 mCfgMutex.unlock();
136
137 EXIT_ANALYZER_FUNCTION();
138 return ret;
139 }
140
getAttrib(rk_aiq_wb_attrib_t * att)141 XCamReturn RkAiqAwbHandleInt::getAttrib(rk_aiq_wb_attrib_t* att) {
142 ENTER_ANALYZER_FUNCTION();
143
144 SmartLock lock (mCfgMutex);
145
146 XCamReturn ret = XCAM_RETURN_NO_ERROR;
147
148 rk_aiq_uapi_awb_GetAttrib(mAlgoCtx, att);
149
150 EXIT_ANALYZER_FUNCTION();
151 return ret;
152 }
153
getCct(rk_aiq_wb_cct_t * cct)154 XCamReturn RkAiqAwbHandleInt::getCct(rk_aiq_wb_cct_t* cct) {
155 ENTER_ANALYZER_FUNCTION();
156
157 XCamReturn ret = XCAM_RETURN_NO_ERROR;
158
159 rk_aiq_uapiV2_awb_GetCCT(mAlgoCtx, cct);
160
161 EXIT_ANALYZER_FUNCTION();
162 return ret;
163 }
164
queryWBInfo(rk_aiq_wb_querry_info_t * wb_querry_info)165 XCamReturn RkAiqAwbHandleInt::queryWBInfo(rk_aiq_wb_querry_info_t* wb_querry_info) {
166 ENTER_ANALYZER_FUNCTION();
167
168 SmartLock lock (mCfgMutex);
169
170 XCamReturn ret = XCAM_RETURN_NO_ERROR;
171
172 rk_aiq_uapiV2_awb_QueryWBInfo(mAlgoCtx, wb_querry_info);
173
174 EXIT_ANALYZER_FUNCTION();
175 return ret;
176 }
177
lock()178 XCamReturn RkAiqAwbHandleInt::lock() {
179 ENTER_ANALYZER_FUNCTION();
180
181 XCamReturn ret = XCAM_RETURN_NO_ERROR;
182
183 rk_aiq_uapiV2_awb_Lock(mAlgoCtx);
184
185 EXIT_ANALYZER_FUNCTION();
186 return ret;
187 }
188
unlock()189 XCamReturn RkAiqAwbHandleInt::unlock() {
190 ENTER_ANALYZER_FUNCTION();
191
192 XCamReturn ret = XCAM_RETURN_NO_ERROR;
193
194 rk_aiq_uapiV2_awb_Unlock(mAlgoCtx);
195
196 EXIT_ANALYZER_FUNCTION();
197 return ret;
198 }
199
getAlgoStat(rk_tool_awb_stat_res_full_t * awb_stat_algo)200 XCamReturn RkAiqAwbHandleInt::getAlgoStat(rk_tool_awb_stat_res_full_t *awb_stat_algo) {
201 ENTER_ANALYZER_FUNCTION();
202
203 SmartLock lock (mCfgMutex);
204
205 XCamReturn ret = XCAM_RETURN_NO_ERROR;
206
207 rk_aiq_uapiV2_awb_GetAlgoStat(mAlgoCtx,awb_stat_algo);
208
209 EXIT_ANALYZER_FUNCTION();
210 return ret;
211 }
212
getStrategyResult(rk_tool_awb_strategy_result_t * awb_strategy_result)213 XCamReturn RkAiqAwbHandleInt::getStrategyResult(rk_tool_awb_strategy_result_t *awb_strategy_result) {
214 ENTER_ANALYZER_FUNCTION();
215
216 SmartLock lock (mCfgMutex);
217
218 XCamReturn ret = XCAM_RETURN_NO_ERROR;
219
220 rk_aiq_uapiV2_awb_GetStrategyResult(mAlgoCtx,awb_strategy_result);
221
222 EXIT_ANALYZER_FUNCTION();
223 return ret;
224 }
setWbV20Attrib(rk_aiq_uapiV2_wbV20_attrib_t att)225 XCamReturn RkAiqAwbHandleInt::setWbV20Attrib(rk_aiq_uapiV2_wbV20_attrib_t att) {
226 ENTER_ANALYZER_FUNCTION();
227
228 XCamReturn ret = XCAM_RETURN_NO_ERROR;
229 #ifdef RKAIQ_HAVE_AWB_V20
230 mCfgMutex.lock();
231 #ifdef DISABLE_HANDLE_ATTRIB
232 ret = rk_aiq_uapiV2_awbV20_SetAttrib(mAlgoCtx, att, false);
233 #else
234 // TODO
235 // check if there is different between att & mCurAtt
236 // if something changed, set att to mNewAtt, and
237 // the new params will be effective later when updateConfig
238 // called by RkAiqCore
239
240 // if something changed
241 if (0 != memcmp(&mCurWbV20Attr, &att, sizeof(rk_aiq_uapiV2_wbV20_attrib_t))) {
242 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t wbGainAdjustBK = mNewWbV20Attr.stAuto.wbGainAdjust;
243 mNewWbV20Attr = att;
244 mNewWbV20Attr.stAuto.wbGainAdjust = wbGainAdjustBK;
245 mallocAndCopyWbGainAdjustAttrib(&mNewWbV20Attr.stAuto.wbGainAdjust,&att.stAuto.wbGainAdjust);
246 updateWbV20Attr = true;
247 waitSignal();
248 }
249 #endif
250
251 mCfgMutex.unlock();
252 #endif
253 EXIT_ANALYZER_FUNCTION();
254 return ret;
255 }
256
getWbV20Attrib(rk_aiq_uapiV2_wbV20_attrib_t * att)257 XCamReturn RkAiqAwbHandleInt::getWbV20Attrib(rk_aiq_uapiV2_wbV20_attrib_t* att) {
258 ENTER_ANALYZER_FUNCTION();
259
260 SmartLock lock (mCfgMutex);
261
262 XCamReturn ret = XCAM_RETURN_NO_ERROR;
263
264 #ifdef RKAIQ_HAVE_AWB_V20
265 rk_aiq_uapiV2_awbV20_GetAttrib(mAlgoCtx, att);
266 #endif
267 EXIT_ANALYZER_FUNCTION();
268 return ret;
269 }
270
setWbOpModeAttrib(rk_aiq_uapiV2_wb_opMode_t att)271 XCamReturn RkAiqAwbHandleInt::setWbOpModeAttrib(rk_aiq_uapiV2_wb_opMode_t att) {
272 ENTER_ANALYZER_FUNCTION();
273
274 XCamReturn ret = XCAM_RETURN_NO_ERROR;
275 mCfgMutex.lock();
276 #ifdef DISABLE_HANDLE_ATTRIB
277 ret = rk_aiq_uapiV2_awb_SetMwbMode(mAlgoCtx, att.mode, false);
278 #else
279
280 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
281 // if something changed, set att to mNewAtt, and
282 // the new params will be effective later when updateConfig
283 // called by RkAiqCore
284 bool isChanged = false;
285 if (att.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
286 memcmp(&mNewWbOpModeAttr, &att, sizeof(att)))
287 isChanged = true;
288 else if (att.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
289 memcmp(&mCurWbOpModeAttr, &att, sizeof(att)))
290 isChanged = true;
291
292 // if something changed
293 if (isChanged) {
294 mNewWbOpModeAttr = att;
295 updateWbOpModeAttr = true;
296 waitSignal(att.sync.sync_mode);
297 }
298 #endif
299 mCfgMutex.unlock();
300
301 EXIT_ANALYZER_FUNCTION();
302 return ret;
303 }
304
getWbOpModeAttrib(rk_aiq_uapiV2_wb_opMode_t * att)305 XCamReturn RkAiqAwbHandleInt::getWbOpModeAttrib(rk_aiq_uapiV2_wb_opMode_t* att) {
306 ENTER_ANALYZER_FUNCTION();
307
308 XCamReturn ret = XCAM_RETURN_NO_ERROR;
309
310 #ifdef DISABLE_HANDLE_ATTRIB
311 mCfgMutex.lock();
312 rk_aiq_uapiV2_awb_GetMwbMode(mAlgoCtx, &att->mode);
313 mCfgMutex.unlock();
314 #else
315 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
316 mCfgMutex.lock();
317 rk_aiq_uapiV2_awb_GetMwbMode(mAlgoCtx, &att->mode);
318 att->sync.done = true;
319 mCfgMutex.unlock();
320 } else {
321 if (updateWbOpModeAttr) {
322 memcpy(att, &mNewWbOpModeAttr, sizeof(mNewWbOpModeAttr));
323 att->sync.done = false;
324 } else {
325 rk_aiq_uapiV2_awb_GetMwbMode(mAlgoCtx, &att->mode);
326 att->sync.sync_mode = mNewWbOpModeAttr.sync.sync_mode;
327 att->sync.done = true;
328 }
329 }
330 #endif
331
332 EXIT_ANALYZER_FUNCTION();
333 return ret;
334 }
335
setMwbAttrib(rk_aiq_wb_mwb_attrib_t att)336 XCamReturn RkAiqAwbHandleInt::setMwbAttrib(rk_aiq_wb_mwb_attrib_t att) {
337 ENTER_ANALYZER_FUNCTION();
338
339 XCamReturn ret = XCAM_RETURN_NO_ERROR;
340 mCfgMutex.lock();
341
342 #ifdef DISABLE_HANDLE_ATTRIB
343 ret = rk_aiq_uapiV2_awb_SetMwbAttrib(mAlgoCtx, att, false);
344 #else
345 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
346 // if something changed, set att to mNewAtt, and
347 // the new params will be effective later when updateConfig
348 // called by RkAiqCore
349 bool isChanged = false;
350 if (att.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
351 memcmp(&mNewWbMwbAttr, &att, sizeof(att)))
352 isChanged = true;
353 else if (att.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
354 memcmp(&mCurWbMwbAttr, &att, sizeof(att)))
355 isChanged = true;
356
357 // if something changed
358 if (isChanged) {
359 mNewWbMwbAttr = att;
360 updateWbMwbAttr = true;
361 waitSignal(att.sync.sync_mode);
362 }
363 #endif
364
365 mCfgMutex.unlock();
366
367 EXIT_ANALYZER_FUNCTION();
368 return ret;
369 }
370
getMwbAttrib(rk_aiq_wb_mwb_attrib_t * att)371 XCamReturn RkAiqAwbHandleInt::getMwbAttrib(rk_aiq_wb_mwb_attrib_t* att) {
372 ENTER_ANALYZER_FUNCTION();
373
374 XCamReturn ret = XCAM_RETURN_NO_ERROR;
375
376 #ifdef DISABLE_HANDLE_ATTRIB
377 mCfgMutex.lock();
378 rk_aiq_uapiV2_awb_GetMwbAttrib(mAlgoCtx, att);
379 mCfgMutex.unlock();
380 #else
381 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
382 mCfgMutex.lock();
383 rk_aiq_uapiV2_awb_GetMwbAttrib(mAlgoCtx, att);
384 att->sync.done = true;
385 mCfgMutex.unlock();
386 } else {
387 if (updateWbMwbAttr) {
388 memcpy(att, &mNewWbMwbAttr, sizeof(mNewWbMwbAttr));
389 att->sync.done = false;
390 } else {
391 rk_aiq_uapiV2_awb_GetMwbAttrib(mAlgoCtx, att);
392 att->sync.sync_mode = mNewWbMwbAttr.sync.sync_mode;
393 att->sync.done = true;
394 }
395 }
396 #endif
397
398 EXIT_ANALYZER_FUNCTION();
399 return ret;
400 }
401
setAwbV20Attrib(rk_aiq_uapiV2_wbV20_awb_attrib_t att)402 XCamReturn RkAiqAwbHandleInt::setAwbV20Attrib(rk_aiq_uapiV2_wbV20_awb_attrib_t att) {
403 ENTER_ANALYZER_FUNCTION();
404
405 XCamReturn ret = XCAM_RETURN_NO_ERROR;
406 #if defined(RKAIQ_HAVE_AWB_V20) || defined(RKAIQ_HAVE_AWB_V21)
407 mCfgMutex.lock();
408 #ifdef DISABLE_HANDLE_ATTRIB
409 ret = rk_aiq_uapiV2_awbV20_SetAwbAttrib(mAlgoCtx, att, false);
410 #else
411 // TODO
412 // check if there is different between att & mCurAtt
413 // if something changed, set att to mNewAtt, and
414 // the new params will be effective later when updateConfig
415 // called by RkAiqCore
416
417 // if something changed
418 if (0 != memcmp(&mCurWbAwbAttr, &att, sizeof(rk_aiq_uapiV2_wbV20_awb_attrib_t))) {
419 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t wbGainAdjustBK = mNewWbAwbAttr.wbGainAdjust;
420 mNewWbAwbAttr = att;
421 mNewWbAwbAttr.wbGainAdjust = wbGainAdjustBK;
422 mallocAndCopyWbGainAdjustAttrib(&mNewWbAwbAttr.wbGainAdjust,&att.wbGainAdjust);
423 updateWbAwbAttr = true;
424 waitSignal();
425 }
426 #endif
427
428 mCfgMutex.unlock();
429 #endif
430 EXIT_ANALYZER_FUNCTION();
431 return ret;
432 }
433
getAwbV20Attrib(rk_aiq_uapiV2_wbV20_awb_attrib_t * att)434 XCamReturn RkAiqAwbHandleInt::getAwbV20Attrib(rk_aiq_uapiV2_wbV20_awb_attrib_t* att) {
435 ENTER_ANALYZER_FUNCTION();
436
437 SmartLock lock (mCfgMutex);
438
439 XCamReturn ret = XCAM_RETURN_NO_ERROR;
440
441 #if defined(RKAIQ_HAVE_AWB_V20) || defined(RKAIQ_HAVE_AWB_V21)
442 rk_aiq_uapiV2_awbV20_GetAwbAttrib(mAlgoCtx, att);
443 #endif
444 EXIT_ANALYZER_FUNCTION();
445 return ret;
446 }
447
448 #ifndef DISABLE_HANDLE_ATTRIB
mallocAndCopyWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t * dst,const rk_aiq_uapiV2_wb_awb_wbGainAdjust_t * src)449 XCamReturn RkAiqAwbHandleInt::mallocAndCopyWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t* dst,
450 const rk_aiq_uapiV2_wb_awb_wbGainAdjust_t *src)
451 {
452 ENTER_ANALYZER_FUNCTION();
453
454 XCamReturn ret = XCAM_RETURN_NO_ERROR;
455
456 //free
457 for(int i = 0; i < dst->lutAll_len; i++) {
458 int srcNum2 = src->lutAll[i].ct_grid_num * src->lutAll[i].cri_grid_num;
459 int dstNum2 = dst->lutAll[i].ct_grid_num * dst->lutAll[i].cri_grid_num;
460 if(dst->lutAll[i].cri_lut_out && dstNum2 < srcNum2){
461 //LOGE_AWB("free dst->lutAll[%d].cri_lut_out= %p",i,dst->lutAll[i].cri_lut_out);
462 free(dst->lutAll[i].cri_lut_out);
463 dst->lutAll[i].cri_lut_out = NULL;
464 }
465 if(dst->lutAll[i].ct_lut_out && dstNum2 < srcNum2){
466 free(dst->lutAll[i].ct_lut_out);
467 dst->lutAll[i].ct_lut_out = NULL;
468 }
469 }
470 if (dst->lutAll && dst->lutAll_len < src->lutAll_len) {
471 //LOGE_AWB(" free dst->lutAll= %p",dst->lutAll);
472 free(dst->lutAll);
473 dst->lutAll = NULL;
474 }
475 //malloc
476 if (!dst->lutAll){
477 dst->lutAll = (rk_aiq_uapiV2_wb_awb_wbGainAdjustLut_t*)malloc(sizeof(rk_aiq_uapiV2_wb_awb_wbGainAdjustLut_t)*src->lutAll_len);
478 //LOGE_AWB("malloc dst->lutAll= %p",dst->lutAll);
479 memset(dst->lutAll,0,sizeof(rk_aiq_uapiV2_wb_awb_wbGainAdjustLut_t)*src->lutAll_len);
480 for(int i = 0; i < src->lutAll_len; i++) {
481 int num2 = src->lutAll[i].ct_grid_num * src->lutAll[i].cri_grid_num;
482 if (!dst->lutAll[i].cri_lut_out){
483 dst->lutAll[i].cri_lut_out = (float*)malloc(sizeof(float) * num2);
484 memset(dst->lutAll[i].cri_lut_out,0,sizeof(float) * num2);
485
486 }
487 if (!dst->lutAll[i].ct_lut_out){
488 dst->lutAll[i].ct_lut_out = (float*)malloc(sizeof(float) * num2);
489 memset( dst->lutAll[i].ct_lut_out,0,sizeof(float) * num2);
490 }
491 //LOGE_AWB("malloc dst->lutAll[%d].cri_lut_out= %p",i,dst->lutAll[i].cri_lut_out);
492 }
493 }
494 //copy
495 dst->enable = src->enable;
496 dst->lutAll_len = src->lutAll_len;
497 dst->sync = src->sync;
498 for(int i = 0; i < src->lutAll_len; i++) {
499 dst->lutAll[i].ct_grid_num = src->lutAll[i].ct_grid_num;
500 dst->lutAll[i].cri_grid_num = src->lutAll[i].cri_grid_num;
501 dst->lutAll[i].ct_in_range[0] = src->lutAll[i].ct_in_range[0];
502 dst->lutAll[i].ct_in_range[1] = src->lutAll[i].ct_in_range[1];
503 dst->lutAll[i].cri_in_range[0] = src->lutAll[i].cri_in_range[0];
504 dst->lutAll[i].cri_in_range[1] = src->lutAll[i].cri_in_range[1];
505 dst->lutAll[i].lumaValue = src->lutAll[i].lumaValue;
506 int num2 = dst->lutAll[i].ct_grid_num * dst->lutAll[i].cri_grid_num;
507 memcpy(dst->lutAll[i].cri_lut_out, src->lutAll[i].cri_lut_out,
508 sizeof(dst->lutAll[i].cri_lut_out[0])*num2);
509 memcpy(dst->lutAll[i].ct_lut_out, src->lutAll[i].ct_lut_out,
510 sizeof(dst->lutAll[i].ct_lut_out[0])*num2);
511 }
512 EXIT_ANALYZER_FUNCTION();
513 return ret;
514 }
515
freeWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t * dst)516 XCamReturn RkAiqAwbHandleInt::freeWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t* dst)
517 {
518 ENTER_ANALYZER_FUNCTION();
519
520 XCamReturn ret = XCAM_RETURN_NO_ERROR;
521 //free
522 for(int i = 0; i < dst->lutAll_len; i++) {
523 //LOGE_AWB("free dst->lutAll[%d].cri_lut_out= %p",i,dst->lutAll[i].cri_lut_out);
524 if(dst->lutAll[i].cri_lut_out ){
525 free(dst->lutAll[i].cri_lut_out);
526 dst->lutAll[i].cri_lut_out = NULL;
527 }
528 if(dst->lutAll[i].ct_lut_out){
529 free(dst->lutAll[i].ct_lut_out);
530 dst->lutAll[i].ct_lut_out = NULL;
531 }
532 }
533 if (dst->lutAll) {
534 //LOGE_AWB(" free dst->lutAll= %p",dst->lutAll);
535 free(dst->lutAll);
536 dst->lutAll = NULL;
537 }
538 EXIT_ANALYZER_FUNCTION();
539 return ret;
540 }
541 #endif
542
setWbAwbWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t att)543 XCamReturn RkAiqAwbHandleInt::setWbAwbWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t att) {
544 ENTER_ANALYZER_FUNCTION();
545
546 XCamReturn ret = XCAM_RETURN_NO_ERROR;
547 mCfgMutex.lock();
548
549 #ifdef DISABLE_HANDLE_ATTRIB
550 ret = rk_aiq_uapiV2_awb_SetAwbGainAdjust(mAlgoCtx, att, false);
551 #else
552 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
553 // if something changed, set att to mNewAtt, and
554 // the new params will be effective later when updateConfig
555 // called by RkAiqCore
556 bool isChanged = false;
557 if (att.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
558 memcmp(&mNewWbAwbWbGainAdjustAttr, &att, sizeof(att)))
559 isChanged = true;
560 else if (att.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
561 memcmp(&mCurWbAwbWbGainAdjustAttr, &att, sizeof(att)))
562 isChanged = true;
563
564 // if something changed
565 if (isChanged) {
566 mallocAndCopyWbGainAdjustAttrib(&mNewWbAwbWbGainAdjustAttr,&att);
567 updateWbAwbWbGainAdjustAttr = true;
568 waitSignal(att.sync.sync_mode);
569 }
570 #endif
571 mCfgMutex.unlock();
572
573 EXIT_ANALYZER_FUNCTION();
574 return ret;
575 }
576
getWbAwbWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t * att)577 XCamReturn RkAiqAwbHandleInt::getWbAwbWbGainAdjustAttrib(rk_aiq_uapiV2_wb_awb_wbGainAdjust_t* att) {
578 ENTER_ANALYZER_FUNCTION();
579
580 XCamReturn ret = XCAM_RETURN_NO_ERROR;
581
582 #ifdef DISABLE_HANDLE_ATTRIB
583 mCfgMutex.lock();
584 rk_aiq_uapiV2_awb_GetAwbGainAdjust(mAlgoCtx, att);
585 mCfgMutex.unlock();
586 #else
587 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
588 mCfgMutex.lock();
589 rk_aiq_uapiV2_awb_GetAwbGainAdjust(mAlgoCtx, att);
590 att->sync.done = true;
591 mCfgMutex.unlock();
592 } else {
593 if (updateWbAwbWbGainAdjustAttr) {
594 mallocAndCopyWbGainAdjustAttrib(att,&mNewWbAwbWbGainAdjustAttr);
595 att->sync.done = false;
596 } else {
597 mCfgMutex.lock();
598 rk_aiq_uapiV2_awb_GetAwbGainAdjust(mAlgoCtx, att);
599 mCfgMutex.unlock();
600 att->sync.sync_mode = mNewWbAwbWbGainAdjustAttr.sync.sync_mode;
601 att->sync.done = true;
602 }
603
604 }
605 #endif
606
607
608 EXIT_ANALYZER_FUNCTION();
609 return ret;
610 }
611
setWbAwbWbGainOffsetAttrib(rk_aiq_uapiV2_wb_awb_wbGainOffset_t att)612 XCamReturn RkAiqAwbHandleInt::setWbAwbWbGainOffsetAttrib(rk_aiq_uapiV2_wb_awb_wbGainOffset_t att) {
613 ENTER_ANALYZER_FUNCTION();
614
615 XCamReturn ret = XCAM_RETURN_NO_ERROR;
616 mCfgMutex.lock();
617 #ifdef DISABLE_HANDLE_ATTRIB
618 ret = rk_aiq_uapiV2_awb_SetAwbGainOffset(mAlgoCtx, att.gainOffset, false);
619 #else
620
621 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
622 // if something changed, set att to mNewAtt, and
623 // the new params will be effective later when updateConfig
624 // called by RkAiqCore
625 bool isChanged = false;
626 if (att.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
627 memcmp(&mNewWbAwbWbGainOffsetAttr, &att, sizeof(att)))
628 isChanged = true;
629 else if (att.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
630 memcmp(&mCurWbAwbWbGainOffsetAttr, &att, sizeof(att)))
631 isChanged = true;
632
633 // if something changed
634 if (isChanged) {
635 mNewWbAwbWbGainOffsetAttr = att;
636 updateWbAwbWbGainOffsetAttr = true;
637 waitSignal(att.sync.sync_mode);
638 }
639 #endif
640 mCfgMutex.unlock();
641
642 EXIT_ANALYZER_FUNCTION();
643 return ret;
644 }
645
getWbAwbWbGainOffsetAttrib(rk_aiq_uapiV2_wb_awb_wbGainOffset_t * att)646 XCamReturn RkAiqAwbHandleInt::getWbAwbWbGainOffsetAttrib(rk_aiq_uapiV2_wb_awb_wbGainOffset_t* att) {
647 ENTER_ANALYZER_FUNCTION();
648
649 XCamReturn ret = XCAM_RETURN_NO_ERROR;
650
651 #ifdef DISABLE_HANDLE_ATTRIB
652 mCfgMutex.lock();
653 rk_aiq_uapiV2_awb_GetAwbGainOffset(mAlgoCtx, &att->gainOffset);
654 mCfgMutex.unlock();
655 #else
656 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
657 mCfgMutex.lock();
658 rk_aiq_uapiV2_awb_GetAwbGainOffset(mAlgoCtx, &att->gainOffset);
659 att->sync.done = true;
660 mCfgMutex.unlock();
661 } else {
662 if (updateWbAwbWbGainOffsetAttr) {
663 memcpy(att, &mNewWbAwbWbGainOffsetAttr, sizeof(mNewWbAwbWbGainOffsetAttr));
664 att->sync.done = false;
665 } else {
666 mCfgMutex.lock();
667 rk_aiq_uapiV2_awb_GetAwbGainOffset(mAlgoCtx, &att->gainOffset);
668 mCfgMutex.unlock();
669 att->sync.sync_mode = mNewWbAwbWbGainOffsetAttr.sync.sync_mode;
670 att->sync.done = true;
671 }
672 }
673 #endif
674
675 EXIT_ANALYZER_FUNCTION();
676 return ret;
677 }
678
setWbAwbMultiWindowAttrib(rk_aiq_uapiV2_wb_awb_mulWindow_t att)679 XCamReturn RkAiqAwbHandleInt::setWbAwbMultiWindowAttrib(rk_aiq_uapiV2_wb_awb_mulWindow_t att) {
680 ENTER_ANALYZER_FUNCTION();
681
682 XCamReturn ret = XCAM_RETURN_NO_ERROR;
683 mCfgMutex.lock();
684
685 #ifdef DISABLE_HANDLE_ATTRIB
686 ret = rk_aiq_uapiV2_awb_SetAwbMultiwindow(mAlgoCtx, att.multiWindw, false);
687 #else
688
689 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
690 // if something changed, set att to mNewAtt, and
691 // the new params will be effective later when updateConfig
692 // called by RkAiqCore
693 bool isChanged = false;
694 if (att.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
695 memcmp(&mNewWbAwbMultiWindowAttr, &att, sizeof(att)))
696 isChanged = true;
697 else if (att.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
698 memcmp(&mCurWbAwbMultiWindowAttr, &att, sizeof(att)))
699 isChanged = true;
700
701 // if something changed
702 if (isChanged) {
703 mNewWbAwbMultiWindowAttr = att;
704 updateWbAwbMultiWindowAttr = true;
705 waitSignal(att.sync.sync_mode);
706 }
707 #endif
708
709 mCfgMutex.unlock();
710
711 EXIT_ANALYZER_FUNCTION();
712 return ret;
713 }
714
getWbAwbMultiWindowAttrib(rk_aiq_uapiV2_wb_awb_mulWindow_t * att)715 XCamReturn RkAiqAwbHandleInt::getWbAwbMultiWindowAttrib(rk_aiq_uapiV2_wb_awb_mulWindow_t* att) {
716 ENTER_ANALYZER_FUNCTION();
717
718 XCamReturn ret = XCAM_RETURN_NO_ERROR;
719
720 #ifdef DISABLE_HANDLE_ATTRIB
721 mCfgMutex.lock();
722 rk_aiq_uapiV2_awb_GetAwbMultiwindow(mAlgoCtx, &att->multiWindw);
723 mCfgMutex.unlock();
724 #else
725 if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
726 mCfgMutex.lock();
727 rk_aiq_uapiV2_awb_GetAwbMultiwindow(mAlgoCtx, &att->multiWindw);
728 att->sync.done = true;
729 mCfgMutex.unlock();
730 } else {
731 if (updateWbAwbMultiWindowAttr) {
732 memcpy(att, &mNewWbAwbMultiWindowAttr, sizeof(mNewWbAwbMultiWindowAttr));
733 att->sync.done = false;
734 } else {
735 mCfgMutex.lock();
736 rk_aiq_uapiV2_awb_GetAwbMultiwindow(mAlgoCtx, &att->multiWindw);
737 mCfgMutex.unlock();
738 att->sync.sync_mode = mNewWbAwbMultiWindowAttr.sync.sync_mode;
739 att->sync.done = true;
740 }
741 }
742 #endif
743
744 EXIT_ANALYZER_FUNCTION();
745 return ret;
746 }
747
setFFWbgainAttrib(rk_aiq_uapiV2_awb_ffwbgain_attr_t att)748 XCamReturn RkAiqAwbHandleInt::setFFWbgainAttrib(rk_aiq_uapiV2_awb_ffwbgain_attr_t att) {
749 ENTER_ANALYZER_FUNCTION();
750
751 XCamReturn ret = XCAM_RETURN_NO_ERROR;
752 mCfgMutex.lock();
753 #ifdef DISABLE_HANDLE_ATTRIB
754 ret = rk_aiq_uapiV2_awb_SetFstFrWbgain(mAlgoCtx, att.wggain, false);
755 #else
756 // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
757 // if something changed, set att to mNewAtt, and
758 // the new params will be effective later when updateConfig
759 // called by RkAiqCore
760 bool isChanged = false;
761 if (att.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
762 memcmp(&mNewFFWbgainAttr, &att, sizeof(att)))
763 isChanged = true;
764 else if (att.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
765 memcmp(&mCurFFWbgainAttr, &att, sizeof(att)))
766 isChanged = true;
767
768 // if something changed
769 if (isChanged) {
770 mNewFFWbgainAttr = att;
771 updateFFWbgainAttr = true;
772 waitSignal(att.sync.sync_mode);
773 }
774 #endif
775 mCfgMutex.unlock();
776
777 EXIT_ANALYZER_FUNCTION();
778 return ret;
779 }
780
prepare()781 XCamReturn RkAiqAwbHandleInt::prepare() {
782 ENTER_ANALYZER_FUNCTION();
783
784 XCamReturn ret = XCAM_RETURN_NO_ERROR;
785
786 ret = RkAiqHandle::prepare();
787 RKAIQCORE_CHECK_RET(ret, "awb handle prepare failed");
788
789 RkAiqAlgoConfigAwb* awb_config_int = (RkAiqAlgoConfigAwb*)mConfig;
790 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
791 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
792 // TODO
793 // awb_config_int->rawBit;
794 awb_config_int->mem_ops_ptr = mAiqCore->mShareMemOps;
795 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
796 mCfgMutex.lock();
797 ret = des->prepare(mConfig);
798 mCfgMutex.unlock();
799 RKAIQCORE_CHECK_RET(ret, "awb algo prepare failed");
800
801 EXIT_ANALYZER_FUNCTION();
802 return ret;
803 }
804
preProcess()805 XCamReturn RkAiqAwbHandleInt::preProcess() {
806 ENTER_ANALYZER_FUNCTION();
807
808 XCamReturn ret = XCAM_RETURN_NO_ERROR;
809 #if 0
810 RkAiqAlgoPreAwb* awb_pre_int = (RkAiqAlgoPreAwb*)mPreInParam;
811 RkAiqAlgoPreResAwb* awb_pre_res_int = (RkAiqAlgoPreResAwb*)mPreOutParam;
812 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
813 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
814 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
815
816 ret = RkAiqHandle::preProcess();
817 if (ret) {
818 RKAIQCORE_CHECK_RET(ret, "awb handle preProcess failed");
819 }
820 if (!sharedCom->init) {
821 if (shared->awbStatsBuf == nullptr) {
822 LOGE("no awb stats, ignore!");
823 return XCAM_RETURN_BYPASS;
824 }
825 }
826
827 int module_hw_version = sharedCom->ctxCfigs[RK_AIQ_ALGO_TYPE_AWB].module_hw_version;
828 //awb_pre_int->awbStatsBuf = shared->awbStatsBuf;
829 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
830 ret = des->pre_process(mPreInParam, mPreOutParam);
831 RKAIQCORE_CHECK_RET(ret, "awb algo pre_process failed");
832
833 EXIT_ANALYZER_FUNCTION();
834 #endif
835 return ret;
836 }
837
processing()838 XCamReturn RkAiqAwbHandleInt::processing() {
839 ENTER_ANALYZER_FUNCTION();
840
841 XCamReturn ret = XCAM_RETURN_NO_ERROR;
842
843 RkAiqAlgoProcAwb* awb_proc_int = (RkAiqAlgoProcAwb*)mProcInParam;
844 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
845 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
846 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
847
848 if (!sharedCom->init) {
849 if (shared->awbStatsBuf == nullptr) {
850 LOGE("no awb stats, ignore!");
851 return XCAM_RETURN_BYPASS;
852 }
853 }
854
855 RkAiqAlgoProcResAwb* awb_proc_res_int = (RkAiqAlgoProcResAwb*)mProcOutParam;
856
857 #if RKAIQ_HAVE_AWB_V32
858 if (shared->awbStatsBuf)
859 awb_proc_int->awb_statsBuf_v32 = &shared->awbStatsBuf->awb_stats_v32;
860 else
861 awb_proc_int->awb_statsBuf_v32 = NULL;
862 #elif RKAIQ_HAVE_AWB_V21
863 #if defined(ISP_HW_V30)
864 if (shared->awbStatsBuf)
865 awb_proc_int->awb_statsBuf_v3x = &shared->awbStatsBuf->awb_stats_v3x;
866 else
867 awb_proc_int->awb_statsBuf_v3x = NULL;
868 awb_proc_int->blc_cfg_effect = &shared->awbStatsBuf->blc_cfg_effect;
869 #else
870 if (shared->awbStatsBuf)
871 awb_proc_int->awb_statsBuf_v201 = &shared->awbStatsBuf->awb_stats_v201;
872 else
873 awb_proc_int->awb_statsBuf_v201 = NULL;
874 #endif
875 #elif RKAIQ_HAVE_AWB_V20
876 if (shared->awbStatsBuf)
877 awb_proc_int->awbStatsBuf = &shared->awbStatsBuf->awb_stats;
878 else
879 awb_proc_int->awbStatsBuf = NULL;
880 #else
881 LOGE_AWB("module_hw_version of awb is isvalid!!!!");
882 #endif
883
884 if (shared->aecStatsBuf)
885 awb_proc_int->aecStatsBuf = &shared->aecStatsBuf->aec_stats;
886 else
887 awb_proc_int->aecStatsBuf = NULL;
888
889 awb_proc_int->ablcProcResVaid = false;
890 #if RKAIQ_HAVE_BLC_V1
891 /*SmartPtr<RkAiqHandle>* ablc_handle = mAiqCore->getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ABLC);
892 int algo_id = (*ablc_handle)->getAlgoId();
893
894 if (ablc_handle) {
895 if (algo_id == 0) {
896 RkAiqAblcHandleInt* ablc_algo = dynamic_cast<RkAiqAblcHandleInt*>(ablc_handle->ptr());
897 ablc_algo->getProcRes(&awb_proc_int->ablcProcRes);
898 awb_proc_int->ablcProcResVaid = true;
899 }
900 }*/
901 awb_proc_int->ablcProcRes= shared->res_comb.ablc_proc_res;
902 awb_proc_int->ablcProcResVaid = true;
903 #endif
904 #if RKAIQ_HAVE_BLC_V32
905 awb_proc_int->ablcProcResV32= shared->res_comb.ablcV32_proc_res;
906 awb_proc_int->ablcProcResVaid = true;
907 #endif
908 // for otp awb
909 awb_proc_int->awb_otp = &sharedCom->snsDes.otp_awb;
910
911 #if defined(ISP_HW_V30)
912 awb_proc_res_int->awb_hw1_para = &shared->fullParams->mAwbV3xParams->data()->result;
913 #elif defined(ISP_HW_V21)
914 awb_proc_res_int->awb_hw1_para = &shared->fullParams->mAwbV21Params->data()->result;
915 #elif defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
916 awb_proc_res_int->awb_hw32_para = &shared->fullParams->mAwbV32Params->data()->result;
917 #else
918 awb_proc_res_int->awb_hw0_para = &shared->fullParams->mAwbParams->data()->result;
919 #endif
920
921 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
922 awb_proc_res_int->awb_gain_algo = &shared->fullParams->mAwbGainV32Params->data()->result;
923 #else
924 awb_proc_res_int->awb_gain_algo = &shared->fullParams->mAwbGainParams->data()->result;
925 #endif
926
927 ret = RkAiqHandle::processing();
928 if (ret < 0) {
929 LOGE_ANALYZER("awb handle processing failed ret %d", ret);
930 return ret;
931 } else if (ret == XCAM_RETURN_BYPASS) {
932 LOGW_ANALYZER("%s:%d bypass !", __func__, __LINE__);
933 return ret;
934 }
935
936 #ifdef DISABLE_HANDLE_ATTRIB
937 mCfgMutex.lock();
938 #endif
939 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
940 #if 0
941 ret = des->processing(mProcInParam, mProcOutParam);
942 #else
943 ret = des->processing(mProcInParam, (RkAiqAlgoResCom*)awb_proc_res_int);
944 #endif
945 #ifdef DISABLE_HANDLE_ATTRIB
946 mCfgMutex.unlock();
947 #endif
948 if (ret < 0) {
949 LOGE_ANALYZER("awb algo processing failed ret %d", ret);
950 return ret;
951 } else if (ret == XCAM_RETURN_BYPASS) {
952 LOGW_ANALYZER("%s:%d bypass !", __func__, __LINE__);
953 ret = XCAM_RETURN_NO_ERROR;
954 }
955
956 if (awb_proc_res_int->awb_cfg_update || awb_proc_res_int->awb_gain_update) {
957 if (getAlgoId() == 0) {
958 mProcResShared = new RkAiqAlgoProcResAwbIntShared();
959 }
960 memcpy(&mProcResShared->result.awb_gain_algo, awb_proc_res_int->awb_gain_algo, sizeof(rk_aiq_wb_gain_t));
961 mProcResShared->result.awb_smooth_factor = awb_proc_res_int->awb_smooth_factor;
962 mProcResShared->result.varianceLuma = awb_proc_res_int->varianceLuma;
963 mProcResShared->result.awbConverged = awb_proc_res_int->awbConverged;
964 } else {
965 LOGD_AWB("awb results not updated");
966 }
967
968 if (mPostShared) {
969 if (mAiqCore->mAlogsComSharedParams.init) {
970 RkAiqCore::RkAiqAlgosGroupShared_t* grpShared = nullptr;
971 uint64_t grpMask = grpId2GrpMask(RK_AIQ_CORE_ANALYZE_GRP1);
972 if (!mAiqCore->getGroupSharedParams(grpMask, grpShared)) {
973 if (grpShared) {
974 mProcResShared->set_sequence(0);
975 XCamVideoBuffer* xCamAwbProcRes = convert_to_XCamVideoBuffer(mProcResShared);
976 grpShared->res_comb.awb_proc_res = xCamAwbProcRes;
977 }
978 }
979 } else {
980 mProcResShared->set_sequence(shared->frameId);
981 RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_AWB_PROC_RES_OK, shared->frameId, mProcResShared);
982 mAiqCore->post_message(msg);
983 }
984 }
985
986 EXIT_ANALYZER_FUNCTION();
987 return ret;
988 }
989
postProcess()990 XCamReturn RkAiqAwbHandleInt::postProcess() {
991 ENTER_ANALYZER_FUNCTION();
992
993 XCamReturn ret = XCAM_RETURN_NO_ERROR;
994 #if 0
995 RkAiqAlgoPostAwb* awb_post_int = (RkAiqAlgoPostAwb*)mPostInParam;
996 RkAiqAlgoPostResAwb* awb_post_res_int = (RkAiqAlgoPostResAwb*)mPostOutParam;
997 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
998 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
999 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
1000
1001 ret = RkAiqHandle::postProcess();
1002 if (ret) {
1003 RKAIQCORE_CHECK_RET(ret, "awb handle postProcess failed");
1004 return ret;
1005 }
1006
1007 if (!sharedCom->init) {
1008 if (shared->awbStatsBuf == nullptr) {
1009 LOGE("no awb stats, ignore!");
1010 return XCAM_RETURN_BYPASS;
1011 }
1012 }
1013
1014 RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
1015 ret = des->post_process(mPostInParam, mPostOutParam);
1016 RKAIQCORE_CHECK_RET(ret, "awb algo post_process failed");
1017
1018 EXIT_ANALYZER_FUNCTION();
1019 #endif
1020 return ret;
1021 }
1022
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)1023 XCamReturn RkAiqAwbHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
1024 ENTER_ANALYZER_FUNCTION();
1025
1026 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1027
1028 if (mIsMulRun && this->getAlgoId() == 0) {
1029 // do nothing for rkawb if custom algo running with rk algo
1030 return ret;
1031 }
1032
1033 RkAiqCore::RkAiqAlgosGroupShared_t* shared =
1034 (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
1035 RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
1036
1037 RkAiqAlgoProcResAwb* awb_com = (RkAiqAlgoProcResAwb*)mProcOutParam;
1038
1039 #if defined(ISP_HW_V30)
1040 rk_aiq_isp_awb_params_v3x_t* awb_param = params->mAwbV3xParams->data().ptr();
1041 #elif defined(ISP_HW_V21)
1042 rk_aiq_isp_awb_params_v21_t* awb_param = params->mAwbV21Params->data().ptr();
1043 #elif defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1044 rk_aiq_isp_awb_params_v32_t* awb_param = params->mAwbV32Params->data().ptr();
1045 #else
1046 rk_aiq_isp_awb_params_v20_t* awb_param = params->mAwbParams->data().ptr();
1047 #endif
1048 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1049 rk_aiq_isp_awb_gain_params_v32_t* awb_gain_param = params->mAwbGainV32Params->data().ptr();
1050 #else
1051 rk_aiq_isp_awb_gain_params_v20_t* awb_gain_param = params->mAwbGainParams->data().ptr();
1052 #endif
1053
1054 if (sharedCom->init) {
1055 awb_gain_param->frame_id = 0;
1056 awb_param->frame_id = 0;
1057 } else {
1058 awb_gain_param->frame_id = shared->frameId;
1059 awb_param->frame_id = shared->frameId;
1060 }
1061
1062 if (awb_com->awb_gain_update) {
1063 mWbGainSyncFlag = shared->frameId;
1064 awb_gain_param->sync_flag = mWbGainSyncFlag;
1065 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1066 cur_params->mAwbGainV32Params = params->mAwbGainV32Params ;
1067 #else
1068 cur_params->mAwbGainParams = params->mAwbGainParams ;
1069 #endif
1070 awb_gain_param->is_update = true;
1071 LOGD_AWB("[%d] wbgain params from algo", mWbGainSyncFlag);
1072 } else if (mWbGainSyncFlag != awb_param->sync_flag) {
1073 awb_gain_param->sync_flag = mWbGainSyncFlag;
1074 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1075 if (cur_params->mAwbGainV32Params.ptr()) {
1076 awb_gain_param->is_update = true;
1077 awb_gain_param->result = cur_params->mAwbGainV32Params->data()->result;
1078 } else {
1079 LOGE_AWB("no latest params !");
1080 awb_gain_param->is_update = false;
1081 }
1082 #else
1083 if (cur_params->mAwbGainParams.ptr()) {
1084 awb_gain_param->is_update = true;
1085 awb_gain_param->result = cur_params->mAwbGainParams->data()->result;
1086 } else {
1087 LOGE_AWB("no latest params !");
1088 awb_gain_param->is_update = false;
1089 }
1090 #endif
1091 LOGD_AWB("[%d] wbgain from latest [%d]", shared->frameId, mWbGainSyncFlag);
1092 } else {
1093 // do nothing, result in buf needn't update
1094 awb_gain_param->is_update = false;
1095 LOGD_AWB("[%d] wbgain params needn't update", shared->frameId);
1096 }
1097
1098 if (awb_com->awb_cfg_update) {
1099 mWbParamSyncFlag = shared->frameId;
1100 awb_param->sync_flag = mWbParamSyncFlag;
1101 #if defined(ISP_HW_V30)
1102 cur_params->mAwbV3xParams = params->mAwbV3xParams;
1103 #elif defined(ISP_HW_V21)
1104 cur_params->mAwbV21Params = params->mAwbV21Params;
1105 #elif defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1106 cur_params->mAwbV32Params = params->mAwbV32Params;
1107 #else
1108 cur_params->mAwbParams = params->mAwbParams;
1109 #endif
1110 awb_param->is_update = true;
1111 LOGD_AWB("[%d] params from algo", mWbParamSyncFlag);
1112 } else if (mWbParamSyncFlag != awb_param->sync_flag) {
1113 awb_param->sync_flag = mWbParamSyncFlag;
1114 // copy from latest result
1115 #if defined(ISP_HW_V30)
1116 if (cur_params->mAwbV3xParams.ptr()) {
1117 awb_param->is_update = true;
1118 awb_param->result = cur_params->mAwbV3xParams->data()->result;
1119 } else {
1120 LOGE_AWB("no latest params !");
1121 awb_param->is_update = false;
1122 }
1123 #elif defined(ISP_HW_V21)
1124 if (cur_params->mAwbV21Params.ptr()) {
1125 awb_param->is_update = true;
1126 awb_param->result = cur_params->mAwbV21Params->data()->result;
1127 } else {
1128 LOGE_AWB("no latest params !");
1129 awb_param->is_update = false;
1130 }
1131 #elif defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1132 if (cur_params->mAwbV32Params.ptr()) {
1133 awb_param->is_update = true;
1134 awb_param->result = cur_params->mAwbV32Params->data()->result;
1135 } else {
1136 LOGE_AWB("no latest params !");
1137 awb_param->is_update = false;
1138 }
1139 #else
1140 if (cur_params->mAwbParams.ptr()) {
1141 awb_param->is_update = true;
1142 awb_param->result = cur_params->mAwbParams->data()->result;
1143 } else {
1144 LOGE_AWB("no latest params !");
1145 awb_param->is_update = false;
1146 }
1147 #endif
1148 LOGD_AWB("[%d] params from latest [%d]", shared->frameId, mWbParamSyncFlag);
1149 } else {
1150 awb_param->is_update = false;
1151 // do nothing, result in buf needn't update
1152 LOGD_AWB("[%d] params needn't update", shared->frameId);
1153 }
1154
1155 EXIT_ANALYZER_FUNCTION();
1156
1157 return ret;
1158 }
1159
1160 } // namespace RkCam
1161