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
17 #include "rk_aiq_user_api_sysctl.h"
18 #ifdef ANDROID_OS
19 #include <cutils/properties.h>
20 #endif
21 #include "rk_aiq_api_private.h"
22 #include "RkAiqManager.h"
23 #include "socket_server.h"
24 #include "RkAiqCalibDbV2.h"
25 #include "scene/scene_manager.h"
26 #include "rkaiq_ini.h"
27 #ifdef RK_SIMULATOR_HW
28 #include "simulator/CamHwSimulator.h"
29 #else
30 #include "isp20/CamHwIsp20.h"
31 #include "fakecamera/FakeCamHwIsp20.h"
32 #include "isp20/Isp20_module_dbg.h"
33 #include "isp21/CamHwIsp21.h"
34 #include "isp3x/CamHwIsp3x.h"
35 #include "isp32/CamHwIsp32.h"
36 #endif
37 #include "cJSON.h"
38 #include <sys/file.h>
39 #include <fcntl.h>
40
41 using namespace RkCam;
42 using namespace XCam;
43
44 #define RKAIQSYS_CHECK_RET(cond, ret, format, ...) \
45 if ((cond)) { \
46 LOGE(format, ##__VA_ARGS__); \
47 return ret; \
48 }
49
50 #define RKAIQ_DEFAULT_IQ_PATH "/etc/iqfiles/"
51
52 RKAIQ_BEGIN_DECLARE
53
54 int g_rkaiq_isp_hw_ver = 0;
55 bool g_bypass_uapi = false;
56
57 static void _set_fast_aewb_as_init(const rk_aiq_sys_ctx_t* ctx, rk_aiq_working_mode_t mode);
58 static XCamReturn _get_fast_aewb_from_drv(std::string& sensor_name, rkisp32_thunderboot_resmem_head& fastAeAwbInfo);
59
get_next_ctx(const rk_aiq_sys_ctx_t * ctx)60 rk_aiq_sys_ctx_t* get_next_ctx(const rk_aiq_sys_ctx_t* ctx)
61 {
62 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP)
63 return nullptr;
64 else
65 return ctx->next_ctx;
66 }
67
get_binded_group_ctx(const rk_aiq_sys_ctx_t * ctx)68 rk_aiq_camgroup_ctx_t* get_binded_group_ctx(const rk_aiq_sys_ctx_t* ctx)
69 {
70 #ifdef RKAIQ_ENABLE_CAMGROUP
71 if (ctx->_camGroupManager)
72 return (rk_aiq_camgroup_ctx_t*)ctx->_camGroupManager->getContainerCtx();
73 else
74 #endif
75 return NULL;
76 }
77
rk_aiq_ctx_set_tool_mode(const rk_aiq_sys_ctx_t * ctx,bool status)78 void rk_aiq_ctx_set_tool_mode(const rk_aiq_sys_ctx_t* ctx, bool status)
79 {
80 if (!ctx)
81 return;
82
83 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
84 #ifdef RKAIQ_ENABLE_CAMGROUP
85 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
86 for (auto camCtx : camgroup_ctx->cam_ctxs_array)
87 if(camCtx && camCtx->_socket)
88 camCtx->_socket->tool_mode_set(status);
89 #endif
90 } else if(ctx->_socket) {
91 ctx->_socket->tool_mode_set(status);
92 }
93 }
94
is_ctx_need_bypass(const rk_aiq_sys_ctx_t * ctx)95 bool is_ctx_need_bypass(const rk_aiq_sys_ctx_t* ctx)
96 {
97 if (!ctx) {
98 return true;
99 }
100
101 if (!g_bypass_uapi) {
102 return false;
103 }
104
105 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
106 #ifdef RKAIQ_ENABLE_CAMGROUP
107 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
108 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
109 if(camCtx && camCtx->_socket) {
110 if (camCtx->_socket->is_connected() && \
111 camCtx->ctx_type != CTX_TYPE_TOOL_SERVER) {
112 LOG1("bypass the uapi which isn't called by iqtool while socket is connected");
113 return true;
114 }
115 }
116 }
117 #endif
118 } else {
119 if(ctx->_socket) {
120 if (ctx->_socket->is_connected() && \
121 ctx->ctx_type != CTX_TYPE_TOOL_SERVER) {
122 LOG1("bypass the uapi which isn't called by iqtool while socket is connected");
123 return true;
124 }
125 }
126 }
127
128 return false;
129 }
130
131
132 typedef struct rk_aiq_sys_preinit_cfg_s {
133 rk_aiq_working_mode_t mode;
134 std::string force_iq_file;
135 std::string main_scene;
136 std::string sub_scene;
137 rk_aiq_hwevt_cb hwevt_cb;
138 void* hwevt_cb_ctx;
139 void* calib_proj;
rk_aiq_sys_preinit_cfg_srk_aiq_sys_preinit_cfg_s140 rk_aiq_sys_preinit_cfg_s() {
141 mode = RK_AIQ_WORKING_MODE_NORMAL;
142 force_iq_file = "";
143 main_scene = "";
144 sub_scene = "";
145 hwevt_cb = NULL;
146 hwevt_cb_ctx = NULL;
147 calib_proj = NULL;
148 iq_buffer.addr = NULL;
149 iq_buffer.len = 0;
150 tb_info.magic = sizeof(rk_aiq_tb_info_t) - 2;
151 tb_info.is_pre_aiq = false;
152 tb_info.prd_type = RK_AIQ_PRD_TYPE_NORMAL;
153 };
154 rk_aiq_iq_buffer_info_t iq_buffer;
155 rk_aiq_tb_info_t tb_info;
156 std::map<std::string, int> dev_buf_cnt_map;
157 rk_aiq_frame_info_t frame_exp_info[2];
158 } rk_aiq_sys_preinit_cfg_t;
159
160 static std::map<std::string, rk_aiq_sys_preinit_cfg_t> g_rk_aiq_sys_preinit_cfg_map;
161 static void rk_aiq_init_lib(void) /*__attribute__((constructor))*/;
162 static void rk_aiq_deinit_lib(void) /*__attribute__((destructor))*/;
163 static bool g_rk_aiq_init_lib = false;
164 static std::map<std::string, rk_aiq_sys_preinit_cfg_t> g_rk_aiq_offline_raw_exp_map;
165
166 XCamReturn
rk_aiq_uapi_sysctl_preInit(const char * sns_ent_name,rk_aiq_working_mode_t mode,const char * force_iq_file)167 rk_aiq_uapi_sysctl_preInit(const char* sns_ent_name,
168 rk_aiq_working_mode_t mode,
169 const char* force_iq_file)
170 {
171 std::string sns_ent_name_str(sns_ent_name);
172 rk_aiq_sys_preinit_cfg_t cfg;
173
174 cfg.mode = mode;
175 if (force_iq_file)
176 cfg.force_iq_file = force_iq_file;
177 g_rk_aiq_sys_preinit_cfg_map[sns_ent_name_str] = cfg;
178
179 return XCAM_RETURN_NO_ERROR;
180 }
181
182
183 XCamReturn
rk_aiq_uapi_sysctl_preInit_scene(const char * sns_ent_name,const char * main_scene,const char * sub_scene)184 rk_aiq_uapi_sysctl_preInit_scene(const char* sns_ent_name, const char *main_scene,
185 const char *sub_scene)
186 {
187 XCamReturn ret = XCAM_RETURN_NO_ERROR;
188
189 if (!sns_ent_name || !main_scene || !sub_scene) {
190 LOGE("Invalid input parameter");
191 return XCAM_RETURN_ERROR_PARAM;
192 }
193
194 std::string sns_ent_name_str(sns_ent_name);
195
196 LOGI("main_scene: %s, sub_scene: %s", main_scene, sub_scene);
197 g_rk_aiq_sys_preinit_cfg_map[sns_ent_name_str].main_scene = main_scene;
198 g_rk_aiq_sys_preinit_cfg_map[sns_ent_name_str].sub_scene = sub_scene;
199
200 return (ret);
201 }
202
203 XCamReturn
rk_aiq_uapi_sysctl_preInit_tb_info(const char * sns_ent_name,const rk_aiq_tb_info_t * info)204 rk_aiq_uapi_sysctl_preInit_tb_info(const char* sns_ent_name,
205 const rk_aiq_tb_info_t* info)
206 {
207 XCamReturn ret = XCAM_RETURN_NO_ERROR;
208 rkisp32_thunderboot_resmem_head fastAeAwbInfo;
209
210 if (!sns_ent_name || !info) {
211 LOGE("Invalid input parameter");
212 return XCAM_RETURN_ERROR_PARAM;
213 }
214
215 if (!g_rk_aiq_init_lib) {
216 rk_aiq_init_lib();
217 g_rk_aiq_init_lib = true;
218 }
219 std::string sns_ent_name_str(sns_ent_name);
220 ret = _get_fast_aewb_from_drv(sns_ent_name_str, fastAeAwbInfo);
221 LOGI("%s: magic %x, is_pre_aiq : %d, prd_type : %d, kernel status %d",
222 __func__, info->magic, info->is_pre_aiq, info->prd_type, ret);
223
224 if (ret == XCAM_RETURN_NO_ERROR) {
225 if (g_rk_aiq_sys_preinit_cfg_map[sns_ent_name_str].tb_info.magic != info->magic) {
226 LOGE("Wrong magic %x vs %x", g_rk_aiq_sys_preinit_cfg_map[sns_ent_name_str].tb_info.magic,
227 info->magic);
228 return XCAM_RETURN_ERROR_PARAM;
229 }
230 g_rk_aiq_sys_preinit_cfg_map[sns_ent_name_str].tb_info.is_pre_aiq = info->is_pre_aiq;
231 g_rk_aiq_sys_preinit_cfg_map[sns_ent_name_str].tb_info.prd_type = info->prd_type;
232
233 } else {
234 g_rk_aiq_sys_preinit_cfg_map[sns_ent_name_str].tb_info.prd_type = RK_AIQ_PRD_TYPE_NORMAL;
235 LOGE("%s: get fast aewb error, skip set tb_info!", __func__);
236 }
237 return (ret);
238 }
239
rk_aiq_uapi_sysctl_preInit_devBufCnt(const char * sns_ent_name,const char * dev_ent,int buf_cnt)240 XCamReturn rk_aiq_uapi_sysctl_preInit_devBufCnt(const char* sns_ent_name, const char* dev_ent,
241 int buf_cnt) {
242 if (!sns_ent_name || !dev_ent) {
243 LOGE("Invalid input parameter");
244 return XCAM_RETURN_ERROR_PARAM;
245 }
246
247 std::string sns_ent_name_str(sns_ent_name);
248
249 g_rk_aiq_sys_preinit_cfg_map[sns_ent_name_str].dev_buf_cnt_map[dev_ent] = buf_cnt;
250
251 return XCAM_RETURN_NO_ERROR;
252 }
253
rk_aiq_offline_init(rk_aiq_sys_ctx_t * ctx)254 static int rk_aiq_offline_init(rk_aiq_sys_ctx_t* ctx)
255 {
256 XCamReturn ret = XCAM_RETURN_NO_ERROR;
257 #ifdef ANDROID_OS
258 char use_as_fake_cam_env[PROPERTY_VALUE_MAX] = {0};
259 property_get("persist.vendor.rkisp.use_as_fake_cam", use_as_fake_cam_env, "0");
260 #else
261 char* use_as_fake_cam_env = getenv("USE_AS_FAKE_CAM");
262 #endif
263 ini_t* aiq_ini = rkaiq_ini_load(OFFLINE_INI_FILE);
264
265 ENTER_XCORE_FUNCTION();
266
267 if (aiq_ini) {
268 const char* raw_offline_str = rkaiq_ini_get(aiq_ini, "rkaiq", "offline");
269 const char* raw_w_str = rkaiq_ini_get(aiq_ini, "rkaiq", "width");
270 const char* raw_h_str = rkaiq_ini_get(aiq_ini, "rkaiq", "height");
271 const char* raw_fmt_str = rkaiq_ini_get(aiq_ini, "rkaiq", "format");
272
273 bool offline = atoi(raw_offline_str) > 0 ? true : false;
274 int raw_w = atoi(raw_w_str);
275 int raw_h = atoi(raw_h_str);
276
277 // valid offline mode
278 if (offline && raw_w && raw_h && raw_fmt_str) {
279 ctx->_raw_prop.frame_width = raw_w;
280 ctx->_raw_prop.frame_height = raw_h;
281 ctx->_raw_prop.rawbuf_type = RK_AIQ_RAW_FILE;
282 ctx->_use_fakecam = true;
283
284 if (strcmp(raw_fmt_str, "BG10") == 0)
285 ctx->_raw_prop.format = RK_PIX_FMT_SBGGR10;
286 else if (strcmp(raw_fmt_str, "GB10") == 0)
287 ctx->_raw_prop.format = RK_PIX_FMT_SGBRG10;
288 else if (strcmp(raw_fmt_str, "RG10") == 0)
289 ctx->_raw_prop.format = RK_PIX_FMT_SRGGB10;
290 else if (strcmp(raw_fmt_str, "BA10") == 0)
291 ctx->_raw_prop.format = RK_PIX_FMT_SGRBG10;
292 else if (strcmp(raw_fmt_str, "BG12") == 0)
293 ctx->_raw_prop.format = RK_PIX_FMT_SBGGR12;
294 else if (strcmp(raw_fmt_str, "GB12") == 0)
295 ctx->_raw_prop.format = RK_PIX_FMT_SGBRG12;
296 else if (strcmp(raw_fmt_str, "RG12") == 0)
297 ctx->_raw_prop.format = RK_PIX_FMT_SRGGB12;
298 else if (strcmp(raw_fmt_str, "BA12") == 0)
299 ctx->_raw_prop.format = RK_PIX_FMT_SGRBG12;
300 else if (strcmp(raw_fmt_str, "BG14") == 0)
301 ctx->_raw_prop.format = RK_PIX_FMT_SBGGR14;
302 else if (strcmp(raw_fmt_str, "GB14") == 0)
303 ctx->_raw_prop.format = RK_PIX_FMT_SGBRG14;
304 else if (strcmp(raw_fmt_str, "RG14") == 0)
305 ctx->_raw_prop.format = RK_PIX_FMT_SRGGB14;
306 else if (strcmp(raw_fmt_str, "BA14") == 0)
307 ctx->_raw_prop.format = RK_PIX_FMT_SGRBG14;
308 else
309 ctx->_raw_prop.format = RK_PIX_FMT_SBGGR10;
310 }
311
312 rkaiq_ini_free(aiq_ini);
313 }
314
315 #ifdef ANDROID_OS
316 if (!ctx->_use_fakecam) {
317 int use_fakecam = atoi(use_as_fake_cam_env);
318 if (use_fakecam > 0) {
319 ctx->_use_fakecam = true;
320 } else {
321 ctx->_use_fakecam = false;
322 }
323 }
324 #else
325 if (use_as_fake_cam_env)
326 ctx->_use_fakecam = atoi(use_as_fake_cam_env) > 0 ? true : false;
327 #endif
328
329 LOGI("use fakecam %d", ctx->_use_fakecam);
330
331 EXIT_XCORE_FUNCTION();
332
333 return ret;
334 }
335
336 static void
337 rk_aiq_uapi_sysctl_deinit_locked(rk_aiq_sys_ctx_t* ctx);
338
339 rk_aiq_sys_ctx_t*
rk_aiq_uapi_sysctl_init(const char * sns_ent_name,const char * config_file_dir,rk_aiq_error_cb err_cb,rk_aiq_metas_cb metas_cb)340 rk_aiq_uapi_sysctl_init(const char* sns_ent_name,
341 const char* config_file_dir,
342 rk_aiq_error_cb err_cb,
343 rk_aiq_metas_cb metas_cb)
344 {
345 XCamReturn ret = XCAM_RETURN_NO_ERROR;
346
347 ENTER_XCORE_FUNCTION();
348 char config_file[256];
349 std::string main_scene;
350 std::string sub_scene;
351 rk_aiq_iq_buffer_info_t iq_buffer{NULL, 0};
352 char lock_path[255];
353 int lock_res = 0;
354 std::map<std::string, rk_aiq_sys_preinit_cfg_t>::iterator it;
355 void* calib_proj = NULL;
356
357 XCAM_ASSERT(sns_ent_name);
358
359 if (!g_rk_aiq_init_lib) {
360 rk_aiq_init_lib();
361 g_rk_aiq_init_lib = true;
362 }
363
364 bool is_ent_name = true;
365 if (sns_ent_name[0] != 'm' || sns_ent_name[3] != '_')
366 is_ent_name = false;
367
368 if (!is_ent_name) {
369 if (config_file_dir && (strlen(config_file_dir) > 0))
370 sprintf(config_file, "%s/%s.json", config_file_dir, sns_ent_name);
371 else
372 sprintf(config_file, "%s/%s.json", RKAIQ_DEFAULT_IQ_PATH, sns_ent_name);
373 }
374 rk_aiq_sys_ctx_t* ctx = new rk_aiq_sys_ctx_t();
375 RKAIQSYS_CHECK_RET(!ctx, NULL, "malloc main ctx error !");
376
377 ctx->_apiMutex = new Mutex();
378 RKAIQ_API_SMART_LOCK(ctx);
379
380 ctx->_sensor_entity_name = strndup(sns_ent_name, 128);
381 RKAIQSYS_CHECK_RET(!ctx->_sensor_entity_name, NULL, "dup sensor name error !");
382
383 ctx->_rkAiqManager = new RkAiqManager(ctx->_sensor_entity_name,
384 err_cb,
385 metas_cb);
386
387 rk_aiq_static_info_t* s_info = CamHwIsp20::getStaticCamHwInfo(sns_ent_name);
388 // TODO: for sensor sync check(ensure 1608 sensor is slave mode).
389 ctx->_is_1608_sensor = s_info->_is_1608_sensor;
390 ctx->_rkAiqManager->setCamPhyId(s_info->sensor_info.phyId);
391
392 ctx->_camPhyId = s_info->sensor_info.phyId;
393
394 #ifdef RK_SIMULATOR_HW
395 ctx->_camHw = new CamHwSimulator();
396 #else
397 rk_aiq_offline_init(ctx);
398 if (strstr(sns_ent_name, "FakeCamera") || ctx->_use_fakecam || strstr(sns_ent_name, "_s_")) {
399 //ctx->_camHw = new FakeCamHwIsp20();
400 #ifdef RKAIQ_ENABLE_FAKECAM
401 if (s_info->isp_hw_ver == 4) {
402 #ifdef ISP_HW_V20
403 ctx->_camHw = new FakeCamHwIsp20 ();
404 ctx->_analyzer = new RkAiqCore(0);
405 #else
406 XCAM_ASSERT(0);
407 #endif
408 } else if (s_info->isp_hw_ver == 5) {
409 #ifdef ISP_HW_V21
410 ctx->_camHw = new FakeCamHwIsp21 ();
411 ctx->_analyzer = new RkAiqCore(1);
412 #else
413 XCAM_ASSERT(0);
414 #endif
415 } else if (s_info->isp_hw_ver == 6) {
416 #ifdef ISP_HW_V30
417 ctx->_camHw = new FakeCamHwIsp3x ();
418 ctx->_analyzer = new RkAiqCore(3);
419 #else
420 XCAM_ASSERT(0);
421 #endif
422 } else if (s_info->isp_hw_ver == 7 || s_info->isp_hw_ver == 8) {
423 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
424 ctx->_camHw = new FakeCamHwIsp32 ();
425 ctx->_analyzer = new RkAiqCore(4);
426 #else
427 XCAM_ASSERT(0);
428 #endif
429 } else {
430 LOGE("do not support this isp hw version %d !", s_info->isp_hw_ver);
431 goto error;
432 }
433 #endif
434 } else {
435 if (s_info->isp_hw_ver == 4) {
436 #ifdef ISP_HW_V20
437 ctx->_camHw = new CamHwIsp20();
438 ctx->_analyzer = new RkAiqCore(0);
439 #else
440 XCAM_ASSERT(0);
441 #endif
442 } else if (s_info->isp_hw_ver == 5) {
443 #ifdef ISP_HW_V21
444 ctx->_camHw = new CamHwIsp21();
445 ctx->_analyzer = new RkAiqCore(1);
446 #else
447 XCAM_ASSERT(0);
448 #endif
449 } else if (s_info->isp_hw_ver == 6) {
450 #ifdef ISP_HW_V30
451 ctx->_camHw = new CamHwIsp3x();
452 ctx->_analyzer = new RkAiqCore(3);
453 #else
454 XCAM_ASSERT(0);
455 #endif
456 } else if (s_info->isp_hw_ver == 7 || s_info->isp_hw_ver == 8) {
457 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
458 ctx->_camHw = new CamHwIsp32();
459 ctx->_analyzer = new RkAiqCore(4);
460 #else
461 XCAM_ASSERT(0);
462 #endif
463 } else {
464 LOGE("do not support this isp hw version %d !", s_info->isp_hw_ver);
465 goto error;
466 }
467 }
468
469 // use user defined iq file
470 {
471 std::map<std::string, rk_aiq_sys_preinit_cfg_t>::iterator it =
472 g_rk_aiq_sys_preinit_cfg_map.find(std::string(ctx->_sensor_entity_name));
473 int user_hdr_mode = -1;
474 bool user_spec_iq = false;
475 if (it != g_rk_aiq_sys_preinit_cfg_map.end()) {
476 ctx->_rkAiqManager->setHwEvtCb(it->second.hwevt_cb, it->second.hwevt_cb_ctx);
477 ctx->_rkAiqManager->setTbInfo(it->second.tb_info);
478 ctx->_camHw->setTbInfo(it->second.tb_info);
479 if (!it->second.dev_buf_cnt_map.empty())
480 ctx->_camHw->setDevBufCnt(it->second.dev_buf_cnt_map);
481 ctx->_analyzer->setTbInfo(it->second.tb_info);
482 if (it->second.iq_buffer.addr && it->second.iq_buffer.len > 0) {
483 iq_buffer.addr = it->second.iq_buffer.addr;
484 iq_buffer.len = it->second.iq_buffer.len;
485 user_spec_iq = true;
486 LOGI("use user sepcified iq addr %p, len: %zu", iq_buffer.addr, iq_buffer.len);
487 } else if (!it->second.force_iq_file.empty()) {
488 sprintf(config_file, "%s/%s", config_file_dir, it->second.force_iq_file.c_str());
489 LOGI("use user sepcified iq file %s", config_file);
490 user_spec_iq = true;
491 } else if (it->second.calib_proj) {
492 calib_proj = it->second.calib_proj;
493 LOGI("use external CamCalibDbProj: %p", calib_proj);
494 } else {
495 user_hdr_mode = it->second.mode;
496 LOGI("selected by user sepcified hdr mode %d", user_hdr_mode);
497 }
498
499 if (!it->second.main_scene.empty())
500 main_scene = it->second.main_scene;
501 if (!it->second.sub_scene.empty())
502 sub_scene = it->second.sub_scene;
503 } else {
504 rk_aiq_tb_info_t info{0, false, RK_AIQ_PRD_TYPE_NORMAL};
505 ctx->_rkAiqManager->setTbInfo(info);
506 ctx->_camHw->setTbInfo(info);
507 ctx->_analyzer->setTbInfo(info);
508 }
509
510 // use auto selected iq file
511 if (is_ent_name && !user_spec_iq && !ctx->_use_fakecam) {
512 char iq_file[128] = {'\0'};
513 CamHwIsp20::selectIqFile(sns_ent_name, iq_file);
514
515 char* hdr_mode = getenv("HDR_MODE");
516 int start = strlen(iq_file) - strlen(".json");
517
518 if (hdr_mode) {
519 iq_file[start] = '\0';
520 if (strstr(hdr_mode, "32"))
521 strcat(iq_file, "-hdr3.json");
522 else
523 strcat(iq_file, "_normal.json");
524 }
525
526 if (config_file_dir) {
527 sprintf(config_file, "%s/%s", config_file_dir, iq_file);
528 } else {
529 sprintf(config_file, "%s/%s", RKAIQ_DEFAULT_IQ_PATH, iq_file);
530 }
531
532 // use default iq file
533 if (hdr_mode && access(config_file, F_OK)) {
534 LOGW("%s not exist, will use the default !", config_file);
535 if (strstr(hdr_mode, "32"))
536 start = strlen(config_file) - strlen("-hdr3.json");
537 else
538 start = strlen(config_file) - strlen("_normal.json");
539 config_file[start] = '\0';
540 strcat(config_file, ".json");
541 }
542 LOGI("use iq file %s", config_file);
543 } else if (ctx->_use_fakecam && !user_spec_iq) {
544 if (config_file_dir && (strlen(config_file_dir) > 0))
545 sprintf(config_file, "%s/%s", config_file_dir, "FakeCamera0.json");
546 else
547 sprintf(config_file, "%s/%s", RKAIQ_DEFAULT_IQ_PATH, "FakeCamera0.json");
548 }
549 }
550 #endif
551 ctx->_camHw->setCamPhyId(s_info->sensor_info.phyId);
552 ctx->_rkAiqManager->setCamHw(ctx->_camHw);
553
554 #ifndef RK_SIMULATOR_HW
555 ctx->_hw_info.fl_supported = s_info->has_fl;
556 ctx->_hw_info.irc_supported = s_info->has_irc;
557 ctx->_hw_info.lens_supported = s_info->has_lens_vcm;
558 ctx->_hw_info.fl_strth_adj = s_info->fl_strth_adj_sup;
559 ctx->_hw_info.fl_ir_strth_adj = s_info->fl_ir_strth_adj_sup;
560 ctx->_hw_info.is_multi_isp_mode = s_info->is_multi_isp_mode;
561 ctx->_hw_info.multi_isp_extended_pixel = s_info->multi_isp_extended_pixel;
562 ctx->_hw_info.module_rotation = RK_PS_SrcOverlapPosition_0;
563 #endif
564 ctx->_analyzer->setHwInfos(ctx->_hw_info);
565
566 ctx->_analyzer->setCamPhyId(s_info->sensor_info.phyId);
567
568 if (is_ent_name && config_file_dir) {
569 ctx->_analyzer->setResrcPath(config_file_dir);
570 } else
571 ctx->_analyzer->setResrcPath(RKAIQ_DEFAULT_IQ_PATH);
572 ctx->_rkAiqManager->setAnalyzer(ctx->_analyzer);
573 #ifdef ISP_HW_V20
574 ctx->_lumaAnalyzer = new RkLumaCore();
575 ctx->_rkAiqManager->setLumaAnalyzer(ctx->_lumaAnalyzer);
576 #endif
577 //ctx->_calibDb = RkAiqCalibDb::createCalibDb(config_file);
578 ctx->_socket = new SocketServer();
579 //if (!ctx->_calibDb)
580 // goto error;
581 //ctx->_rkAiqManager->setAiqCalibDb(ctx->_calibDb);
582
583 if (strstr(config_file, ".xml")) {
584 LOGE("Should use json instead of xml");
585 strcpy(config_file + strlen(config_file) - strlen(".xml"), ".json");
586 }
587
588 CamCalibDbV2Context_t calibdbv2_ctx;
589 xcam_mem_clear (calibdbv2_ctx);
590
591 if (calib_proj)
592 ctx->_calibDbProj = (CamCalibDbProj_t*)calib_proj;
593 else if (iq_buffer.addr && iq_buffer.len > 0)
594 ctx->_calibDbProj = RkAiqCalibDbV2::createCalibDbProj(iq_buffer.addr, iq_buffer.len);
595 else
596 ctx->_calibDbProj = RkAiqCalibDbV2::createCalibDbProj(config_file);
597 if (!ctx->_calibDbProj)
598 goto error;
599
600 if (!main_scene.empty() && !sub_scene.empty())
601 calibdbv2_ctx = RkAiqSceneManager::refToScene(ctx->_calibDbProj,
602 main_scene.c_str(), sub_scene.c_str());
603
604 if (!calibdbv2_ctx.calib_scene) {
605 if (!main_scene.empty() && !sub_scene.empty())
606 LOGE("Failed to find params of %s:%s scene in json, using default scene",
607 main_scene.c_str(), sub_scene.c_str());
608 calibdbv2_ctx = RkAiqCalibDbV2::toDefaultCalibDb(ctx->_calibDbProj);
609 }
610 ctx->_rkAiqManager->setAiqCalibDb(&calibdbv2_ctx);
611
612 #ifndef __ANDROID__
613 snprintf(lock_path, 255, "/tmp/aiq%d.lock", ctx->_camPhyId);
614 ctx->_lock_file = fopen(lock_path, "w+");
615 lock_res = flock(fileno(ctx->_lock_file), LOCK_EX);
616 if (!lock_res) {
617 LOGI("Locking aiq exclusive");
618 } else {
619 LOGI("Lock aiq exclusive failed with res %d", lock_res);
620 fclose(ctx->_lock_file);
621 ctx->_lock_file = NULL;
622 }
623 #endif
624
625 ret = ctx->_rkAiqManager->init();
626 if (ret)
627 goto error;
628
629 ctx->_socket->Process(ctx, ctx->_camPhyId);
630
631 ctx->ctx_type = CTX_TYPE_USER_MAIN;
632 ctx->next_ctx = new rk_aiq_sys_ctx_t();
633 RKAIQSYS_CHECK_RET(!ctx, NULL, "malloc toolserver ctx error !");
634 *(ctx->next_ctx) = *ctx;
635 ctx->next_ctx->ctx_type = CTX_TYPE_TOOL_SERVER;
636 ctx->next_ctx->next_ctx = NULL;
637 ctx->cam_type = RK_AIQ_CAM_TYPE_SINGLE;
638
639 {
640 #ifdef ANDROID_OS
641 char property_value[PROPERTY_VALUE_MAX] = {0};
642
643 property_get("persist.vendor.rkisp.tuning.bypass_uapi", property_value, "1");
644 if(atoi(property_value) != 0) {
645 g_bypass_uapi = true;
646 } else {
647 g_bypass_uapi = false;
648 }
649 #else
650 const char *bypass_env = std::getenv("persist_camera_tuning_bypass_uapi");
651 if (bypass_env && atoi(bypass_env) != 0) {
652 g_bypass_uapi = true;
653 } else {
654 g_bypass_uapi = false;
655 }
656 #endif
657 }
658
659 EXIT_XCORE_FUNCTION();
660
661 return ctx;
662
663 error:
664 LOGE("_rkAiqManager init error!");
665 rk_aiq_uapi_sysctl_deinit_locked(ctx);
666 return NULL;
667 }
668
669 void
rk_aiq_uapi_sysctl_deinit_locked(rk_aiq_sys_ctx_t * ctx)670 rk_aiq_uapi_sysctl_deinit_locked(rk_aiq_sys_ctx_t* ctx)
671 {
672 std::map<std::string, rk_aiq_sys_preinit_cfg_t>::iterator it =
673 g_rk_aiq_sys_preinit_cfg_map.find(std::string(ctx->_sensor_entity_name));
674 if (it != g_rk_aiq_sys_preinit_cfg_map.end()) {
675 g_rk_aiq_sys_preinit_cfg_map.erase(it);
676 LOGI("unset user specific iq file.");
677 }
678
679 std::map<std::string, rk_aiq_sys_preinit_cfg_t>::iterator exp_it =
680 g_rk_aiq_offline_raw_exp_map.find(std::string(ctx->_sensor_entity_name));
681 if (exp_it != g_rk_aiq_offline_raw_exp_map.end()) {
682 g_rk_aiq_offline_raw_exp_map.erase(exp_it);
683 }
684
685 if (ctx->_rkAiqManager.ptr())
686 ctx->_rkAiqManager->deInit();
687
688 if (ctx->_socket) {
689 ctx->_socket->Deinit();
690 delete(ctx->_socket);
691 ctx->_socket = NULL;
692 }
693
694 ctx->_analyzer.release();
695 #ifdef ISP_HW_V20
696 ctx->_lumaAnalyzer.release();
697 #endif
698 ctx->_rkAiqManager.release();
699 ctx->_camHw.release();
700 if (ctx->_calibDbProj) {
701 // TODO:public common resource release
702 }
703
704 if (ctx->_lock_file) {
705 flock(fileno(ctx->_lock_file), LOCK_UN);
706 fclose(ctx->_lock_file);
707 }
708
709 if (ctx->next_ctx) {
710 delete ctx->next_ctx;
711 }
712
713 if (ctx->_sensor_entity_name)
714 xcam_free((void*)(ctx->_sensor_entity_name));
715
716 #if 0
717 // TODO: this will release all sensor's calibs, and should
718 // only release the current sensor's calib
719 rk_aiq_deinit_lib();
720 g_rk_aiq_init_lib = false;
721 #endif
722 }
723
724 void
rk_aiq_uapi_sysctl_deinit(rk_aiq_sys_ctx_t * ctx)725 rk_aiq_uapi_sysctl_deinit(rk_aiq_sys_ctx_t* ctx)
726 {
727 ENTER_XCORE_FUNCTION();
728 {
729 RKAIQ_API_SMART_LOCK(ctx);
730 rk_aiq_uapi_sysctl_deinit_locked(ctx);
731 }
732 delete ctx;
733 EXIT_XCORE_FUNCTION();
734 }
735
736 static XCamReturn
rk_aiq_uapi_sysctl_rawReproc_setInitExpInfo(const rk_aiq_sys_ctx_t * ctx,rk_aiq_working_mode_t mode)737 rk_aiq_uapi_sysctl_rawReproc_setInitExpInfo(const rk_aiq_sys_ctx_t* ctx,
738 rk_aiq_working_mode_t mode)
739 {
740 XCamReturn ret = XCAM_RETURN_NO_ERROR;
741 std::map<std::string, rk_aiq_sys_preinit_cfg_t>::iterator exp_it =
742 g_rk_aiq_offline_raw_exp_map.find(std::string(ctx->_sensor_entity_name));
743 if (exp_it != g_rk_aiq_offline_raw_exp_map.end()) {
744 rk_aiq_sys_preinit_cfg_t cfg = exp_it->second;
745 rk_aiq_frame_info_t* _finfo = &cfg.frame_exp_info[0];
746 LOGD("_finfo %d, %d, %f, %f\n",
747 _finfo[0].normal_gain_reg,
748 _finfo[0].normal_exp_reg,
749 _finfo[0].normal_exp,
750 _finfo[0].normal_gain);
751 if (mode == RK_AIQ_WORKING_MODE_NORMAL) {
752 Uapi_LinExpAttrV2_t LinExpAttr;
753 ret = rk_aiq_user_api2_ae_getLinExpAttr(ctx, &LinExpAttr);
754
755 LinExpAttr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
756 LinExpAttr.sync.done = false;
757 LinExpAttr.Params.InitExp.InitTimeValue = (float)_finfo[0].normal_exp;
758 LinExpAttr.Params.InitExp.InitGainValue = (float)_finfo[0].normal_gain;
759
760 ret = rk_aiq_user_api2_ae_setLinExpAttr(ctx, LinExpAttr);
761 if (ret == XCAM_RETURN_NO_ERROR) {
762 LOGD("set linear offline exp params success\n");
763 }
764 } else {
765 Uapi_HdrExpAttrV2_t HdrExpAttr;
766 ret = rk_aiq_user_api2_ae_getHdrExpAttr(ctx, &HdrExpAttr);
767
768 HdrExpAttr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
769 HdrExpAttr.sync.done = false;
770 HdrExpAttr.Params.InitExp.InitTimeValue[0] = (float)_finfo[0].hdr_exp_s;
771 HdrExpAttr.Params.InitExp.InitGainValue[0] = (float)_finfo[0].hdr_gain_s;
772 HdrExpAttr.Params.InitExp.InitTimeValue[1] = (float)_finfo[0].hdr_exp_m;
773 HdrExpAttr.Params.InitExp.InitGainValue[1] = (float)_finfo[0].hdr_gain_m;
774 HdrExpAttr.Params.InitExp.InitTimeValue[2] = (float)_finfo[0].hdr_exp_l;
775 HdrExpAttr.Params.InitExp.InitGainValue[2] = (float)_finfo[0].hdr_gain_l;
776
777 ret = rk_aiq_user_api2_ae_setHdrExpAttr(ctx, HdrExpAttr);
778 if (ret == XCAM_RETURN_NO_ERROR) {
779 LOGD("set HDR offline exp params success\n");
780 }
781 }
782 ctx->_camHw->rawReProc_prepare(0, cfg.frame_exp_info);
783 }
784 return ret;
785 }
786
787 XCamReturn
rk_aiq_uapi_sysctl_prepare(const rk_aiq_sys_ctx_t * ctx,uint32_t width,uint32_t height,rk_aiq_working_mode_t mode)788 rk_aiq_uapi_sysctl_prepare(const rk_aiq_sys_ctx_t* ctx,
789 uint32_t width, uint32_t height,
790 rk_aiq_working_mode_t mode)
791 {
792 ENTER_XCORE_FUNCTION();
793 XCAM_ASSERT(ctx != nullptr);
794
795 if (ctx->_use_fakecam && ctx->_raw_prop.format &&
796 ctx->_raw_prop.frame_width &&
797 ctx->_raw_prop.frame_height &&
798 ctx->_raw_prop.rawbuf_type) {
799 rk_aiq_uapi_sysctl_prepareRkRaw(ctx, ctx->_raw_prop);
800 }
801
802 RKAIQ_API_SMART_LOCK(ctx);
803
804 XCamReturn ret = XCAM_RETURN_NO_ERROR;
805 _set_fast_aewb_as_init(ctx, mode);
806
807 rk_aiq_uapi_sysctl_rawReproc_setInitExpInfo(ctx, mode);
808
809 ret = ctx->_rkAiqManager->prepare(width, height, mode);
810 RKAIQSYS_CHECK_RET(ret, ret, "prepare failed !");
811
812 EXIT_XCORE_FUNCTION();
813
814 return ret;
815 }
816
817 XCamReturn
rk_aiq_uapi_sysctl_start(const rk_aiq_sys_ctx_t * ctx)818 rk_aiq_uapi_sysctl_start(const rk_aiq_sys_ctx_t* ctx)
819 {
820 ENTER_XCORE_FUNCTION();
821 RKAIQ_API_SMART_LOCK(ctx);
822
823 XCamReturn ret = XCAM_RETURN_NO_ERROR;
824
825 ret = ctx->_rkAiqManager->start();
826
827 EXIT_XCORE_FUNCTION();
828
829 return ret;
830 }
831
832 XCamReturn
rk_aiq_uapi_sysctl_stop(const rk_aiq_sys_ctx_t * ctx,bool keep_ext_hw_st)833 rk_aiq_uapi_sysctl_stop(const rk_aiq_sys_ctx_t* ctx, bool keep_ext_hw_st)
834 {
835 ENTER_XCORE_FUNCTION();
836 RKAIQ_API_SMART_LOCK(ctx);
837
838 XCamReturn ret = XCAM_RETURN_NO_ERROR;
839
840 ret = ctx->_rkAiqManager->stop(keep_ext_hw_st);
841
842 EXIT_XCORE_FUNCTION();
843
844 return ret;
845 }
846
847 XCamReturn
rk_aiq_uapi_sysctl_getStaticMetas(const char * sns_ent_name,rk_aiq_static_info_t * static_info)848 rk_aiq_uapi_sysctl_getStaticMetas(const char* sns_ent_name, rk_aiq_static_info_t* static_info)
849 {
850 if (!sns_ent_name || !static_info)
851 return XCAM_RETURN_ERROR_FAILED;
852
853 if (!g_rk_aiq_init_lib) {
854 rk_aiq_init_lib();
855 g_rk_aiq_init_lib = true;
856 }
857 #ifdef RK_SIMULATOR_HW
858 /* nothing to do now*/
859 static_info = NULL;
860 #else
861 memcpy(static_info, CamHwIsp20::getStaticCamHwInfo(sns_ent_name), sizeof(rk_aiq_static_info_t));
862 #endif
863 return XCAM_RETURN_NO_ERROR;
864 }
865
866 XCamReturn
rk_aiq_uapi_sysctl_enumStaticMetasByPhyId(int index,rk_aiq_static_info_t * static_info)867 rk_aiq_uapi_sysctl_enumStaticMetasByPhyId(int index, rk_aiq_static_info_t* static_info)
868 {
869 if (!static_info)
870 return XCAM_RETURN_ERROR_FAILED;
871
872 if (!g_rk_aiq_init_lib) {
873 rk_aiq_init_lib();
874 g_rk_aiq_init_lib = true;
875 }
876 #ifdef RK_SIMULATOR_HW
877 /* nothing to do now*/
878 static_info = NULL;
879 #else
880 rk_aiq_static_info_t* tmp = CamHwIsp20::getStaticCamHwInfoByPhyId(NULL, index);
881 if (tmp)
882 memcpy(static_info, tmp, sizeof(rk_aiq_static_info_t));
883 else
884 return XCAM_RETURN_ERROR_OUTOFRANGE;
885 #endif
886 return XCAM_RETURN_NO_ERROR;
887 }
888
889 XCamReturn
rk_aiq_uapi_sysctl_enumStaticMetas(int index,rk_aiq_static_info_t * static_info)890 rk_aiq_uapi_sysctl_enumStaticMetas(int index, rk_aiq_static_info_t* static_info)
891 {
892 if (!static_info)
893 return XCAM_RETURN_ERROR_FAILED;
894
895 if (!g_rk_aiq_init_lib) {
896 rk_aiq_init_lib();
897 g_rk_aiq_init_lib = true;
898 }
899 #ifdef RK_SIMULATOR_HW
900 /* nothing to do now*/
901 static_info = NULL;
902 #else
903 rk_aiq_static_info_t* tmp = CamHwIsp20::getStaticCamHwInfo(NULL, index);
904 if (tmp)
905 memcpy(static_info, tmp, sizeof(rk_aiq_static_info_t));
906 else
907 return XCAM_RETURN_ERROR_OUTOFRANGE;
908 #endif
909 return XCAM_RETURN_NO_ERROR;
910 }
911
912 const char*
rk_aiq_uapi_sysctl_getBindedSnsEntNmByVd(const char * vd)913 rk_aiq_uapi_sysctl_getBindedSnsEntNmByVd(const char* vd)
914 {
915 if (!g_rk_aiq_init_lib) {
916 rk_aiq_init_lib();
917 g_rk_aiq_init_lib = true;
918 }
919
920 #ifndef RK_SIMULATOR_HW
921 return CamHwIsp20::getBindedSnsEntNmByVd(vd);
922 #endif
923 return NULL;
924 }
925
926 XCamReturn
rk_aiq_uapi_sysctl_getMetaData(const rk_aiq_sys_ctx_t * ctx,uint32_t frame_id,rk_aiq_metas_t * metas)927 rk_aiq_uapi_sysctl_getMetaData(const rk_aiq_sys_ctx_t* ctx, uint32_t frame_id, rk_aiq_metas_t* metas)
928 {
929 // TODO
930 return XCAM_RETURN_ERROR_FAILED;
931 }
932
933 XCamReturn
rk_aiq_uapi_sysctl_regLib(const rk_aiq_sys_ctx_t * ctx,RkAiqAlgoDesComm * algo_lib_des)934 rk_aiq_uapi_sysctl_regLib(const rk_aiq_sys_ctx_t* ctx,
935 RkAiqAlgoDesComm* algo_lib_des)
936 {
937 RKAIQ_API_SMART_LOCK(ctx);
938 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
939 #ifdef RKAIQ_ENABLE_CAMGROUP
940 const rk_aiq_camgroup_ctx_t* group_ctx =
941 (const rk_aiq_camgroup_ctx_t*)ctx;
942
943 return group_ctx->cam_group_manager->addAlgo(*algo_lib_des);
944 #else
945 return XCAM_RETURN_ERROR_FAILED;
946 #endif
947 } else
948 return ctx->_analyzer->addAlgo(*algo_lib_des);
949 }
950
951 XCamReturn
rk_aiq_uapi_sysctl_unRegLib(const rk_aiq_sys_ctx_t * ctx,const int algo_type,const int lib_id)952 rk_aiq_uapi_sysctl_unRegLib(const rk_aiq_sys_ctx_t* ctx,
953 const int algo_type,
954 const int lib_id)
955 {
956 RKAIQ_API_SMART_LOCK(ctx);
957 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
958 #ifdef RKAIQ_ENABLE_CAMGROUP
959 const rk_aiq_camgroup_ctx_t* group_ctx =
960 (const rk_aiq_camgroup_ctx_t*)ctx;
961
962 return group_ctx->cam_group_manager->rmAlgo(algo_type, lib_id);
963 #else
964 return XCAM_RETURN_ERROR_FAILED;
965 #endif
966 } else
967 return ctx->_analyzer->rmAlgo(algo_type, lib_id);
968 }
969
970 XCamReturn
rk_aiq_uapi_sysctl_enableAxlib(const rk_aiq_sys_ctx_t * ctx,const int algo_type,const int lib_id,bool enable)971 rk_aiq_uapi_sysctl_enableAxlib(const rk_aiq_sys_ctx_t* ctx,
972 const int algo_type,
973 const int lib_id,
974 bool enable)
975 {
976 RKAIQ_API_SMART_LOCK(ctx);
977 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
978 #ifdef RKAIQ_ENABLE_CAMGROUP
979 const rk_aiq_camgroup_ctx_t* group_ctx =
980 (const rk_aiq_camgroup_ctx_t*)ctx;
981
982 return group_ctx->cam_group_manager->enableAlgo(algo_type, lib_id, enable);
983 #else
984 return XCAM_RETURN_ERROR_FAILED;
985 #endif
986 } else {
987 return ctx->_analyzer->enableAlgo(algo_type, lib_id, enable);
988 }
989 }
990
991 bool
rk_aiq_uapi_sysctl_getAxlibStatus(const rk_aiq_sys_ctx_t * ctx,const int algo_type,const int lib_id)992 rk_aiq_uapi_sysctl_getAxlibStatus(const rk_aiq_sys_ctx_t* ctx,
993 const int algo_type,
994 const int lib_id)
995 {
996 RKAIQ_API_SMART_LOCK(ctx);
997 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
998 #ifdef RKAIQ_ENABLE_CAMGROUP
999 const rk_aiq_camgroup_ctx_t* group_ctx =
1000 (const rk_aiq_camgroup_ctx_t*)ctx;
1001
1002 return group_ctx->cam_group_manager->getAxlibStatus(algo_type, lib_id);
1003 #else
1004 return false;
1005 #endif
1006 } else
1007 return ctx->_analyzer->getAxlibStatus(algo_type, lib_id);
1008 }
1009
1010 RkAiqAlgoContext*
rk_aiq_uapi_sysctl_getEnabledAxlibCtx(const rk_aiq_sys_ctx_t * ctx,const int algo_type)1011 rk_aiq_uapi_sysctl_getEnabledAxlibCtx(const rk_aiq_sys_ctx_t* ctx, const int algo_type)
1012 {
1013 RKAIQ_API_SMART_LOCK(ctx);
1014 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1015 #ifdef RKAIQ_ENABLE_CAMGROUP
1016 const rk_aiq_camgroup_ctx_t* group_ctx =
1017 (const rk_aiq_camgroup_ctx_t*)ctx;
1018
1019 return group_ctx->cam_group_manager->getEnabledAxlibCtx(algo_type);
1020 #else
1021 return nullptr;
1022 #endif
1023 } else
1024 return ctx->_analyzer->getEnabledAxlibCtx(algo_type);
1025 }
1026
1027 RkAiqAlgoContext*
rk_aiq_uapi_sysctl_getAxlibCtx(const rk_aiq_sys_ctx_t * ctx,const int algo_type,const int lib_id)1028 rk_aiq_uapi_sysctl_getAxlibCtx(const rk_aiq_sys_ctx_t* ctx, const int algo_type, const int lib_id)
1029 {
1030 RKAIQ_API_SMART_LOCK(ctx);
1031 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1032 #ifdef RKAIQ_ENABLE_CAMGROUP
1033 const rk_aiq_camgroup_ctx_t* group_ctx =
1034 (const rk_aiq_camgroup_ctx_t*)ctx;
1035
1036 return group_ctx->cam_group_manager->getAxlibCtx(algo_type, lib_id);
1037 #else
1038 return nullptr;
1039 #endif
1040 } else
1041 return ctx->_analyzer->getAxlibCtx(algo_type, lib_id);
1042 }
1043
1044 XCamReturn
rk_aiq_uapi_sysctl_get3AStats(const rk_aiq_sys_ctx_t * ctx,rk_aiq_isp_stats_t * stats)1045 rk_aiq_uapi_sysctl_get3AStats(const rk_aiq_sys_ctx_t* ctx,
1046 rk_aiq_isp_stats_t *stats)
1047 {
1048 RKAIQ_API_SMART_LOCK(ctx);
1049 return ctx->_analyzer->get3AStatsFromCachedList(*stats);
1050 }
1051
1052 XCamReturn
rk_aiq_uapi_sysctl_get3AStatsBlk(const rk_aiq_sys_ctx_t * ctx,rk_aiq_isp_stats_t ** stats,int timeout_ms)1053 rk_aiq_uapi_sysctl_get3AStatsBlk(const rk_aiq_sys_ctx_t* ctx,
1054 rk_aiq_isp_stats_t **stats, int timeout_ms)
1055 {
1056 // blocked API, add lock ?
1057 //RKAIQ_API_SMART_LOCK(ctx);
1058 return ctx->_analyzer->get3AStatsFromCachedList(stats, timeout_ms);
1059 }
1060
1061 void
rk_aiq_uapi_sysctl_release3AStatsRef(const rk_aiq_sys_ctx_t * ctx,rk_aiq_isp_stats_t * stats)1062 rk_aiq_uapi_sysctl_release3AStatsRef(const rk_aiq_sys_ctx_t* ctx,
1063 rk_aiq_isp_stats_t *stats)
1064 {
1065 // blocked API, add lock ?
1066 // RKAIQ_API_SMART_LOCK(ctx);
1067 ctx->_analyzer->release3AStatsRef(stats);
1068 }
1069
1070 RKAIQ_END_DECLARE
1071
1072 template<typename T> static T*
algoHandle(const rk_aiq_sys_ctx_t * ctx,const int algo_type)1073 algoHandle(const rk_aiq_sys_ctx_t* ctx, const int algo_type)
1074 {
1075 T* algo_handle = NULL;
1076
1077 RkCam::RkAiqHandle* handle =
1078 const_cast<RkCam::RkAiqHandle*>(ctx->_analyzer->getAiqAlgoHandle(algo_type));
1079
1080 //XCAM_ASSERT(handle);
1081 if (!handle)
1082 return NULL;
1083
1084 int algo_id = handle->getAlgoId();
1085
1086 if (algo_id == 0)
1087 algo_handle = dynamic_cast<T*>(handle);
1088
1089 return algo_handle;
1090 }
1091
1092 #ifdef RKAIQ_ENABLE_CAMGROUP
1093 template<typename T> static T*
camgroupAlgoHandle(const rk_aiq_sys_ctx_t * ctx,const int algo_type)1094 camgroupAlgoHandle(const rk_aiq_sys_ctx_t* ctx, const int algo_type)
1095 {
1096 T* algo_handle = NULL;
1097
1098 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
1099 RkCam::RkAiqCamgroupHandle* handle =
1100 const_cast<RkCam::RkAiqCamgroupHandle*>(camgroup_ctx->cam_group_manager->getAiqCamgroupHandle(algo_type, 0));
1101
1102 if (!handle)
1103 return NULL;
1104
1105 int algo_id = handle->getAlgoId();
1106
1107 if (algo_id == 0)
1108 algo_handle = dynamic_cast<T*>(handle);
1109
1110 return algo_handle;
1111 }
1112 #endif
1113
1114 #include "RkAiqVersion.h"
1115 #include "RkAiqCalibVersion.h"
1116 #include "rk_aiq_user_api_awb.cpp"
1117 #include "rk_aiq_user_api_adebayer.cpp"
1118 #include "rk_aiq_user_api2_adebayer.cpp"
1119 #include "rk_aiq_user_api_ahdr.cpp"
1120 #include "uAPI2/rk_aiq_user_api2_amerge.cpp"
1121 #include "uAPI2/rk_aiq_user_api2_atmo.cpp"
1122 #include "uAPI2/rk_aiq_user_api2_adrc.cpp"
1123 #include "rk_aiq_user_api_alsc.cpp"
1124 #include "rk_aiq_user_api_accm.cpp"
1125 #include "rk_aiq_user_api_a3dlut.cpp"
1126 #include "rk_aiq_user_api_adehaze.cpp"
1127 #include "uAPI2/rk_aiq_user_api2_adehaze.cpp"
1128 #include "uAPI2/rk_aiq_user_api2_adpcc.cpp"
1129 #include "rk_aiq_user_api_agamma.cpp"
1130 #include "uAPI2/rk_aiq_user_api2_agamma.cpp"
1131 #include "uAPI2/rk_aiq_user_api2_adegamma.cpp"
1132 #include "uAPI2/rk_aiq_user_api2_ablc.cpp"
1133 #include "rk_aiq_user_api_adpcc.cpp"
1134 #include "rk_aiq_user_api_ae.cpp"
1135 #include "uAPI2/rk_aiq_user_api2_ae.cpp"
1136 #include "rk_aiq_user_api_anr.cpp"
1137 #include "rk_aiq_user_api_asharp.cpp"
1138 #include "rk_aiq_user_api_imgproc.cpp"
1139 #include "uAPI2/rk_aiq_user_api2_imgproc.cpp"
1140 #include "rk_aiq_user_api_afec.cpp"
1141 #include "rk_aiq_user_api_af.cpp"
1142 #include "uAPI2/rk_aiq_user_api2_af.cpp"
1143 #include "rk_aiq_user_api_asd.cpp"
1144 #include "rk_aiq_user_api_aldch.cpp"
1145 #include "rk_aiq_user_api2_aldch.cpp"
1146 #include "rk_aiq_user_api2_aldch_v21.cpp"
1147 #include "rk_aiq_user_api_acp.cpp"
1148 #include "rk_aiq_user_api2_acp.cpp"
1149 #include "rk_aiq_user_api_aie.cpp"
1150 #include "rk_aiq_user_api2_aie.cpp"
1151 #include "rk_aiq_user_api_aeis.cpp"
1152 #include "rk_aiq_user_api_abayernr_v2.cpp"
1153 #include "rk_aiq_user_api_aynr_v2.cpp"
1154 #include "rk_aiq_user_api_acnr_v1.cpp"
1155 #include "rk_aiq_user_api_asharp_v3.cpp"
1156 #include "uAPI2/rk_aiq_user_api2_abayernr_v2.cpp"
1157 #include "uAPI2/rk_aiq_user_api2_aynr_v2.cpp"
1158 #include "uAPI2/rk_aiq_user_api2_acnr_v1.cpp"
1159 #include "uAPI2/rk_aiq_user_api2_asharp_v3.cpp"
1160 #include "uAPI2/rk_aiq_user_api2_anr.cpp"
1161 #include "uAPI2/rk_aiq_user_api2_awb.cpp"
1162 #include "uAPI2/rk_aiq_user_api2_alsc.cpp"
1163 #include "uAPI2/rk_aiq_user_api2_accm.cpp"
1164 #include "uAPI2/rk_aiq_user_api2_a3dlut.cpp"
1165 #include "rk_aiq_user_api2_afec.cpp"
1166 #include "uAPI/rk_aiq_user_api_agic.cpp"
1167 #include "uAPI2/rk_aiq_user_api2_camgroup.cpp"
1168 #include "uAPI2/rk_aiq_user_api2_agic.cpp"
1169 #if defined(ISP_HW_V30)|| defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1170 #include "rk_aiq_user_api2_custom_ae.cpp"
1171 #endif
1172 #if defined(ISP_HW_V30)||defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1173 #include "rk_aiq_user_api2_custom_awb.cpp"
1174 #endif
1175 #include "uAPI2/rk_aiq_user_api2_aynr_v3.cpp"
1176 #include "rk_aiq_user_api_aynr_v3.cpp"
1177 #include "uAPI2/rk_aiq_user_api2_acnr_v2.cpp"
1178 #include "rk_aiq_user_api_acnr_v2.cpp"
1179 #include "uAPI2/rk_aiq_user_api2_asharp_v4.cpp"
1180 #include "rk_aiq_user_api_asharp_v4.cpp"
1181 #include "uAPI2/rk_aiq_user_api2_abayer2dnr_v2.cpp"
1182 #include "rk_aiq_user_api_abayer2dnr_v2.cpp"
1183 #include "uAPI2/rk_aiq_user_api2_abayertnr_v2.cpp"
1184 #include "rk_aiq_user_api_abayertnr_v2.cpp"
1185 #include "uAPI2/rk_aiq_user_api2_acsm.cpp"
1186 #include "uAPI2/rk_aiq_user_api2_acgc.cpp"
1187 #include "uAPI2/rk_aiq_user_api2_acac.cpp"
1188 #include "uAPI2/rk_aiq_user_api2_again_v2.cpp"
1189 #include "rk_aiq_user_api_again_v2.cpp"
1190
1191 #include "uAPI2/rk_aiq_user_api2_abayer2dnr_v23.cpp"
1192 #include "rk_aiq_user_api_abayer2dnr_v23.cpp"
1193 #include "uAPI2/rk_aiq_user_api2_abayertnr_v23.cpp"
1194 #include "rk_aiq_user_api_abayertnr_v23.cpp"
1195 #include "uAPI2/rk_aiq_user_api2_aynr_v22.cpp"
1196 #include "rk_aiq_user_api_aynr_v22.cpp"
1197 #include "uAPI2/rk_aiq_user_api2_acnr_v30.cpp"
1198 #include "rk_aiq_user_api_acnr_v30.cpp"
1199 #include "uAPI2/rk_aiq_user_api2_asharp_v33.cpp"
1200 #include "rk_aiq_user_api_asharp_v33.cpp"
1201 #include "uAPI2/rk_aiq_user_api2_ablc_v32.cpp"
1202
1203
1204
1205 #define RK_AIQ_ALGO_TYPE_MODULES (RK_AIQ_ALGO_TYPE_MAX + 1)
1206
1207 XCamReturn
rk_aiq_uapi_sysctl_setModuleCtl(const rk_aiq_sys_ctx_t * ctx,rk_aiq_module_id_t mId,bool mod_en)1208 rk_aiq_uapi_sysctl_setModuleCtl(const rk_aiq_sys_ctx_t* ctx, rk_aiq_module_id_t mId, bool mod_en)
1209 {
1210 ENTER_XCORE_FUNCTION();
1211 CHECK_USER_API_ENABLE2(ctx);
1212 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_MODULES);
1213 RKAIQ_API_SMART_LOCK(ctx);
1214
1215 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1216 if (mId > RK_MODULE_INVAL && mId < RK_MODULE_MAX) {
1217 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1218 #ifdef RKAIQ_ENABLE_CAMGROUP
1219 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
1220 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
1221 if (!camCtx)
1222 continue;
1223
1224 ret = camCtx->_rkAiqManager->setModuleCtl(mId, mod_en);
1225 }
1226 #else
1227 return XCAM_RETURN_ERROR_FAILED;
1228 #endif
1229 } else {
1230 ret = ctx->_rkAiqManager->setModuleCtl(mId, mod_en);
1231 }
1232 } else {
1233 ret = XCAM_RETURN_ERROR_FAILED;
1234 }
1235
1236 EXIT_XCORE_FUNCTION();
1237
1238 return ret;
1239 }
1240
1241 int32_t
rk_aiq_uapi_sysctl_getModuleCtl(const rk_aiq_sys_ctx_t * ctx,rk_aiq_module_id_t mId,bool * mod_en)1242 rk_aiq_uapi_sysctl_getModuleCtl(const rk_aiq_sys_ctx_t* ctx, rk_aiq_module_id_t mId, bool *mod_en)
1243 {
1244 ENTER_XCORE_FUNCTION();
1245 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1246 RKAIQ_API_SMART_LOCK(ctx);
1247 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1248 #ifdef RKAIQ_ENABLE_CAMGROUP
1249 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
1250 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
1251 if (!camCtx)
1252 continue;
1253
1254 bool en;
1255 ret = ctx->_rkAiqManager->getModuleCtl(mId, en);
1256 *mod_en = en;
1257
1258 return ret;
1259 }
1260 #else
1261 return XCAM_RETURN_ERROR_FAILED;
1262 #endif
1263 } else {
1264 NULL_RETURN_RET(ctx, -1);
1265 NULL_RETURN_RET(ctx->_rkAiqManager.ptr(), -1);
1266
1267 bool en;
1268 ret = ctx->_rkAiqManager->getModuleCtl(mId, en);
1269 *mod_en = en;
1270 }
1271 EXIT_XCORE_FUNCTION();
1272
1273 return ret;
1274 }
1275
1276 XCamReturn
rk_aiq_uapi_sysctl_setCpsLtCfg(const rk_aiq_sys_ctx_t * ctx,rk_aiq_cpsl_cfg_t * cfg)1277 rk_aiq_uapi_sysctl_setCpsLtCfg(const rk_aiq_sys_ctx_t* ctx,
1278 rk_aiq_cpsl_cfg_t* cfg)
1279 {
1280 RKAIQ_API_SMART_LOCK(ctx);
1281 #if RKAIQ_HAVE_ASD_V10
1282 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1283 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1284 #ifdef RKAIQ_ENABLE_CAMGROUP
1285 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
1286 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
1287 if (!camCtx)
1288 continue;
1289
1290 ret = camCtx->_analyzer->setCpsLtCfg(*cfg);
1291 }
1292 #else
1293 return XCAM_RETURN_ERROR_FAILED;
1294 #endif
1295 } else {
1296 ret = ctx->_analyzer->setCpsLtCfg(*cfg);
1297 }
1298
1299 return ret;
1300 #else
1301 return XCAM_RETURN_ERROR_UNKNOWN;
1302 #endif
1303 }
1304
1305 XCamReturn
rk_aiq_uapi_sysctl_getCpsLtInfo(const rk_aiq_sys_ctx_t * ctx,rk_aiq_cpsl_info_t * info)1306 rk_aiq_uapi_sysctl_getCpsLtInfo(const rk_aiq_sys_ctx_t* ctx,
1307 rk_aiq_cpsl_info_t* info)
1308 {
1309 RKAIQ_API_SMART_LOCK(ctx);
1310 #if RKAIQ_HAVE_ASD_V10
1311 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1312 #ifdef RKAIQ_ENABLE_CAMGROUP
1313 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
1314 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
1315 if (!camCtx)
1316 continue;
1317
1318 return camCtx->_analyzer->getCpsLtInfo(*info);
1319 }
1320 #else
1321 return XCAM_RETURN_ERROR_FAILED;
1322 #endif
1323 } else {
1324 return ctx->_analyzer->getCpsLtInfo(*info);
1325 }
1326
1327 return XCAM_RETURN_ERROR_FAILED;
1328 #else
1329 return XCAM_RETURN_ERROR_UNKNOWN;
1330 #endif
1331 }
1332
1333 XCamReturn
rk_aiq_uapi_sysctl_queryCpsLtCap(const rk_aiq_sys_ctx_t * ctx,rk_aiq_cpsl_cap_t * cap)1334 rk_aiq_uapi_sysctl_queryCpsLtCap(const rk_aiq_sys_ctx_t* ctx,
1335 rk_aiq_cpsl_cap_t* cap)
1336 {
1337 RKAIQ_API_SMART_LOCK(ctx);
1338 #if RKAIQ_HAVE_ASD_V10
1339 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1340 #ifdef RKAIQ_ENABLE_CAMGROUP
1341 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
1342 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
1343 if (!camCtx)
1344 continue;
1345
1346 return camCtx->_analyzer->queryCpsLtCap(*cap);
1347 }
1348 #else
1349 return XCAM_RETURN_ERROR_FAILED;
1350 #endif
1351 } else {
1352 return ctx->_analyzer->queryCpsLtCap(*cap);
1353 }
1354
1355 return XCAM_RETURN_ERROR_FAILED;
1356 #else
1357 return XCAM_RETURN_ERROR_UNKNOWN;
1358 #endif
1359 }
1360
1361 extern RkAiqAlgoDescription g_RkIspAlgoDescAe;
1362 extern RkAiqAlgoDescription g_RkIspAlgoDescAwb;
1363 #if RKAIQ_HAVE_AF
1364 extern RkAiqAlgoDescription g_RkIspAlgoDescAf;
1365 #endif
1366 #if RKAIQ_HAVE_MERGE_V10 || RKAIQ_HAVE_MERGE_V11 || RKAIQ_HAVE_MERGE_V12
1367 extern RkAiqAlgoDescription g_RkIspAlgoDescAmerge;
1368 #endif
1369 #if RKAIQ_HAVE_TMO_V1
1370 extern RkAiqAlgoDescription g_RkIspAlgoDescAtmo;
1371 #endif
1372
1373
_print_versions()1374 static void _print_versions()
1375 {
1376 printf("\n"
1377 "************************** VERSION INFOS **************************\n"
1378 "version release date: %s\n"
1379 " AIQ: %s\n"
1380 " IQ PARSER: %s\n"
1381 "************************ VERSION INFOS END ************************\n"
1382 , RK_AIQ_RELEASE_DATE
1383 , RK_AIQ_VERSION
1384 , RK_AIQ_CALIB_VERSION
1385 );
1386 }
1387
rk_aiq_uapi_get_version_info(rk_aiq_ver_info_t * vers)1388 void rk_aiq_uapi_get_version_info(rk_aiq_ver_info_t* vers)
1389 {
1390 uint32_t iq_parser_magic_code;
1391
1392 xcam_mem_clear (*vers);
1393 const char* ver_str = RK_AIQ_CALIB_VERSION;
1394 const char* start = ver_str + strlen(RK_AIQ_CALIB_VERSION_HEAD);
1395 const char* stop = strstr(ver_str, RK_AIQ_CALIB_VERSION_MAGIC_JOINT);
1396
1397 // TODO: use strncpy instead of memcpy, but has compile warning now
1398 memcpy(vers->iq_parser_ver, start, stop - start);
1399
1400 start = strstr(ver_str, RK_AIQ_CALIB_VERSION_MAGIC_CODE_HEAD) +
1401 strlen(RK_AIQ_CALIB_VERSION_MAGIC_CODE_HEAD);
1402
1403 vers->iq_parser_magic_code = atoi(start);
1404
1405 ver_str = RK_AIQ_VERSION;
1406 start = ver_str + strlen(RK_AIQ_VERSION_HEAD);
1407 strcpy(vers->aiq_ver, start);
1408
1409 strcpy(vers->awb_algo_ver, g_RkIspAlgoDescAwb.common.version);
1410 strcpy(vers->ae_algo_ver, g_RkIspAlgoDescAe.common.version);
1411 #if RKAIQ_HAVE_AF
1412 strcpy(vers->af_algo_ver, g_RkIspAlgoDescAf.common.version);
1413 #endif
1414 #if RKAIQ_HAVE_MERGE_V10 || RKAIQ_HAVE_MERGE_V11 || RKAIQ_HAVE_MERGE_V12
1415 strcpy(vers->ahdr_algo_ver, g_RkIspAlgoDescAmerge.common.version);
1416 #endif
1417 #if RKAIQ_HAVE_TMO_V1
1418 strcpy(vers->ahdr_algo_ver, g_RkIspAlgoDescAtmo.common.version);
1419 #endif
1420
1421
1422 LOGI("aiq ver %s, parser ver %s, magic code %d, awb ver %s\n"
1423 "ae ver %s, af ver %s, ahdr ver %s", vers->aiq_ver,
1424 vers->iq_parser_ver, vers->iq_parser_magic_code,
1425 vers->awb_algo_ver, vers->ae_algo_ver,
1426 vers->af_algo_ver, vers->ahdr_algo_ver);
1427 }
1428
rk_aiq_init_lib(void)1429 static void rk_aiq_init_lib(void)
1430 {
1431 xcam_get_log_level();
1432 ENTER_XCORE_FUNCTION();
1433 #ifdef RK_SIMULATOR_HW
1434 /* nothing to do now */
1435 #else
1436 CamHwIsp20::initCamHwInfos();
1437 rk_aiq_static_info_t* s_info = CamHwIsp20::getStaticCamHwInfo(NULL, 0);
1438
1439 if (s_info != nullptr) {
1440 if (s_info->isp_hw_ver == 4)
1441 g_rkaiq_isp_hw_ver = 20;
1442 else if (s_info->isp_hw_ver == 5)
1443 g_rkaiq_isp_hw_ver = 21;
1444 else if (s_info->isp_hw_ver == 6)
1445 g_rkaiq_isp_hw_ver = 30;
1446 else if (s_info->isp_hw_ver == 7)
1447 g_rkaiq_isp_hw_ver = 32;
1448 else if (s_info->isp_hw_ver == 8)
1449 g_rkaiq_isp_hw_ver = 321;
1450 else
1451 LOGE("do not support isp hw ver %d now !", s_info->isp_hw_ver);
1452 }
1453 #endif
1454 #if defined(ISP_HW_V20)
1455 assert(g_rkaiq_isp_hw_ver == 20);
1456 #elif defined(ISP_HW_V21)
1457 assert(g_rkaiq_isp_hw_ver == 21);
1458 #elif defined(ISP_HW_V30)
1459 assert(g_rkaiq_isp_hw_ver == 30);
1460 #elif defined(ISP_HW_V32)
1461 assert(g_rkaiq_isp_hw_ver == 32);
1462 #elif defined(ISP_HW_V32_LITE)
1463 assert(g_rkaiq_isp_hw_ver == 321);
1464 #else
1465 #error "WRONG ISP_HW_VERSION, ONLY SUPPORT V20 AND V21 NOW !"
1466 #endif
1467 _print_versions();
1468 EXIT_XCORE_FUNCTION();
1469
1470 }
1471
rk_aiq_deinit_lib(void)1472 static void rk_aiq_deinit_lib(void)
1473 {
1474 ENTER_XCORE_FUNCTION();
1475 #ifdef RK_SIMULATOR_HW
1476 /* nothing to do now */
1477 #else
1478 RkAiqCalibDbV2::releaseCalibDbProj();
1479 #ifdef RKAIQ_ENABLE_PARSER_V1
1480 RkAiqCalibDb::releaseCalibDb();
1481 #endif
1482 CamHwIsp20::clearStaticCamHwInfo();
1483 #endif
1484 EXIT_XCORE_FUNCTION();
1485 }
1486
1487 XCamReturn
rk_aiq_uapi_sysctl_enqueueRkRawBuf(const rk_aiq_sys_ctx_t * ctx,void * rawdata,bool sync)1488 rk_aiq_uapi_sysctl_enqueueRkRawBuf(const rk_aiq_sys_ctx_t* ctx, void *rawdata, bool sync)
1489 {
1490 ENTER_XCORE_FUNCTION();
1491 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1492 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1493 #ifdef RKAIQ_ENABLE_CAMGROUP
1494 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
1495 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
1496 if (!camCtx)
1497 continue;
1498
1499 ret = camCtx->_rkAiqManager->enqueueRawBuffer(rawdata, sync);
1500 }
1501 #else
1502 return XCAM_RETURN_ERROR_FAILED;
1503 #endif
1504 } else {
1505 ret = ctx->_rkAiqManager->enqueueRawBuffer(rawdata, sync);
1506 }
1507 EXIT_XCORE_FUNCTION();
1508
1509 return ret;
1510 }
1511
1512 XCamReturn
rk_aiq_uapi_sysctl_enqueueRkRawFile(const rk_aiq_sys_ctx_t * ctx,const char * path)1513 rk_aiq_uapi_sysctl_enqueueRkRawFile(const rk_aiq_sys_ctx_t* ctx, const char *path)
1514 {
1515 ENTER_XCORE_FUNCTION();
1516 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1517 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1518 #ifdef RKAIQ_ENABLE_CAMGROUP
1519 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
1520 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
1521 if (!camCtx)
1522 continue;
1523
1524 ret = camCtx->_rkAiqManager->enqueueRawFile(path);
1525 }
1526 #else
1527 return XCAM_RETURN_ERROR_FAILED;
1528 #endif
1529 } else {
1530 ret = ctx->_rkAiqManager->enqueueRawFile(path);
1531 }
1532 EXIT_XCORE_FUNCTION();
1533
1534 return ret;
1535 }
1536
1537 XCamReturn
rk_aiq_uapi_sysctl_registRkRawCb(const rk_aiq_sys_ctx_t * ctx,void (* callback)(void *))1538 rk_aiq_uapi_sysctl_registRkRawCb(const rk_aiq_sys_ctx_t* ctx, void (*callback)(void*))
1539 {
1540 ENTER_XCORE_FUNCTION();
1541 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1542 if (callback == NULL)
1543 return XCAM_RETURN_ERROR_PARAM;
1544
1545 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1546 #ifdef RKAIQ_ENABLE_CAMGROUP
1547 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
1548 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
1549 if (!camCtx)
1550 continue;
1551
1552 ret = camCtx->_rkAiqManager->registRawdataCb(callback);
1553 }
1554 #else
1555 return XCAM_RETURN_ERROR_FAILED;
1556 #endif
1557 } else {
1558 ret = ctx->_rkAiqManager->registRawdataCb(callback);
1559 }
1560 EXIT_XCORE_FUNCTION();
1561 return ret;
1562 }
1563
1564 XCamReturn
rk_aiq_uapi_sysctl_prepareRkRaw(const rk_aiq_sys_ctx_t * ctx,rk_aiq_raw_prop_t prop)1565 rk_aiq_uapi_sysctl_prepareRkRaw(const rk_aiq_sys_ctx_t* ctx, rk_aiq_raw_prop_t prop)
1566 {
1567 ENTER_XCORE_FUNCTION();
1568 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1569 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1570 #ifdef RKAIQ_ENABLE_CAMGROUP
1571 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
1572 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
1573 if (!camCtx)
1574 continue;
1575
1576 ret = camCtx->_rkAiqManager->rawdataPrepare(prop);
1577 }
1578 #else
1579 return XCAM_RETURN_ERROR_FAILED;
1580 #endif
1581 } else {
1582 ret = ctx->_rkAiqManager->rawdataPrepare(prop);
1583 }
1584 EXIT_XCORE_FUNCTION();
1585
1586 return ret;
1587 }
1588
1589 XCamReturn
rk_aiq_uapi_sysctl_setSharpFbcRotation(const rk_aiq_sys_ctx_t * ctx,rk_aiq_rotation_t rot)1590 rk_aiq_uapi_sysctl_setSharpFbcRotation(const rk_aiq_sys_ctx_t* ctx, rk_aiq_rotation_t rot)
1591 {
1592 ENTER_XCORE_FUNCTION();
1593 RKAIQ_API_SMART_LOCK(ctx);
1594 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1595 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1596 #ifdef RKAIQ_ENABLE_CAMGROUP
1597 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
1598 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
1599 if (!camCtx)
1600 continue;
1601
1602 ret = camCtx->_rkAiqManager->setSharpFbcRotation(rot);
1603 }
1604 #else
1605 return XCAM_RETURN_ERROR_FAILED;
1606 #endif
1607 } else {
1608 ret = ctx->_rkAiqManager->setSharpFbcRotation(rot);
1609 }
1610 EXIT_XCORE_FUNCTION();
1611 return ret;
1612 }
1613
1614 /*!
1615 * \brief switch working mode dynamically
1616 * this aims to switch the isp pipeline working mode fast, and can be called on
1617 * streaming status. On non streaming status, should call rk_aiq_uapi_sysctl_prepare
1618 * instead of this to set working mode.
1619 */
1620 XCamReturn
rk_aiq_uapi_sysctl_swWorkingModeDyn(const rk_aiq_sys_ctx_t * ctx,rk_aiq_working_mode_t mode)1621 rk_aiq_uapi_sysctl_swWorkingModeDyn(const rk_aiq_sys_ctx_t* ctx, rk_aiq_working_mode_t mode)
1622 {
1623 ENTER_XCORE_FUNCTION();
1624 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP)
1625 return XCAM_RETURN_ERROR_FAILED;
1626 RKAIQ_API_SMART_LOCK(ctx);
1627 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1628 /* ret = ctx->_rkAiqManager->swWorkingModeDyn(mode); */
1629 ret = ctx->_rkAiqManager->swWorkingModeDyn_msg(mode);
1630 EXIT_XCORE_FUNCTION();
1631 return ret;
1632 }
1633
1634 void
rk_aiq_uapi_sysctl_setMulCamConc(const rk_aiq_sys_ctx_t * ctx,bool cc)1635 rk_aiq_uapi_sysctl_setMulCamConc(const rk_aiq_sys_ctx_t* ctx, bool cc)
1636 {
1637 ENTER_XCORE_FUNCTION();
1638 RKAIQ_API_SMART_LOCK(ctx);
1639 ctx->_rkAiqManager->setMulCamConc(cc);
1640 EXIT_XCORE_FUNCTION();
1641 }
1642
1643 XCamReturn
rk_aiq_uapi_sysctl_setCrop(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_rect_t rect)1644 rk_aiq_uapi_sysctl_setCrop(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_rect_t rect)
1645 {
1646 RKAIQ_API_SMART_LOCK(sys_ctx);
1647 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1648 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1649 #ifdef RKAIQ_ENABLE_CAMGROUP
1650 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
1651 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
1652 if (!camCtx)
1653 continue;
1654
1655 ret = camCtx->_camHw->setSensorCrop(rect);
1656 }
1657 #else
1658 return XCAM_RETURN_ERROR_FAILED;
1659 #endif
1660 } else {
1661 ret = sys_ctx->_camHw->setSensorCrop(rect);
1662 }
1663 return ret;
1664 }
1665
1666 XCamReturn
rk_aiq_uapi_sysctl_getCrop(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_rect_t * rect)1667 rk_aiq_uapi_sysctl_getCrop(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_rect_t* rect)
1668 {
1669 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1670 LOGE("%s: not support for camgroup\n", __func__);
1671 return XCAM_RETURN_ERROR_FAILED;
1672 }
1673
1674 RKAIQ_API_SMART_LOCK(sys_ctx);
1675 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1676 ret = sys_ctx->_camHw->getSensorCrop(*rect);
1677
1678 return ret;
1679 }
1680
1681 XCamReturn
rk_aiq_uapi_sysctl_updateIq(rk_aiq_sys_ctx_t * sys_ctx,char * iqfile)1682 rk_aiq_uapi_sysctl_updateIq(rk_aiq_sys_ctx_t* sys_ctx, char* iqfile)
1683 {
1684 if (!sys_ctx) {
1685 LOGE("%s: sys_ctx is invalied\n", __func__);
1686 return XCAM_RETURN_ERROR_FAILED;
1687 }
1688
1689 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1690 LOGE("%s: not support for camgroup\n", __func__);
1691 return XCAM_RETURN_ERROR_FAILED;
1692 }
1693
1694 RKAIQ_API_SMART_LOCK(sys_ctx);
1695 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1696
1697 LOGI("applying new iq file:%s\n", iqfile);
1698
1699 auto calibDbProj = RkAiqCalibDbV2::createCalibDbProj(iqfile);
1700 if (!calibDbProj) {
1701 LOGE("failed to create CalibDbProj from iqfile\n");
1702 return XCAM_RETURN_ERROR_PARAM;
1703 }
1704
1705 CamCalibDbV2Context_t calibdbv2_ctx =
1706 RkAiqCalibDbV2::toDefaultCalibDb(calibDbProj);
1707 ret = sys_ctx->_rkAiqManager->updateCalibDb(&calibdbv2_ctx);
1708
1709 if (ret) {
1710 LOGE("failed to update iqfile\n");
1711 return ret;
1712 }
1713
1714 sys_ctx->_calibDbProj = calibDbProj;
1715
1716 return XCAM_RETURN_NO_ERROR;
1717 }
1718
1719 XCamReturn
rk_aiq_uapi_sysctl_tuning(const rk_aiq_sys_ctx_t * sys_ctx,char * param)1720 rk_aiq_uapi_sysctl_tuning(const rk_aiq_sys_ctx_t* sys_ctx, char* param)
1721 {
1722 RKAIQ_API_SMART_LOCK(sys_ctx);
1723 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1724
1725 if (!sys_ctx) {
1726 LOGE("%s: sys_ctx is invalied\n", __func__);
1727 return XCAM_RETURN_ERROR_FAILED;
1728 }
1729
1730 // Find json patch
1731 std::string patch_str(param);
1732 size_t json_start = patch_str.find_first_of("[");
1733 size_t json_end = patch_str.find_last_of("]");
1734
1735 LOGI("patch is:%s\n", patch_str.c_str());
1736
1737 if (json_start >= patch_str.size() || json_end > patch_str.size() ||
1738 json_start >= json_end) {
1739 LOGE("%s: patch is invalied\n", __func__);
1740 return XCAM_RETURN_ERROR_FAILED;
1741 }
1742 std::string json_str = patch_str.substr(json_start, json_end + 1);
1743
1744 if (json_str.empty()) {
1745 LOGE("%s: patch is empty\n", __func__);
1746 return XCAM_RETURN_ERROR_FAILED;
1747 }
1748
1749 auto last_calib = sys_ctx->_rkAiqManager->getCurrentCalibDBV2();
1750
1751 if (!last_calib) {
1752 *last_calib = RkAiqCalibDbV2::toDefaultCalibDb(sys_ctx->_calibDbProj);
1753 if (!last_calib) {
1754 LOGE("%s: default calib is invalied\n", __func__);
1755 return XCAM_RETURN_ERROR_FAILED;
1756 }
1757 }
1758
1759 auto tuning_calib = RkCam::RkAiqCalibDbV2::analyzTuningCalib(
1760 last_calib, json_str.c_str());
1761
1762 #ifdef RKAIQ_ENABLE_CAMGROUP
1763 // api helper call with single instance
1764 if (get_binded_group_ctx(sys_ctx)) {
1765 int crt_cam_index = 0;
1766 rk_aiq_camgroup_ctx_t* grp_ctx = get_binded_group_ctx(sys_ctx);
1767 if (!grp_ctx)
1768 return XCAM_RETURN_ERROR_FAILED;
1769
1770 ret = grp_ctx->cam_group_manager->calibTuning(tuning_calib.calib,
1771 tuning_calib.ModuleNames);
1772 if (ret)
1773 LOGE("Faile to update the calib of camGroup\n", __func__);
1774
1775 for (auto cam_ctx : grp_ctx->cam_ctxs_array) {
1776 if (cam_ctx) {
1777 // Avoid double free
1778 if (crt_cam_index > 0) {
1779 cam_ctx->_rkAiqManager->unsetTuningCalibDb();
1780 }
1781 ret = cam_ctx->_rkAiqManager->calibTuning(tuning_calib.calib,
1782 tuning_calib.ModuleNames);
1783 crt_cam_index++;
1784 }
1785 }
1786 } else {
1787 ret = sys_ctx->_rkAiqManager->calibTuning(tuning_calib.calib,
1788 tuning_calib.ModuleNames);
1789 }
1790 #else
1791 ret = sys_ctx->_rkAiqManager->calibTuning(tuning_calib.calib,
1792 tuning_calib.ModuleNames);
1793 #endif
1794
1795 return ret;
1796 }
1797
rk_aiq_uapi_sysctl_readiq(const rk_aiq_sys_ctx_t * sys_ctx,char * param)1798 char* rk_aiq_uapi_sysctl_readiq(const rk_aiq_sys_ctx_t* sys_ctx, char* param)
1799 {
1800 RKAIQ_API_SMART_LOCK(sys_ctx);
1801 cJSON* cmd_json = NULL;
1802 char* ret_str = NULL;
1803
1804 if (!sys_ctx) {
1805 LOGE("%s: sys_ctx is invalied\n", __func__);
1806 return NULL;
1807 }
1808
1809 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1810 LOGE("%s: not support for camgroup\n", __func__);
1811 return NULL;
1812 }
1813
1814 // Find json patch
1815 std::string patch_str(param);
1816 size_t json_start = patch_str.find_first_of("[");
1817 size_t json_end = patch_str.find_first_of("]");
1818
1819 LOGI("request is:%s\n", patch_str.c_str());
1820
1821 if (json_start >= patch_str.size() || json_end > patch_str.size() ||
1822 json_start >= json_end) {
1823 LOGE("%s: request is invalied\n", __func__);
1824 return NULL;
1825 }
1826 std::string json_str = patch_str.substr(json_start, json_end + 1);
1827
1828 if (json_str.empty()) {
1829 LOGE("%s: request is empty\n", __func__);
1830 return NULL;
1831 }
1832
1833 auto last_calib = sys_ctx->_rkAiqManager->getCurrentCalibDBV2();
1834
1835 if (!last_calib) {
1836 *last_calib = RkAiqCalibDbV2::toDefaultCalibDb(sys_ctx->_calibDbProj);
1837 if (!last_calib) {
1838 LOGE("%s: default calib is invalied\n", __func__);
1839 return NULL;
1840 }
1841 }
1842
1843 ret_str = RkCam::RkAiqCalibDbV2::readIQNodeStrFromJstr(last_calib,
1844 json_str.c_str());
1845
1846 return ret_str;
1847 }
1848
rk_aiq_uapi_sysctl_regMemsSensorIntf(const rk_aiq_sys_ctx_t * sys_ctx,const rk_aiq_mems_sensor_intf_t * intf)1849 XCamReturn rk_aiq_uapi_sysctl_regMemsSensorIntf(const rk_aiq_sys_ctx_t* sys_ctx,
1850 const rk_aiq_mems_sensor_intf_t* intf) {
1851 RKAIQ_API_SMART_LOCK(sys_ctx);
1852 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1853
1854 assert(sys_ctx != nullptr);
1855
1856 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1857 LOGE("%s: not support for camgroup\n", __func__);
1858 return XCAM_RETURN_ERROR_FAILED;
1859 }
1860
1861 ret = sys_ctx->_analyzer->setMemsSensorIntf(intf);
1862 if (ret) {
1863 LOGE("failed to update iqfile\n");
1864 ret = XCAM_RETURN_ERROR_FAILED;
1865 }
1866
1867 return ret;
1868 }
1869
rk_aiq_uapi_sysctl_switch_scene(const rk_aiq_sys_ctx_t * sys_ctx,const char * main_scene,const char * sub_scene)1870 int rk_aiq_uapi_sysctl_switch_scene(const rk_aiq_sys_ctx_t* sys_ctx,
1871 const char* main_scene,
1872 const char* sub_scene)
1873 {
1874 RKAIQ_API_SMART_LOCK(sys_ctx);
1875 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1876
1877 if (!sys_ctx) {
1878 LOGE("%s: sys_ctx is invalied\n", __func__);
1879 return XCAM_RETURN_ERROR_PARAM;
1880 }
1881
1882 if (!main_scene || !sub_scene) {
1883 LOGE("%s: request is invalied\n", __func__);
1884 return XCAM_RETURN_ERROR_PARAM;
1885 }
1886
1887 #ifdef RKAIQ_ENABLE_CAMGROUP
1888 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
1889 rk_aiq_camgroup_ctx_t* grp_ctx = (rk_aiq_camgroup_ctx_t*)(sys_ctx);
1890 if (!grp_ctx)
1891 return XCAM_RETURN_ERROR_FAILED;
1892
1893 for (auto cam_ctx : grp_ctx->cam_ctxs_array) {
1894 if (cam_ctx) {
1895 auto new_calib = RkAiqSceneManager::refToScene(cam_ctx->_calibDbProj,
1896 main_scene, sub_scene);
1897
1898 if (!new_calib.calib_scene) {
1899 LOGE("failed to find scene calib\n");
1900 return -1;
1901 }
1902
1903 ret = cam_ctx->_rkAiqManager->updateCalibDb(&new_calib);
1904 if (ret) {
1905 LOGE("failed to switch scene\n");
1906 return ret;
1907 }
1908 }
1909 }
1910
1911 auto new_calib = RkAiqSceneManager::refToScene(grp_ctx->cam_ctxs_array[0]->_calibDbProj,
1912 main_scene, sub_scene);
1913
1914 if (!new_calib.calib_scene) {
1915 LOGE("failed to find scene calib\n");
1916 return -1;
1917 }
1918
1919 ret = grp_ctx->cam_group_manager->updateCalibDb(&new_calib);
1920 if (ret) {
1921 LOGE("failed to switch scene\n");
1922 return ret;
1923 }
1924 }
1925 #endif
1926 if (sys_ctx->cam_type != RK_AIQ_CAM_TYPE_GROUP) {
1927 auto new_calib = RkAiqSceneManager::refToScene(sys_ctx->_calibDbProj,
1928 main_scene, sub_scene);
1929
1930 if (!new_calib.calib_scene) {
1931 LOGE("failed to find scene calib\n");
1932 return -1;
1933 }
1934
1935 ret = sys_ctx->_rkAiqManager->updateCalibDb(&new_calib);
1936 if (ret) {
1937 LOGE("failed to switch scene\n");
1938 return ret;
1939 }
1940 }
1941
1942 return XCAM_RETURN_NO_ERROR;
1943 }
1944
1945 static XCamReturn
_get_fast_aewb_from_drv(std::string & sensor_name,rkisp32_thunderboot_resmem_head & fastAeAwbInfo)1946 _get_fast_aewb_from_drv(std::string& sensor_name, rkisp32_thunderboot_resmem_head& fastAeAwbInfo)
1947 {
1948 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1949
1950 auto it = CamHwIsp20::mSensorHwInfos.find(sensor_name);
1951 if (it == CamHwIsp20::mSensorHwInfos.end()) {
1952 LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", sensor_name.c_str());
1953 return XCAM_RETURN_ERROR_SENSOR;
1954 }
1955 rk_sensor_full_info_t *s_info = it->second.ptr();
1956 SmartPtr<V4l2SubDevice> IspCoreDev = new V4l2SubDevice(s_info->isp_info->isp_dev_path);
1957 IspCoreDev->open();
1958
1959 if (IspCoreDev->io_control(RKISP_CMD_GET_TB_HEAD_V32, &fastAeAwbInfo) < 0)
1960 ret = XCAM_RETURN_ERROR_FAILED;
1961
1962 IspCoreDev->close();
1963
1964 return ret;
1965 }
1966
_set_fast_aewb_as_init(const rk_aiq_sys_ctx_t * ctx,rk_aiq_working_mode_t mode)1967 static void _set_fast_aewb_as_init(const rk_aiq_sys_ctx_t* ctx, rk_aiq_working_mode_t mode)
1968 {
1969 rkisp32_thunderboot_resmem_head fastAeAwbInfo;
1970 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1971 std::string sensor_name(ctx->_sensor_entity_name);
1972 ret = _get_fast_aewb_from_drv(sensor_name, fastAeAwbInfo);
1973 if (ret == XCAM_RETURN_NO_ERROR) {
1974 // set initial wb
1975 rk_aiq_uapiV2_awb_ffwbgain_attr_t attr;
1976
1977 attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1978 attr.sync.done = false;
1979
1980 // TODO: check last expmode(Linear/Hdr),use hdr_mode in head
1981
1982 if( mode == RK_AIQ_WORKING_MODE_NORMAL) {
1983 float minGain = (8<<8);
1984 minGain = (minGain < fastAeAwbInfo.cfg.others.awb_gain_cfg.awb1_gain_r) ? minGain : fastAeAwbInfo.cfg.others.awb_gain_cfg.awb1_gain_r;
1985 minGain = (minGain < fastAeAwbInfo.cfg.others.awb_gain_cfg.awb1_gain_gr) ? minGain : fastAeAwbInfo.cfg.others.awb_gain_cfg.awb1_gain_gr;
1986 minGain = (minGain < fastAeAwbInfo.cfg.others.awb_gain_cfg.awb1_gain_gb) ? minGain : fastAeAwbInfo.cfg.others.awb_gain_cfg.awb1_gain_gb;
1987 minGain = (minGain < fastAeAwbInfo.cfg.others.awb_gain_cfg.awb1_gain_b) ? minGain : fastAeAwbInfo.cfg.others.awb_gain_cfg.awb1_gain_b;
1988 attr.wggain.rgain = (float)fastAeAwbInfo.cfg.others.awb_gain_cfg.awb1_gain_r / minGain;
1989 attr.wggain.grgain = (float)fastAeAwbInfo.cfg.others.awb_gain_cfg.awb1_gain_gr / minGain;
1990 attr.wggain.gbgain = (float)fastAeAwbInfo.cfg.others.awb_gain_cfg.awb1_gain_gb / minGain;
1991 attr.wggain.bgain = (float)fastAeAwbInfo.cfg.others.awb_gain_cfg.awb1_gain_b / minGain;
1992 } else {
1993 float minGain = (8<<8);
1994 minGain = (minGain < fastAeAwbInfo.cfg.others.awb_gain_cfg.gain0_red) ? minGain : fastAeAwbInfo.cfg.others.awb_gain_cfg.gain0_red;
1995 minGain = (minGain < fastAeAwbInfo.cfg.others.awb_gain_cfg.gain0_green_r) ? minGain : fastAeAwbInfo.cfg.others.awb_gain_cfg.gain0_green_r;
1996 minGain = (minGain < fastAeAwbInfo.cfg.others.awb_gain_cfg.gain0_green_b) ? minGain : fastAeAwbInfo.cfg.others.awb_gain_cfg.gain0_green_b;
1997 minGain = (minGain < fastAeAwbInfo.cfg.others.awb_gain_cfg.gain0_blue) ? minGain : fastAeAwbInfo.cfg.others.awb_gain_cfg.gain0_blue;
1998 attr.wggain.rgain = (float)fastAeAwbInfo.cfg.others.awb_gain_cfg.gain0_red / minGain;
1999 attr.wggain.grgain = (float)fastAeAwbInfo.cfg.others.awb_gain_cfg.gain0_green_r/ minGain;
2000 attr.wggain.gbgain = (float)fastAeAwbInfo.cfg.others.awb_gain_cfg.gain0_green_b / minGain;
2001 attr.wggain.bgain = (float)fastAeAwbInfo.cfg.others.awb_gain_cfg.gain0_blue / minGain;
2002 }
2003
2004 rk_aiq_user_api2_awb_SetFFWbgainAttrib(ctx, attr);
2005
2006 // set initial exposure
2007 if( mode == RK_AIQ_WORKING_MODE_NORMAL) {
2008 Uapi_LinExpAttrV2_t LinExpAttr;
2009 ret = rk_aiq_user_api2_ae_getLinExpAttr(ctx, &LinExpAttr);
2010
2011 LinExpAttr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
2012 LinExpAttr.sync.done = false;
2013 LinExpAttr.Params.InitExp.InitTimeValue = (float)fastAeAwbInfo.head.exp_time[0] / (1 << 16);
2014 LinExpAttr.Params.InitExp.InitGainValue = (float)fastAeAwbInfo.head.exp_gain[0] / (1 << 16);
2015
2016 ret = rk_aiq_user_api2_ae_setLinExpAttr(ctx, LinExpAttr);
2017 } else {
2018 Uapi_HdrExpAttrV2_t HdrExpAttr;
2019 ret = rk_aiq_user_api2_ae_getHdrExpAttr(ctx, &HdrExpAttr);
2020
2021 HdrExpAttr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
2022 HdrExpAttr.sync.done = false;
2023 HdrExpAttr.Params.InitExp.InitTimeValue[0] = (float)fastAeAwbInfo.head.exp_time[0] / (1 << 16);
2024 HdrExpAttr.Params.InitExp.InitGainValue[0] = (float)fastAeAwbInfo.head.exp_gain[0] / (1 << 16);
2025 HdrExpAttr.Params.InitExp.InitTimeValue[1] = (float)fastAeAwbInfo.head.exp_time[1] / (1 << 16);
2026 HdrExpAttr.Params.InitExp.InitGainValue[1] = (float)fastAeAwbInfo.head.exp_gain[1] / (1 << 16);
2027 HdrExpAttr.Params.InitExp.InitTimeValue[2] = (float)fastAeAwbInfo.head.exp_time[2] / (1 << 16);
2028 HdrExpAttr.Params.InitExp.InitGainValue[2] = (float)fastAeAwbInfo.head.exp_gain[2] / (1 << 16);
2029
2030 ret = rk_aiq_user_api2_ae_setHdrExpAttr(ctx, HdrExpAttr);
2031 }
2032 }
2033 }
2034
rk_aiq_uapi_sysctl_tuning_enable(rk_aiq_sys_ctx_t * sys_ctx,bool enable)2035 int rk_aiq_uapi_sysctl_tuning_enable(rk_aiq_sys_ctx_t* sys_ctx, bool enable)
2036 {
2037 RKAIQ_API_SMART_LOCK(sys_ctx);
2038
2039 if (!sys_ctx) {
2040 LOGE("%s: sys_ctx is invalied\n", __func__);
2041 return XCAM_RETURN_ERROR_PARAM;
2042 }
2043
2044 #ifdef RKAIQ_ENABLE_CAMGROUP
2045 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
2046 rk_aiq_camgroup_ctx_t* grp_ctx = (rk_aiq_camgroup_ctx_t*)(sys_ctx);
2047 if (!grp_ctx)
2048 return XCAM_RETURN_ERROR_FAILED;
2049
2050 for (auto cam_ctx : grp_ctx->cam_ctxs_array) {
2051 if (cam_ctx) {
2052 if (enable && cam_ctx->_socket) {
2053 LOGW("%s: socket server is already enabled!\n", __func__);
2054 continue;
2055 }
2056
2057 if (!enable && !cam_ctx->_socket) {
2058 LOGW("%s: socket server is already disabled!\n", __func__);
2059 continue;
2060 }
2061
2062 if (enable) {
2063 cam_ctx->_socket = new SocketServer();
2064 cam_ctx->_socket->Process(cam_ctx, sys_ctx->_camPhyId);
2065 } else {
2066 cam_ctx->_socket->Deinit();
2067 delete(cam_ctx->_socket);
2068 cam_ctx->_socket = NULL;
2069 }
2070
2071 LOGD("%s: change socket server status to %d!\n", __func__, enable);
2072 }
2073 }
2074 return XCAM_RETURN_NO_ERROR;
2075 }
2076 #endif
2077
2078 if (enable && sys_ctx->_socket) {
2079 LOGW("%s: socket server is already enabled!\n", __func__);
2080 return XCAM_RETURN_NO_ERROR;
2081 }
2082
2083 if (!enable && !sys_ctx->_socket) {
2084 LOGW("%s: socket server is already disabled!\n", __func__);
2085 return XCAM_RETURN_NO_ERROR;
2086 }
2087
2088 if (enable) {
2089 sys_ctx->_socket = new SocketServer();
2090 sys_ctx->_socket->Process(sys_ctx, sys_ctx->_camPhyId);
2091 } else {
2092 sys_ctx->_socket->Deinit();
2093 delete(sys_ctx->_socket);
2094 sys_ctx->_socket = NULL;
2095 }
2096
2097 LOGD("%s: change socket server status to %d!\n", __func__, enable);
2098
2099 return XCAM_RETURN_NO_ERROR;
2100 }
2101