1 /*
2 * Copyright (c) 2019-2021 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 "RkAiqManager.h"
17
18 #include <fcntl.h>
19 #include <unistd.h>
20
21 #ifdef RKAIQ_ENABLE_CAMGROUP
22 #include "RkAiqCamGroupManager.h"
23 #endif
24 #include "isp20/Isp20_module_dbg.h"
25 #include "isp20/CamHwIsp20.h"
26 #include "isp21/CamHwIsp21.h"
27 #include "isp3x/CamHwIsp3x.h"
28
29 using namespace XCam;
30 namespace RkCam {
31
32 #define RKAIQMNG_CHECK_RET(ret, format, ...) \
33 if (ret) { \
34 LOGE(format, ##__VA_ARGS__); \
35 return ret; \
36 }
37
38 #define DISABLE_RESULT_APPLY_THREADS
39
40 bool
loop()41 RkAiqMngCmdThread::loop ()
42 {
43 ENTER_XCORE_FUNCTION();
44
45 const static int32_t timeout = -1;
46 XCamReturn ret = XCAM_RETURN_NO_ERROR;
47 SmartPtr<msg_t> msg = mAiqCmdQueue.pop (timeout);
48
49 if (!msg.ptr()) {
50 XCAM_LOG_WARNING("RkAiqMngCmdThread got empty result, stop thread");
51 return false;
52 }
53
54 XCAM_ASSERT (mAiqMng);
55
56 switch (msg->cmd) {
57 case MSG_CMD_SW_WORKING_MODE:
58 if (msg->sync)
59 msg->mutex->lock();
60 mAiqMng->swWorkingModeDyn(msg->data.sw_wk_mode.mode);
61 mAiqMng->mWkSwitching = false;
62 if (msg->sync) {
63 msg->cond->broadcast ();
64 msg->mutex->unlock();
65 }
66 break;
67 default:
68 break;
69 }
70 // always true
71 return true;
72 }
73
74 bool
loop()75 RkAiqRstApplyThread::loop ()
76 {
77 ENTER_XCORE_FUNCTION();
78
79 const static int32_t timeout = -1;
80 XCamReturn ret = XCAM_RETURN_NO_ERROR;
81 SmartPtr<RkAiqFullParamsProxy> results = mAiqRstQueue.pop (timeout);
82
83 XCAM_ASSERT (mAiqMng);
84
85 if (!results.ptr()) {
86 XCAM_LOG_WARNING("RkAiqRstApplyThread got empty result, stop thread");
87 return false;
88 }
89
90 #ifdef RUNTIME_MODULE_DEBUG
91 #ifndef RK_SIMULATOR_HW
92 if (g_apply_init_params_only)
93 goto out;
94 #endif
95 #endif
96 ret = mAiqMng->applyAnalyzerResult(results);
97 if (ret == XCAM_RETURN_NO_ERROR)
98 return true;
99
100 EXIT_XCORE_FUNCTION();
101 out:
102 // always true
103 return true;
104 }
105
RkAiqManager(const char * sns_ent_name,rk_aiq_error_cb err_cb,rk_aiq_metas_cb metas_cb)106 RkAiqManager::RkAiqManager(const char* sns_ent_name,
107 rk_aiq_error_cb err_cb,
108 rk_aiq_metas_cb metas_cb)
109 : mCamHw(NULL)
110 , mRkAiqAnalyzer(NULL)
111 #ifndef DISABLE_RESULT_APPLY_THREADS
112 , mAiqRstAppTh(new RkAiqRstApplyThread(this))
113 #endif
114 , mAiqMngCmdTh(new RkAiqMngCmdThread(this))
115 #ifdef ISP_HW_V20
116 , mRkLumaAnalyzer(NULL)
117 #endif
118 , mErrCb(err_cb)
119 , mMetasCb(metas_cb)
120 , mHwEvtCb(NULL)
121 , mHwEvtCbCtx(NULL)
122 , mSnsEntName(sns_ent_name)
123 #ifdef RKAIQ_ENABLE_PARSER_V1
124 , mCalibDb(NULL)
125 #endif
126 , mCalibDbV2(NULL)
127 , tuningCalib(NULL)
128 , mWorkingMode(RK_AIQ_WORKING_MODE_NORMAL)
129 , mOldWkModeForGray(RK_AIQ_WORKING_MODE_NORMAL)
130 , mWkSwitching(false)
131 , _state(AIQ_STATE_INVALID)
132 , mCurMirror(false)
133 , mCurFlip(false)
134 #ifdef RKAIQ_ENABLE_CAMGROUP
135 , mCamGroupCoreManager(NULL)
136 #endif
137 , mIsMain(false)
138 {
139 ENTER_XCORE_FUNCTION();
140 EXIT_XCORE_FUNCTION();
141 }
142
~RkAiqManager()143 RkAiqManager::~RkAiqManager()
144 {
145 ENTER_XCORE_FUNCTION();
146 EXIT_XCORE_FUNCTION();
147 }
148
149 void
setCamHw(SmartPtr<ICamHw> & camhw)150 RkAiqManager::setCamHw(SmartPtr<ICamHw>& camhw)
151 {
152 ENTER_XCORE_FUNCTION();
153 XCAM_ASSERT (!mCamHw.ptr());
154 mCamHw = camhw;
155 EXIT_XCORE_FUNCTION();
156 }
157
158 void
setAnalyzer(SmartPtr<RkAiqCore> analyzer)159 RkAiqManager::setAnalyzer(SmartPtr<RkAiqCore> analyzer)
160 {
161 ENTER_XCORE_FUNCTION();
162 XCAM_ASSERT (!mRkAiqAnalyzer.ptr());
163 mRkAiqAnalyzer = analyzer;
164 EXIT_XCORE_FUNCTION();
165 }
166
167 #ifdef ISP_HW_V20
168 void
setLumaAnalyzer(SmartPtr<RkLumaCore> analyzer)169 RkAiqManager::setLumaAnalyzer(SmartPtr<RkLumaCore> analyzer)
170 {
171 ENTER_XCORE_FUNCTION();
172 XCAM_ASSERT (!mRkLumaAnalyzer.ptr());
173 mRkLumaAnalyzer = analyzer;
174 EXIT_XCORE_FUNCTION();
175 }
176 #endif
177
178 #ifdef RKAIQ_ENABLE_PARSER_V1
179 void
setAiqCalibDb(const CamCalibDbContext_t * calibDb)180 RkAiqManager::setAiqCalibDb(const CamCalibDbContext_t* calibDb)
181 {
182 ENTER_XCORE_FUNCTION();
183 XCAM_ASSERT (!mCalibDb);
184 mCalibDb = calibDb;
185 EXIT_XCORE_FUNCTION();
186 }
187 #endif
188
189 void
setAiqCalibDb(const CamCalibDbV2Context_t * calibDb)190 RkAiqManager::setAiqCalibDb(const CamCalibDbV2Context_t* calibDb)
191 {
192 ENTER_XCORE_FUNCTION();
193 XCAM_ASSERT (!mCalibDbV2);
194 mCalibDbV2 = new CamCalibDbV2Context_t();
195 *mCalibDbV2 = *calibDb;
196 EXIT_XCORE_FUNCTION();
197 }
198
199 XCamReturn
init()200 RkAiqManager::init()
201 {
202 ENTER_XCORE_FUNCTION();
203
204 XCamReturn ret = XCAM_RETURN_NO_ERROR;
205
206 XCAM_ASSERT (mSnsEntName);
207 XCAM_ASSERT (mRkAiqAnalyzer.ptr());
208 XCAM_ASSERT (mCamHw.ptr());
209 XCAM_ASSERT (mCalibDbV2);
210
211 mRkAiqAnalyzer->setAnalyzeResultCb(this);
212 #ifdef RKAIQ_ENABLE_PARSER_V1
213 ret = mRkAiqAnalyzer->init(mSnsEntName, mCalibDb, mCalibDbV2);
214 #else
215 ret = mRkAiqAnalyzer->init(mSnsEntName, nullptr, mCalibDbV2);
216 #endif
217 RKAIQMNG_CHECK_RET(ret, "analyzer init error %d !", ret);
218
219 #ifdef ISP_HW_V20
220 mRkLumaAnalyzer->setAnalyzeResultCb(this);
221 CalibDbV2_LUMA_DETECT_t *lumaDetect =
222 (CalibDbV2_LUMA_DETECT_t*)(CALIBDBV2_GET_MODULE_PTR((void*)mCalibDbV2, lumaDetect));
223 if (lumaDetect) {
224 ret = mRkLumaAnalyzer->init(lumaDetect);
225 RKAIQMNG_CHECK_RET(ret, "luma analyzer init error %d !", ret);
226 } else {
227 mRkLumaAnalyzer.release();
228 }
229 #endif
230 mCamHw->setHwResListener(this);
231 ret = mCamHw->init(mSnsEntName);
232 RKAIQMNG_CHECK_RET(ret, "camHw init error %d !", ret);
233 _state = AIQ_STATE_INITED;
234 isp_drv_share_mem_ops_t *mem_ops = NULL;
235 mCamHw->getShareMemOps(&mem_ops);
236 mRkAiqAnalyzer->setShareMemOps(mem_ops);
237 // set default mirror & flip
238 setDefMirrorFlip();
239 mAiqMngCmdTh->triger_start();
240 bool bret = mAiqMngCmdTh->start();
241 ret = bret ? XCAM_RETURN_NO_ERROR : XCAM_RETURN_ERROR_FAILED;
242 RKAIQMNG_CHECK_RET(ret, "cmd thread start error");
243
244 mDleayCpslParams = NULL;
245
246 EXIT_XCORE_FUNCTION();
247
248 return ret;
249 }
250
251 XCamReturn
prepare(uint32_t width,uint32_t height,rk_aiq_working_mode_t mode)252 RkAiqManager::prepare(uint32_t width, uint32_t height, rk_aiq_working_mode_t mode)
253 {
254 ENTER_XCORE_FUNCTION();
255
256 XCamReturn ret = XCAM_RETURN_NO_ERROR;
257 rk_aiq_exposure_sensor_descriptor sensor_des;
258
259 XCAM_ASSERT (mCalibDbV2);
260 #ifdef RUNTIME_MODULE_DEBUG
261 #ifndef RK_SIMULATOR_HW
262 get_dbg_force_disable_mods_env();
263 #endif
264 #endif
265 int working_mode_hw = RK_AIQ_WORKING_MODE_NORMAL;
266 if (mode == RK_AIQ_WORKING_MODE_NORMAL) {
267 working_mode_hw = mode;
268 } else {
269 if (mode == RK_AIQ_WORKING_MODE_ISP_HDR2)
270 working_mode_hw = RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR;
271 else if (mode == RK_AIQ_WORKING_MODE_ISP_HDR3)
272 working_mode_hw = RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR;
273 else
274 LOGE_ANALYZER("Not supported HDR mode !");
275 }
276 mCamHw->setCalib(mCalibDbV2);
277 CalibDb_Sensor_ParaV2_t* sensor_calib =
278 (CalibDb_Sensor_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR(mCalibDbV2, sensor_calib));
279
280 #ifdef RKAIQ_ENABLE_CAMGROUP
281 mCamHw->setGroupMode(mCamGroupCoreManager ? true : false, mIsMain);
282 #endif
283
284 if(mode != RK_AIQ_WORKING_MODE_NORMAL)
285 ret = mCamHw->prepare(width, height, working_mode_hw,
286 sensor_calib->CISExpUpdate.Hdr.time_update,
287 sensor_calib->CISExpUpdate.Hdr.gain_update);
288 else
289 ret = mCamHw->prepare(width, height, working_mode_hw,
290 sensor_calib->CISExpUpdate.Linear.time_update,
291 sensor_calib->CISExpUpdate.Linear.gain_update);
292
293 RKAIQMNG_CHECK_RET(ret, "camhw prepare error %d", ret);
294
295 xcam_mem_clear(sensor_des);
296 ret = mCamHw->getSensorModeData(mSnsEntName, sensor_des);
297
298 sensor_output_width = sensor_des.sensor_output_width;
299 sensor_output_height = sensor_des.sensor_output_height;
300 int w, h, aligned_w, aligned_h;
301 ret = mCamHw->get_sp_resolution(w, h, aligned_w, aligned_h);
302 ret = mRkAiqAnalyzer->set_sp_resolution(w, h, aligned_w, aligned_h);
303 #ifdef ISP_HW_V20
304 if (mRkLumaAnalyzer.ptr())
305 ret = mRkLumaAnalyzer->prepare(working_mode_hw);
306 #endif
307 #if RKAIQ_HAVE_PDAF
308 ret = mRkAiqAnalyzer->set_pdaf_support(mCamHw->get_pdaf_support());
309 #endif
310
311 RKAIQMNG_CHECK_RET(ret, "getSensorModeData error %d", ret);
312 mRkAiqAnalyzer->notifyIspStreamMode(mCamHw->getIspStreamMode());
313 ret = mRkAiqAnalyzer->prepare(&sensor_des, working_mode_hw);
314 RKAIQMNG_CHECK_RET(ret, "analyzer prepare error %d", ret);
315
316 SmartPtr<RkAiqFullParamsProxy> initParams = mRkAiqAnalyzer->getAiqFullParams();
317
318 if (mTbInfo.is_pre_aiq) {
319 #ifndef DISABLE_RESULT_APPLY_THREADS
320 mAiqRstAppTh->triger_start();
321 #endif
322 }
323 #ifdef RKAIQ_ENABLE_CAMGROUP
324 if (!mCamGroupCoreManager) {
325 #endif
326 ret = applyAnalyzerResult(initParams, true);
327 RKAIQMNG_CHECK_RET(ret, "set initial params error %d", ret);
328 #ifdef RKAIQ_ENABLE_CAMGROUP
329 }
330 #endif
331
332 mWorkingMode = mode;
333 mOldWkModeForGray = RK_AIQ_WORKING_MODE_NORMAL;
334 mWidth = width;
335 mHeight = height;
336 _state = AIQ_STATE_PREPARED;
337 EXIT_XCORE_FUNCTION();
338
339 return ret;
340 }
341
342 XCamReturn
start()343 RkAiqManager::start()
344 {
345 ENTER_XCORE_FUNCTION();
346
347 XCamReturn ret = XCAM_RETURN_NO_ERROR;
348
349 // restart
350 if (_state == AIQ_STATE_STOPED) {
351 SmartPtr<RkAiqFullParamsProxy> initParams = mRkAiqAnalyzer->getAiqFullParams();
352
353 #if 0
354 if (initParams->data()->mIspMeasParams.ptr()) {
355 initParams->data()->mIspMeasParams->data()->frame_id = 0;
356 }
357
358 if (initParams->data()->mIsppMeasParams.ptr()) {
359 initParams->data()->mIsppMeasParams->data()->frame_id = 0;
360 }
361 #endif
362 applyAnalyzerResult(initParams, true);
363 } else if (_state == AIQ_STATE_STARTED) {
364 return ret;
365 }
366
367 if (mTbInfo.is_pre_aiq) {
368 #ifndef DISABLE_RESULT_APPLY_THREADS
369 bool bret = mAiqRstAppTh->start();
370 ret = bret ? XCAM_RETURN_NO_ERROR : XCAM_RETURN_ERROR_FAILED;
371 RKAIQMNG_CHECK_RET(ret, "apply result thread start error");
372 #endif
373 }
374
375 ret = mRkAiqAnalyzer->start();
376 RKAIQMNG_CHECK_RET(ret, "analyzer start error %d", ret);
377
378 #ifdef ISP_HW_V20
379 if (mRkLumaAnalyzer.ptr()) {
380 ret = mRkLumaAnalyzer->start();
381 RKAIQMNG_CHECK_RET(ret, "luma analyzer start error %d", ret);
382 }
383 #endif
384 ret = mCamHw->start();
385 RKAIQMNG_CHECK_RET(ret, "camhw start error %d", ret);
386
387 if (!mTbInfo.is_pre_aiq) {
388 #ifndef DISABLE_RESULT_APPLY_THREADS
389 mAiqRstAppTh->triger_start();
390
391 bool bret = mAiqRstAppTh->start();
392 ret = bret ? XCAM_RETURN_NO_ERROR : XCAM_RETURN_ERROR_FAILED;
393 RKAIQMNG_CHECK_RET(ret, "apply result thread start error");
394 #endif
395 }
396
397 _state = AIQ_STATE_STARTED;
398
399 EXIT_XCORE_FUNCTION();
400
401 return ret;
402 }
403
404 XCamReturn
stop(bool keep_ext_hw_st)405 RkAiqManager::stop(bool keep_ext_hw_st)
406 {
407 ENTER_XCORE_FUNCTION();
408
409 XCamReturn ret = XCAM_RETURN_NO_ERROR;
410
411 if (_state == AIQ_STATE_STOPED) {
412 return ret;
413 }
414
415 #ifndef DISABLE_RESULT_APPLY_THREADS
416 mAiqRstAppTh->triger_stop();
417 bool bret = mAiqRstAppTh->stop();
418 ret = bret ? XCAM_RETURN_NO_ERROR : XCAM_RETURN_ERROR_FAILED;
419 RKAIQMNG_CHECK_RET(ret, "apply result thread stop error");
420 #endif
421 ret = mRkAiqAnalyzer->stop();
422 RKAIQMNG_CHECK_RET(ret, "analyzer stop error %d", ret);
423
424 #ifdef ISP_HW_V20
425 if (mRkLumaAnalyzer.ptr()) {
426 ret = mRkLumaAnalyzer->stop();
427 RKAIQMNG_CHECK_RET(ret, "luma analyzer stop error %d", ret);
428 }
429 #endif
430 mCamHw->keepHwStAtStop(keep_ext_hw_st);
431 ret = mCamHw->stop();
432 RKAIQMNG_CHECK_RET(ret, "camhw stop error %d", ret);
433
434 mDleayCpslParams = NULL;
435
436 _state = AIQ_STATE_STOPED;
437
438 EXIT_XCORE_FUNCTION();
439
440 return ret;
441 }
442
443 XCamReturn
deInit()444 RkAiqManager::deInit()
445 {
446 ENTER_XCORE_FUNCTION();
447
448 XCamReturn ret = XCAM_RETURN_NO_ERROR;
449
450 // stop first in prepared status, some resources and process were
451 // done at prepare stage
452 if (_state == AIQ_STATE_PREPARED)
453 stop(false);
454
455 mAiqMngCmdTh->triger_stop();
456
457 bool bret = mAiqMngCmdTh->stop();
458 ret = bret ? XCAM_RETURN_NO_ERROR : XCAM_RETURN_ERROR_FAILED;
459 RKAIQMNG_CHECK_RET(ret, "cmd thread stop error");
460
461 ret = mRkAiqAnalyzer->deInit();
462 RKAIQMNG_CHECK_RET(ret, "analyzer deinit error %d", ret);
463
464 #ifdef ISP_HW_V20
465 if (mRkLumaAnalyzer.ptr()) {
466 ret = mRkLumaAnalyzer->deInit();
467 RKAIQMNG_CHECK_RET(ret, "luma analyzer deinit error %d", ret);
468 }
469 #endif
470 ret = mCamHw->deInit();
471 RKAIQMNG_CHECK_RET(ret, "camhw deinit error %d", ret);
472 if (mCalibDbV2) {
473 delete mCalibDbV2;
474 mCalibDbV2 = NULL;
475 }
476 if (tuningCalib) {
477 RkAiqCalibDbV2::FreeCalibByJ2S(tuningCalib);
478 mCalibDbV2 = NULL;
479 }
480
481 _state = AIQ_STATE_INVALID;
482
483 EXIT_XCORE_FUNCTION();
484
485 return ret;
486 }
487
488 XCamReturn
updateCalibDb(const CamCalibDbV2Context_t * newCalibDb)489 RkAiqManager::updateCalibDb(const CamCalibDbV2Context_t* newCalibDb)
490 {
491 XCamReturn ret = XCAM_RETURN_NO_ERROR;
492 auto update_list = std::make_shared<std::list<std::string>>();
493 update_list->push_back("colorAsGrey");
494
495 *mCalibDbV2 = *(CamCalibDbV2Context_t*)newCalibDb;
496 mCamHw->setCalib(newCalibDb);
497
498 ret = mRkAiqAnalyzer->setCalib(mCalibDbV2);
499
500 if (!mRkAiqAnalyzer->isRunningState()) {
501 mRkAiqAnalyzer->updateCalibDbBrutal(mCalibDbV2);
502 } else {
503 mRkAiqAnalyzer->calibTuning(mCalibDbV2, update_list);
504 }
505
506 EXIT_XCORE_FUNCTION();
507 return XCAM_RETURN_NO_ERROR;
508 }
509
510 XCamReturn
syncSofEvt(SmartPtr<VideoBuffer> & hwres)511 RkAiqManager::syncSofEvt(SmartPtr<VideoBuffer>& hwres)
512 {
513 ENTER_XCORE_FUNCTION();
514
515 if (hwres->_buf_type == ISP_POLL_SOF) {
516 xcam_get_runtime_log_level();
517 SmartPtr<CamHwIsp20> mCamHwIsp20 = mCamHw.dynamic_cast_ptr<CamHwIsp20>();
518 mCamHwIsp20->notify_sof(hwres);
519
520 SmartPtr<SofEventBuffer> evtbuf = hwres.dynamic_cast_ptr<SofEventBuffer>();
521 SmartPtr<SofEventData> evtdata = evtbuf->get_data();
522 SmartPtr<ispHwEvt_t> hw_evt = mCamHwIsp20->make_ispHwEvt(evtdata->_frameid, V4L2_EVENT_FRAME_SYNC, evtdata->_timestamp);
523 mRkAiqAnalyzer->pushEvts(hw_evt);
524
525 // TODO: moved to aiq core ?
526 if (mMetasCb) {
527 rk_aiq_metas_t metas;
528 metas.frame_id = hwres->get_sequence();
529 #ifdef ANDROID_OS
530 mMetasCb(&metas);
531 #else
532 (*mMetasCb)(&metas);
533 #endif
534 }
535 }
536
537 EXIT_XCORE_FUNCTION();
538 return XCAM_RETURN_NO_ERROR;
539 }
540
541 XCamReturn
hwResCb(SmartPtr<VideoBuffer> & hwres)542 RkAiqManager::hwResCb(SmartPtr<VideoBuffer>& hwres)
543 {
544 ENTER_XCORE_FUNCTION();
545 XCamReturn ret = XCAM_RETURN_NO_ERROR;
546
547 if (hwres->_buf_type == ISP_POLL_3A_STATS) {
548 if (mTbInfo.is_pre_aiq) {
549 uint32_t seq = -1;
550 seq = hwres.dynamic_cast_ptr<VideoBuffer>()->get_sequence();
551 if (seq == 0 && mTBStatsCnt == 0) {
552 LOGE("<TB> tb hwResCb stats %d\n", seq);
553 struct timespec tp;
554 clock_gettime(CLOCK_MONOTONIC_RAW, &tp);
555
556 SmartPtr<CamHwIsp20> mCamHwIsp20 =
557 mCamHw.dynamic_cast_ptr<CamHwIsp20>();
558 SmartPtr<ispHwEvt_t> hw_evt = mCamHwIsp20->make_ispHwEvt(
559 0, V4L2_EVENT_FRAME_SYNC,
560 tp.tv_sec * 1000 * 1000 * 1000 + tp.tv_nsec);
561 LOGE("<TB> push sof %d\n", seq);
562 mRkAiqAnalyzer->pushEvts(hw_evt);
563 }
564
565 if (mTBStatsCnt == 0) ret = mRkAiqAnalyzer->pushStats(hwres);
566
567 mTBStatsCnt++;
568 } else {
569 ret = mRkAiqAnalyzer->pushStats(hwres);
570 }
571 #ifdef ISP_HW_V20
572 } else if (hwres->_buf_type == ISP_POLL_LUMA) {
573 if (mRkLumaAnalyzer.ptr())
574 ret = mRkLumaAnalyzer->pushStats(hwres);
575 #endif
576 } else if (hwres->_buf_type == ISP_POLL_PARAMS) {
577 rk_aiq_err_msg_t msg;
578 msg.err_code = XCAM_RETURN_BYPASS;
579 if (mTbInfo.is_pre_aiq && mErrCb)
580 (*mErrCb)(&msg);
581 } else if (hwres->_buf_type == ISPP_POLL_NR_STATS) {
582 ret = mRkAiqAnalyzer->pushStats(hwres);
583 } else if (hwres->_buf_type == ISP_POLL_SOF) {
584 SmartPtr<CamHwIsp20> mCamHwIsp20 = mCamHw.dynamic_cast_ptr<CamHwIsp20>();
585 mCamHwIsp20->notify_sof(hwres);
586
587 SmartPtr<SofEventBuffer> evtbuf = hwres.dynamic_cast_ptr<SofEventBuffer>();
588 SmartPtr<SofEventData> evtdata = evtbuf->get_data();
589 SmartPtr<ispHwEvt_t> hw_evt = mCamHwIsp20->make_ispHwEvt(evtdata->_frameid, V4L2_EVENT_FRAME_SYNC, evtdata->_timestamp);
590
591 if (evtdata->_frameid % 100 == 0)
592 xcam_get_runtime_log_level();
593
594 if (mTbInfo.is_pre_aiq) {
595 LOGE("<TB> skip real sof %d\n", evtdata->_frameid);
596 return ret;
597 }
598 mRkAiqAnalyzer->pushEvts(hw_evt);
599 // TODO: moved to aiq core ?
600 if (mMetasCb) {
601 rk_aiq_metas_t metas;
602 metas.frame_id = evtdata->_frameid;
603 #ifdef ANDROID_OS
604 mMetasCb(&metas);
605 #else
606 (*mMetasCb)(&metas);
607 #endif
608 }
609 } else if (hwres->_buf_type == ISP_POLL_TX) {
610 #if 0
611 XCamVideoBuffer* camVBuf = convert_to_XCamVideoBuffer(hwres);
612 LOGD_ANALYZER("raw: \n format: 0x%x\n color_bits: %d\n width: %d\n height: %d\n aligned_width: %d\naligned_height: %d\n"
613 "size: %d\n components: %d\n strides[0]: %d\n strides[1]: %d\n offset[0]: %d\n offset[1]: %d\n",
614 camVBuf->info.format, camVBuf->info.color_bits, camVBuf->info.width, camVBuf->info.height,
615 camVBuf->info.aligned_width, camVBuf->info.aligned_height, camVBuf->info.size, camVBuf->info.components,
616 camVBuf->info.strides[0], camVBuf->info.strides[1], camVBuf->info.offsets[0], camVBuf->info.offsets[1]);
617
618 camVBuf->unref(camVBuf);
619 #endif
620 ret = mRkAiqAnalyzer->pushStats(hwres);
621 } else if (hwres->_buf_type == ISP_POLL_SP) {
622 #if 0
623 XCamVideoBuffer* camVBuf = convert_to_XCamVideoBuffer(hwres);
624 LOGD_ANALYZER("spimg: frameid:%d \n format: 0x%x\n color_bits: %d\n width: %d\n height: %d\n aligned_width: %d\naligned_height: %d\n"
625 "size: %d\n components: %d\n strides[0]: %d\n strides[1]: %d\n offset[0]: %d\n offset[1]: %d\n", hwres->get_sequence(),
626 camVBuf->info.format, camVBuf->info.color_bits, camVBuf->info.width, camVBuf->info.height,
627 camVBuf->info.aligned_width, camVBuf->info.aligned_height, camVBuf->info.size, camVBuf->info.components,
628 camVBuf->info.strides[0], camVBuf->info.strides[1], camVBuf->info.offsets[0], camVBuf->info.offsets[1]);
629 camVBuf->unref(camVBuf);
630 #endif
631 LOGD_ANALYZER("ISP_IMG");
632 ret = mRkAiqAnalyzer->pushStats(hwres);
633 } else if (hwres->_buf_type == ISP_NR_IMG) {
634 #if 0
635 XCamVideoBuffer* camVBuf = convert_to_XCamVideoBuffer(hwres);
636 LOGD_ANALYZER("nrimg: \n format: 0x%x\n color_bits: %d\n width: %d\n height: %d\n aligned_width: %d\naligned_height: %d\n"
637 "size: %d\n components: %d\n strides[0]: %d\n strides[1]: %d\n offset[0]: %d\n offset[1]: %d\n",
638 camVBuf->info.format, camVBuf->info.color_bits, camVBuf->info.width, camVBuf->info.height,
639 camVBuf->info.aligned_width, camVBuf->info.aligned_height, camVBuf->info.size, camVBuf->info.components,
640 camVBuf->info.strides[0], camVBuf->info.strides[1], camVBuf->info.offsets[0], camVBuf->info.offsets[1]);
641 camVBuf->unref(camVBuf);
642 #endif
643 ret = mRkAiqAnalyzer->pushStats(hwres);
644 } else if (hwres->_buf_type == ISP_GAIN) {
645 LOGD_ANALYZER("ISP_GAIN");
646 ret = mRkAiqAnalyzer->pushStats(hwres);
647 } else if (hwres->_buf_type == ISPP_GAIN_WR) {
648 LOGD_ANALYZER("ISPP_GAIN_WR");
649 ret = mRkAiqAnalyzer->pushStats(hwres);
650 } else if (hwres->_buf_type == ISPP_GAIN_KG) {
651 LOGD_ANALYZER("ISPP_GAIN_KG");
652 ret = mRkAiqAnalyzer->pushStats(hwres);
653 #if RKAIQ_HAVE_PDAF
654 } else if (hwres->_buf_type == ISP_POLL_PDAF_STATS) {
655 LOGD_ANALYZER("ISP_POLL_PDAF_STATS");
656 ret = mRkAiqAnalyzer->pushStats(hwres);
657 #endif
658 } else if (hwres->_buf_type == VICAP_STREAM_ON_EVT) {
659 LOGD_ANALYZER("VICAP_STREAM_ON_EVT ... ");
660 if (mHwEvtCb) {
661 rk_aiq_hwevt_t hwevt;
662 memset(&hwevt, 0, sizeof(hwevt));
663 hwevt.cam_id = mCamHw->getCamPhyId();
664 #ifdef RKAIQ_ENABLE_CAMGROUP
665 if (mCamGroupCoreManager) {
666 mCamGroupCoreManager->setVicapReady(&hwevt);
667 if (mCamGroupCoreManager->isAllVicapReady())
668 hwevt.aiq_status = RK_AIQ_STATUS_VICAP_READY;
669 else
670 hwevt.aiq_status = 0;
671 } else
672 hwevt.aiq_status = RK_AIQ_STATUS_VICAP_READY;
673 #else
674 hwevt.aiq_status = RK_AIQ_STATUS_VICAP_READY;
675 #endif
676 hwevt.ctx = mHwEvtCbCtx;
677 (*mHwEvtCb)(&hwevt);
678 }
679 } else if (hwres->_buf_type == VICAP_RESET_EVT) {
680 LOGD_ANALYZER(" VICAP_RESET_EVT... ");
681 if (mHwEvtCb) {
682 rk_aiq_hwevt_t hwevt;
683
684 memset(&hwevt, 0, sizeof(hwevt));
685 hwevt.cam_id = mCamHw->getCamPhyId();
686 hwevt.aiq_status = RK_AIQ_STATUS_VICAP_RESET;
687 hwevt.ctx = mHwEvtCbCtx;
688
689 LOGE_ANALYZER("cam: %d, VICAP_RESET_EVT...", hwevt.cam_id);
690 (*mHwEvtCb)(&hwevt);
691 }
692 } else if (hwres->_buf_type == VICAP_WITH_RK1608_RESET_EVT) {
693 LOGD_ANALYZER(" VICAP_WITH_RK1608_RESET_EVT... ");
694 SmartPtr<CamHwIsp20> mCamHwIsp20 = mCamHw.dynamic_cast_ptr<CamHwIsp20>();
695 if (mHwEvtCb && mCamHwIsp20.ptr()) {
696 rk_aiq_hwevt_t hwevt;
697
698 memset(&hwevt, 0, sizeof(hwevt));
699 for(int id = 0; id < 8; id++)
700 hwevt.multi_cam.multi_cam_id[id] = -1;
701
702 int i = 0;
703 for(int camPhyId = 0; camPhyId < CAM_INDEX_FOR_1608; camPhyId++) {
704 if (CamHwIsp20::rk1608_share_inf.raw_proc_unit[camPhyId]) {
705 hwevt.multi_cam.multi_cam_id[i++] = camPhyId;
706 }
707 }
708 hwevt.multi_cam.cam_count = i;
709 hwevt.cam_id = -1;
710 hwevt.aiq_status = RK_AIQ_STATUS_VICAP_WITH_MULTI_CAM_RESET;
711 hwevt.ctx = mHwEvtCbCtx;
712
713 for (i = 0; i < 8; i++) {
714 LOGV_ANALYZER("multi_cam_id[%d]: %d \n", i, hwevt.multi_cam.multi_cam_id[i]);
715 }
716
717 (*mHwEvtCb)(&hwevt);
718 }
719 } else if (hwres->_buf_type == VICAP_POLL_SCL) {
720 ret = mRkAiqAnalyzer->pushStats(hwres);
721 }
722
723 EXIT_XCORE_FUNCTION();
724
725 return ret;
726 }
727
728 XCamReturn
applyAnalyzerResult(SmartPtr<RkAiqFullParamsProxy> & results,bool ignoreIsUpdate)729 RkAiqManager::applyAnalyzerResult(SmartPtr<RkAiqFullParamsProxy>& results, bool ignoreIsUpdate)
730 {
731 ENTER_XCORE_FUNCTION();
732 //xcam_get_runtime_log_level();
733 XCamReturn ret = XCAM_RETURN_NO_ERROR;
734 RkAiqFullParams* aiqParams = NULL;
735
736 if (!results.ptr()) {
737 LOGW_ANALYZER("empty aiq params results!");
738 return ret;
739 }
740
741 aiqParams = results->data().ptr();
742 cam3aResultList results_list;
743
744 if (aiqParams->mExposureParams.ptr()) {
745 aiqParams->mExposureParams->setType(RESULT_TYPE_EXPOSURE_PARAM);
746 results_list.push_back(aiqParams->mExposureParams);
747 }
748
749 if (aiqParams->mIrisParams.ptr()) {
750 aiqParams->mIrisParams->setType(RESULT_TYPE_IRIS_PARAM);
751 results_list.push_back(aiqParams->mIrisParams);
752 }
753
754 if (aiqParams->mFocusParams.ptr() && (ignoreIsUpdate || aiqParams->mFocusParams->data()->is_update)) {
755 aiqParams->mFocusParams->setType(RESULT_TYPE_FOCUS_PARAM);
756 aiqParams->mFocusParams->data()->is_update = false;
757 results_list.push_back(aiqParams->mFocusParams);
758 }
759
760
761 #define APPLY_ANALYZER_RESULT(lc, BC) \
762 if (aiqParams->m##lc##Params.ptr() && (ignoreIsUpdate || aiqParams->m##lc##Params->data()->is_update)) { \
763 LOGD("new result type: %s", #BC);\
764 aiqParams->m##lc##Params->setType(RESULT_TYPE_##BC##_PARAM); \
765 aiqParams->m##lc##Params->setId(aiqParams->mFrmId); \
766 aiqParams->m##lc##Params->data()->is_update = false; \
767 results_list.push_back(aiqParams->m##lc##Params); \
768 } \
769
770 #if RKAIQ_HAVE_ASD_V10
771 APPLY_ANALYZER_RESULT(Cpsl, CPSL);
772 #endif
773
774 #if RKAIQ_HAVE_AE_V1
775 APPLY_ANALYZER_RESULT(Aec, AEC);
776 APPLY_ANALYZER_RESULT(Hist, HIST);
777 #endif
778 #if RKAIQ_HAVE_AWB_V20
779 APPLY_ANALYZER_RESULT(Awb, AWB);
780 #endif
781 APPLY_ANALYZER_RESULT(AwbGain, AWBGAIN);
782 #if RKAIQ_HAVE_AF_V20 || RKAIQ_ONLY_AF_STATS_V20
783 APPLY_ANALYZER_RESULT(Af, AF);
784 #endif
785 #if RKAIQ_HAVE_DPCC_V1
786 APPLY_ANALYZER_RESULT(Dpcc, DPCC);
787 #endif
788 #if (RKAIQ_HAVE_MERGE_V10 | RKAIQ_HAVE_MERGE_V11 | RKAIQ_HAVE_MERGE_V12)
789 APPLY_ANALYZER_RESULT(Merge, MERGE);
790 #endif
791 #if RKAIQ_HAVE_TMO_V1
792 APPLY_ANALYZER_RESULT(Tmo, TMO);
793 #endif
794 #if RKAIQ_HAVE_CCM_V1
795 APPLY_ANALYZER_RESULT(Ccm, CCM);
796 #endif
797 #if RKAIQ_HAVE_BLC_V1
798 APPLY_ANALYZER_RESULT(Blc, BLC);
799 #endif
800 #if RKAIQ_HAVE_ANR_V1
801 APPLY_ANALYZER_RESULT(Rawnr, RAWNR);
802 #endif
803 #if (RKAIQ_HAVE_GIC_V1 || RKAIQ_HAVE_GIC_V2)
804 APPLY_ANALYZER_RESULT(Gic, GIC);
805 #endif
806 #if RKAIQ_HAVE_DEBAYER_V1
807 APPLY_ANALYZER_RESULT(Debayer, DEBAYER);
808 #endif
809 #if RKAIQ_HAVE_LDCH_V10
810 APPLY_ANALYZER_RESULT(Ldch, LDCH);
811 #endif
812 #if RKAIQ_HAVE_3DLUT_V1
813 APPLY_ANALYZER_RESULT(Lut3d, LUT3D);
814 #endif
815 #if (RKAIQ_HAVE_DEHAZE_V10 | RKAIQ_HAVE_DEHAZE_V11 | RKAIQ_HAVE_DEHAZE_V11_DUO | RKAIQ_HAVE_DEHAZE_V12)
816 APPLY_ANALYZER_RESULT(Dehaze, DEHAZE);
817 #endif
818 #if (RKAIQ_HAVE_GAMMA_V10 | RKAIQ_HAVE_GAMMA_V11)
819 APPLY_ANALYZER_RESULT(Agamma, AGAMMA);
820 #endif
821 #if RKAIQ_HAVE_DEGAMMA_V1
822 APPLY_ANALYZER_RESULT(Adegamma, ADEGAMMA);
823 #endif
824 #if RKAIQ_HAVE_WDR_V1
825 APPLY_ANALYZER_RESULT(Wdr, WDR);
826 #endif
827 #if RKAIQ_HAVE_CSM_V1
828 APPLY_ANALYZER_RESULT(Csm, CSM);
829 #endif
830 #if RKAIQ_HAVE_CGC_V1
831 APPLY_ANALYZER_RESULT(Cgc, CGC);
832 #endif
833 APPLY_ANALYZER_RESULT(Conv422, CONV422);
834 APPLY_ANALYZER_RESULT(Yuvconv, YUVCONV);
835 #if RKAIQ_HAVE_GAIN_V1
836 APPLY_ANALYZER_RESULT(Gain, GAIN);
837 #endif
838 #if RKAIQ_HAVE_ACP_V10
839 APPLY_ANALYZER_RESULT(Cp, CP);
840 #endif
841 #if RKAIQ_HAVE_AIE_V10
842 APPLY_ANALYZER_RESULT(Ie, IE);
843 #endif
844 #if RKAIQ_HAVE_AMD_V1
845 APPLY_ANALYZER_RESULT(Motion, MOTION);
846 #endif
847 #if RKAIQ_HAVE_ANR_V1
848 APPLY_ANALYZER_RESULT(Tnr, TNR);
849 APPLY_ANALYZER_RESULT(Ynr, YNR);
850 APPLY_ANALYZER_RESULT(Uvnr, UVNR);
851 APPLY_ANALYZER_RESULT(Sharpen, SHARPEN);
852 APPLY_ANALYZER_RESULT(Edgeflt, EDGEFLT);
853 #endif
854 #if RKAIQ_HAVE_FEC_V10
855 APPLY_ANALYZER_RESULT(Fec, FEC);
856 #endif
857 #if RKAIQ_HAVE_ORB_V1
858 APPLY_ANALYZER_RESULT(Orb, ORB);
859 #endif
860 #if RKAIQ_HAVE_TMO_V1
861 APPLY_ANALYZER_RESULT(Tmo, TMO);
862 #endif
863 // ispv21
864 #if (RKAIQ_HAVE_DRC_V10 || RKAIQ_HAVE_DRC_V11 || RKAIQ_HAVE_DRC_V12 || RKAIQ_HAVE_DRC_V12_LITE)
865 APPLY_ANALYZER_RESULT(Drc, DRC);
866 #endif
867 #if RKAIQ_HAVE_AWB_V21
868 APPLY_ANALYZER_RESULT(AwbV21, AWB);
869 #endif
870 #if RKAIQ_HAVE_YNR_V2
871 APPLY_ANALYZER_RESULT(YnrV21, YNR);
872 #endif
873 #if RKAIQ_HAVE_CNR_V1
874 APPLY_ANALYZER_RESULT(CnrV21, UVNR);
875 #endif
876 #if RKAIQ_HAVE_SHARP_V3
877 APPLY_ANALYZER_RESULT(SharpenV21, SHARPEN);
878 #endif
879 #if RKAIQ_HAVE_BAYERNR_V2
880 APPLY_ANALYZER_RESULT(BaynrV21, RAWNR);
881 #endif
882 // ispv3x
883 #if RKAIQ_HAVE_AWB_V21
884 APPLY_ANALYZER_RESULT(AwbV3x, AWB);
885 #endif
886 #if RKAIQ_HAVE_BLC_V1
887 APPLY_ANALYZER_RESULT(BlcV21, BLC);
888 #endif
889 #if (RKAIQ_HAVE_LSC_V1 | RKAIQ_HAVE_LSC_V2 | RKAIQ_HAVE_LSC_V3)
890 APPLY_ANALYZER_RESULT(Lsc, LSC);
891 #endif
892 #if RKAIQ_HAVE_AF_V30 || RKAIQ_ONLY_AF_STATS_V30
893 APPLY_ANALYZER_RESULT(AfV3x, AF);
894 #endif
895 #if RKAIQ_HAVE_BAYER2DNR_V2
896 APPLY_ANALYZER_RESULT(BaynrV3x, RAWNR);
897 #endif
898 #if RKAIQ_HAVE_YNR_V3
899 APPLY_ANALYZER_RESULT(YnrV3x, YNR);
900 #endif
901 #if RKAIQ_HAVE_CNR_V2
902 APPLY_ANALYZER_RESULT(CnrV3x, UVNR);
903 #endif
904 #if RKAIQ_HAVE_SHARP_V4
905 APPLY_ANALYZER_RESULT(SharpenV3x, SHARPEN);
906 #endif
907 #if RKAIQ_HAVE_CAC_V03
908 APPLY_ANALYZER_RESULT(CacV3x, CAC);
909 #endif
910 #if RKAIQ_HAVE_GAIN_V2
911 APPLY_ANALYZER_RESULT(GainV3x, GAIN);
912 #endif
913 #if RKAIQ_HAVE_BAYERTNR_V2
914 APPLY_ANALYZER_RESULT(TnrV3x, TNR);
915 #endif
916 // ispv32
917 #if RKAIQ_HAVE_BLC_V32
918 APPLY_ANALYZER_RESULT(BlcV32, BLC);
919 #endif
920 #if (RKAIQ_HAVE_BAYERTNR_V23 || RKAIQ_HAVE_BAYERTNR_V23_LITE)
921 APPLY_ANALYZER_RESULT(TnrV32, TNR);
922 #endif
923 #if RKAIQ_HAVE_BAYER2DNR_V23
924 APPLY_ANALYZER_RESULT(BaynrV32, RAWNR);
925 #endif
926 #if RKAIQ_HAVE_CAC_V11
927 APPLY_ANALYZER_RESULT(CacV32, CAC);
928 #endif
929 #if RKAIQ_HAVE_DEBAYER_V2 || RKAIQ_HAVE_DEBAYER_V2_LITE
930 APPLY_ANALYZER_RESULT(DebayerV32, DEBAYER);
931 #endif
932 #if RKAIQ_HAVE_CCM_V2
933 APPLY_ANALYZER_RESULT(CcmV32, CCM);
934 #endif
935 // APPLY_ANALYZER_RESULT(DehazeV32, DEHAZE);
936 #if RKAIQ_HAVE_LDCH_V21
937 APPLY_ANALYZER_RESULT(LdchV32, LDCH);
938 #endif
939 #if RKAIQ_HAVE_YNR_V22
940 APPLY_ANALYZER_RESULT(YnrV32, YNR);
941 #endif
942 #if (RKAIQ_HAVE_CNR_V30 || RKAIQ_HAVE_CNR_V30_LITE)
943 APPLY_ANALYZER_RESULT(CnrV32, UVNR);
944 #endif
945 #if (RKAIQ_HAVE_SHARP_V33 || RKAIQ_HAVE_SHARP_V33_LITE)
946 APPLY_ANALYZER_RESULT(SharpV32, SHARPEN);
947 #endif
948 #if RKAIQ_HAVE_AWB_V32
949 APPLY_ANALYZER_RESULT(AwbV32, AWB);
950 #endif
951 #if RKAIQ_HAVE_AF_V31 || RKAIQ_ONLY_AF_STATS_V31
952 APPLY_ANALYZER_RESULT(AfV32, AF);
953 #endif
954 #if RKAIQ_HAVE_AWB_V32
955 APPLY_ANALYZER_RESULT(AwbGainV32, AWBGAIN);
956 #endif
957 #if RKAIQ_HAVE_AF_V32_LITE || RKAIQ_ONLY_AF_STATS_V32_LITE
958 APPLY_ANALYZER_RESULT(AfV32Lite, AF);
959 #endif
960 #if RKAIQ_HAVE_AFD_V1 || RKAIQ_HAVE_AFD_V2
961 APPLY_ANALYZER_RESULT(Afd, AFD);
962 #endif
963 mCamHw->applyAnalyzerResult(results_list);
964
965 EXIT_XCORE_FUNCTION();
966
967 return ret;
968 }
969
970 void
rkAiqCalcDone(SmartPtr<RkAiqFullParamsProxy> & results)971 RkAiqManager::rkAiqCalcDone(SmartPtr<RkAiqFullParamsProxy> &results)
972 {
973 ENTER_XCORE_FUNCTION();
974
975 #ifndef DISABLE_RESULT_APPLY_THREADS
976 XCAM_ASSERT (mAiqRstAppTh.ptr());
977 mAiqRstAppTh->push_results(results);
978 #else
979 applyAnalyzerResult(results);
980 #endif
981 EXIT_XCORE_FUNCTION();
982 }
983
984 void
rkAiqCalcFailed(const char * msg)985 RkAiqManager::rkAiqCalcFailed(const char* msg)
986 {
987 ENTER_XCORE_FUNCTION();
988 // TODO
989 EXIT_XCORE_FUNCTION();
990 return ;
991 }
992
993 void
rkLumaCalcDone(rk_aiq_luma_params_t luma_params)994 RkAiqManager::rkLumaCalcDone(rk_aiq_luma_params_t luma_params)
995 {
996 ENTER_XCORE_FUNCTION();
997 XCamReturn ret = XCAM_RETURN_NO_ERROR;
998 ret = mCamHw->setHdrProcessCount(luma_params);
999 EXIT_XCORE_FUNCTION();
1000 }
1001
1002 void
rkLumaCalcFailed(const char * msg)1003 RkAiqManager::rkLumaCalcFailed(const char* msg)
1004 {
1005 ENTER_XCORE_FUNCTION();
1006 // TODO
1007 EXIT_XCORE_FUNCTION();
1008 return ;
1009 }
1010
1011 XCamReturn
setModuleCtl(rk_aiq_module_id_t mId,bool mod_en)1012 RkAiqManager::setModuleCtl(rk_aiq_module_id_t mId, bool mod_en)
1013 {
1014 ENTER_XCORE_FUNCTION();
1015 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1016 ret = mCamHw->setModuleCtl(mId, mod_en);
1017 EXIT_XCORE_FUNCTION();
1018 return ret;
1019 }
1020
1021 XCamReturn
getModuleCtl(rk_aiq_module_id_t mId,bool & mod_en)1022 RkAiqManager::getModuleCtl(rk_aiq_module_id_t mId, bool& mod_en)
1023 {
1024 ENTER_XCORE_FUNCTION();
1025 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1026 ret = mCamHw->getModuleCtl(mId, mod_en);
1027 EXIT_XCORE_FUNCTION();
1028 return ret;
1029 }
1030
1031 XCamReturn
rawdataPrepare(rk_aiq_raw_prop_t prop)1032 RkAiqManager::rawdataPrepare(rk_aiq_raw_prop_t prop)
1033 {
1034 ENTER_XCORE_FUNCTION();
1035 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1036 ret = mCamHw->rawdataPrepare(prop);
1037 EXIT_XCORE_FUNCTION();
1038 return ret;
1039 }
1040
1041 XCamReturn
enqueueRawBuffer(void * rawdata,bool sync)1042 RkAiqManager::enqueueRawBuffer(void *rawdata, bool sync)
1043 {
1044 ENTER_XCORE_FUNCTION();
1045 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1046 ret = mCamHw->enqueueRawBuffer(rawdata, sync);
1047 EXIT_XCORE_FUNCTION();
1048 return ret;
1049 }
1050
1051 XCamReturn
enqueueRawFile(const char * path)1052 RkAiqManager::enqueueRawFile(const char *path)
1053 {
1054 ENTER_XCORE_FUNCTION();
1055 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1056 ret = mCamHw->enqueueRawFile(path);
1057 EXIT_XCORE_FUNCTION();
1058 return ret;
1059 }
1060
1061 XCamReturn
registRawdataCb(void (* callback)(void *))1062 RkAiqManager::registRawdataCb(void (*callback)(void *))
1063 {
1064 ENTER_XCORE_FUNCTION();
1065 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1066 ret = mCamHw->registRawdataCb(callback);
1067 EXIT_XCORE_FUNCTION();
1068 return ret;
1069 }
1070
setSharpFbcRotation(rk_aiq_rotation_t rot)1071 XCamReturn RkAiqManager::setSharpFbcRotation(rk_aiq_rotation_t rot)
1072 {
1073 #ifndef RK_SIMULATOR_HW
1074 SmartPtr<CamHwIsp20> camHwIsp20 = mCamHw.dynamic_cast_ptr<CamHwIsp20>();
1075
1076 if (camHwIsp20.ptr())
1077 return camHwIsp20->setSharpFbcRotation(rot);
1078 else
1079 return XCAM_RETURN_ERROR_FAILED;
1080 #else
1081 return XCAM_RETURN_ERROR_FAILED;
1082 #endif
1083 }
1084
setMirrorFlip(bool mirror,bool flip,int skip_frm_cnt)1085 XCamReturn RkAiqManager::setMirrorFlip(bool mirror, bool flip, int skip_frm_cnt)
1086 {
1087 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1088 ENTER_XCORE_FUNCTION();
1089 if (_state == AIQ_STATE_INVALID) {
1090 LOGE_ANALYZER("wrong aiq state !");
1091 return XCAM_RETURN_ERROR_FAILED;
1092 }
1093 ret = mCamHw->setSensorFlip(mirror, flip, skip_frm_cnt);
1094 if (ret == XCAM_RETURN_NO_ERROR) {
1095 // notify aiq sensor flip is changed
1096 mRkAiqAnalyzer->setSensorFlip(mirror, flip);
1097 mCurMirror = mirror;
1098 mCurFlip = flip;
1099 } else {
1100 LOGW_ANALYZER("set mirror %d, flip %d error", mirror, flip);
1101 }
1102 return ret;
1103 EXIT_XCORE_FUNCTION();
1104 }
1105
getMirrorFlip(bool & mirror,bool & flip)1106 XCamReturn RkAiqManager::getMirrorFlip(bool& mirror, bool& flip)
1107 {
1108 ENTER_XCORE_FUNCTION();
1109 if (_state == AIQ_STATE_INVALID) {
1110 LOGE_ANALYZER("wrong aiq state !");
1111 return XCAM_RETURN_ERROR_FAILED;
1112 }
1113
1114 mirror = mCurMirror;
1115 flip = mCurFlip;
1116
1117 EXIT_XCORE_FUNCTION();
1118 return XCAM_RETURN_NO_ERROR;
1119 }
1120
setDefMirrorFlip()1121 void RkAiqManager::setDefMirrorFlip()
1122 {
1123 /* set defalut mirror & flip from iq*/
1124 CalibDb_Sensor_ParaV2_t* sensor =
1125 (CalibDb_Sensor_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR(mCalibDbV2, sensor_calib));
1126
1127 if (mTbInfo.prd_type == RK_AIQ_PRD_TYPE_TB_DOORLOCK ||
1128 mTbInfo.prd_type == RK_AIQ_PRD_TYPE_TB_BATIPC) {
1129 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1130
1131 ret = mCamHw->getSensorFlip(mCurMirror, mCurFlip);
1132 if (ret == XCAM_RETURN_NO_ERROR) {
1133 sensor->CISFlip = 0x0;
1134 if (mCurMirror) {
1135 sensor->CISFlip |= 0x1;
1136 }
1137 if (mCurFlip) {
1138 sensor->CISFlip |= 0x2;
1139 }
1140
1141 LOGI_ANALYZER("get mirror %d, flip %d from sensor driver", mCurMirror, mCurFlip);
1142
1143 // notify aiq sensor flip is changed
1144 mRkAiqAnalyzer->setSensorFlip(mCurMirror, mCurFlip);
1145 if (updateCalibDb(mCalibDbV2) < 0) {
1146 LOGW_ANALYZER("Failed to updateCalibDb for update sensor mirror/flip");
1147 }
1148 } else {
1149 LOGW_ANALYZER("Failed to get mirror/flip from sensor driver");
1150 }
1151 } else {
1152 bool def_mirr = sensor->CISFlip & 0x1 ? true : false;
1153 bool def_flip = sensor->CISFlip & 0x2 ? true : false;
1154 setMirrorFlip(def_mirr, def_flip, 0);
1155 }
1156 }
1157
swWorkingModeDyn_msg(rk_aiq_working_mode_t mode)1158 XCamReturn RkAiqManager::swWorkingModeDyn_msg(rk_aiq_working_mode_t mode) {
1159 SmartPtr<RkAiqMngCmdThread::msg_t> msg = new RkAiqMngCmdThread::msg_t();
1160 msg->cmd = RkAiqMngCmdThread::MSG_CMD_SW_WORKING_MODE;
1161 msg->sync = true;
1162 msg->data.sw_wk_mode.mode = mode;
1163 mAiqMngCmdTh->send_cmd(msg);
1164
1165 return XCAM_RETURN_NO_ERROR;
1166 }
1167
swWorkingModeDyn(rk_aiq_working_mode_t mode)1168 XCamReturn RkAiqManager::swWorkingModeDyn(rk_aiq_working_mode_t mode)
1169 {
1170 ENTER_XCORE_FUNCTION();
1171
1172 SmartPtr<RkAiqFullParamsProxy> initParams;
1173 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1174 if (mode == mWorkingMode)
1175 return ret;
1176
1177 if (_state != AIQ_STATE_STARTED) {
1178 LOGW_ANALYZER("should be called at STARTED state");
1179 return ret;
1180 }
1181 // 1. stop analyzer, re-preapre with the new mode
1182 // 2. stop luma analyzer, re-preapre with the new mode
1183 LOGI_ANALYZER("stop analyzer ...");
1184 #ifndef DISABLE_RESULT_APPLY_THREADS
1185 mAiqRstAppTh->triger_stop();
1186 bool bret = mAiqRstAppTh->stop();
1187 ret = bret ? XCAM_RETURN_NO_ERROR : XCAM_RETURN_ERROR_FAILED;
1188 RKAIQMNG_CHECK_RET(ret, "apply result thread stop error");
1189 #endif
1190 ret = mRkAiqAnalyzer->stop();
1191 RKAIQMNG_CHECK_RET(ret, "analyzer stop error %d", ret);
1192
1193 #ifdef ISP_HW_V20
1194 if (mRkLumaAnalyzer.ptr()) {
1195 ret = mRkLumaAnalyzer->stop();
1196 RKAIQMNG_CHECK_RET(ret, "luma analyzer stop error %d", ret);
1197 }
1198 #endif
1199 // 3. pause hwi
1200 LOGI_ANALYZER("pause hwi ...");
1201 ret = mCamHw->pause();
1202 RKAIQMNG_CHECK_RET(ret, "pause hwi error %d", ret);
1203
1204 int working_mode_hw = RK_AIQ_WORKING_MODE_NORMAL;
1205 if (mode == RK_AIQ_WORKING_MODE_ISP_HDR2)
1206 working_mode_hw = RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR;
1207 else if (mode == RK_AIQ_WORKING_MODE_ISP_HDR3)
1208 working_mode_hw = RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR;
1209
1210 // 4. set new mode to hwi
1211 ret = mCamHw->swWorkingModeDyn(working_mode_hw);
1212 if (ret) {
1213 LOGE_ANALYZER("hwi swWorkingModeDyn error ...");
1214 goto restart;
1215 }
1216
1217 // 5. re-prepare analyzer
1218 LOGI_ANALYZER("reprepare analyzer ...");
1219 rk_aiq_exposure_sensor_descriptor sensor_des;
1220 ret = mCamHw->getSensorModeData(mSnsEntName, sensor_des);
1221 mRkAiqAnalyzer->notifyIspStreamMode(mCamHw->getIspStreamMode());
1222 ret = mRkAiqAnalyzer->prepare(&sensor_des, working_mode_hw);
1223 RKAIQMNG_CHECK_RET(ret, "analyzer prepare error %d", ret);
1224
1225 initParams = mRkAiqAnalyzer->getAiqFullParams();
1226
1227 ret = applyAnalyzerResult(initParams);
1228 RKAIQMNG_CHECK_RET(ret, "set initial params error %d", ret);
1229
1230 restart:
1231 // 6. resume hwi
1232 LOGI_ANALYZER("resume hwi");
1233 ret = mCamHw->resume();
1234 RKAIQMNG_CHECK_RET(ret, "pause hwi error %d", ret);
1235
1236 // 7. restart analyzer
1237 #ifndef DISABLE_RESULT_APPLY_THREADS
1238 LOGI_ANALYZER("restart analyzer");
1239 mAiqRstAppTh->triger_start();
1240 bret = mAiqRstAppTh->start();
1241 ret = bret ? XCAM_RETURN_NO_ERROR : XCAM_RETURN_ERROR_FAILED;
1242 RKAIQMNG_CHECK_RET(ret, "apply result thread start error");
1243 #endif
1244 ret = mRkAiqAnalyzer->start();
1245 RKAIQMNG_CHECK_RET(ret, "analyzer start error %d", ret);
1246
1247 #ifdef ISP_HW_V20
1248 if (mRkLumaAnalyzer.ptr()) {
1249 ret = mRkLumaAnalyzer->start();
1250 RKAIQMNG_CHECK_RET(ret, "luma analyzer start error %d", ret);
1251 }
1252 #endif
1253 /* // 7. resume hwi */
1254 /* LOGI_ANALYZER("resume hwi"); */
1255 /* ret = mCamHw->resume(); */
1256 /* RKAIQMNG_CHECK_RET(ret, "pause hwi error %d", ret); */
1257
1258 mWorkingMode = mode;
1259 EXIT_XCORE_FUNCTION();
1260 return XCAM_RETURN_NO_ERROR;
1261 }
1262
setMulCamConc(bool cc)1263 void RkAiqManager::setMulCamConc(bool cc)
1264 {
1265 #ifndef RK_SIMULATOR_HW
1266 SmartPtr<CamHwIsp20> camHwIsp20 = mCamHw.dynamic_cast_ptr<CamHwIsp20>();
1267
1268 if (camHwIsp20.ptr())
1269 camHwIsp20->setMulCamConc(cc);
1270
1271 mRkAiqAnalyzer->setMulCamConc(cc);
1272 #endif
1273 }
1274
getCurrentCalibDBV2()1275 CamCalibDbV2Context_t* RkAiqManager::getCurrentCalibDBV2()
1276 {
1277 return mCalibDbV2;
1278 }
1279
calibTuning(CamCalibDbV2Context_t * aiqCalib,ModuleNameList & change_list)1280 XCamReturn RkAiqManager::calibTuning(CamCalibDbV2Context_t* aiqCalib,
1281 ModuleNameList& change_list)
1282 {
1283 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1284
1285 mCamHw->setCalib(aiqCalib);
1286 ret = mRkAiqAnalyzer->setCalib(aiqCalib);
1287
1288 if (change_list != nullptr)
1289 std::for_each(
1290 std::begin(*change_list), std::end(*change_list),
1291 [](const std::string & name) {
1292 std::cout << "tuning : " << name << std::endl;
1293 });
1294 mRkAiqAnalyzer->calibTuning(aiqCalib, change_list);
1295
1296 // Won't free calib witch from iqfiles
1297 RkAiqCalibDbV2::FreeCalibByJ2S(tuningCalib);
1298 *mCalibDbV2 = *aiqCalib;
1299 tuningCalib = const_cast<CamCalibDbV2Context_t*>(aiqCalib);
1300
1301 change_list.reset();
1302
1303 EXIT_XCORE_FUNCTION();
1304
1305 return ret;
1306 }
1307
unsetTuningCalibDb()1308 void RkAiqManager::unsetTuningCalibDb()
1309 {
1310 tuningCalib = NULL;
1311 }
1312
1313 } //namespace RkCam
1314
1315