xref: /OK3568_Linux_fs/external/camera_engine_rkaiq/rkaiq/aiq_core/algo_handlers/RkAiqAeHandle.cpp (revision 4882a59341e53eb6f0b4789bf948001014eff981) 
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 "RkAiqAeHandle.h"
17 #include "RkAiqAfHandle.h"
18 #include "RkAiqAfdHandle.h"
19 #include "RkAiqAmergeHandle.h"
20 #include "RkAiqAdrcHandle.h"
21 #include "smart_buffer_priv.h"
22 
23 #include "RkAiqCore.h"
24 
25 namespace RkCam {
26 
27 DEFINE_HANDLE_REGISTER_TYPE(RkAiqAeHandleInt);
28 
init()29 void RkAiqAeHandleInt::init() {
30     ENTER_ANALYZER_FUNCTION();
31 
32     RkAiqHandle::deInit();
33     mConfig       = (RkAiqAlgoCom*)(new RkAiqAlgoConfigAe());
34     mPreInParam   = (RkAiqAlgoCom*)(new RkAiqAlgoPreAe());
35     mPreOutParam  = NULL;
36     mProcInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoProcAe());
37     mProcOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoProcResAe());
38     mPostInParam  = (RkAiqAlgoCom*)(new RkAiqAlgoPostAe());
39     mPostOutParam = (RkAiqAlgoResCom*)(new RkAiqAlgoPostResAe());
40 #if RKAIQ_HAVE_AF
41     mAf_handle = mAiqCore->getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AF);
42 #endif
43 #if RKAIQ_HAVE_AFD_V1 || RKAIQ_HAVE_AFD_V2
44     mAfd_handle = mAiqCore->getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AFD);
45 #endif
46 
47     mAmerge_handle = mAiqCore->getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_AMERGE);
48     mAdrc_handle = mAiqCore->getCurAlgoTypeHandle(RK_AIQ_ALGO_TYPE_ADRC);
49 
50     EXIT_ANALYZER_FUNCTION();
51 }
52 
updateConfig(bool needSync)53 XCamReturn RkAiqAeHandleInt::updateConfig(bool needSync) {
54     ENTER_ANALYZER_FUNCTION();
55 
56     XCamReturn ret = XCAM_RETURN_NO_ERROR;
57 
58 #ifndef DISABLE_HANDLE_ATTRIB
59     if (needSync) mCfgMutex.lock();
60     // if something changed, api will modify aecCfg in mAlgoCtx
61     if (updateExpSwAttr) {
62         mCurExpSwAttr   = mNewExpSwAttr;
63         rk_aiq_uapi_ae_convExpSwAttr_v1Tov2(&mCurExpSwAttr, &mCurExpSwAttrV2);
64         rk_aiq_uapi_ae_setExpSwAttr(mAlgoCtx, &mCurExpSwAttrV2, false, false);
65         updateExpSwAttr = false;
66         updateAttr |= UPDATE_EXPSWATTR;
67         sendSignal();
68     }
69 
70     if (updateLinExpAttr) {
71         mCurLinExpAttr   = mNewLinExpAttr;
72         rk_aiq_uapi_ae_convLinExpAttr_v1Tov2(&mCurLinExpAttr, &mCurLinExpAttrV2);
73         rk_aiq_uapi_ae_setLinExpAttr(mAlgoCtx, &mCurLinExpAttrV2, false, false);
74         updateLinExpAttr = false;
75         updateAttr |= UPDATE_LINEXPATTR;
76         sendSignal();
77     }
78 
79     if (updateHdrExpAttr) {
80         mCurHdrExpAttr   = mNewHdrExpAttr;
81         rk_aiq_uapi_ae_convHdrExpAttr_v1Tov2(&mCurHdrExpAttr, &mCurHdrExpAttrV2);
82         rk_aiq_uapi_ae_setHdrExpAttr(mAlgoCtx, &mCurHdrExpAttrV2, false, false);
83         updateHdrExpAttr = false;
84         updateAttr |= UPDATE_HDREXPATTR;
85         sendSignal();
86     }
87 
88     // TODO: update v2
89 
90     if (updateExpSwAttrV2) {
91         mCurExpSwAttrV2   = mNewExpSwAttrV2;
92         rk_aiq_uapi_ae_setExpSwAttr(mAlgoCtx, &mCurExpSwAttrV2, false, false);
93         updateExpSwAttrV2 = false;
94         updateAttr |= UPDATE_EXPSWATTR;
95         sendSignal(mCurExpSwAttrV2.sync.sync_mode);
96     }
97 
98     if (updateLinExpAttrV2) {
99         mCurLinExpAttrV2   = mNewLinExpAttrV2;
100         rk_aiq_uapi_ae_setLinExpAttr(mAlgoCtx, &mCurLinExpAttrV2, false, false);
101         updateLinExpAttrV2 = false;
102         updateAttr |= UPDATE_LINEXPATTR;
103         sendSignal(mCurLinExpAttrV2.sync.sync_mode);
104     }
105 
106     if (updateHdrExpAttrV2) {
107         mCurHdrExpAttrV2   = mNewHdrExpAttrV2;
108         rk_aiq_uapi_ae_setHdrExpAttr(mAlgoCtx, &mCurHdrExpAttrV2, false, false);
109         updateHdrExpAttrV2 = false;
110         updateAttr |= UPDATE_HDREXPATTR;
111         sendSignal(mCurHdrExpAttrV2.sync.sync_mode);
112     }
113 
114     if (updateLinAeRouteAttr) {
115         mCurLinAeRouteAttr   = mNewLinAeRouteAttr;
116         rk_aiq_uapi_ae_setLinAeRouteAttr(mAlgoCtx, &mCurLinAeRouteAttr, false, false);
117         updateLinAeRouteAttr = false;
118         updateAttr |= UPDATE_LINAEROUTEATTR;
119         sendSignal(mCurLinAeRouteAttr.sync.sync_mode);
120     }
121     if (updateHdrAeRouteAttr) {
122         mCurHdrAeRouteAttr   = mNewHdrAeRouteAttr;
123         rk_aiq_uapi_ae_setHdrAeRouteAttr(mAlgoCtx, &mCurHdrAeRouteAttr, false, false);
124         updateHdrAeRouteAttr = false;
125         updateAttr |= UPDATE_HDRAEROUTEATTR;
126         sendSignal(mCurHdrAeRouteAttr.sync.sync_mode);
127     }
128     if (updateIrisAttr) {
129         mCurIrisAttr   = mNewIrisAttr;
130         rk_aiq_uapi_ae_setIrisAttr(mAlgoCtx, &mCurIrisAttr, false);
131         updateIrisAttr = false;
132         updateAttr |= UPDATE_IRISATTR;
133         sendSignal(mCurIrisAttr.sync.sync_mode);
134     }
135     if (updateSyncTestAttr) {
136         mCurAecSyncTestAttr = mNewAecSyncTestAttr;
137         rk_aiq_uapi_ae_setSyncTest(mAlgoCtx, &mCurAecSyncTestAttr, false, false);
138         updateSyncTestAttr  = false;
139         updateAttr |= UPDATE_SYNCTESTATTR;
140         sendSignal(mCurAecSyncTestAttr.sync.sync_mode);
141     }
142     if (updateExpWinAttr) {
143         mCurExpWinAttr   = mNewExpWinAttr;
144         rk_aiq_uapi_ae_setExpWinAttr(mAlgoCtx, &mCurExpWinAttr, false);
145         updateExpWinAttr = false;
146         updateAttr |= UPDATE_EXPWINATTR;
147         sendSignal(mCurExpWinAttr.sync.sync_mode);
148     }
149 
150     // once any params are changed, run reconfig to convert aecCfg to paectx
151     AeInstanceConfig_t* pAeInstConfig = (AeInstanceConfig_t*)mAlgoCtx;
152     AeConfig_t pAecCfg                = pAeInstConfig->aecCfg;
153     pAecCfg->IsReconfig |= updateAttr;
154     updateAttr = 0;
155     if (needSync) mCfgMutex.unlock();
156 #endif
157     EXIT_ANALYZER_FUNCTION();
158     return ret;
159 }
160 
setExpSwAttr(Uapi_ExpSwAttr_t ExpSwAttr)161 XCamReturn RkAiqAeHandleInt::setExpSwAttr(Uapi_ExpSwAttr_t ExpSwAttr) {
162     ENTER_ANALYZER_FUNCTION();
163 
164     XCamReturn ret = XCAM_RETURN_NO_ERROR;
165     mCfgMutex.lock();
166 #ifdef DISABLE_HANDLE_ATTRIB
167     Uapi_ExpSwAttrV2_t att2;
168     rk_aiq_uapi_ae_convExpSwAttr_v1Tov2(&ExpSwAttr, &att2);
169     rk_aiq_uapi_ae_setExpSwAttr(mAlgoCtx, &att2, false, false);
170     AeInstanceConfig_t* pAeInstConfig = (AeInstanceConfig_t*)mAlgoCtx;
171     AeConfig_t pAecCfg                = pAeInstConfig->aecCfg;
172     pAecCfg->IsReconfig |= UPDATE_EXPSWATTR;
173 #else
174     // TODO
175     // check if there is different between att & mCurAtt
176     // if something changed, set att to mNewAtt, and
177     // the new params will be effective later when updateConfig
178     // called by RkAiqCore
179 
180     // if something changed
181     if (0 != memcmp(&mCurExpSwAttr, &ExpSwAttr, sizeof(Uapi_ExpSwAttr_t))) {
182         mNewExpSwAttr   = ExpSwAttr;
183         updateExpSwAttr = true;
184         waitSignal();
185     }
186 #endif
187     mCfgMutex.unlock();
188 
189     EXIT_ANALYZER_FUNCTION();
190     return ret;
191 }
192 
getExpSwAttr(Uapi_ExpSwAttr_t * pExpSwAttr)193 XCamReturn RkAiqAeHandleInt::getExpSwAttr(Uapi_ExpSwAttr_t* pExpSwAttr) {
194     ENTER_ANALYZER_FUNCTION();
195 
196     XCamReturn ret = XCAM_RETURN_NO_ERROR;
197     Uapi_ExpSwAttrV2_t ExpSwAttrV2;
198 
199     mCfgMutex.lock();
200 
201     rk_aiq_uapi_ae_getExpSwAttr(mAlgoCtx, &ExpSwAttrV2, false);
202     rk_aiq_uapi_ae_convExpSwAttr_v2Tov1(&ExpSwAttrV2, pExpSwAttr);
203 
204     mCfgMutex.unlock();
205 
206     EXIT_ANALYZER_FUNCTION();
207     return ret;
208 }
209 
setExpSwAttr(Uapi_ExpSwAttrV2_t ExpSwAttrV2)210 XCamReturn RkAiqAeHandleInt::setExpSwAttr(Uapi_ExpSwAttrV2_t ExpSwAttrV2) {
211     ENTER_ANALYZER_FUNCTION();
212 
213     XCamReturn ret = XCAM_RETURN_NO_ERROR;
214     mCfgMutex.lock();
215 
216 #ifdef DISABLE_HANDLE_ATTRIB
217     rk_aiq_uapi_ae_setExpSwAttr(mAlgoCtx, &ExpSwAttrV2, false, false);
218     AeInstanceConfig_t* pAeInstConfig = (AeInstanceConfig_t*)mAlgoCtx;
219     AeConfig_t pAecCfg                = pAeInstConfig->aecCfg;
220     pAecCfg->IsReconfig |= UPDATE_EXPSWATTR;
221 #else
222     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
223     // if something changed, set att to mNewAtt, and
224     // the new params will be effective later when updateConfig
225     // called by RkAiqCore
226     bool isChanged = false;
227     if (ExpSwAttrV2.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
228             memcmp(&mNewExpSwAttrV2, &ExpSwAttrV2, sizeof(ExpSwAttrV2)))
229         isChanged = true;
230     else if (ExpSwAttrV2.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
231              memcmp(&mCurExpSwAttrV2, &ExpSwAttrV2, sizeof(ExpSwAttrV2)))
232         isChanged = true;
233 
234     // if something changed
235     if (isChanged) {
236         mNewExpSwAttrV2   = ExpSwAttrV2;
237         updateExpSwAttrV2 = true;
238         waitSignal(ExpSwAttrV2.sync.sync_mode);
239     }
240 #endif
241     mCfgMutex.unlock();
242 
243     EXIT_ANALYZER_FUNCTION();
244     return ret;
245 }
246 
getExpSwAttr(Uapi_ExpSwAttrV2_t * pExpSwAttrV2)247 XCamReturn RkAiqAeHandleInt::getExpSwAttr(Uapi_ExpSwAttrV2_t* pExpSwAttrV2) {
248     ENTER_ANALYZER_FUNCTION();
249 
250     XCamReturn ret = XCAM_RETURN_NO_ERROR;
251 
252 #ifdef DISABLE_HANDLE_ATTRIB
253     mCfgMutex.lock();
254     rk_aiq_uapi_ae_getExpSwAttr(mAlgoCtx, pExpSwAttrV2, false);
255     pExpSwAttrV2->sync.done = true;
256     mCfgMutex.unlock();
257 #else
258     if (pExpSwAttrV2->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
259         mCfgMutex.lock();
260         rk_aiq_uapi_ae_getExpSwAttr(mAlgoCtx, pExpSwAttrV2, false);
261         pExpSwAttrV2->sync.done = true;
262         mCfgMutex.unlock();
263     } else {
264         if (updateExpSwAttrV2) {
265             memcpy(pExpSwAttrV2, &mNewExpSwAttrV2, sizeof(mNewExpSwAttrV2));
266             pExpSwAttrV2->sync.done = false;
267         } else {
268             rk_aiq_uapi_ae_getExpSwAttr(mAlgoCtx, pExpSwAttrV2, false);
269             pExpSwAttrV2->sync.sync_mode = mNewExpSwAttrV2.sync.sync_mode;
270             pExpSwAttrV2->sync.done = true;
271         }
272     }
273 #endif
274     mCfgMutex.unlock();
275 
276     EXIT_ANALYZER_FUNCTION();
277     return ret;
278 }
279 
setLinExpAttr(Uapi_LinExpAttr_t LinExpAttr)280 XCamReturn RkAiqAeHandleInt::setLinExpAttr(Uapi_LinExpAttr_t LinExpAttr) {
281     ENTER_ANALYZER_FUNCTION();
282 
283     XCamReturn ret = XCAM_RETURN_NO_ERROR;
284     mCfgMutex.lock();
285 #ifdef DISABLE_HANDLE_ATTRIB
286     Uapi_LinExpAttrV2_t att2;
287     rk_aiq_uapi_ae_convLinExpAttr_v1Tov2(&LinExpAttr, &att2);
288     rk_aiq_uapi_ae_setLinExpAttr(mAlgoCtx, &att2, false, false);
289     AeInstanceConfig_t* pAeInstConfig = (AeInstanceConfig_t*)mAlgoCtx;
290     AeConfig_t pAecCfg                = pAeInstConfig->aecCfg;
291     pAecCfg->IsReconfig |= UPDATE_LINEXPATTR;
292 #else
293     // TODO
294     // check if there is different between att & mCurAtt
295     // if something changed, set att to mNewAtt, and
296     // the new params will be effective later when updateConfig
297     // called by RkAiqCore
298 
299     // if something changed
300     if (0 != memcmp(& mCurLinExpAttr, &LinExpAttr, sizeof(Uapi_LinExpAttr_t))) {
301         mNewLinExpAttr   = LinExpAttr;
302         updateLinExpAttr = true;
303         waitSignal();
304     }
305 #endif
306     mCfgMutex.unlock();
307 
308     EXIT_ANALYZER_FUNCTION();
309     return ret;
310 }
311 
getLinExpAttr(Uapi_LinExpAttr_t * pLinExpAttr)312 XCamReturn RkAiqAeHandleInt::getLinExpAttr(Uapi_LinExpAttr_t* pLinExpAttr) {
313     ENTER_ANALYZER_FUNCTION();
314 
315     XCamReturn ret = XCAM_RETURN_NO_ERROR;
316 
317     mCfgMutex.lock();
318     Uapi_LinExpAttrV2_t att2;
319     rk_aiq_uapi_ae_getLinExpAttr(mAlgoCtx, &att2, false);
320     rk_aiq_uapi_ae_convLinExpAttr_v2Tov1(&att2, pLinExpAttr);
321     mCfgMutex.unlock();
322 
323     EXIT_ANALYZER_FUNCTION();
324     return ret;
325 }
326 
setLinExpAttr(Uapi_LinExpAttrV2_t LinExpAttrV2)327 XCamReturn RkAiqAeHandleInt::setLinExpAttr(Uapi_LinExpAttrV2_t LinExpAttrV2) {
328     ENTER_ANALYZER_FUNCTION();
329 
330     XCamReturn ret = XCAM_RETURN_NO_ERROR;
331     mCfgMutex.lock();
332 #ifdef DISABLE_HANDLE_ATTRIB
333     rk_aiq_uapi_ae_setLinExpAttr(mAlgoCtx, &LinExpAttrV2, false, false);
334     AeInstanceConfig_t* pAeInstConfig = (AeInstanceConfig_t*)mAlgoCtx;
335     AeConfig_t pAecCfg                = pAeInstConfig->aecCfg;
336     pAecCfg->IsReconfig |= UPDATE_LINEXPATTR;
337 #else
338     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
339     // if something changed, set att to mNewAtt, and
340     // the new params will be effective later when updateConfig
341     // called by RkAiqCore
342     bool isChanged = false;
343     if (LinExpAttrV2.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
344             memcmp(&mNewLinExpAttrV2, &LinExpAttrV2, sizeof(LinExpAttrV2)))
345         isChanged = true;
346     else if (LinExpAttrV2.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
347              memcmp(&mCurLinExpAttrV2, &LinExpAttrV2, sizeof(LinExpAttrV2)))
348         isChanged = true;
349 
350     // if something changed
351     if (isChanged) {
352         mNewLinExpAttrV2   = LinExpAttrV2;
353         updateLinExpAttrV2 = true;
354         waitSignal(LinExpAttrV2.sync.sync_mode);
355     }
356 #endif
357     mCfgMutex.unlock();
358 
359     EXIT_ANALYZER_FUNCTION();
360     return ret;
361 }
362 
getLinExpAttr(Uapi_LinExpAttrV2_t * pLinExpAttrV2)363 XCamReturn RkAiqAeHandleInt::getLinExpAttr(Uapi_LinExpAttrV2_t* pLinExpAttrV2) {
364     ENTER_ANALYZER_FUNCTION();
365 
366     XCamReturn ret = XCAM_RETURN_NO_ERROR;
367 
368 #ifdef DISABLE_HANDLE_ATTRIB
369     mCfgMutex.lock();
370     rk_aiq_uapi_ae_getLinExpAttr(mAlgoCtx, pLinExpAttrV2, false);
371     pLinExpAttrV2->sync.done = true;
372     mCfgMutex.unlock();
373 #else
374     if (pLinExpAttrV2->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
375         mCfgMutex.lock();
376         rk_aiq_uapi_ae_getLinExpAttr(mAlgoCtx, pLinExpAttrV2, false);
377         pLinExpAttrV2->sync.done = true;
378         mCfgMutex.unlock();
379     } else {
380         if (updateLinExpAttrV2) {
381             memcpy(pLinExpAttrV2, &mNewLinExpAttrV2, sizeof(mNewLinExpAttrV2));
382             pLinExpAttrV2->sync.done = false;
383         } else {
384             rk_aiq_uapi_ae_getLinExpAttr(mAlgoCtx, pLinExpAttrV2, false);
385             pLinExpAttrV2->sync.sync_mode = mNewLinExpAttrV2.sync.sync_mode;
386             pLinExpAttrV2->sync.done      = true;
387         }
388     }
389 #endif
390 
391     EXIT_ANALYZER_FUNCTION();
392     return ret;
393 }
394 
setHdrExpAttr(Uapi_HdrExpAttr_t HdrExpAttr)395 XCamReturn RkAiqAeHandleInt::setHdrExpAttr(Uapi_HdrExpAttr_t HdrExpAttr) {
396     ENTER_ANALYZER_FUNCTION();
397 
398     XCamReturn ret = XCAM_RETURN_NO_ERROR;
399     mCfgMutex.lock();
400 #ifdef DISABLE_HANDLE_ATTRIB
401     Uapi_HdrExpAttrV2_t att2;
402     rk_aiq_uapi_ae_convHdrExpAttr_v1Tov2(&HdrExpAttr, &att2);
403     rk_aiq_uapi_ae_setHdrExpAttr(mAlgoCtx, &att2, false, false);
404     AeInstanceConfig_t* pAeInstConfig = (AeInstanceConfig_t*)mAlgoCtx;
405     AeConfig_t pAecCfg                = pAeInstConfig->aecCfg;
406     pAecCfg->IsReconfig |= UPDATE_HDREXPATTR;
407 #else
408     // TODO
409     // check if there is different between att & mCurAtt
410     // if something changed, set att to mNewAtt, and
411     // the new params will be effective later when updateConfig
412     // called by RkAiqCore
413 
414     // if something changed
415     if (0 != memcmp(&mCurHdrExpAttr, &HdrExpAttr, sizeof(Uapi_HdrExpAttr_t))) {
416         mNewHdrExpAttr   = HdrExpAttr;
417         updateHdrExpAttr = true;
418         waitSignal();
419     }
420 #endif
421     mCfgMutex.unlock();
422 
423     EXIT_ANALYZER_FUNCTION();
424     return ret;
425 }
426 
getHdrExpAttr(Uapi_HdrExpAttr_t * pHdrExpAttr)427 XCamReturn RkAiqAeHandleInt::getHdrExpAttr(Uapi_HdrExpAttr_t* pHdrExpAttr) {
428     ENTER_ANALYZER_FUNCTION();
429 
430     XCamReturn ret = XCAM_RETURN_NO_ERROR;
431 
432     mCfgMutex.lock();
433     Uapi_HdrExpAttrV2_t att2;
434     rk_aiq_uapi_ae_getHdrExpAttr(mAlgoCtx, &att2, false);
435     rk_aiq_uapi_ae_convHdrExpAttr_v2Tov1(&att2, pHdrExpAttr);
436     mCfgMutex.unlock();
437 
438     EXIT_ANALYZER_FUNCTION();
439     return ret;
440 }
441 
setHdrExpAttr(Uapi_HdrExpAttrV2_t HdrExpAttrV2)442 XCamReturn RkAiqAeHandleInt::setHdrExpAttr(Uapi_HdrExpAttrV2_t HdrExpAttrV2) {
443     ENTER_ANALYZER_FUNCTION();
444 
445     XCamReturn ret = XCAM_RETURN_NO_ERROR;
446     mCfgMutex.lock();
447 
448 #ifdef DISABLE_HANDLE_ATTRIB
449     rk_aiq_uapi_ae_setHdrExpAttr(mAlgoCtx, &HdrExpAttrV2, false, false);
450     AeInstanceConfig_t* pAeInstConfig = (AeInstanceConfig_t*)mAlgoCtx;
451     AeConfig_t pAecCfg                = pAeInstConfig->aecCfg;
452     pAecCfg->IsReconfig |= UPDATE_HDREXPATTR;
453 #else
454     bool isChanged = false;
455     if (HdrExpAttrV2.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
456             memcmp(&mNewHdrExpAttrV2, &HdrExpAttrV2, sizeof(HdrExpAttrV2)))
457         isChanged = true;
458     else if (HdrExpAttrV2.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
459              memcmp(&mCurHdrExpAttrV2, &HdrExpAttrV2, sizeof(HdrExpAttrV2)))
460         isChanged = true;
461 
462     // if something changed
463     if (isChanged) {
464         mNewHdrExpAttrV2   = HdrExpAttrV2;
465         updateHdrExpAttrV2 = true;
466         waitSignal(HdrExpAttrV2.sync.sync_mode);
467     }
468 #endif
469     mCfgMutex.unlock();
470 
471     EXIT_ANALYZER_FUNCTION();
472     return ret;
473 }
474 
getHdrExpAttr(Uapi_HdrExpAttrV2_t * pHdrExpAttrV2)475 XCamReturn RkAiqAeHandleInt::getHdrExpAttr(Uapi_HdrExpAttrV2_t* pHdrExpAttrV2) {
476     ENTER_ANALYZER_FUNCTION();
477 
478     XCamReturn ret = XCAM_RETURN_NO_ERROR;
479 
480 #ifdef DISABLE_HANDLE_ATTRIB
481     mCfgMutex.lock();
482     rk_aiq_uapi_ae_getHdrExpAttr(mAlgoCtx, pHdrExpAttrV2, false);
483     pHdrExpAttrV2->sync.done = true;
484     mCfgMutex.unlock();
485 #else
486     if (pHdrExpAttrV2->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
487         mCfgMutex.lock();
488         rk_aiq_uapi_ae_getHdrExpAttr(mAlgoCtx, pHdrExpAttrV2, false);
489         pHdrExpAttrV2->sync.done = true;
490         mCfgMutex.unlock();
491     } else {
492         if (updateHdrExpAttrV2) {
493             memcpy(pHdrExpAttrV2, &mNewHdrExpAttrV2, sizeof(mNewHdrExpAttrV2));
494             pHdrExpAttrV2->sync.done = false;
495         } else {
496             rk_aiq_uapi_ae_getHdrExpAttr(mAlgoCtx, pHdrExpAttrV2, false);
497             pHdrExpAttrV2->sync.sync_mode = mNewHdrExpAttrV2.sync.sync_mode;
498             pHdrExpAttrV2->sync.done      = true;
499         }
500     }
501 #endif
502 
503     EXIT_ANALYZER_FUNCTION();
504     return ret;
505 }
506 
setLinAeRouteAttr(Uapi_LinAeRouteAttr_t LinAeRouteAttr)507 XCamReturn RkAiqAeHandleInt::setLinAeRouteAttr(Uapi_LinAeRouteAttr_t LinAeRouteAttr) {
508     ENTER_ANALYZER_FUNCTION();
509 
510     XCamReturn ret = XCAM_RETURN_NO_ERROR;
511     mCfgMutex.lock();
512 
513 #ifdef DISABLE_HANDLE_ATTRIB
514     rk_aiq_uapi_ae_setLinAeRouteAttr(mAlgoCtx, &LinAeRouteAttr, false, false);
515     AeInstanceConfig_t* pAeInstConfig = (AeInstanceConfig_t*)mAlgoCtx;
516     AeConfig_t pAecCfg                = pAeInstConfig->aecCfg;
517     pAecCfg->IsReconfig |= UPDATE_LINAEROUTEATTR;
518 #else
519     bool isChanged = false;
520     if (LinAeRouteAttr.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
521             memcmp(&mNewLinAeRouteAttr, &LinAeRouteAttr, sizeof(LinAeRouteAttr)))
522         isChanged = true;
523     else if (LinAeRouteAttr.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
524              memcmp(&mCurLinAeRouteAttr, &LinAeRouteAttr, sizeof(LinAeRouteAttr)))
525         isChanged = true;
526 
527     // if something changed
528     if (isChanged) {
529         mNewLinAeRouteAttr   = LinAeRouteAttr;
530         updateLinAeRouteAttr = true;
531         waitSignal(LinAeRouteAttr.sync.sync_mode);
532     }
533 #endif
534     mCfgMutex.unlock();
535 
536     EXIT_ANALYZER_FUNCTION();
537     return ret;
538 }
539 
getLinAeRouteAttr(Uapi_LinAeRouteAttr_t * pLinAeRouteAttr)540 XCamReturn RkAiqAeHandleInt::getLinAeRouteAttr(Uapi_LinAeRouteAttr_t* pLinAeRouteAttr) {
541     ENTER_ANALYZER_FUNCTION();
542 
543     XCamReturn ret = XCAM_RETURN_NO_ERROR;
544 
545 #ifdef DISABLE_HANDLE_ATTRIB
546     mCfgMutex.lock();
547     rk_aiq_uapi_ae_getLinAeRouteAttr(mAlgoCtx, pLinAeRouteAttr, false);
548     pLinAeRouteAttr->sync.done = true;
549     mCfgMutex.unlock();
550 #else
551     if (pLinAeRouteAttr->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
552         mCfgMutex.lock();
553         rk_aiq_uapi_ae_getLinAeRouteAttr(mAlgoCtx, pLinAeRouteAttr, false);
554         pLinAeRouteAttr->sync.done = true;
555         mCfgMutex.unlock();
556     } else {
557         if (updateLinAeRouteAttr) {
558             memcpy(pLinAeRouteAttr, &mNewLinAeRouteAttr, sizeof(mNewLinAeRouteAttr));
559             pLinAeRouteAttr->sync.done = false;
560         } else {
561             rk_aiq_uapi_ae_getLinAeRouteAttr(mAlgoCtx, pLinAeRouteAttr, false);
562             pLinAeRouteAttr->sync.sync_mode = mNewLinAeRouteAttr.sync.sync_mode;
563             pLinAeRouteAttr->sync.done      = true;
564         }
565     }
566 #endif
567     EXIT_ANALYZER_FUNCTION();
568     return ret;
569 }
570 
setHdrAeRouteAttr(Uapi_HdrAeRouteAttr_t HdrAeRouteAttr)571 XCamReturn RkAiqAeHandleInt::setHdrAeRouteAttr(Uapi_HdrAeRouteAttr_t HdrAeRouteAttr) {
572     ENTER_ANALYZER_FUNCTION();
573 
574     XCamReturn ret = XCAM_RETURN_NO_ERROR;
575     mCfgMutex.lock();
576 
577 #ifdef DISABLE_HANDLE_ATTRIB
578     rk_aiq_uapi_ae_setHdrAeRouteAttr(mAlgoCtx, &HdrAeRouteAttr, false, false);
579     AeInstanceConfig_t* pAeInstConfig = (AeInstanceConfig_t*)mAlgoCtx;
580     AeConfig_t pAecCfg                = pAeInstConfig->aecCfg;
581     pAecCfg->IsReconfig |= UPDATE_HDRAEROUTEATTR;
582 #else
583     bool isChanged = false;
584     if (HdrAeRouteAttr.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
585             memcmp(&mNewHdrAeRouteAttr, &HdrAeRouteAttr, sizeof(HdrAeRouteAttr)))
586         isChanged = true;
587     else if (HdrAeRouteAttr.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
588              memcmp(&mCurHdrAeRouteAttr, &HdrAeRouteAttr, sizeof(HdrAeRouteAttr)))
589         isChanged = true;
590 
591     // if something changed
592     if (isChanged) {
593         mNewHdrAeRouteAttr   = HdrAeRouteAttr;
594         updateHdrAeRouteAttr = true;
595         waitSignal(HdrAeRouteAttr.sync.sync_mode);
596     }
597 #endif
598     mCfgMutex.unlock();
599 
600     EXIT_ANALYZER_FUNCTION();
601     return ret;
602 }
603 
getHdrAeRouteAttr(Uapi_HdrAeRouteAttr_t * pHdrAeRouteAttr)604 XCamReturn RkAiqAeHandleInt::getHdrAeRouteAttr(Uapi_HdrAeRouteAttr_t* pHdrAeRouteAttr) {
605     ENTER_ANALYZER_FUNCTION();
606 
607     XCamReturn ret = XCAM_RETURN_NO_ERROR;
608 
609 #ifdef DISABLE_HANDLE_ATTRIB
610     mCfgMutex.lock();
611     rk_aiq_uapi_ae_getHdrAeRouteAttr(mAlgoCtx, pHdrAeRouteAttr, false);
612     pHdrAeRouteAttr->sync.done = true;
613     mCfgMutex.unlock();
614 #else
615     if (pHdrAeRouteAttr->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
616         mCfgMutex.lock();
617         rk_aiq_uapi_ae_getHdrAeRouteAttr(mAlgoCtx, pHdrAeRouteAttr, false);
618         pHdrAeRouteAttr->sync.done = true;
619         mCfgMutex.unlock();
620     } else {
621         if (updateHdrAeRouteAttr) {
622             memcpy(pHdrAeRouteAttr, &mNewHdrAeRouteAttr, sizeof(mNewHdrAeRouteAttr));
623             pHdrAeRouteAttr->sync.done = false;
624         } else {
625             rk_aiq_uapi_ae_getHdrAeRouteAttr(mAlgoCtx, pHdrAeRouteAttr, false);
626             pHdrAeRouteAttr->sync.sync_mode = mNewHdrAeRouteAttr.sync.sync_mode;
627             pHdrAeRouteAttr->sync.done      = true;
628         }
629     }
630 #endif
631 
632     EXIT_ANALYZER_FUNCTION();
633     return ret;
634 }
635 
setIrisAttr(Uapi_IrisAttrV2_t IrisAttr)636 XCamReturn RkAiqAeHandleInt::setIrisAttr(Uapi_IrisAttrV2_t IrisAttr) {
637     ENTER_ANALYZER_FUNCTION();
638 
639     XCamReturn ret = XCAM_RETURN_NO_ERROR;
640     mCfgMutex.lock();
641 
642 #ifdef DISABLE_HANDLE_ATTRIB
643     rk_aiq_uapi_ae_setIrisAttr(mAlgoCtx, &IrisAttr, false);
644     AeInstanceConfig_t* pAeInstConfig = (AeInstanceConfig_t*)mAlgoCtx;
645     AeConfig_t pAecCfg                = pAeInstConfig->aecCfg;
646     pAecCfg->IsReconfig |= UPDATE_IRISATTR;
647 #else
648     bool isChanged = false;
649     if (IrisAttr.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
650             memcmp(&mNewIrisAttr, &IrisAttr, sizeof(IrisAttr)))
651         isChanged = true;
652     else if (IrisAttr.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
653              memcmp(&mCurIrisAttr, &IrisAttr, sizeof(IrisAttr)))
654         isChanged = true;
655 
656     // if something changed
657     if (isChanged) {
658         mNewIrisAttr   = IrisAttr;
659         updateIrisAttr = true;
660         waitSignal(IrisAttr.sync.sync_mode);
661     }
662 #endif
663 
664     mCfgMutex.unlock();
665 
666     EXIT_ANALYZER_FUNCTION();
667     return ret;
668 }
669 
getIrisAttr(Uapi_IrisAttrV2_t * pIrisAttr)670 XCamReturn RkAiqAeHandleInt::getIrisAttr(Uapi_IrisAttrV2_t* pIrisAttr) {
671     ENTER_ANALYZER_FUNCTION();
672 
673     XCamReturn ret = XCAM_RETURN_NO_ERROR;
674 
675 #ifdef DISABLE_HANDLE_ATTRIB
676     mCfgMutex.lock();
677     rk_aiq_uapi_ae_getIrisAttr(mAlgoCtx, pIrisAttr);
678     pIrisAttr->sync.done = true;
679     mCfgMutex.unlock();
680 #else
681     if (pIrisAttr->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
682         mCfgMutex.lock();
683         rk_aiq_uapi_ae_getIrisAttr(mAlgoCtx, pIrisAttr);
684         pIrisAttr->sync.done = true;
685         mCfgMutex.unlock();
686     } else {
687         if (updateIrisAttr) {
688             memcpy(pIrisAttr, &mNewIrisAttr, sizeof(mNewIrisAttr));
689             pIrisAttr->sync.done = false;
690         } else {
691             rk_aiq_uapi_ae_getIrisAttr(mAlgoCtx, pIrisAttr);
692             pIrisAttr->sync.sync_mode = mNewIrisAttr.sync.sync_mode;
693             pIrisAttr->sync.done      = true;
694         }
695     }
696 #endif
697 
698     EXIT_ANALYZER_FUNCTION();
699     return ret;
700 }
701 
setSyncTestAttr(Uapi_AecSyncTest_t SyncTestAttr)702 XCamReturn RkAiqAeHandleInt::setSyncTestAttr(Uapi_AecSyncTest_t SyncTestAttr) {
703     ENTER_ANALYZER_FUNCTION();
704 
705     XCamReturn ret = XCAM_RETURN_NO_ERROR;
706     mCfgMutex.lock();
707 
708 #ifdef DISABLE_HANDLE_ATTRIB
709     rk_aiq_uapi_ae_setSyncTest(mAlgoCtx, &SyncTestAttr, false, false);
710     AeInstanceConfig_t* pAeInstConfig = (AeInstanceConfig_t*)mAlgoCtx;
711     AeConfig_t pAecCfg                = pAeInstConfig->aecCfg;
712     pAecCfg->IsReconfig |= UPDATE_SYNCTESTATTR;
713 #else
714     bool isChanged = false;
715     if (SyncTestAttr.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
716             memcmp(&mNewAecSyncTestAttr, &SyncTestAttr, sizeof(SyncTestAttr)))
717         isChanged = true;
718     else if (SyncTestAttr.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
719              memcmp(&mCurAecSyncTestAttr, &SyncTestAttr, sizeof(SyncTestAttr)))
720         isChanged = true;
721 
722     // if something changed
723     if (isChanged) {
724         mNewAecSyncTestAttr = SyncTestAttr;
725         updateSyncTestAttr  = true;
726         waitSignal(SyncTestAttr.sync.sync_mode);
727     }
728 #endif
729 
730     mCfgMutex.unlock();
731 
732     EXIT_ANALYZER_FUNCTION();
733     return ret;
734 }
735 
getSyncTestAttr(Uapi_AecSyncTest_t * pSyncTestAttr)736 XCamReturn RkAiqAeHandleInt::getSyncTestAttr(Uapi_AecSyncTest_t* pSyncTestAttr) {
737     ENTER_ANALYZER_FUNCTION();
738 
739     XCamReturn ret = XCAM_RETURN_NO_ERROR;
740 
741 #ifdef DISABLE_HANDLE_ATTRIB
742     mCfgMutex.lock();
743     rk_aiq_uapi_ae_getSyncTest(mAlgoCtx, pSyncTestAttr, false);
744     pSyncTestAttr->sync.done = true;
745     mCfgMutex.unlock();
746 #else
747     if (pSyncTestAttr->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
748         mCfgMutex.lock();
749         rk_aiq_uapi_ae_getSyncTest(mAlgoCtx, pSyncTestAttr, false);
750         pSyncTestAttr->sync.done = true;
751         mCfgMutex.unlock();
752     } else {
753         if (updateSyncTestAttr) {
754             memcpy(pSyncTestAttr, &mNewAecSyncTestAttr, sizeof(mNewAecSyncTestAttr));
755             pSyncTestAttr->sync.done = false;
756         } else {
757             rk_aiq_uapi_ae_getSyncTest(mAlgoCtx, pSyncTestAttr, false);
758             pSyncTestAttr->sync.sync_mode = mNewAecSyncTestAttr.sync.sync_mode;
759             pSyncTestAttr->sync.done      = true;
760         }
761     }
762 #endif
763 
764     EXIT_ANALYZER_FUNCTION();
765     return ret;
766 }
767 
setExpWinAttr(Uapi_ExpWin_t ExpWinAttr)768 XCamReturn RkAiqAeHandleInt::setExpWinAttr(Uapi_ExpWin_t ExpWinAttr) {
769     ENTER_ANALYZER_FUNCTION();
770 
771     XCamReturn ret = XCAM_RETURN_NO_ERROR;
772     mCfgMutex.lock();
773 
774 #ifdef DISABLE_HANDLE_ATTRIB
775     rk_aiq_uapi_ae_setExpWinAttr(mAlgoCtx, &ExpWinAttr, false);
776     AeInstanceConfig_t* pAeInstConfig = (AeInstanceConfig_t*)mAlgoCtx;
777     AeConfig_t pAecCfg                = pAeInstConfig->aecCfg;
778     pAecCfg->IsReconfig |= UPDATE_EXPWINATTR;
779 #else
780     bool isChanged = false;
781     if (ExpWinAttr.sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && \
782             memcmp(&mNewExpWinAttr, &ExpWinAttr, sizeof(ExpWinAttr)))
783         isChanged = true;
784     else if (ExpWinAttr.sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC && \
785              memcmp(&mCurExpWinAttr, &ExpWinAttr, sizeof(ExpWinAttr)))
786         isChanged = true;
787 
788     // if something changed
789     if (isChanged) {
790         mNewExpWinAttr   = ExpWinAttr;
791         updateExpWinAttr = true;
792         waitSignal(ExpWinAttr.sync.sync_mode);
793     }
794 #endif
795 
796     mCfgMutex.unlock();
797 
798     EXIT_ANALYZER_FUNCTION();
799     return ret;
800 }
801 
getExpWinAttr(Uapi_ExpWin_t * pExpWinAttr)802 XCamReturn RkAiqAeHandleInt::getExpWinAttr(Uapi_ExpWin_t* pExpWinAttr) {
803     ENTER_ANALYZER_FUNCTION();
804 
805     XCamReturn ret = XCAM_RETURN_NO_ERROR;
806 
807 #ifdef DISABLE_HANDLE_ATTRIB
808     mCfgMutex.lock();
809     rk_aiq_uapi_ae_getExpWinAttr(mAlgoCtx, pExpWinAttr);
810     pExpWinAttr->sync.done = true;
811     mCfgMutex.unlock();
812 #else
813     if (pExpWinAttr->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
814         mCfgMutex.lock();
815         rk_aiq_uapi_ae_getExpWinAttr(mAlgoCtx, pExpWinAttr);
816         pExpWinAttr->sync.done = true;
817         mCfgMutex.unlock();
818     } else {
819         if (updateExpWinAttr) {
820             memcpy(pExpWinAttr, &mNewExpWinAttr, sizeof(mNewExpWinAttr));
821             pExpWinAttr->sync.done = false;
822         } else {
823             rk_aiq_uapi_ae_getExpWinAttr(mAlgoCtx, pExpWinAttr);
824             pExpWinAttr->sync.sync_mode = mNewExpWinAttr.sync.sync_mode;
825             pExpWinAttr->sync.done      = true;
826         }
827     }
828 #endif
829 
830     EXIT_ANALYZER_FUNCTION();
831     return ret;
832 }
833 
queryExpInfo(Uapi_ExpQueryInfo_t * pExpQueryInfo)834 XCamReturn RkAiqAeHandleInt::queryExpInfo(Uapi_ExpQueryInfo_t* pExpQueryInfo) {
835     ENTER_ANALYZER_FUNCTION();
836 
837     XCamReturn ret = XCAM_RETURN_NO_ERROR;
838 
839     rk_aiq_uapi_ae_queryExpInfo(mAlgoCtx, pExpQueryInfo, false);
840 
841     EXIT_ANALYZER_FUNCTION();
842     return ret;
843 }
844 
setLockAeForAf(bool lock_ae)845 XCamReturn RkAiqAeHandleInt::setLockAeForAf(bool lock_ae) {
846     ENTER_ANALYZER_FUNCTION();
847 
848     XCamReturn ret = XCAM_RETURN_NO_ERROR;
849     mLockAebyAfMutex.lock();
850     lockaebyaf = lock_ae;
851     mLockAebyAfMutex.unlock();
852 
853     EXIT_ANALYZER_FUNCTION();
854     return ret;
855 }
856 
getAfdResForAE(AfdPeakRes_t AfdRes)857 XCamReturn RkAiqAeHandleInt::getAfdResForAE(AfdPeakRes_t AfdRes) {
858     ENTER_ANALYZER_FUNCTION();
859 
860     XCamReturn ret = XCAM_RETURN_NO_ERROR;
861     mGetAfdResMutex.lock();
862     mAfdRes = AfdRes;
863     mGetAfdResMutex.unlock();
864 
865     EXIT_ANALYZER_FUNCTION();
866     return ret;
867 }
868 
prepare()869 XCamReturn RkAiqAeHandleInt::prepare() {
870     ENTER_ANALYZER_FUNCTION();
871 
872     XCamReturn ret = XCAM_RETURN_NO_ERROR;
873 
874     ret = RkAiqHandle::prepare();
875     RKAIQCORE_CHECK_RET(ret, "ae handle prepare failed");
876 
877     RkAiqAlgoConfigAe* ae_config_int = (RkAiqAlgoConfigAe*)mConfig;
878     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
879         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
880     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
881 
882     // TODO config ae common params:
883 
884     /*****************AecConfig Sensor Exp related info*****************/
885     ae_config_int->LinePeriodsPerField = (float)sharedCom->snsDes.frame_length_lines;
886     ae_config_int->PixelPeriodsPerLine = (float)sharedCom->snsDes.line_length_pck;
887     ae_config_int->PixelClockFreqMHZ   = (float)sharedCom->snsDes.pixel_clock_freq_mhz;
888 
889     /*****************AecConfig pic-info params*****************/
890     ae_config_int->RawWidth  = sharedCom->snsDes.isp_acq_width;
891     ae_config_int->RawHeight = sharedCom->snsDes.isp_acq_height;
892     ae_config_int->nr_switch = sharedCom->snsDes.nr_switch;
893 
894     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
895     ret                       = des->prepare(mConfig);
896     RKAIQCORE_CHECK_RET(ret, "ae algo prepare failed");
897 
898     EXIT_ANALYZER_FUNCTION();
899     return XCAM_RETURN_NO_ERROR;
900 }
901 
preProcess()902 XCamReturn RkAiqAeHandleInt::preProcess() {
903     ENTER_ANALYZER_FUNCTION();
904 
905     XCamReturn ret = XCAM_RETURN_NO_ERROR;
906 
907     RkAiqAlgoPreAe* ae_pre_int        = (RkAiqAlgoPreAe*)mPreInParam;
908     bool postMsg = true;
909     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
910         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
911     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
912 
913     RkAiqAecStats* xAecStats = nullptr;
914     if (shared->aecStatsBuf) {
915         xAecStats = shared->aecStatsBuf;
916         if (!xAecStats) LOGE_AEC("aec stats is null");
917     } else {
918         LOGW_AEC("the xcamvideobuffer of aec stats is null");
919     }
920     if ((!xAecStats || !xAecStats->aec_stats_valid) && !sharedCom->init) {
921         LOGW("no aec stats, ignore!");
922         mPreResShared = NULL;
923         return XCAM_RETURN_BYPASS;
924     }
925 
926     int algoId = this->getAlgoId();
927     if (algoId == 0)
928         mPreResShared = new RkAiqAlgoPreResAeIntShared();
929     if (!mPreResShared.ptr()) {
930         LOGE("new ae mPreOutParam failed, bypass!");
931         return XCAM_RETURN_BYPASS;
932     }
933 
934     ret = RkAiqHandle::preProcess();
935     if (ret < 0) {
936         LOGE_ANALYZER("ae handle preProcess failed ret %d", ret);
937         mPreResShared = NULL;
938         return ret;
939     } else if (ret == XCAM_RETURN_BYPASS) {
940         LOGW_ANALYZER("%s:%d bypass !", __func__, __LINE__);
941         mPreResShared = NULL;
942         return ret;
943     }
944 
945     if (xAecStats) {
946         ae_pre_int->aecStatsBuf = &xAecStats->aec_stats;
947         ae_pre_int->af_prior= xAecStats->af_prior;
948     } else {
949         ae_pre_int->aecStatsBuf = NULL;
950         ae_pre_int->af_prior= false;
951     }
952 
953     if (algoId == 0) {
954         AeInstanceConfig_t* pAeInstConfig           = (AeInstanceConfig_t*)mAlgoCtx;
955 
956         mGetAfdResMutex.lock();
957         pAeInstConfig->aecCfg->AfdRes = mAfdRes;
958         mGetAfdResMutex.unlock();
959     }
960 
961     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
962     if (des->pre_process) {
963 #ifdef DISABLE_HANDLE_ATTRIB
964         mCfgMutex.lock();
965 #endif
966         ret = des->pre_process(mPreInParam, (RkAiqAlgoResCom*)(&mPreResShared->result));
967 #ifdef DISABLE_HANDLE_ATTRIB
968         mCfgMutex.unlock();
969 #endif
970         if (ret < 0) {
971             LOGE_ANALYZER("ae handle pre_process failed ret %d", ret);
972             mPreResShared = NULL;
973             return ret;
974         } else if (ret == XCAM_RETURN_BYPASS) {
975             LOGW_ANALYZER("%s:%d bypass !", __func__, __LINE__);
976             mPreResShared = NULL;
977             return ret;
978         }
979     }
980 
981     if (mPostShared) {
982         if (mAiqCore->mAlogsComSharedParams.init) {
983             RkAiqCore::RkAiqAlgosGroupShared_t* grpShared = nullptr;
984             for (uint32_t i = 0; i < RK_AIQ_CORE_ANALYZE_MAX; i++) {
985                 uint64_t grpMask = grpId2GrpMask(i);
986                 if (!mAiqCore->getGroupSharedParams(grpMask, grpShared)) {
987                     if (grpShared)
988                         grpShared->res_comb.ae_pre_res = convert_to_XCamVideoBuffer(mPreResShared);
989                 }
990             }
991         } else {
992             mPreResShared->set_sequence(shared->frameId);
993             RkAiqCoreVdBufMsg msg(XCAM_MESSAGE_AE_PRE_RES_OK, shared->frameId, mPreResShared);
994             mAiqCore->post_message(msg);
995         }
996     }
997 
998     EXIT_ANALYZER_FUNCTION();
999     return XCAM_RETURN_NO_ERROR;
1000 }
1001 
processing()1002 XCamReturn RkAiqAeHandleInt::processing() {
1003     ENTER_ANALYZER_FUNCTION();
1004 
1005     XCamReturn ret = XCAM_RETURN_NO_ERROR;
1006 
1007     RkAiqAlgoProcAe* ae_proc_int        = (RkAiqAlgoProcAe*)mProcInParam;
1008     RkAiqAlgoProcResAe* ae_proc_res_int        = (RkAiqAlgoProcResAe*)mProcOutParam;
1009     bool postMsg = true;
1010     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
1011         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
1012     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
1013 
1014     RkAiqAecStats* xAecStats = nullptr;
1015     if (shared->aecStatsBuf) {
1016         xAecStats = shared->aecStatsBuf;
1017         if (!xAecStats) LOGE_AEC("aec stats is null");
1018     } else {
1019         LOGW_AEC("the xcamvideobuffer of aec stats is null");
1020     }
1021     if ((!xAecStats || !xAecStats->aec_stats_valid) && !sharedCom->init) {
1022         LOGW("no aec stats, ignore!");
1023         mPreResShared = NULL;
1024         return XCAM_RETURN_BYPASS;
1025     }
1026 
1027     int algoId = this->getAlgoId();
1028     if (algoId == 0) {
1029         AeInstanceConfig_t* pAeInstConfig           = (AeInstanceConfig_t*)mAlgoCtx;
1030 
1031         mLockAebyAfMutex.lock();
1032         pAeInstConfig->lockaebyaf = lockaebyaf;
1033         mLockAebyAfMutex.unlock();
1034     }
1035 
1036     ae_proc_res_int->new_ae_exp = &shared->fullParams->mExposureParams->data()->result.new_ae_exp;
1037     ae_proc_res_int->ae_proc_res_rk = &shared->fullParams->mExposureParams->data()->result.ae_proc_res_rk;
1038     ae_proc_res_int->exp_i2c_params = &shared->fullParams->mExposureParams->data()->result.exp_i2c_params;
1039     ae_proc_res_int->ae_meas = &shared->fullParams->mAecParams->data()->result;
1040     ae_proc_res_int->hist_meas = &shared->fullParams->mHistParams->data()->result;
1041 
1042     ret = RkAiqHandle::processing();
1043     if (ret < 0) {
1044         LOGE_ANALYZER("ae handle processing failed ret %d", ret);
1045         mPreResShared = NULL;
1046         return ret;
1047     } else if (ret == XCAM_RETURN_BYPASS) {
1048         LOGW_ANALYZER("%s:%d bypass !", __func__, __LINE__);
1049         mPreResShared = NULL;
1050         return ret;
1051     }
1052 
1053     // TODO config common ae processing params
1054     if (xAecStats)
1055         ae_proc_int->aecStatsBuf = &xAecStats->aec_stats;
1056     else
1057         ae_proc_int->aecStatsBuf = NULL;
1058 
1059     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
1060     if (des->processing) {
1061 #ifdef DISABLE_HANDLE_ATTRIB
1062         mCfgMutex.lock();
1063 #endif
1064         ret = des->processing(mProcInParam, (RkAiqAlgoResCom*)(mProcOutParam));
1065 #ifdef DISABLE_HANDLE_ATTRIB
1066         mCfgMutex.unlock();
1067 #endif
1068         if (ret < 0) {
1069             LOGE_ANALYZER("ae algo processing failed ret %d", ret);
1070             mPreResShared = NULL;
1071             return ret;
1072         } else if (ret == XCAM_RETURN_BYPASS) {
1073             LOGW_ANALYZER("%s:%d bypass !", __func__, __LINE__);
1074             mPreResShared = NULL;
1075             return ret;
1076         }
1077     }
1078 
1079     if (mAiqCore->mAlogsComSharedParams.init) {
1080         RkAiqCore::RkAiqAlgosGroupShared_t* measGroupshared = nullptr;
1081         if (mAiqCore->getGroupSharedParams(RK_AIQ_CORE_ANALYZE_MEAS, measGroupshared) !=
1082                 XCAM_RETURN_NO_ERROR) {
1083             LOGW("get the shared of meas failed");
1084         }
1085         if (measGroupshared) {
1086             measGroupshared->frameId                 = shared->frameId;
1087         }
1088 
1089         /* Transfer the initial exposure to other algorithm modules */
1090         for (auto type = RK_AIQ_CORE_ANALYZE_MEAS; type < RK_AIQ_CORE_ANALYZE_MAX; \
1091                 type = (rk_aiq_core_analyze_type_e)(type + 1)) {
1092             uint64_t grpMask = grpId2GrpMask(type);
1093             if (!mAiqCore->getGroupSharedParams(grpMask, shared)) {
1094                 if (shared) {
1095                     shared->preExp = *ae_proc_res_int->new_ae_exp;
1096                     shared->curExp = *ae_proc_res_int->new_ae_exp;
1097                     shared->nxtExp = *ae_proc_res_int->new_ae_exp;
1098                 }
1099             }
1100 
1101         }
1102     } else {
1103 #if 0 // no algo need ae proc result now
1104         if (mPostShared) {
1105             SmartPtr<BufferProxy> msg_data = new BufferProxy(mProcResShared);
1106             msg_data->set_sequence(shared->frameId);
1107             SmartPtr<XCamMessage> msg =
1108                 new RkAiqCoreVdBufMsg(XCAM_MESSAGE_AE_PROC_RES_OK, shared->frameId, msg_data);
1109             mAiqCore->post_message(msg);
1110         }
1111 #endif
1112     }
1113 
1114 #if RKAIQ_HAVE_AF
1115     if (mAf_handle) {
1116         int algo_id                      = (*mAf_handle)->getAlgoId();
1117         if (algo_id == 0) {
1118             RkAiqAfHandleInt* af_algo = dynamic_cast<RkAiqAfHandleInt*>(mAf_handle->ptr());
1119 
1120             af_algo->setAeStable(ae_proc_res_int->ae_proc_res_rk->IsConverged);
1121         }
1122     }
1123 #endif
1124 
1125     RkAiqAlgoProcResAeShared_t aeProcResShared;
1126 
1127     aeProcResShared.IsConverged = ae_proc_res_int->ae_proc_res_rk->IsConverged;
1128     aeProcResShared.IsEnvChanged = ae_proc_res_int->ae_proc_res_rk->IsEnvChanged;
1129     aeProcResShared.IsAutoAfd =  ae_proc_res_int->ae_proc_res_rk->IsAutoAfd;
1130     aeProcResShared.LongFrmMode =  ae_proc_res_int->ae_proc_res_rk->LongFrmMode;
1131 
1132 #if RKAIQ_HAVE_AFD_V1 || RKAIQ_HAVE_AFD_V2
1133     if (mAfd_handle) {
1134         RkAiqAfdHandleInt* afd_algo = dynamic_cast<RkAiqAfdHandleInt*>(mAfd_handle->ptr());
1135 
1136         afd_algo->setAeProcRes(&aeProcResShared);
1137     }
1138 #endif
1139 
1140     if (mAmerge_handle) {
1141         RkAiqAmergeHandleInt* amerge_algo = dynamic_cast<RkAiqAmergeHandleInt*>(mAmerge_handle->ptr());
1142         amerge_algo->setAeProcRes(&aeProcResShared);
1143     }
1144 
1145     if (mAdrc_handle) {
1146         RkAiqAdrcHandleInt* adrc_algo = dynamic_cast<RkAiqAdrcHandleInt*>(mAdrc_handle->ptr());
1147         adrc_algo->setAeProcRes(&aeProcResShared);
1148     }
1149 
1150     EXIT_ANALYZER_FUNCTION();
1151     return ret;
1152 }
1153 
postProcess()1154 XCamReturn RkAiqAeHandleInt::postProcess() {
1155     ENTER_ANALYZER_FUNCTION();
1156 
1157     XCamReturn ret = XCAM_RETURN_NO_ERROR;
1158 
1159     RkAiqAlgoPostAe* ae_post_int        = (RkAiqAlgoPostAe*)mPostInParam;
1160     RkAiqAlgoPostResAe* ae_post_res_int = (RkAiqAlgoPostResAe*)mPostOutParam;
1161     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
1162         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
1163     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
1164 
1165     RkAiqAecStats* xAecStats = nullptr;
1166     if (shared->aecStatsBuf) {
1167         xAecStats = shared->aecStatsBuf;
1168         if (!xAecStats) LOGE_AEC("aec stats is null");
1169     } else {
1170         LOGW_AEC("the xcamvideobuffer of aec stats is null");
1171     }
1172     if ((!xAecStats || !xAecStats->aec_stats_valid) && !sharedCom->init) {
1173         LOGW("no aec stats, ignore!");
1174         mPreResShared = NULL;
1175         return XCAM_RETURN_BYPASS;
1176     }
1177     ret = RkAiqHandle::postProcess();
1178     if (ret) {
1179         RKAIQCORE_CHECK_RET(ret, "ae handle postProcess failed");
1180         mPreResShared = NULL;
1181         return ret;
1182     }
1183 
1184     RkAiqAlgoDescription* des = (RkAiqAlgoDescription*)mDes;
1185     if (des->post_process)
1186         ret                       = des->post_process(mPostInParam, mPostOutParam);
1187     RKAIQCORE_CHECK_RET(ret, "ae algo post_process failed");
1188 
1189     EXIT_ANALYZER_FUNCTION();
1190     return ret;
1191 }
1192 
genIspResult(RkAiqFullParams * params,RkAiqFullParams * cur_params)1193 XCamReturn RkAiqAeHandleInt::genIspResult(RkAiqFullParams* params, RkAiqFullParams* cur_params) {
1194     ENTER_ANALYZER_FUNCTION();
1195 
1196     XCamReturn ret = XCAM_RETURN_NO_ERROR;
1197 
1198     if (mIsMulRun && this->getAlgoId() == 0) {
1199         // do nothing for rkawb if custom algo running with rk algo
1200         return ret;
1201     }
1202 
1203     RkAiqCore::RkAiqAlgosGroupShared_t* shared =
1204         (RkAiqCore::RkAiqAlgosGroupShared_t*)(getGroupShared());
1205     RkAiqCore::RkAiqAlgosComShared_t* sharedCom = &mAiqCore->mAlogsComSharedParams;
1206 
1207     RkAiqAlgoProcResAe* ae_proc                 = (RkAiqAlgoProcResAe*)mProcOutParam;
1208     RkAiqAlgoPostResAe* ae_post                 = (RkAiqAlgoPostResAe*)mPostOutParam;
1209 
1210     rk_aiq_isp_aec_params_v20_t* aec_param   = params->mAecParams->data().ptr();
1211     rk_aiq_isp_hist_params_v20_t* hist_param = params->mHistParams->data().ptr();
1212     rk_aiq_exposure_params_wrapper_t* exp_param = params->mExposureParams->data().ptr();
1213     rk_aiq_iris_params_wrapper_t* iris_param    = params->mIrisParams->data().ptr();
1214 
1215     int algo_id = this->getAlgoId();
1216 
1217     if (sharedCom->init) {
1218         aec_param->frame_id  = 0;
1219         hist_param->frame_id = 0;
1220         exp_param->frame_id  = 0;
1221     } else {
1222         aec_param->frame_id  = shared->frameId;
1223         hist_param->frame_id = shared->frameId;
1224         exp_param->frame_id  = shared->frameId;
1225     }
1226 
1227     // exposure
1228     exp_param->result.algo_id      = 0;//algo_id;
1229     cur_params->mExposureParams = params->mExposureParams;
1230 
1231     // iris
1232     if (algo_id == 0) {
1233         RkAiqAlgoPostResAe* ae_post_rk = (RkAiqAlgoPostResAe*)ae_post;
1234         // HDC iris control
1235         iris_param->DCIris.update = ae_post_rk->ae_post_res_rk.DCIris.update;
1236         iris_param->DCIris.pwmDuty = ae_post_rk->ae_post_res_rk.DCIris.pwmDuty;
1237         // HDC iris control
1238         iris_param->HDCIris.update = ae_post_rk->ae_post_res_rk.HDCIris.update;
1239         iris_param->HDCIris.target = ae_post_rk->ae_post_res_rk.HDCIris.target;
1240         ae_post_rk->ae_post_res_rk.HDCIris.adc = iris_param->HDCIris.adc;
1241         ae_post_rk->ae_post_res_rk.HDCIris.zoomPos = iris_param->HDCIris.zoomPos;
1242         cur_params->mIrisParams = params->mIrisParams;
1243     }
1244 
1245     // meas
1246     if (ae_proc->ae_meas->ae_meas_update) {
1247         mMeasSyncFlag = shared->frameId;
1248         aec_param->sync_flag = mMeasSyncFlag;
1249         // copy from algo result
1250         // set as the latest result
1251         cur_params->mAecParams = params->mAecParams;
1252         aec_param->is_update = true;
1253         LOGD_AEC("[%d] meas params from algo", mMeasSyncFlag);
1254     } else if (mMeasSyncFlag != aec_param->sync_flag) {
1255         aec_param->sync_flag = mMeasSyncFlag;
1256         // copy from latest result
1257         if (cur_params->mAecParams.ptr()) {
1258             aec_param->result = cur_params->mAecParams->data()->result;
1259             aec_param->is_update = true;
1260         } else {
1261             LOGE_AEC("no latest meas params !");
1262             aec_param->is_update = false;
1263         }
1264         LOGD_AEC("[%d] meas params from latest [%d]", shared->frameId, mMeasSyncFlag);
1265     } else {
1266         // do nothing, result in buf needn't update
1267         aec_param->is_update = false;
1268         LOGD_AEC("[%d] meas params needn't update", shared->frameId);
1269     }
1270 
1271     // hist
1272     if (ae_proc->hist_meas->hist_meas_update) {
1273         mHistSyncFlag = shared->frameId;
1274         hist_param->sync_flag = mHistSyncFlag;
1275         // copy from algo result
1276         // set as the latest result
1277         cur_params->mHistParams = params->mHistParams;
1278         hist_param->is_update = true;
1279         LOGD_AEC("[%d] hist params from algo", mHistSyncFlag);
1280     } else if (mHistSyncFlag != hist_param->sync_flag) {
1281         hist_param->sync_flag = mHistSyncFlag;
1282         // copy from latest result
1283         if (cur_params->mHistParams.ptr()) {
1284             hist_param->result = cur_params->mHistParams->data()->result;
1285             hist_param->is_update = true;
1286         } else {
1287             LOGE_AEC("no latest hist params !");
1288             hist_param->is_update = false;
1289         }
1290         LOGD_AEC("[%d] hist params from latest [%d]", shared->frameId, mHistSyncFlag);
1291     } else {
1292         // do nothing, result in buf needn't update
1293         hist_param->is_update = false;
1294         LOGD_AEC("[%d] hist params needn't update", shared->frameId);
1295     }
1296 
1297     mPreResShared = NULL;
1298 
1299     EXIT_ANALYZER_FUNCTION();
1300 
1301     return ret;
1302 }
1303 
1304 }  // namespace RkCam
1305