1 /*
2 * Copyright (c) 2019-2022 Rockchip Eletronics Co., Ltd.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include "RkAiqCalibDbV2.h"
17
18 #include <fstream>
19 #include <sys/stat.h>
20
21 #include "RkAiqCalibDbV2Helper.h"
22 #include "cJSON_Utils.h"
23 #include "j2s.h"
24 #include "scene/scene_manager.h"
25
26 #ifndef __ANDROID__
27 //#define IQ_DEBUG
28 #endif
29
30 #define CamCalibDbProj_JSON "CamCalibDbProj_t"
31 #define CamCalibDbContextV2_JSON "CamCalibDbV2Context_t"
32 #define JSON_PATCH_PATH "path"
33 #define JSON_PATCH_VALUE "value"
34
calibdbV2_ctx_new()35 CamCalibDbV2Context_t* calibdbV2_ctx_new() {
36 void* calib_scene = NULL;
37
38 #if defined(ISP_HW_V20)
39 calib_scene = new CamCalibDbV2ContextIsp20_t();
40 memset(calib_scene, 0, sizeof(CamCalibDbV2ContextIsp20_t));
41 #elif defined(ISP_HW_V21)
42 calib_scene = new CamCalibDbV2ContextIsp21_t();
43 memset(calib_scene, 0, sizeof(CamCalibDbV2ContextIsp21_t));
44 #elif defined(ISP_HW_V30)
45 calib_scene = new CamCalibDbV2ContextIsp30_t();
46 memset(calib_scene, 0, sizeof(CamCalibDbV2ContextIsp30_t));
47 #elif defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
48 calib_scene = new CamCalibDbV2ContextIsp32_t();
49 memset(calib_scene, 0, sizeof(CamCalibDbV2ContextIsp32_t));
50 #else
51 XCAM_LOG_ERROR("not supported ISP plateform");
52 return NULL;
53 #endif
54
55 CamCalibDbV2Context_t* calib_ctx = new CamCalibDbV2Context_t();
56 calib_ctx->calib_scene = (char*)calib_scene;
57
58 calib_ctx->sensor_info = new CalibDb_Sensor_ParaV2_t();
59 memset(calib_ctx->sensor_info, 0, sizeof(CalibDb_Sensor_ParaV2_t));
60
61 calib_ctx->module_info = new CalibDb_Module_ParaV2_t();
62 memset(calib_ctx->module_info, 0, sizeof(CalibDb_Module_ParaV2_t));
63
64 calib_ctx->sys_cfg = new CalibDb_SysStaticCfg_ParaV2_t();
65 memset(calib_ctx->sys_cfg, 0, sizeof(CalibDb_SysStaticCfg_ParaV2_t));
66
67 return calib_ctx;
68 }
69
calibdbV2_ctx_delete(CamCalibDbV2Context_t * calib_ctx)70 void calibdbV2_ctx_delete(CamCalibDbV2Context_t* calib_ctx) {
71 if (calib_ctx->calib_scene)
72 delete calib_ctx->calib_scene;
73 if (calib_ctx->sensor_info)
74 delete calib_ctx->sensor_info;
75 if (calib_ctx->module_info)
76 delete calib_ctx->module_info;
77 if (calib_ctx->sys_cfg)
78 delete calib_ctx->sys_cfg;
79 delete calib_ctx;
80 }
81
82 namespace RkCam {
83
84 std::map<std::string, CamCalibDbProj_t *> RkAiqCalibDbV2::mCalibDbsMap;
85 std::mutex RkAiqCalibDbV2::calib_mutex;
86
CalibV2Alloc()87 CamCalibDbV2Context_t *RkAiqCalibDbV2::CalibV2Alloc() {
88 CamCalibDbV2Context_t *calibv2 = calibdbV2_ctx_new();
89
90 if (!calibv2) {
91 XCAM_LOG_ERROR("malloc for new calibv2 failed.");
92 return nullptr;
93 }
94 //memset(calibv2, 0, calibdbV2_ctx_size(calibv2));
95
96 return calibv2;
97 }
98
CalibV2Free(CamCalibDbV2Context_t * calibv2)99 int RkAiqCalibDbV2::CalibV2Free(CamCalibDbV2Context_t *calibv2) {
100 if (calibv2) {
101 // TODO: free calibv2 internal space which allocated by j2s
102 calibdbV2_ctx_delete(calibv2);
103 } else {
104 XCAM_LOG_WARNING("try to free an empty calibv2");
105 }
106
107 return 0;
108 }
109
CamCalibDbProjAlloc()110 CamCalibDbProj_t *RkAiqCalibDbV2::CamCalibDbProjAlloc() {
111 CamCalibDbProj_t *calibproj =
112 (CamCalibDbProj_t *)malloc(sizeof(CamCalibDbProj_t));
113 if (!calibproj) {
114 XCAM_LOG_ERROR("malloc for new calibv2 failed.");
115 return nullptr;
116 }
117 memset(calibproj, 0, sizeof(CamCalibDbProj_t));
118
119 return calibproj;
120 }
121
calib_free(void * ptr)122 void calib_free(void *ptr)
123 {
124 if (ptr)
125 free(ptr);
126 XCAM_LOG_DEBUG("free %p\n", ptr);
127 }
128
CamCalibDbProjFree(CamCalibDbProj_t * calibproj)129 int RkAiqCalibDbV2::CamCalibDbProjFree(CamCalibDbProj_t *calibproj) {
130 if (calibproj) {
131 CamCalibDbFreeSensorCtx(&calibproj->sensor_calib);
132 for (int i = 0; i < calibproj->main_scene_len; i++) {
133 CamCalibMainSceneList_t* main_scene = calibproj->main_scene + i;
134 if (main_scene->name)
135 calib_free(main_scene->name);
136 for (int j = 0; j < main_scene->sub_scene_len; j++) {
137 CamCalibSubSceneList_t* sub_scene = main_scene->sub_scene + j;
138 CamCalibDbFreeSceneCtx(calibdbv2_get_scene_ptr(sub_scene));
139 if (sub_scene->name)
140 calib_free(sub_scene->name);
141 }
142 calib_free(main_scene->sub_scene);
143 }
144 if (calibproj->main_scene)
145 calib_free(calibproj->main_scene);
146 if (calibproj->uapi) {
147 for (int i = 0; i < calibproj->uapi_len; i++)
148 CamCalibDbFreeUapiCtx(calibproj->uapi + i);
149 calib_free(calibproj->uapi);
150 }
151 CamCalibDbFreeSysStaticCtx(&calibproj->sys_static_cfg);
152 free(calibproj);
153 } else {
154 XCAM_LOG_WARNING("try to free an empty CamCalibDbProj_t");
155 }
156
157 return 0;
158 }
159
json2calib(const char * jsfile)160 CamCalibDbV2Context_t *RkAiqCalibDbV2::json2calib(const char *jsfile) {
161 #if 0
162 j2s_ctx ctx;
163 int ret = -1;
164
165 j2s_init(&ctx);
166 ctx.format_json = false;
167 ctx.manage_data = false;
168
169 CamCalibDbV2Context_t *calib = CalibV2Alloc();
170
171 ret = j2s_json_file_to_struct(&ctx, jsfile,
172 calibdbv2_get_ctx_struct_name(calib), calib);
173 j2s_deinit(&ctx);
174
175 if (ret) {
176 CalibV2Free(calib);
177 return nullptr;
178 }
179
180 #ifdef IQ_DEBUG
181 calib2json("/tmp/iq_dump.json", calib);
182 #endif
183
184 return calib;
185 #else
186 // TODO
187 return NULL;
188 #endif
189 }
190
json2calibproj(const char * jsfile)191 CamCalibDbProj_t *RkAiqCalibDbV2::json2calibproj(const char *jsfile) {
192 j2s_ctx ctx;
193 char* json_buff = NULL;
194 size_t json_size = 0;
195 cJSON* base_json = NULL;
196 int ret = -1;
197
198 json_buff = (char*)j2s_read_file(jsfile, &json_size);
199 if (!json_buff) {
200 return nullptr;
201 }
202
203 base_json = cJSON_Parse(json_buff);
204 if (!base_json) {
205 free(json_buff);
206 return nullptr;
207 }
208
209 j2s_init(&ctx);
210 ctx.format_json = false;
211 ctx.manage_data = false;
212
213 if (!RkAiqSceneManager::mergeMultiSceneIQ(base_json)) {
214 cJSON_Delete(base_json);
215 j2s_deinit(&ctx);
216 free(json_buff);
217 return nullptr;
218 }
219
220 CamCalibDbProj_t *calibproj = CamCalibDbProjAlloc();
221
222 ret = j2s_json_to_struct(&ctx, base_json, NULL, calibproj);
223 cJSON_Delete(base_json);
224 j2s_deinit(&ctx);
225
226 if (ret) {
227 CamCalibDbProjFree(calibproj);
228 free(json_buff);
229 return nullptr;
230 }
231
232 #ifdef IQ_DEBUG
233 calibproj2json("/tmp/iq_dump.json", calibproj);
234 #endif
235
236 free(json_buff);
237 return calibproj;
238 }
239
json2calibproj(const char * jstr,size_t len)240 CamCalibDbProj_t *RkAiqCalibDbV2::json2calibproj(const char *jstr, size_t len) {
241 j2s_ctx ctx;
242 cJSON* base_json = NULL;
243 int ret = -1;
244
245 if (!jstr || !len) {
246 return nullptr;
247 }
248
249 base_json = cJSON_Parse(jstr);
250 if (!base_json) {
251 return nullptr;
252 }
253
254 j2s_init(&ctx);
255 ctx.format_json = false;
256 ctx.manage_data = false;
257
258 if (!RkAiqSceneManager::mergeMultiSceneIQ(base_json)) {
259 cJSON_Delete(base_json);
260 j2s_deinit(&ctx);
261 return nullptr;
262 }
263
264 CamCalibDbProj_t *calibproj = CamCalibDbProjAlloc();
265
266 ret = j2s_json_to_struct(&ctx, base_json, NULL, calibproj);
267 cJSON_Delete(base_json);
268 j2s_deinit(&ctx);
269
270 if (ret) {
271 CamCalibDbProjFree(calibproj);
272 return nullptr;
273 }
274
275 #ifdef IQ_DEBUG
276 calibproj2json("/tmp/iq_dump.json", calibproj);
277 #endif
278
279 return calibproj;
280 }
281
bin2calibproj(const char * binfile)282 CamCalibDbProj_t *RkAiqCalibDbV2::bin2calibproj(const char *binfile) {
283 CamCalibDbProj_t *calibproj = NULL;
284 char* bin_buff = NULL;
285 size_t bin_size = 0;
286 int ret = -1;
287
288 bin_buff = (char*)loadWholeFile(binfile, &bin_size);
289 if (!bin_buff) {
290 return NULL;
291 }
292
293 ret = parseBinStructMap((uint8_t*)bin_buff, bin_size);
294 if (ret) {
295 return NULL;
296 }
297
298 calibproj = (CamCalibDbProj_t*) bin_buff;
299
300 return calibproj;
301 }
302
bin2calibproj(const void * bin_buff,size_t len)303 CamCalibDbProj_t *RkAiqCalibDbV2::bin2calibproj(const void *bin_buff, size_t len) {
304 CamCalibDbProj_t *calibproj = NULL;
305 int ret = -1;
306
307 if (!bin_buff || !len)
308 return NULL;
309
310 ret = parseBinStructMap((uint8_t*)bin_buff, len);
311 if (ret) {
312 return NULL;
313 }
314
315 calibproj = (CamCalibDbProj_t*) bin_buff;
316
317 return calibproj;
318 }
319
createCalibDbCamgroup(const char * jsfile)320 CamCalibDbCamgroup_t* RkAiqCalibDbV2::createCalibDbCamgroup(const char *jsfile) {
321 j2s_ctx ctx;
322 int ret = -1;
323
324 j2s_camgroup_init(&ctx);
325 ctx.format_json = false;
326 ctx.manage_data = false;
327
328 CamCalibDbCamgroup_t* calib_camgroup =
329 (CamCalibDbCamgroup_t*)calloc(1, sizeof(CamCalibDbCamgroup_t));
330 ret = j2s_json_file_to_root_struct(&ctx, jsfile, calib_camgroup);
331 j2s_deinit(&ctx);
332
333 if (ret) {
334 CamCalibDbCamgroupFree(calib_camgroup);
335 return nullptr;
336 }
337
338 return calib_camgroup;
339 }
340
CamCalibDbCamgroupFree(CamCalibDbCamgroup_t * calib_camgroup)341 int RkAiqCalibDbV2::CamCalibDbCamgroupFree(CamCalibDbCamgroup_t* calib_camgroup)
342 {
343 if (calib_camgroup)
344 free(calib_camgroup);
345 return 0;
346 }
347
calibproj2json(const char * jsfile,CamCalibDbProj_t * calibproj)348 int RkAiqCalibDbV2::calibproj2json(const char *jsfile,
349 CamCalibDbProj_t *calibproj) {
350 char *json_buff = NULL;
351 j2s_ctx ctx;
352
353 ctx.format_json = true;
354 ctx.manage_data = false;
355
356 if (0 != access(jsfile, F_OK)) {
357 XCAM_LOG_INFO("Calibproj file already %s exist, oaverride now!", jsfile);
358 }
359
360 std::ofstream ofile(jsfile);
361 if (ofile.fail()) {
362 XCAM_LOG_ERROR("write %s failed!", jsfile);
363 return -1;
364 }
365
366 j2s_init(&ctx);
367 json_buff = j2s_dump_root_struct(&ctx, calibproj);
368 j2s_deinit(&ctx);
369
370 if (!json_buff) {
371 XCAM_LOG_ERROR("create %s failed.", jsfile);
372 return -1;
373 }
374
375 ofile << json_buff;
376
377 free(json_buff);
378
379 return 0;
380 }
381
calib2json(const char * jsfile,CamCalibDbV2Context_t * calib)382 int RkAiqCalibDbV2::calib2json(const char *jsfile,
383 CamCalibDbV2Context_t *calib) {
384 char *json_buff = NULL;
385 j2s_ctx ctx;
386
387 ctx.format_json = true;
388
389 if (0 != access(jsfile, F_OK)) {
390 XCAM_LOG_INFO("Calib file already %s exist, oaverride now!", jsfile);
391 }
392
393 std::ofstream ofile(jsfile);
394 if (ofile.fail()) {
395 XCAM_LOG_ERROR("write %s failed!", jsfile);
396 return -1;
397 }
398
399 j2s_init(&ctx);
400 json_buff = j2s_dump_struct(&ctx, calibdbv2_get_scene_ctx_struct_name(calib), calib->calib_scene);
401 j2s_deinit(&ctx);
402
403 if (!json_buff) {
404 XCAM_LOG_ERROR("create %s failed.", jsfile);
405 return -1;
406 }
407
408 ofile << json_buff;
409
410 free(json_buff);
411
412 return 0;
413 }
414
cjson2calib(cJSON * json)415 CamCalibDbV2Context_t *RkAiqCalibDbV2::cjson2calib(cJSON *json) {
416 j2s_ctx ctx;
417 int ret = -1;
418
419 j2s_init(&ctx);
420 ctx.format_json = false;
421 ctx.manage_data = false;
422
423 CamCalibDbV2Context_t *calib = CalibV2Alloc();
424
425 ret = j2s_json_to_struct(&ctx, json, calibdbv2_get_scene_ctx_struct_name(calib), calib->calib_scene);
426 j2s_deinit(&ctx);
427
428 if (ret) {
429 CalibV2Free(calib);
430 return nullptr;
431 }
432
433 return calib;
434 }
435
calib2cjson(const CamCalibDbV2Context_t * calib)436 cJSON *RkAiqCalibDbV2::calib2cjson(const CamCalibDbV2Context_t *calib) {
437 cJSON *json = NULL;
438 j2s_ctx ctx;
439
440 j2s_init(&ctx);
441 json = j2s_struct_to_json(&ctx, calibdbv2_get_scene_ctx_struct_name(calib), (void *)calib->calib_scene);
442 j2s_deinit(&ctx);
443
444 if (!json) {
445 XCAM_LOG_ERROR("%s failed.", __func__);
446 return nullptr;
447 }
448
449 return json;
450 }
451
createCalibDbProj(const char * jsfile)452 CamCalibDbProj_t *RkAiqCalibDbV2::createCalibDbProj(const char *jsfile) {
453 std::map<std::string, CamCalibDbProj_t *>::iterator it;
454 CamCalibDbProj_t *calibproj = NULL;
455 std::string str(jsfile);
456 const std::lock_guard<std::mutex> lock(RkAiqCalibDbV2::calib_mutex);
457
458 it = mCalibDbsMap.find(str);
459 if (it != mCalibDbsMap.end()) {
460 XCAM_LOG_INFO("use cached calibdb for %s!", jsfile);
461 return it->second;
462 } else {
463 std::string binfile = str.substr(0, str.find_last_of(".")) + ".bin";
464 if (0 == access(jsfile, F_OK)) {
465 calibproj = json2calibproj(jsfile);
466 } else if (0 == access(binfile.c_str(), F_OK)) {
467 calibproj = bin2calibproj(binfile.c_str());
468 } else {
469 XCAM_LOG_ERROR("access %s && %s failed!", jsfile, binfile.c_str());
470 return nullptr;
471 }
472
473 if (calibproj) {
474 mCalibDbsMap[str] = calibproj;
475 XCAM_LOG_INFO("create calibdb from %s success.", jsfile);
476 return calibproj;
477 } else {
478 XCAM_LOG_ERROR("parse %s failed.", jsfile);
479 return nullptr;
480 }
481 }
482 }
483
createCalibDbProj(const void * bin_buff,size_t len)484 CamCalibDbProj_t *RkAiqCalibDbV2::createCalibDbProj(const void *bin_buff,
485 size_t len) {
486 CamCalibDbProj_t *calibproj = NULL;
487 const std::lock_guard<std::mutex> lock(RkAiqCalibDbV2::calib_mutex);
488
489 calibproj = bin2calibproj(bin_buff, len);
490
491 if (calibproj) {
492 XCAM_LOG_INFO("create calibdb from buffer success.");
493 return calibproj;
494 }
495
496 XCAM_LOG_ERROR("parse binary iq buffer failed.");
497 return nullptr;
498 }
499
releaseCalibDbProj()500 void RkAiqCalibDbV2::releaseCalibDbProj() {
501 std::map<std::string, CamCalibDbProj_t *>::iterator it;
502 for (it = mCalibDbsMap.begin(); it != mCalibDbsMap.end(); it++) {
503 CamCalibDbProj_t *calibproj = it->second;
504 if (calibproj) {
505 CamCalibDbProjFree(calibproj);
506 }
507 }
508 mCalibDbsMap.clear();
509 }
510
511 CamCalibDbV2Context_t
toDefaultCalibDb(CamCalibDbProj_t * calibproj)512 RkAiqCalibDbV2::toDefaultCalibDb(CamCalibDbProj_t *calibproj) {
513 CamCalibDbV2Context_t ctx;
514 memset(&ctx, 0, sizeof(CamCalibDbV2Context_t));
515 if (!calibproj || !calibproj->main_scene ||
516 !calibproj->main_scene[0].sub_scene) {
517 XCAM_LOG_ERROR("CamCalibDbProj in invalied!");
518 return ctx;
519 }
520 ctx.calib_scene = (char*)(calibdbv2_get_scene_ptr(&calibproj->main_scene[0].sub_scene[0]));
521 ctx.sensor_info = &calibproj->sensor_calib;
522 ctx.module_info = &calibproj->module_calib;
523 ctx.sys_cfg = &calibproj->sys_static_cfg;
524
525 return ctx;
526 }
527
528 CamCalibDbV2Context_t *
applyPatch(const CamCalibDbV2Context_t * calib,cJSON * patch)529 RkAiqCalibDbV2::applyPatch(const CamCalibDbV2Context_t *calib, cJSON *patch) {
530 cJSON *base_json = NULL;
531 int ret = -1;
532
533 if (!calib || !patch) {
534 XCAM_LOG_ERROR("%s input invalied!", __func__);
535 return nullptr;
536 }
537
538 base_json = calib2cjson(calib);
539
540 if (!base_json) {
541 XCAM_LOG_ERROR("%s conver failed!", __func__);
542 return nullptr;
543 }
544
545 ret = cJSONUtils_ApplyPatches(base_json, patch);
546 if (0 != ret) {
547 XCAM_LOG_ERROR("%s apply patch failed %d!", __func__, ret);
548 return nullptr;
549 }
550
551 return cjson2calib(base_json);
552 }
553
554 CamCalibDbV2Context_t *
applyPatch(const CamCalibDbV2Context_t * calib,const char * patch_str)555 RkAiqCalibDbV2::applyPatch(const CamCalibDbV2Context_t *calib,
556 const char *patch_str) {
557 cJSON *patch_json = NULL;
558
559 patch_json = cJSON_Parse(patch_str);
560
561 return applyPatch(calib, patch_json);
562 }
563
564 CamCalibDbV2Context_t *
applyPatch2(const CamCalibDbV2Context_t * calib,cJSON * patch)565 RkAiqCalibDbV2::applyPatch2(const CamCalibDbV2Context_t *calib, cJSON *patch) {
566 CamCalibDbV2Context_t *new_calib = NULL;
567 cJSON *base_json = NULL;
568 cJSON *arr_item = NULL;
569 j2s_ctx ctx;
570 ctx.format_json = true;
571 int change_sum = 0;
572 int ret = -1;
573 const std::lock_guard<std::mutex> lock(RkAiqCalibDbV2::calib_mutex);
574
575 if (!calib || !patch) {
576 XCAM_LOG_ERROR("%s input invalied!", __func__);
577 return nullptr;
578 }
579
580 change_sum = cJSON_GetArraySize(patch);
581
582 if (change_sum <= 0) {
583 XCAM_LOG_INFO("[Tuning]: analyz change failed!\n");
584 return nullptr;
585 }
586
587 // check if not common info add "calib_scene" prefix to path
588 arr_item = patch->child;
589
590 for (int i = 0; i <= (change_sum - 1); ++i) {
591 if (arr_item) {
592 auto path_str = std::string(
593 cJSON_GetObjectItem(arr_item, JSON_PATCH_PATH)->valuestring);
594 auto headless = path_str.substr(path_str.find_first_not_of("/"),
595 path_str.find_last_not_of("/"));
596 auto module_name = headless.substr(0, headless.find_first_of("/"));
597
598 if (module_name.compare(std::string("sensor_calib")) == 0) {
599 continue;
600 } else if (module_name.compare(std::string("module_calib")) == 0) {
601 continue;
602 } else if (module_name.compare(std::string("sys_static_cfg")) == 0) {
603 continue;
604 }
605 path_str = std::string("/calib_scene") + path_str;
606 cJSON_ReplaceItemInObject(arr_item, JSON_PATCH_PATH,
607 cJSON_CreateString(path_str.c_str()));
608 }
609 arr_item = arr_item->next;
610 }
611
612 // convert CamCalibDbV2Context_t to CamCalibDbV2Tuning_t
613 CamCalibDbV2Tuning_t tuning_base;
614 memset(&tuning_base, 0, sizeof(CamCalibDbV2Tuning_t));
615 calibdbV2_to_tuningdb(&tuning_base, calib);
616
617 j2s_init(&ctx);
618 base_json = j2s_struct_to_json(&ctx, "CamCalibDbV2Tuning_t", &tuning_base);
619
620 if (!base_json) {
621 XCAM_LOG_ERROR("create CamCalibDbV2Tuning_t failed.");
622 goto patch_failed;
623 }
624
625 ret = cJSONUtils_ApplyPatches(base_json, patch);
626 if (0 != ret) {
627 XCAM_LOG_ERROR("%s apply patch failed %d!", __func__, ret);
628 goto patch_failed;
629 }
630
631 CamCalibDbV2Tuning_t tuning_patched;
632 memset(&tuning_patched, 0, sizeof(CamCalibDbV2Tuning_t));
633 ret = j2s_json_to_struct(&ctx, base_json, "CamCalibDbV2Tuning_t",
634 &tuning_patched);
635 if (0 != ret) {
636 XCAM_LOG_ERROR("%s apply patch failed %d!", __func__, ret);
637 goto patch_failed;
638 }
639
640 new_calib = CalibV2Alloc();
641 calibdbV2_from_tuningdb(new_calib, &tuning_patched);
642
643 patch_failed:
644 j2s_deinit(&ctx);
645
646 if (base_json)
647 cJSON_Delete(base_json);
648
649 return new_calib;
650 }
651
652 CamCalibDbV2Context_t *
applyPatchFile(const CamCalibDbV2Context_t * calib,const char * patch_file)653 RkAiqCalibDbV2::applyPatchFile(const CamCalibDbV2Context_t *calib,
654 const char *patch_file) {
655 size_t json_size = 0;
656 char *json_str = NULL;
657
658 json_str = (char *)j2s_read_file(patch_file, &json_size);
659
660 return applyPatch(calib, json_str);
661 }
662
applyPatch(const char * jsfile,const char * js_patch)663 CamCalibDbV2Context_t *RkAiqCalibDbV2::applyPatch(const char *jsfile,
664 const char *js_patch) {
665 return NULL;
666 }
667
string2algostype(const char * str)668 RkAiqAlgoType_t RkAiqCalibDbV2::string2algostype(const char *str) {
669 static std::unordered_map<std::string, RkAiqAlgoType_t> const table = {
670 {"sensor_calib", RK_AIQ_ALGO_TYPE_AE},
671 {"module_calib", RK_AIQ_ALGO_TYPE_AE},
672 {"ae_calib", RK_AIQ_ALGO_TYPE_AE},
673 {"wb_v20", RK_AIQ_ALGO_TYPE_AWB},
674 {"wb_v21", RK_AIQ_ALGO_TYPE_AWB},
675 {"af_calib", RK_AIQ_ALGO_TYPE_AF},
676 {"af_v30", RK_AIQ_ALGO_TYPE_AF},
677 {"af_v31", RK_AIQ_ALGO_TYPE_AF},
678 {"af_v32", RK_AIQ_ALGO_TYPE_AF},
679 {"ablc_calib", RK_AIQ_ALGO_TYPE_ABLC},
680 {"adpcc_calib", RK_AIQ_ALGO_TYPE_ADPCC},
681 {"amerge_calib_v10", RK_AIQ_ALGO_TYPE_AMERGE},
682 {"amerge_calib_v11", RK_AIQ_ALGO_TYPE_AMERGE},
683 {"amerge_calib_v12", RK_AIQ_ALGO_TYPE_AMERGE},
684 {"atmo_calib", RK_AIQ_ALGO_TYPE_ATMO},
685 {"anr_calib", RK_AIQ_ALGO_TYPE_ANR},
686 {"lsc_v2", RK_AIQ_ALGO_TYPE_ALSC},
687 {"agic_calib_v20", RK_AIQ_ALGO_TYPE_AGIC},
688 {"agic_calib_v21", RK_AIQ_ALGO_TYPE_AGIC},
689 {"debayer_v2", RK_AIQ_ALGO_TYPE_ADEBAYER},
690 {"debayer", RK_AIQ_ALGO_TYPE_ADEBAYER},
691 {"ccm_calib", RK_AIQ_ALGO_TYPE_ACCM},
692 {"ccm_calib_v2", RK_AIQ_ALGO_TYPE_ACCM},
693 {"agamma_calib_v10", RK_AIQ_ALGO_TYPE_AGAMMA},
694 {"agamma_calib_v11", RK_AIQ_ALGO_TYPE_AGAMMA},
695 {"awdr_calib", RK_AIQ_ALGO_TYPE_AWDR},
696 {"adehaze_calib_v10", RK_AIQ_ALGO_TYPE_ADHAZ},
697 {"adehaze_calib_v11", RK_AIQ_ALGO_TYPE_ADHAZ},
698 {"adehaze_calib_v12", RK_AIQ_ALGO_TYPE_ADHAZ},
699 {"lut3d_calib", RK_AIQ_ALGO_TYPE_A3DLUT},
700 {"aldch", RK_AIQ_ALGO_TYPE_ALDCH},
701 {"csm", RK_AIQ_ALGO_TYPE_ACSM},
702 {"cproc", RK_AIQ_ALGO_TYPE_ACP},
703 {"ie", RK_AIQ_ALGO_TYPE_AIE},
704 {"sharp_v1", RK_AIQ_ALGO_TYPE_ASHARP},
705 {"edgefilter_v1", RK_AIQ_ALGO_TYPE_ASHARP},
706 {"aorb_calib", RK_AIQ_ALGO_TYPE_AORB},
707 {"cgc", RK_AIQ_ALGO_TYPE_ACGC},
708 {"asd_calib", RK_AIQ_ALGO_TYPE_ASD},
709 {"adrc_calib_v10", RK_AIQ_ALGO_TYPE_ADRC},
710 {"adrc_calib_v11", RK_AIQ_ALGO_TYPE_ADRC},
711 {"adrc_calib_v12", RK_AIQ_ALGO_TYPE_ADRC},
712 {"adegamma_calib", RK_AIQ_ALGO_TYPE_ADEGAMMA},
713 {"cac_v03", RK_AIQ_ALGO_TYPE_ACAC},
714 {"cac_v10", RK_AIQ_ALGO_TYPE_ACAC},
715 {"cac_v11", RK_AIQ_ALGO_TYPE_ACAC},
716
717 #if ANR_NO_SEPERATE_MARCO
718 {"bayernr_v1", RK_AIQ_ALGO_TYPE_ANR},
719 {"mfnr_v1", RK_AIQ_ALGO_TYPE_ANR},
720 {"ynr_v1", RK_AIQ_ALGO_TYPE_ANR},
721 {"uvnr_v1", RK_AIQ_ALGO_TYPE_ANR},
722 #else
723 {"bayernr_v1", RK_AIQ_ALGO_TYPE_ARAWNR},
724 {"mfnr_v1", RK_AIQ_ALGO_TYPE_AMFNR},
725 {"ynr_v1", RK_AIQ_ALGO_TYPE_AYNR},
726 {"uvnr_v1", RK_AIQ_ALGO_TYPE_ACNR},
727 #endif
728 {"aeis_calib", RK_AIQ_ALGO_TYPE_AEIS},
729 {"afec_calib", RK_AIQ_ALGO_TYPE_AFEC},
730
731 // ror rk356x nr & sharp
732 {"bayernr_v2", RK_AIQ_ALGO_TYPE_ARAWNR},
733 {"ynr_v2", RK_AIQ_ALGO_TYPE_AYNR},
734 {"cnr_v1", RK_AIQ_ALGO_TYPE_ACNR},
735 {"sharp_v3", RK_AIQ_ALGO_TYPE_ASHARP},
736
737 // rk3588 nr & sharp
738 {"bayer2dnr_v2", RK_AIQ_ALGO_TYPE_ARAWNR},
739 {"bayertnr_v2", RK_AIQ_ALGO_TYPE_AMFNR},
740 {"ynr_v3", RK_AIQ_ALGO_TYPE_AYNR},
741 {"cnr_v2", RK_AIQ_ALGO_TYPE_ACNR},
742 {"sharp_v4", RK_AIQ_ALGO_TYPE_ASHARP},
743 {"gain_v2", RK_AIQ_ALGO_TYPE_AGAIN},
744
745 // rv1106 blc nr & sharp
746 {"ablcV32_calib", RK_AIQ_ALGO_TYPE_ABLC},
747 {"bayer2dnr_v23", RK_AIQ_ALGO_TYPE_ARAWNR},
748 {"bayertnr_v23", RK_AIQ_ALGO_TYPE_AMFNR},
749 {"ynr_v22", RK_AIQ_ALGO_TYPE_AYNR},
750 {"cnr_v30", RK_AIQ_ALGO_TYPE_ACNR},
751 {"sharp_v33", RK_AIQ_ALGO_TYPE_ASHARP},
752 {"wb_v32", RK_AIQ_ALGO_TYPE_AWB},
753 };
754
755 auto it = table.find(std::string(str));
756 if (it != table.end()) {
757 return it->second;
758 }
759
760 return RK_AIQ_ALGO_TYPE_NONE;
761 }
762
analyzChange(cJSON * patch)763 ModuleNameList RkAiqCalibDbV2::analyzChange(cJSON *patch) {
764 auto change_name_list = std::make_shared<std::list<std::string>>();
765 cJSON *arr_item = NULL;
766 int change_sum = 0;
767
768 change_sum = cJSON_GetArraySize(patch);
769
770 XCAM_LOG_INFO("[Tuning]: %d changes in this cmd!\n", change_sum);
771
772 if (change_sum <= 0) {
773 XCAM_LOG_INFO("[Tuning]: analyz change failed!\n");
774 return nullptr;
775 }
776
777 arr_item = patch->child;
778
779 for (int i = 0; i <= (change_sum - 1); ++i) {
780 if (arr_item) {
781 auto path_str = std::string(
782 cJSON_GetObjectItem(arr_item, JSON_PATCH_PATH)->valuestring);
783 auto headless = path_str.substr(path_str.find_first_not_of("/"),
784 path_str.find_last_not_of("/"));
785 auto calib_name = headless.substr(0, headless.find_first_of("/"));
786 XCAM_LOG_INFO("[Tuning]: %s changed!\n", calib_name.c_str());
787 change_name_list->push_back(calib_name);
788 }
789 arr_item = arr_item->next;
790 }
791
792 // Remove duplicated item
793 change_name_list->sort();
794 change_name_list->unique();
795
796 return change_name_list;
797 }
798
799 RkAiqCalibDbV2::TuningCalib
analyzTuningCalib(const CamCalibDbV2Context_t * calib,cJSON * patch)800 RkAiqCalibDbV2::analyzTuningCalib(const CamCalibDbV2Context_t *calib,
801 cJSON *patch) {
802 TuningCalib tuning_calib;
803
804 tuning_calib.ModuleNames = analyzChange(patch);
805 tuning_calib.calib = applyPatch2(calib, patch);
806
807 if (patch)
808 cJSON_Delete(patch);
809
810 return tuning_calib;
811 }
812
813 RkAiqCalibDbV2::TuningCalib
analyzTuningCalib(const CamCalibDbV2Context_t * calib,const char * patch_str)814 RkAiqCalibDbV2::analyzTuningCalib(const CamCalibDbV2Context_t *calib,
815 const char *patch_str) {
816 cJSON *patch_json = NULL;
817
818 patch_json = cJSON_Parse(patch_str);
819
820 return analyzTuningCalib(calib, patch_json);
821 }
822
readIQNode(const CamCalibDbV2Context_t * calib,const char * node_path)823 cJSON *RkAiqCalibDbV2::readIQNode(const CamCalibDbV2Context_t *calib,
824 const char *node_path) {
825 cJSON *base_json = NULL;
826 cJSON *ret_json = NULL;
827 auto path_str = std::string(node_path);
828 auto headless = path_str.substr(path_str.find_first_not_of("/"),
829 path_str.find_last_not_of("/"));
830 auto module_name = headless.substr(0, headless.find_first_of("/"));
831
832 if (module_name.compare(std::string("sensor_calib")) == 0 ||
833 module_name.compare(std::string("module_calib")) == 0 ||
834 module_name.compare(std::string("sys_static_cfg")) == 0) {
835 j2s_ctx ctx;
836 ctx.format_json = true;
837 CamCalibDbV2Tuning_t tuning_base;
838
839 memset(&tuning_base, 0, sizeof(CamCalibDbV2Tuning_t));
840 calibdbV2_to_tuningdb(&tuning_base, calib);
841
842 j2s_init(&ctx);
843 base_json = j2s_struct_to_json(&ctx, "CamCalibDbV2Tuning_t", &tuning_base);
844 j2s_deinit(&ctx);
845 } else {
846 base_json = calib2cjson(calib);
847 }
848
849 if (!base_json) {
850 XCAM_LOG_ERROR("%s conver failed!", __func__);
851 return nullptr;
852 }
853
854 cJSON *node_json = cJSONUtils_GetPointer(base_json, node_path);
855 if (node_json) {
856 ret_json = cJSON_Duplicate(node_json, 1);
857 }
858
859 cJSON_Delete(base_json);
860
861 return ret_json;
862 }
863
864 /**
865 * @brief read json string from a json iq
866 *
867 * @param calib
868 * @param node_path
869 *
870 * @return string buffer or NULL, must be free outside.
871 */
readIQNodeStr(const CamCalibDbV2Context_t * calib,const char * node_path)872 char* RkAiqCalibDbV2::readIQNodeStr(const CamCalibDbV2Context_t* calib,
873 const char* node_path) {
874 cJSON* node_json = readIQNode(calib, node_path);
875 if (!node_json) {
876 XCAM_LOG_ERROR("%s find json node failed!", __func__);
877 return nullptr;
878 }
879
880 return cJSON_Print(node_json);
881 }
882
readIQNodeStrFromJstr(const CamCalibDbV2Context_t * calib,const char * json_str)883 char* RkAiqCalibDbV2::readIQNodeStrFromJstr(const CamCalibDbV2Context_t* calib,
884 const char* json_str) {
885 cJSON *request_json = NULL;
886 cJSON *arr_item = NULL;
887 char* ret_str = NULL;
888 int request_sum = 0;
889
890 cJSON *ret_json;
891 ret_json = cJSON_CreateArray();
892
893 request_json = cJSON_Parse(json_str);
894 request_sum = cJSON_GetArraySize(request_json);
895
896 if (request_sum <= 0) {
897 XCAM_LOG_INFO("[Tuning]: analyz request failed!\n");
898 return nullptr;
899 }
900
901 arr_item = request_json->child;
902
903 for (int i = 0; i <= (request_sum - 1); ++i) {
904 if (arr_item) {
905 char* path_str = cJSON_GetObjectItem(arr_item, JSON_PATCH_PATH)->valuestring;
906 cJSON* ret_node = readIQNode(calib, path_str);
907 if (ret_node) {
908 cJSON* ret_item = cJSON_CreateObject();
909 cJSON_AddStringToObject(ret_item, JSON_PATCH_PATH, path_str);
910 cJSON_AddItemToObject(ret_item, JSON_PATCH_VALUE, ret_node);
911 cJSON_AddItemToArray(ret_json, ret_item);
912 }
913 }
914 arr_item = arr_item->next;
915 }
916
917 ret_str = cJSON_Print(ret_json);
918
919 cJSON_Delete(ret_json);
920 cJSON_Delete(request_json);
921
922 return ret_str;
923 }
924
CamCalibDbFreeSysStaticCtx(CalibDb_SysStaticCfg_ParaV2_t * sys_static)925 int RkAiqCalibDbV2::CamCalibDbFreeSysStaticCtx(CalibDb_SysStaticCfg_ParaV2_t* sys_static)
926 {
927 CalibDb_AlgoSwitch_t* algoSwitch = &sys_static->algoSwitch;
928
929 if (algoSwitch->disable_algos)
930 calib_free(algoSwitch->disable_algos);
931
932 return 0;
933 }
934
CamCalibDbFreeUapiCtx(RkaiqUapi_t * uapi)935 int RkAiqCalibDbV2::CamCalibDbFreeUapiCtx(RkaiqUapi_t* uapi)
936 {
937 RkaiqSysCtl_t* system = &uapi->system;
938 aiq_scene_t* scene = &system->scene;
939 if (scene->main_scene)
940 calib_free(scene->main_scene);
941 if (scene->sub_scene)
942 calib_free(scene->sub_scene);
943
944 return 0;
945 }
946
CamCalibDbFreeSensorCtx(CalibDb_Sensor_ParaV2_t * sensor)947 int RkAiqCalibDbV2::CamCalibDbFreeSensorCtx(CalibDb_Sensor_ParaV2_t* sensor)
948 {
949 CalibDb_AecGainRangeV2_t* Gain2Reg = &sensor->Gain2Reg;
950 if (Gain2Reg->GainRange)
951 calib_free(Gain2Reg->GainRange);
952 return 0;
953 }
954
CamCalibDbFreeModuleCtx(CalibDb_Module_ParaV2_t * module)955 int RkAiqCalibDbV2::CamCalibDbFreeModuleCtx(CalibDb_Module_ParaV2_t* module)
956 {
957 return 0;
958 }
959
CamCalibDbFreeAeCtx(CalibDb_Aec_ParaV2_t * ae)960 int RkAiqCalibDbV2::CamCalibDbFreeAeCtx(CalibDb_Aec_ParaV2_t* ae)
961 {
962 CalibDb_LinearAE_AttrV2_t *LinearAeCtrl = &ae->LinearAeCtrl;
963 CalibDb_LinAeRoute_AttrV2_t *Route = &LinearAeCtrl->Route;
964 if (Route->TimeDot)
965 calib_free(Route->TimeDot);
966 if (Route->GainDot)
967 calib_free(Route->GainDot);
968 if (Route->IspDGainDot)
969 calib_free(Route->IspDGainDot);
970 if (Route->PIrisDot)
971 calib_free(Route->PIrisDot);
972
973 CalibDb_AecDynamicSetpointV2_t* DySetpoint = &LinearAeCtrl->DySetpoint;
974 if (DySetpoint->ExpLevel)
975 calib_free(DySetpoint->ExpLevel);
976 if (DySetpoint->DySetpoint)
977 calib_free(DySetpoint->DySetpoint);
978
979 CalibDb_AecBacklightV2_t *BackLightCtrl = &LinearAeCtrl->BackLightCtrl;
980 CalibDb_BacklitSetPointV2_t* BacklitSetPoint = &BackLightCtrl->BacklitSetPoint;
981 if (BacklitSetPoint->ExpLevel)
982 calib_free(BacklitSetPoint->ExpLevel);
983 if (BacklitSetPoint->NonOEPdfTh)
984 calib_free(BacklitSetPoint->NonOEPdfTh);
985 if (BacklitSetPoint->LowLightPdfTh)
986 calib_free(BacklitSetPoint->LowLightPdfTh);
987 if (BacklitSetPoint->TargetLLLuma)
988 calib_free(BacklitSetPoint->TargetLLLuma);
989
990 CalibDb_AecOverExpCtrlV2_t* OverExpCtrl = &LinearAeCtrl->OverExpCtrl;
991 CalibDb_OverExpSetPointV2_t* OverExpSetPoint = &OverExpCtrl->OverExpSetPoint;
992 if (OverExpSetPoint->OEpdf)
993 calib_free(OverExpSetPoint->OEpdf);
994 if (OverExpSetPoint->LowLightWeight)
995 calib_free(OverExpSetPoint->LowLightWeight);
996 if (OverExpSetPoint->HighLightWeight)
997 calib_free(OverExpSetPoint->HighLightWeight);
998
999 CalibDb_HdrAE_AttrV2_t* HdrAeCtrl = &ae->HdrAeCtrl;
1000 CalibDb_ExpRatioCtrlV2_t* ExpRatioCtrl = &HdrAeCtrl->ExpRatioCtrl;
1001 CalibDb_ExpRatioV2_t* ExpRatio = &ExpRatioCtrl->ExpRatio;
1002 if (ExpRatio->RatioExpDot)
1003 calib_free(ExpRatio->RatioExpDot);
1004 if (ExpRatio->M2SRatioFix)
1005 calib_free(ExpRatio->M2SRatioFix);
1006 if (ExpRatio->L2MRatioFix)
1007 calib_free(ExpRatio->L2MRatioFix);
1008 if (ExpRatio->M2SRatioMax)
1009 calib_free(ExpRatio->M2SRatioMax);
1010 if (ExpRatio->L2MRatioMax)
1011 calib_free(ExpRatio->L2MRatioMax);
1012
1013 CalibDb_HdrAeRoute_AttrV2_t* hdr_Route = &HdrAeCtrl->Route;
1014 if (hdr_Route->Frm0TimeDot)
1015 calib_free(hdr_Route->Frm0TimeDot);
1016 if (hdr_Route->Frm0GainDot)
1017 calib_free(hdr_Route->Frm0GainDot);
1018 if (hdr_Route->Frm0IspDGainDot)
1019 calib_free(hdr_Route->Frm0IspDGainDot);
1020 if (hdr_Route->Frm1TimeDot)
1021 calib_free(hdr_Route->Frm1TimeDot);
1022 if (hdr_Route->Frm1GainDot)
1023 calib_free(hdr_Route->Frm1GainDot);
1024 if (hdr_Route->Frm1IspDGainDot)
1025 calib_free(hdr_Route->Frm1IspDGainDot);
1026 if (hdr_Route->Frm2TimeDot)
1027 calib_free(hdr_Route->Frm2TimeDot);
1028 if (hdr_Route->Frm2GainDot)
1029 calib_free(hdr_Route->Frm2GainDot);
1030 if (hdr_Route->Frm2IspDGainDot)
1031 calib_free(hdr_Route->Frm2IspDGainDot);
1032 if (hdr_Route->PIrisDot)
1033 calib_free(hdr_Route->PIrisDot);
1034
1035 CalibDb_LfrmCtrlV2_t* LframeCtrl = &HdrAeCtrl->LframeCtrl;
1036 CalibDb_LfrmSetPointV2_t* LfrmSetPoint = &LframeCtrl->LfrmSetPoint;
1037 if (LfrmSetPoint->LExpLevel)
1038 calib_free(LfrmSetPoint->LExpLevel);
1039 if (LfrmSetPoint->NonOEPdfTh)
1040 calib_free(LfrmSetPoint->NonOEPdfTh);
1041 if (LfrmSetPoint->LowLightPdfTh)
1042 calib_free(LfrmSetPoint->LowLightPdfTh);
1043 if (LfrmSetPoint->LSetPoint)
1044 calib_free(LfrmSetPoint->LSetPoint);
1045 if (LfrmSetPoint->TargetLLLuma)
1046 calib_free(LfrmSetPoint->TargetLLLuma);
1047
1048 CalibDb_MfrmCtrlV2_t* MframeCtrl = &HdrAeCtrl->MframeCtrl;
1049 if (MframeCtrl->MExpLevel)
1050 calib_free(MframeCtrl->MExpLevel);
1051 if (MframeCtrl->MSetPoint)
1052 calib_free(MframeCtrl->MSetPoint);
1053
1054 CalibDb_SfrmCtrlV2_t* SframeCtrl = &HdrAeCtrl->SframeCtrl;
1055 CalibDb_SfrmSetPointV2_t* SfrmSetPoint = &SframeCtrl->SfrmSetPoint;
1056 if (SfrmSetPoint->SExpLevel)
1057 calib_free(SfrmSetPoint->SExpLevel);
1058 if (SfrmSetPoint->SSetPoint)
1059 calib_free(SfrmSetPoint->SSetPoint);
1060 if (SfrmSetPoint->TargetHLLuma)
1061 calib_free(SfrmSetPoint->TargetHLLuma);
1062
1063 CalibDb_AeSyncTestV2_t* SyncTest = &ae->SyncTest;
1064 CalibDb_AlterExpV2_t* AlterExp = &SyncTest->AlterExp;
1065 if (AlterExp->LinearAE)
1066 calib_free(AlterExp->LinearAE);
1067 if (AlterExp->HdrAE)
1068 calib_free(AlterExp->HdrAE);
1069
1070 return 0;
1071 }
1072 #if RKAIQ_HAVE_AWB_V21
CamCalibDbFreeAwbV21Ctx(CalibDbV2_Wb_Para_V21_t * awb)1073 int RkAiqCalibDbV2::CamCalibDbFreeAwbV21Ctx(CalibDbV2_Wb_Para_V21_t* awb)
1074 {
1075 CalibDbV2_Wb_Awb_Para_V21_t* autoPara = &awb->autoPara;
1076 if (autoPara->lsUsedForYuvDet) {
1077 for (int i = 0; i < autoPara->lsUsedForYuvDet_len; i++)
1078 calib_free(autoPara->lsUsedForYuvDet[i]);
1079 }
1080 calib_free(autoPara->lsUsedForYuvDet);
1081
1082 CalibDbV2_Awb_Luma_Weight_t* wpDiffLumaWeight = &autoPara->wpDiffLumaWeight;
1083 if (wpDiffLumaWeight->wpDiffWeightLvSet) {
1084 for (int i = 0; i < wpDiffLumaWeight->wpDiffWeightLvSet_len; i++) {
1085 CalibDbV2_Awb_Luma_Weight_Lv_t* wpDiffWeightLvSet = wpDiffLumaWeight->wpDiffWeightLvSet + i;
1086 if (wpDiffWeightLvSet->ratioSet)
1087 calib_free(wpDiffWeightLvSet->ratioSet);
1088 }
1089 calib_free(wpDiffLumaWeight->wpDiffWeightLvSet);
1090 }
1091
1092 if (autoPara->lightSources) {
1093 for (int i = 0; i < autoPara->lightSources_len; i++) {
1094 CalibDbV2_Awb_Light_V21_t* lightSource = autoPara->lightSources + i;
1095 calib_free(lightSource->name);
1096 if(lightSource->weight.lumaValue)
1097 calib_free(lightSource->weight.lumaValue);
1098 if(lightSource->weight.weight)
1099 calib_free(lightSource->weight.weight);
1100 }
1101 calib_free(autoPara->lightSources);
1102 }
1103 if(autoPara->limitRange.lumaValue)
1104 calib_free(autoPara->limitRange.lumaValue);
1105 if(autoPara->limitRange.maxB)
1106 calib_free(autoPara->limitRange.maxB);
1107 if(autoPara->limitRange.maxR)
1108 calib_free(autoPara->limitRange.maxR);
1109 if(autoPara->limitRange.maxG)
1110 calib_free(autoPara->limitRange.maxG);
1111 if(autoPara->limitRange.maxY)
1112 calib_free(autoPara->limitRange.maxY);
1113 if(autoPara->limitRange.minB)
1114 calib_free(autoPara->limitRange.minB);
1115 if(autoPara->limitRange.minR)
1116 calib_free(autoPara->limitRange.minR);
1117 if(autoPara->limitRange.minG)
1118 calib_free(autoPara->limitRange.minG);
1119 if(autoPara->limitRange.minY)
1120 calib_free(autoPara->limitRange.minY);
1121 CalibDbV2_Wb_Awb_Ext_Com_Para_t* autoExtPara = &awb->autoExtPara;
1122 if (autoExtPara->lightSourceForFirstFrame)
1123 calib_free(autoExtPara->lightSourceForFirstFrame);
1124 CalibDbV2_Awb_Tolerance_t* tolerance = &autoExtPara->tolerance;
1125 if (tolerance->lumaValue)
1126 calib_free(tolerance->lumaValue);
1127 if (tolerance->toleranceValue)
1128 calib_free(tolerance->toleranceValue);
1129
1130 CalibDbV2_Awb_runinterval_t* runInterval = &autoExtPara->runInterval;
1131 if (runInterval->lumaValue)
1132 calib_free(runInterval->lumaValue);
1133 if (runInterval->intervalValue)
1134 calib_free(runInterval->intervalValue);
1135
1136 CalibDbV2_Awb_GainAdjust_t* wbGainAdjust = &autoExtPara->wbGainAdjust;
1137 if (wbGainAdjust->lutAll) {
1138 for (int i = 0; i < wbGainAdjust->lutAll_len; i++) {
1139 CalibDbV2_Awb_Cct_Lut_Cfg_Lv_t *lutAll = wbGainAdjust->lutAll + i;
1140 if (lutAll->ct_lut_out)
1141 calib_free(lutAll->ct_lut_out);
1142 if (lutAll->cri_lut_out)
1143 calib_free(lutAll->cri_lut_out);
1144 }
1145 calib_free(wbGainAdjust->lutAll);
1146 }
1147
1148 CalibDbV2_Awb_Cct_Clip_Cfg_t* wbGainClip = &autoExtPara->wbGainClip;
1149 if (wbGainClip->cct)
1150 calib_free(wbGainClip->cct);
1151 if (wbGainClip->cri_bound_up)
1152 calib_free(wbGainClip->cri_bound_up);
1153 if (wbGainClip->cri_bound_low)
1154 calib_free(wbGainClip->cri_bound_low);
1155
1156 if (autoExtPara->weightForNightGainCalc)
1157 calib_free(autoExtPara->weightForNightGainCalc);
1158
1159 CalibDbV2_Awb_Sgc_t* singleColorProces = &autoExtPara->singleColorProces;
1160 if (singleColorProces->colorBlock)
1161 calib_free(singleColorProces->colorBlock);
1162 if (singleColorProces->lsUsedForEstimation) {
1163 for (int i = 0; i < singleColorProces->lsUsedForEstimation_len; i++) {
1164 CalibDbV2_Awb_Sgc_Ls_t *lsUsedForEstimation = singleColorProces->lsUsedForEstimation + i;
1165 calib_free(lsUsedForEstimation->name);
1166 }
1167 calib_free(singleColorProces->lsUsedForEstimation);
1168 }
1169 if(autoExtPara->division.wpNumTh.high)
1170 calib_free(autoExtPara->division.wpNumTh.high);
1171 if(autoExtPara->division.wpNumTh.low)
1172 calib_free(autoExtPara->division.wpNumTh.low);
1173 if(autoExtPara->division.wpNumTh.lumaValue)
1174 calib_free(autoExtPara->division.wpNumTh.lumaValue);
1175 if(autoExtPara->xyRegionStableSelection.wpNumTh.lumaValue)
1176 calib_free(autoExtPara->xyRegionStableSelection.wpNumTh.lumaValue);
1177 if(autoExtPara->xyRegionStableSelection.wpNumTh.forBigType)
1178 calib_free(autoExtPara->xyRegionStableSelection.wpNumTh.forBigType);
1179 if(autoExtPara->xyRegionStableSelection.wpNumTh.forExtraType)
1180 calib_free(autoExtPara->xyRegionStableSelection.wpNumTh.forExtraType);
1181 CalibDbV2_Awb_SmartRun_t* smartRun = &autoExtPara->smartRun;
1182 if (smartRun->cfg.lumaValue)
1183 calib_free(smartRun->cfg.lumaValue);
1184 if (smartRun->cfg.lvVarTh)
1185 calib_free(smartRun->cfg.lvVarTh);
1186 if (smartRun->cfg.wbgainAlgDiffTh)
1187 calib_free(smartRun->cfg.wbgainAlgDiffTh);
1188 if (smartRun->cfg.wbgainHwDiffTh)
1189 calib_free(smartRun->cfg.wbgainHwDiffTh);
1190 return 0;
1191 }
1192 #endif
1193 #if RKAIQ_HAVE_AWB_V32
CamCalibDbFreeAwbV32Ctx(CalibDbV2_Wb_Para_V32_t * awb)1194 int RkAiqCalibDbV2::CamCalibDbFreeAwbV32Ctx(CalibDbV2_Wb_Para_V32_t* awb)
1195 {
1196 CalibDbV2_Wb_Awb_Para_V32_t* autoPara = &awb->autoPara;
1197 CalibDbV2_Awb_offset_data_t* offset = &autoPara->blc2ForAwb.offset;
1198 if (offset->ISO)
1199 calib_free(offset->ISO);
1200 if (offset->R_Channel)
1201 calib_free(offset->R_Channel);
1202 if (offset->Gr_Channel)
1203 calib_free(offset->Gr_Channel);
1204 if (offset->Gb_Channel)
1205 calib_free(offset->Gb_Channel);
1206 if (offset->B_Channel)
1207 calib_free(offset->B_Channel);
1208
1209
1210 CalibDbV2_Awb_Luma_Weight_t* wpDiffLumaWeight = &autoPara->wpDiffLumaWeight;
1211 if (wpDiffLumaWeight->wpDiffWeightLvSet) {
1212 for (int i = 0; i < wpDiffLumaWeight->wpDiffWeightLvSet_len; i++) {
1213 CalibDbV2_Awb_Luma_Weight_Lv_t* wpDiffWeightLvSet = wpDiffLumaWeight->wpDiffWeightLvSet + i;
1214 if (wpDiffWeightLvSet->ratioSet)
1215 calib_free(wpDiffWeightLvSet->ratioSet);
1216 }
1217 calib_free(wpDiffLumaWeight->wpDiffWeightLvSet);
1218 }
1219
1220 if (autoPara->lightSources) {
1221 for (int i = 0; i < autoPara->lightSources_len; i++) {
1222 CalibDbV2_Awb_Light_V32_t* lightSource = autoPara->lightSources + i;
1223 calib_free(lightSource->name);
1224 if(lightSource->weight.lumaValue)
1225 calib_free(lightSource->weight.lumaValue);
1226 if(lightSource->weight.weight)
1227 calib_free(lightSource->weight.weight);
1228 }
1229 calib_free(autoPara->lightSources);
1230 }
1231 if(autoPara->limitRange.lumaValue)
1232 calib_free(autoPara->limitRange.lumaValue);
1233 if(autoPara->limitRange.maxB)
1234 calib_free(autoPara->limitRange.maxB);
1235 if(autoPara->limitRange.maxR)
1236 calib_free(autoPara->limitRange.maxR);
1237 if(autoPara->limitRange.maxG)
1238 calib_free(autoPara->limitRange.maxG);
1239 if(autoPara->limitRange.maxY)
1240 calib_free(autoPara->limitRange.maxY);
1241 if(autoPara->limitRange.minB)
1242 calib_free(autoPara->limitRange.minB);
1243 if(autoPara->limitRange.minR)
1244 calib_free(autoPara->limitRange.minR);
1245 if(autoPara->limitRange.minG)
1246 calib_free(autoPara->limitRange.minG);
1247 if(autoPara->limitRange.minY)
1248 calib_free(autoPara->limitRange.minY);
1249 for(int i=0;i<CALD_AWB_EXCRANGE_NUM_MAX;i++){
1250 if(autoPara->extraWpRange[i].weightInculde.lumaValue)
1251 calib_free(autoPara->extraWpRange[i].weightInculde.lumaValue);
1252 if(autoPara->extraWpRange[i].weightInculde.weight)
1253 calib_free(autoPara->extraWpRange[i].weightInculde.weight);
1254 }
1255 CalibDbV2_Wb_Awb_Ext_Para_V32_t* autoExtPara = &awb->autoExtPara;
1256 if (autoExtPara->lightSourceForFirstFrame)
1257 calib_free(autoExtPara->lightSourceForFirstFrame);
1258 CalibDbV2_Awb_SmartRun_t* smartRun = &autoExtPara->smartRun;
1259 if (smartRun->cfg.lumaValue)
1260 calib_free(smartRun->cfg.lumaValue);
1261 if (smartRun->cfg.lvVarTh)
1262 calib_free(smartRun->cfg.lvVarTh);
1263 if (smartRun->cfg.wbgainAlgDiffTh)
1264 calib_free(smartRun->cfg.wbgainAlgDiffTh);
1265 if (smartRun->cfg.wbgainHwDiffTh)
1266 calib_free(smartRun->cfg.wbgainHwDiffTh);
1267
1268
1269 CalibDbV2_Awb_Tolerance_t* tolerance = &autoExtPara->tolerance;
1270 if (tolerance->lumaValue)
1271 calib_free(tolerance->lumaValue);
1272 if (tolerance->toleranceValue)
1273 calib_free(tolerance->toleranceValue);
1274
1275 CalibDbV2_Awb_runinterval_t* runInterval = &autoExtPara->runInterval;
1276 if (runInterval->lumaValue)
1277 calib_free(runInterval->lumaValue);
1278 if (runInterval->intervalValue)
1279 calib_free(runInterval->intervalValue);
1280
1281 CalibDbV2_Awb_GainAdjust2_t* wbGainAdjust = &autoExtPara->wbGainAdjust;
1282 if (wbGainAdjust->lutAll) {
1283 calib_free(wbGainAdjust->lutAll);
1284 }
1285
1286 CalibDbV2_Awb_Cct_Clip_Cfg_t* wbGainClip = &autoExtPara->wbGainClip;
1287 if (wbGainClip->cct)
1288 calib_free(wbGainClip->cct);
1289 if (wbGainClip->cri_bound_up)
1290 calib_free(wbGainClip->cri_bound_up);
1291 if (wbGainClip->cri_bound_low)
1292 calib_free(wbGainClip->cri_bound_low);
1293
1294 if (autoExtPara->weightForNightGainCalc)
1295 calib_free(autoExtPara->weightForNightGainCalc);
1296
1297 CalibDbV2_Awb_Sgc_t* singleColorProces = &autoExtPara->singleColorProces;
1298 if (singleColorProces->colorBlock)
1299 calib_free(singleColorProces->colorBlock);
1300 if (singleColorProces->lsUsedForEstimation) {
1301 for (int i = 0; i < singleColorProces->lsUsedForEstimation_len; i++) {
1302 CalibDbV2_Awb_Sgc_Ls_t *lsUsedForEstimation = singleColorProces->lsUsedForEstimation + i;
1303 calib_free(lsUsedForEstimation->name);
1304 }
1305 calib_free(singleColorProces->lsUsedForEstimation);
1306 }
1307 if(autoExtPara->division.wpNumTh.high)
1308 calib_free(autoExtPara->division.wpNumTh.high);
1309 if(autoExtPara->division.wpNumTh.low)
1310 calib_free(autoExtPara->division.wpNumTh.low);
1311 if(autoExtPara->division.wpNumTh.lumaValue)
1312 calib_free(autoExtPara->division.wpNumTh.lumaValue);
1313 if(autoExtPara->xyRegionStableSelection.wpNumTh.lumaValue)
1314 calib_free(autoExtPara->xyRegionStableSelection.wpNumTh.lumaValue);
1315 if(autoExtPara->xyRegionStableSelection.wpNumTh.forBigType)
1316 calib_free(autoExtPara->xyRegionStableSelection.wpNumTh.forBigType);
1317 if(autoExtPara->xyRegionStableSelection.wpNumTh.forExtraType)
1318 calib_free(autoExtPara->xyRegionStableSelection.wpNumTh.forExtraType);
1319 return 0;
1320 }
1321 #endif
1322
1323 #if RKAIQ_HAVE_GAMMA_V10
CamCalibDbFreeGammaCtx(CalibDbV2_gamma_v10_t * gamma)1324 int RkAiqCalibDbV2::CamCalibDbFreeGammaCtx(CalibDbV2_gamma_v10_t* gamma) {
1325 return 0;
1326 }
1327 #endif
1328
1329 #if RKAIQ_HAVE_GAMMA_V11
CamCalibDbFreeGammaV2Ctx(CalibDbV2_gamma_v11_t * gamma)1330 int RkAiqCalibDbV2::CamCalibDbFreeGammaV2Ctx(CalibDbV2_gamma_v11_t* gamma) {
1331 return 0;
1332 }
1333 #endif
1334
1335 #if RKAIQ_HAVE_BLC_V1
CamCalibDbFreeBlcCtx(CalibDbV2_Ablc_t * blc)1336 int RkAiqCalibDbV2::CamCalibDbFreeBlcCtx(CalibDbV2_Ablc_t* blc)
1337 {
1338 return 0;
1339 }
1340 #endif
1341
1342 #if RKAIQ_HAVE_BLC_V32
CamCalibDbFreeBlcV32Ctx(CalibDbV2_Blc_V32_t * blc_v32)1343 int RkAiqCalibDbV2::CamCalibDbFreeBlcV32Ctx(CalibDbV2_Blc_V32_t* blc_v32)
1344 {
1345 return 0;
1346 }
1347 #endif
1348 #if RKAIQ_HAVE_GIC_V21
CamCalibDbFreeGicV21Ctx(CalibDbV2_Gic_V21_t * gic)1349 int RkAiqCalibDbV2::CamCalibDbFreeGicV21Ctx(CalibDbV2_Gic_V21_t* gic)
1350 {
1351 CalibDbGicV21_t* GicTuningPara = &gic->GicTuningPara;
1352 Gic_setting_v21_t* GicData = &GicTuningPara->GicData;
1353 if (GicData->ISO)
1354 calib_free(GicData->ISO);
1355 if (GicData->min_busy_thre)
1356 calib_free(GicData->min_busy_thre);
1357 if (GicData->min_grad_thr1)
1358 calib_free(GicData->min_grad_thr1);
1359 if (GicData->min_grad_thr2)
1360 calib_free(GicData->min_grad_thr2);
1361 if (GicData->k_grad1)
1362 calib_free(GicData->k_grad1);
1363 if (GicData->k_grad2)
1364 calib_free(GicData->k_grad2);
1365 if (GicData->gb_thre)
1366 calib_free(GicData->gb_thre);
1367 if (GicData->maxCorV)
1368 calib_free(GicData->maxCorV);
1369 if (GicData->maxCorVboth)
1370 calib_free(GicData->maxCorVboth);
1371 if (GicData->dark_thre)
1372 calib_free(GicData->dark_thre);
1373 if (GicData->dark_threHi)
1374 calib_free(GicData->dark_threHi);
1375 if (GicData->k_grad1_dark)
1376 calib_free(GicData->k_grad1_dark);
1377 if (GicData->k_grad2_dark)
1378 calib_free(GicData->k_grad2_dark);
1379 if (GicData->min_grad_thr_dark1)
1380 calib_free(GicData->min_grad_thr_dark1);
1381 if (GicData->min_grad_thr_dark2)
1382 calib_free(GicData->min_grad_thr_dark2);
1383 if (GicData->noiseCurve_0)
1384 calib_free(GicData->noiseCurve_0);
1385 if (GicData->noiseCurve_1)
1386 calib_free(GicData->noiseCurve_1);
1387 if (GicData->NoiseScale)
1388 calib_free(GicData->NoiseScale);
1389 if (GicData->NoiseBase)
1390 calib_free(GicData->NoiseBase);
1391 if (GicData->globalStrength)
1392 calib_free(GicData->globalStrength);
1393 if (GicData->diff_clip)
1394 calib_free(GicData->diff_clip);
1395
1396 return 0;
1397 }
1398 #endif
1399
CamCalibDbFreeDpccCtx(CalibDbV2_Dpcc_t * dpcc)1400 int RkAiqCalibDbV2::CamCalibDbFreeDpccCtx(CalibDbV2_Dpcc_t* dpcc)
1401 {
1402 CalibDbDpccV20_t* DpccTuningPara = &dpcc->DpccTuningPara;
1403 CalibDb_Dpcc_Fast_Mode_V20_t* Fast_Mode = &DpccTuningPara->Fast_Mode;
1404 FastData_t* Fast_Data = &Fast_Mode->Fast_Data;
1405
1406 if (Fast_Data->ISO)
1407 calib_free(Fast_Data->ISO);
1408 if (Fast_Data->Single_level)
1409 calib_free(Fast_Data->Single_level);
1410 if (Fast_Data->Double_level)
1411 calib_free(Fast_Data->Double_level);
1412 if (Fast_Data->Triple_level)
1413 calib_free(Fast_Data->Triple_level);
1414
1415 CalibDb_Dpcc_Sensor_V20_t* Sensor_dpcc = &DpccTuningPara->Sensor_dpcc;
1416 SensorDpccData_t* SensorDpcc_Data = &Sensor_dpcc->SensorDpcc_Data;
1417 if (SensorDpcc_Data->ISO)
1418 calib_free(SensorDpcc_Data->ISO);
1419 if (SensorDpcc_Data->level_single)
1420 calib_free(SensorDpcc_Data->level_single);
1421 if (SensorDpcc_Data->level_multiple)
1422 calib_free(SensorDpcc_Data->level_multiple);
1423
1424 return 0;
1425 }
1426
1427 #if RKAIQ_HAVE_ORB_V1
CamCalibDbFreeOrbCtx(CalibDbV2_Orb_t * orb)1428 int RkAiqCalibDbV2::CamCalibDbFreeOrbCtx(CalibDbV2_Orb_t* orb)
1429 {
1430 return 0;
1431 }
1432 #endif
1433
1434
1435 #if RKAIQ_HAVE_DEBAYER_V1
CamCalibDbFreeDebayerCtx(CalibDbV2_Debayer_t * debayer_v1)1436 int RkAiqCalibDbV2::CamCalibDbFreeDebayerCtx(CalibDbV2_Debayer_t* debayer_v1)
1437 {
1438 return 0;
1439 }
1440 #endif
1441
1442 #if RKAIQ_HAVE_DEBAYER_V2
CamCalibDbFreeDebayerV2Ctx(CalibDbV2_Debayer_v2_t * debayer_v2)1443 int RkAiqCalibDbV2::CamCalibDbFreeDebayerV2Ctx(CalibDbV2_Debayer_v2_t* debayer_v2)
1444 {
1445 return 0;
1446 }
1447 #endif
1448
1449 #if RKAIQ_HAVE_DEBAYER_V2_LITE
CamCalibDbFreeDebayerV2Ctx(CalibDbV2_Debayer_v2_lite_t * debayer_v2)1450 int RkAiqCalibDbV2::CamCalibDbFreeDebayerV2Ctx(CalibDbV2_Debayer_v2_lite_t* debayer_v2)
1451 {
1452 return 0;
1453 }
1454 #endif
1455
1456 #if RKAIQ_HAVE_ACP_V10
CamCalibDbFreeCprocCtx(CalibDbV2_Cproc_t * cproc)1457 int RkAiqCalibDbV2::CamCalibDbFreeCprocCtx(CalibDbV2_Cproc_t* cproc)
1458 {
1459 return 0;
1460 }
1461 #endif
1462 #if RKAIQ_HAVE_AIE_V10
CamCalibDbFreeIeCtx(CalibDbV2_IE_t * ie)1463 int RkAiqCalibDbV2::CamCalibDbFreeIeCtx(CalibDbV2_IE_t* ie)
1464 {
1465 return 0;
1466 }
1467 #endif
1468
CamCalibDbFreeLscCtx(CalibDbV2_LSC_t * lsc)1469 int RkAiqCalibDbV2::CamCalibDbFreeLscCtx(CalibDbV2_LSC_t* lsc)
1470 {
1471 CalibDbV2_Lsc_Common_t* common = &lsc->common;
1472 if (common->resolutionAll)
1473 calib_free(common->resolutionAll);
1474
1475 CalibDbV2_AlscCof_t* alscCoef = &lsc->alscCoef;
1476 if (alscCoef->illAll) {
1477 for (int i = 0; i < alscCoef->illAll_len; i++) {
1478 CalibDbV2_AlscCof_ill_t* ill = alscCoef->illAll + i;
1479 if (ill->tableUsed)
1480 calib_free(ill->tableUsed);
1481 if (ill->gains)
1482 calib_free(ill->gains);
1483 if (ill->vig)
1484 calib_free(ill->vig);
1485 }
1486 calib_free(alscCoef->illAll);
1487 }
1488
1489 CalibDbV2_LscTable_t* tbl = &lsc->tbl;
1490 if (tbl->tableAll)
1491 calib_free(tbl->tableAll);
1492
1493 return 0;
1494 }
1495
CamCalibDbFreeColorAsGreyCtx(CalibDbV2_ColorAsGrey_t * colorAsGrey)1496 int RkAiqCalibDbV2::CamCalibDbFreeColorAsGreyCtx(CalibDbV2_ColorAsGrey_t* colorAsGrey)
1497 {
1498 return 0;
1499 }
1500
CamCalibDbFreeLumaDetectCtx(CalibDbV2_LUMA_DETECT_t * lumaDetect)1501 int RkAiqCalibDbV2::CamCalibDbFreeLumaDetectCtx(CalibDbV2_LUMA_DETECT_t* lumaDetect)
1502 {
1503 return 0;
1504 }
1505
1506 #if (RKAIQ_HAVE_LDCH_V10 || RKAIQ_HAVE_LDCH_V21)
CamCalibDbFreeLdchCtx(CalibDbV2_LDCH_t * ldch)1507 int RkAiqCalibDbV2::CamCalibDbFreeLdchCtx(CalibDbV2_LDCH_t* ldch)
1508 {
1509 return 0;
1510 }
1511 #endif
1512
1513 #if RKAIQ_HAVE_CCM_V1
CamCalibDbFreeCcmV1Ctx(CalibDbV2_Ccm_Para_V2_t * ccm)1514 int RkAiqCalibDbV2::CamCalibDbFreeCcmV1Ctx(CalibDbV2_Ccm_Para_V2_t* ccm) {
1515 CalibDbV2_Ccm_Tuning_Para_t* TuningPara = &ccm->TuningPara;
1516 CalibDbV2_Ccm_illu_est_Para_t* illu_estim = &TuningPara->illu_estim;
1517
1518 if (illu_estim->default_illu) calib_free(illu_estim->default_illu);
1519
1520 if (TuningPara->aCcmCof) {
1521 for (int i = 0; i < TuningPara->aCcmCof_len; i++) {
1522 CalibDbV2_Ccm_Accm_Cof_Para_t* aCcmCof = TuningPara->aCcmCof + i;
1523 if (aCcmCof->name) calib_free(aCcmCof->name);
1524 for (int j = 0; j < aCcmCof->matrixUsed_len; j++) {
1525 if (aCcmCof->matrixUsed[j]) calib_free(aCcmCof->matrixUsed[j]);
1526 }
1527 if (aCcmCof->matrixUsed) calib_free(aCcmCof->matrixUsed);
1528 }
1529 calib_free(TuningPara->aCcmCof);
1530 }
1531
1532 if (TuningPara->matrixAll) {
1533 for (int i = 0; i < TuningPara->matrixAll_len; i++) {
1534 CalibDbV2_Ccm_Matrix_Para_t* matrixAll = TuningPara->matrixAll + i;
1535 if (matrixAll->name) calib_free(matrixAll->name);
1536 if (matrixAll->illumination) calib_free(matrixAll->illumination);
1537 }
1538 calib_free(TuningPara->matrixAll);
1539 }
1540
1541 return 0;
1542 }
1543 #endif
1544
1545 #if RKAIQ_HAVE_CCM_V2
CamCalibDbFreeCcmV2Ctx(CalibDbV2_Ccm_Para_V32_t * ccm)1546 int RkAiqCalibDbV2::CamCalibDbFreeCcmV2Ctx(CalibDbV2_Ccm_Para_V32_t* ccm) {
1547 CalibDbV2_Ccm_Tuning_Para_t* TuningPara = &ccm->TuningPara;
1548 CalibDbV2_Ccm_illu_est_Para_t* illu_estim = &TuningPara->illu_estim;
1549
1550 if (illu_estim->default_illu)
1551 calib_free(illu_estim->default_illu);
1552
1553 if (TuningPara->aCcmCof) {
1554 for (int i = 0; i < TuningPara->aCcmCof_len; i++) {
1555 CalibDbV2_Ccm_Accm_Cof_Para_t* aCcmCof = TuningPara->aCcmCof + i;
1556 if (aCcmCof->name)
1557 calib_free(aCcmCof->name);
1558 for ( int j = 0; j < aCcmCof->matrixUsed_len; j++) {
1559 if (aCcmCof->matrixUsed[j])
1560 calib_free(aCcmCof->matrixUsed[j]);
1561 }
1562 if (aCcmCof->matrixUsed)
1563 calib_free(aCcmCof->matrixUsed);
1564 }
1565 calib_free(TuningPara->aCcmCof);
1566 }
1567
1568 if (TuningPara->matrixAll) {
1569 for (int i = 0; i < TuningPara->matrixAll_len; i++) {
1570 CalibDbV2_Ccm_Matrix_Para_t* matrixAll = TuningPara->matrixAll + i;
1571 if (matrixAll->name)
1572 calib_free(matrixAll->name);
1573 if (matrixAll->illumination)
1574 calib_free(matrixAll->illumination);
1575 }
1576 calib_free(TuningPara->matrixAll);
1577 }
1578
1579 return 0;
1580 }
1581 #endif
1582
1583 #if RKAIQ_HAVE_3DLUT_V1
CamCalibDbFreeLut3dCtx(CalibDbV2_Lut3D_Para_V2_t * lut3d)1584 int RkAiqCalibDbV2::CamCalibDbFreeLut3dCtx(CalibDbV2_Lut3D_Para_V2_t* lut3d)
1585 {
1586 CalibDbV2_Lut3D_Auto_Para_t* ALut3D = &lut3d->ALut3D;
1587 if (ALut3D->lutAll) {
1588 CalibDbV2_Lut3D_LutPara_t* lutAll = ALut3D->lutAll;
1589 for (int i = 0; i < ALut3D->lutAll_len; i++) {
1590 lutAll = lutAll + i;
1591 if (lutAll->name)
1592 calib_free(lutAll->name);
1593 }
1594
1595 calib_free(ALut3D->lutAll);
1596 }
1597
1598 return 0;
1599 }
1600 #endif
1601
1602 #if RKAIQ_HAVE_AF_V20
CamCalibDbFreeAfV2xCtx(CalibDbV2_AF_t * af)1603 int RkAiqCalibDbV2::CamCalibDbFreeAfV2xCtx(CalibDbV2_AF_t* af)
1604 {
1605 CalibDbV2_AF_Tuning_Para_t* TuningPara = &af->TuningPara;
1606 CalibDbV2_Af_ZoomFocusTbl_t* zoomfocus_tbl = &TuningPara->zoomfocus_tbl;
1607
1608 if (zoomfocus_tbl->zoom_move_dot)
1609 calib_free(zoomfocus_tbl->zoom_move_dot);
1610 if (zoomfocus_tbl->zoom_move_step)
1611 calib_free(zoomfocus_tbl->zoom_move_step);
1612 if (zoomfocus_tbl->focal_length)
1613 calib_free(zoomfocus_tbl->focal_length);
1614 if (zoomfocus_tbl->zoomcode)
1615 calib_free(zoomfocus_tbl->zoomcode);
1616
1617 for (int i = 0; i < zoomfocus_tbl->focuscode_len; i++) {
1618 if (zoomfocus_tbl->focuscode[i].code)
1619 calib_free(zoomfocus_tbl->focuscode[i].code);
1620 }
1621 if (zoomfocus_tbl->focuscode)
1622 calib_free(zoomfocus_tbl->focuscode);
1623
1624 if (zoomfocus_tbl->ZoomSearchTbl)
1625 calib_free(zoomfocus_tbl->ZoomSearchTbl);
1626 if (zoomfocus_tbl->FocusSearchPlusRange)
1627 calib_free(zoomfocus_tbl->FocusSearchPlusRange);
1628 if (zoomfocus_tbl->ZoomInfoDir)
1629 calib_free(zoomfocus_tbl->ZoomInfoDir);
1630
1631 if (TuningPara->contrast_af.AdaptRangeTbl)
1632 calib_free(TuningPara->contrast_af.AdaptRangeTbl);
1633 if (TuningPara->contrast_af.TrigThers)
1634 calib_free(TuningPara->contrast_af.TrigThers);
1635 if (TuningPara->contrast_af.TrigThersFv)
1636 calib_free(TuningPara->contrast_af.TrigThersFv);
1637
1638 if (TuningPara->contrast_af.ZoomCfg.QuickFoundThersZoomIdx)
1639 calib_free(TuningPara->contrast_af.ZoomCfg.QuickFoundThersZoomIdx);
1640 if (TuningPara->contrast_af.ZoomCfg.QuickFoundThers)
1641 calib_free(TuningPara->contrast_af.ZoomCfg.QuickFoundThers);
1642 if (TuningPara->contrast_af.ZoomCfg.SearchStepZoomIdx)
1643 calib_free(TuningPara->contrast_af.ZoomCfg.SearchStepZoomIdx);
1644 if (TuningPara->contrast_af.ZoomCfg.SearchStep)
1645 calib_free(TuningPara->contrast_af.ZoomCfg.SearchStep);
1646 if (TuningPara->contrast_af.ZoomCfg.StopStepZoomIdx)
1647 calib_free(TuningPara->contrast_af.ZoomCfg.StopStepZoomIdx);
1648 if (TuningPara->contrast_af.ZoomCfg.StopStep)
1649 calib_free(TuningPara->contrast_af.ZoomCfg.StopStep);
1650
1651 if (TuningPara->video_contrast_af.AdaptRangeTbl)
1652 calib_free(TuningPara->video_contrast_af.AdaptRangeTbl);
1653 if (TuningPara->video_contrast_af.TrigThers)
1654 calib_free(TuningPara->video_contrast_af.TrigThers);
1655 if (TuningPara->video_contrast_af.TrigThersFv)
1656 calib_free(TuningPara->video_contrast_af.TrigThersFv);
1657
1658 if (TuningPara->video_contrast_af.ZoomCfg.QuickFoundThersZoomIdx)
1659 calib_free(TuningPara->video_contrast_af.ZoomCfg.QuickFoundThersZoomIdx);
1660 if (TuningPara->video_contrast_af.ZoomCfg.QuickFoundThers)
1661 calib_free(TuningPara->video_contrast_af.ZoomCfg.QuickFoundThers);
1662 if (TuningPara->video_contrast_af.ZoomCfg.SearchStepZoomIdx)
1663 calib_free(TuningPara->video_contrast_af.ZoomCfg.SearchStepZoomIdx);
1664 if (TuningPara->video_contrast_af.ZoomCfg.SearchStep)
1665 calib_free(TuningPara->video_contrast_af.ZoomCfg.SearchStep);
1666 if (TuningPara->video_contrast_af.ZoomCfg.StopStepZoomIdx)
1667 calib_free(TuningPara->video_contrast_af.ZoomCfg.StopStepZoomIdx);
1668 if (TuningPara->video_contrast_af.ZoomCfg.StopStep)
1669 calib_free(TuningPara->video_contrast_af.ZoomCfg.StopStep);
1670
1671 #if RKAIQ_HAVE_PDAF
1672 if (TuningPara->pdaf.pdIsoPara) {
1673 for (int i = 0; i < TuningPara->pdaf.pdIsoPara_len; i++) {
1674 if (TuningPara->pdaf.pdIsoPara[i].fineSearchTbl)
1675 calib_free(TuningPara->pdaf.pdIsoPara[i].fineSearchTbl);
1676 }
1677 calib_free(TuningPara->pdaf.pdIsoPara);
1678 }
1679 if (TuningPara->pdaf.pdResoInf)
1680 calib_free(TuningPara->pdaf.pdResoInf);
1681 #endif
1682
1683 return 0;
1684 }
1685 #endif
1686
1687 #if RKAIQ_HAVE_AF_V32_LITE
CamCalibDbFreeAfV32Ctx(CalibDbV2_AFV32_t * af)1688 int RkAiqCalibDbV2::CamCalibDbFreeAfV32Ctx(CalibDbV2_AFV32_t* af)
1689 {
1690 CalibDbV2_AFV32_Tuning_Para_t* TuningPara = &af->TuningPara;
1691 CalibDbV2_Af_ZoomFocusTbl_t* zoomfocus_tbl = &TuningPara->zoomfocus_tbl;
1692
1693 if (zoomfocus_tbl->zoom_move_dot)
1694 calib_free(zoomfocus_tbl->zoom_move_dot);
1695 if (zoomfocus_tbl->zoom_move_step)
1696 calib_free(zoomfocus_tbl->zoom_move_step);
1697 if (zoomfocus_tbl->focal_length)
1698 calib_free(zoomfocus_tbl->focal_length);
1699 if (zoomfocus_tbl->zoomcode)
1700 calib_free(zoomfocus_tbl->zoomcode);
1701
1702 for (int i = 0; i < zoomfocus_tbl->focuscode_len; i++) {
1703 if (zoomfocus_tbl->focuscode[i].code)
1704 calib_free(zoomfocus_tbl->focuscode[i].code);
1705 }
1706 if (zoomfocus_tbl->focuscode)
1707 calib_free(zoomfocus_tbl->focuscode);
1708
1709 if (zoomfocus_tbl->ZoomSearchTbl)
1710 calib_free(zoomfocus_tbl->ZoomSearchTbl);
1711 if (zoomfocus_tbl->FocusSearchPlusRange)
1712 calib_free(zoomfocus_tbl->FocusSearchPlusRange);
1713 if (zoomfocus_tbl->ZoomInfoDir)
1714 calib_free(zoomfocus_tbl->ZoomInfoDir);
1715
1716 if (TuningPara->contrast_af.AdaptRangeTbl)
1717 calib_free(TuningPara->contrast_af.AdaptRangeTbl);
1718 if (TuningPara->contrast_af.TrigThers)
1719 calib_free(TuningPara->contrast_af.TrigThers);
1720 if (TuningPara->contrast_af.TrigThersFv)
1721 calib_free(TuningPara->contrast_af.TrigThersFv);
1722
1723 if (TuningPara->contrast_af.ZoomCfg.QuickFoundThersZoomIdx)
1724 calib_free(TuningPara->contrast_af.ZoomCfg.QuickFoundThersZoomIdx);
1725 if (TuningPara->contrast_af.ZoomCfg.QuickFoundThers)
1726 calib_free(TuningPara->contrast_af.ZoomCfg.QuickFoundThers);
1727 if (TuningPara->contrast_af.ZoomCfg.SearchStepZoomIdx)
1728 calib_free(TuningPara->contrast_af.ZoomCfg.SearchStepZoomIdx);
1729 if (TuningPara->contrast_af.ZoomCfg.SearchStep)
1730 calib_free(TuningPara->contrast_af.ZoomCfg.SearchStep);
1731 if (TuningPara->contrast_af.ZoomCfg.StopStepZoomIdx)
1732 calib_free(TuningPara->contrast_af.ZoomCfg.StopStepZoomIdx);
1733 if (TuningPara->contrast_af.ZoomCfg.StopStep)
1734 calib_free(TuningPara->contrast_af.ZoomCfg.StopStep);
1735
1736 if (TuningPara->video_contrast_af.AdaptRangeTbl)
1737 calib_free(TuningPara->video_contrast_af.AdaptRangeTbl);
1738 if (TuningPara->video_contrast_af.TrigThers)
1739 calib_free(TuningPara->video_contrast_af.TrigThers);
1740 if (TuningPara->video_contrast_af.TrigThersFv)
1741 calib_free(TuningPara->video_contrast_af.TrigThersFv);
1742
1743 if (TuningPara->video_contrast_af.ZoomCfg.QuickFoundThersZoomIdx)
1744 calib_free(TuningPara->video_contrast_af.ZoomCfg.QuickFoundThersZoomIdx);
1745 if (TuningPara->video_contrast_af.ZoomCfg.QuickFoundThers)
1746 calib_free(TuningPara->video_contrast_af.ZoomCfg.QuickFoundThers);
1747 if (TuningPara->video_contrast_af.ZoomCfg.SearchStepZoomIdx)
1748 calib_free(TuningPara->video_contrast_af.ZoomCfg.SearchStepZoomIdx);
1749 if (TuningPara->video_contrast_af.ZoomCfg.SearchStep)
1750 calib_free(TuningPara->video_contrast_af.ZoomCfg.SearchStep);
1751 if (TuningPara->video_contrast_af.ZoomCfg.StopStepZoomIdx)
1752 calib_free(TuningPara->video_contrast_af.ZoomCfg.StopStepZoomIdx);
1753 if (TuningPara->video_contrast_af.ZoomCfg.StopStep)
1754 calib_free(TuningPara->video_contrast_af.ZoomCfg.StopStep);
1755
1756 for (int i = 0; i < TuningPara->zoom_meas_len; i++) {
1757 CalibDbV2_AfV30_ZoomMeas_t *zoom_meas = TuningPara->zoom_meas + i;
1758
1759 if (zoom_meas->measiso)
1760 calib_free(zoom_meas->measiso);
1761 }
1762 if (TuningPara->zoom_meas)
1763 calib_free(TuningPara->zoom_meas);
1764 if (TuningPara->meascfg_tbl)
1765 calib_free(TuningPara->meascfg_tbl);
1766
1767 #if RKAIQ_HAVE_PDAF
1768 if (TuningPara->pdaf.pdIsoPara) {
1769 for (int i = 0; i < TuningPara->pdaf.pdIsoPara_len; i++) {
1770 if (TuningPara->pdaf.pdIsoPara[i].fineSearchTbl)
1771 calib_free(TuningPara->pdaf.pdIsoPara[i].fineSearchTbl);
1772 }
1773 calib_free(TuningPara->pdaf.pdIsoPara);
1774 }
1775 if (TuningPara->pdaf.pdResoInf)
1776 calib_free(TuningPara->pdaf.pdResoInf);
1777 #endif
1778
1779 return 0;
1780 }
1781 #endif
1782
1783 #if RKAIQ_HAVE_AF_V31
CamCalibDbFreeAfV31Ctx(CalibDbV2_AFV31_t * af)1784 int RkAiqCalibDbV2::CamCalibDbFreeAfV31Ctx(CalibDbV2_AFV31_t* af)
1785 {
1786 CalibDbV2_AFV31_Tuning_Para_t* TuningPara = &af->TuningPara;
1787 CalibDbV2_Af_ZoomFocusTbl_t* zoomfocus_tbl = &TuningPara->zoomfocus_tbl;
1788
1789 if (zoomfocus_tbl->zoom_move_dot)
1790 calib_free(zoomfocus_tbl->zoom_move_dot);
1791 if (zoomfocus_tbl->zoom_move_step)
1792 calib_free(zoomfocus_tbl->zoom_move_step);
1793 if (zoomfocus_tbl->focal_length)
1794 calib_free(zoomfocus_tbl->focal_length);
1795 if (zoomfocus_tbl->zoomcode)
1796 calib_free(zoomfocus_tbl->zoomcode);
1797
1798 for (int i = 0; i < zoomfocus_tbl->focuscode_len; i++) {
1799 if (zoomfocus_tbl->focuscode[i].code)
1800 calib_free(zoomfocus_tbl->focuscode[i].code);
1801 }
1802 if (zoomfocus_tbl->focuscode)
1803 calib_free(zoomfocus_tbl->focuscode);
1804
1805 if (zoomfocus_tbl->ZoomSearchTbl)
1806 calib_free(zoomfocus_tbl->ZoomSearchTbl);
1807 if (zoomfocus_tbl->FocusSearchPlusRange)
1808 calib_free(zoomfocus_tbl->FocusSearchPlusRange);
1809 if (zoomfocus_tbl->ZoomInfoDir)
1810 calib_free(zoomfocus_tbl->ZoomInfoDir);
1811
1812 if (TuningPara->contrast_af.AdaptRangeTbl)
1813 calib_free(TuningPara->contrast_af.AdaptRangeTbl);
1814 if (TuningPara->contrast_af.TrigThers)
1815 calib_free(TuningPara->contrast_af.TrigThers);
1816 if (TuningPara->contrast_af.TrigThersFv)
1817 calib_free(TuningPara->contrast_af.TrigThersFv);
1818
1819 if (TuningPara->contrast_af.ZoomCfg.QuickFoundThersZoomIdx)
1820 calib_free(TuningPara->contrast_af.ZoomCfg.QuickFoundThersZoomIdx);
1821 if (TuningPara->contrast_af.ZoomCfg.QuickFoundThers)
1822 calib_free(TuningPara->contrast_af.ZoomCfg.QuickFoundThers);
1823 if (TuningPara->contrast_af.ZoomCfg.SearchStepZoomIdx)
1824 calib_free(TuningPara->contrast_af.ZoomCfg.SearchStepZoomIdx);
1825 if (TuningPara->contrast_af.ZoomCfg.SearchStep)
1826 calib_free(TuningPara->contrast_af.ZoomCfg.SearchStep);
1827 if (TuningPara->contrast_af.ZoomCfg.StopStepZoomIdx)
1828 calib_free(TuningPara->contrast_af.ZoomCfg.StopStepZoomIdx);
1829 if (TuningPara->contrast_af.ZoomCfg.StopStep)
1830 calib_free(TuningPara->contrast_af.ZoomCfg.StopStep);
1831
1832 if (TuningPara->video_contrast_af.AdaptRangeTbl)
1833 calib_free(TuningPara->video_contrast_af.AdaptRangeTbl);
1834 if (TuningPara->video_contrast_af.TrigThers)
1835 calib_free(TuningPara->video_contrast_af.TrigThers);
1836 if (TuningPara->video_contrast_af.TrigThersFv)
1837 calib_free(TuningPara->video_contrast_af.TrigThersFv);
1838
1839 if (TuningPara->video_contrast_af.ZoomCfg.QuickFoundThersZoomIdx)
1840 calib_free(TuningPara->video_contrast_af.ZoomCfg.QuickFoundThersZoomIdx);
1841 if (TuningPara->video_contrast_af.ZoomCfg.QuickFoundThers)
1842 calib_free(TuningPara->video_contrast_af.ZoomCfg.QuickFoundThers);
1843 if (TuningPara->video_contrast_af.ZoomCfg.SearchStepZoomIdx)
1844 calib_free(TuningPara->video_contrast_af.ZoomCfg.SearchStepZoomIdx);
1845 if (TuningPara->video_contrast_af.ZoomCfg.SearchStep)
1846 calib_free(TuningPara->video_contrast_af.ZoomCfg.SearchStep);
1847 if (TuningPara->video_contrast_af.ZoomCfg.StopStepZoomIdx)
1848 calib_free(TuningPara->video_contrast_af.ZoomCfg.StopStepZoomIdx);
1849 if (TuningPara->video_contrast_af.ZoomCfg.StopStep)
1850 calib_free(TuningPara->video_contrast_af.ZoomCfg.StopStep);
1851
1852 for (int i = 0; i < TuningPara->zoom_meas_len; i++) {
1853 CalibDbV2_AfV30_ZoomMeas_t *zoom_meas = TuningPara->zoom_meas + i;
1854
1855 if (zoom_meas->measiso)
1856 calib_free(zoom_meas->measiso);
1857 }
1858 if (TuningPara->zoom_meas)
1859 calib_free(TuningPara->zoom_meas);
1860 if (TuningPara->meascfg_tbl)
1861 calib_free(TuningPara->meascfg_tbl);
1862
1863 #if RKAIQ_HAVE_PDAF
1864 if (TuningPara->pdaf.pdIsoPara) {
1865 for (int i = 0; i < TuningPara->pdaf.pdIsoPara_len; i++) {
1866 if (TuningPara->pdaf.pdIsoPara[i].fineSearchTbl)
1867 calib_free(TuningPara->pdaf.pdIsoPara[i].fineSearchTbl);
1868 }
1869 calib_free(TuningPara->pdaf.pdIsoPara);
1870 }
1871 if (TuningPara->pdaf.pdResoInf)
1872 calib_free(TuningPara->pdaf.pdResoInf);
1873 #endif
1874
1875 return 0;
1876 }
1877 #endif
1878
1879 #if RKAIQ_HAVE_AF_V30
CamCalibDbFreeAfV30Ctx(CalibDbV2_AFV30_t * af)1880 int RkAiqCalibDbV2::CamCalibDbFreeAfV30Ctx(CalibDbV2_AFV30_t* af)
1881 {
1882 CalibDbV2_AFV30_Tuning_Para_t* TuningPara = &af->TuningPara;
1883 CalibDbV2_Af_ZoomFocusTbl_t* zoomfocus_tbl = &TuningPara->zoomfocus_tbl;
1884
1885 if (zoomfocus_tbl->zoom_move_dot)
1886 calib_free(zoomfocus_tbl->zoom_move_dot);
1887 if (zoomfocus_tbl->zoom_move_step)
1888 calib_free(zoomfocus_tbl->zoom_move_step);
1889 if (zoomfocus_tbl->focal_length)
1890 calib_free(zoomfocus_tbl->focal_length);
1891 if (zoomfocus_tbl->zoomcode)
1892 calib_free(zoomfocus_tbl->zoomcode);
1893
1894 for (int i = 0; i < zoomfocus_tbl->focuscode_len; i++) {
1895 if (zoomfocus_tbl->focuscode[i].code)
1896 calib_free(zoomfocus_tbl->focuscode[i].code);
1897 }
1898 if (zoomfocus_tbl->focuscode)
1899 calib_free(zoomfocus_tbl->focuscode);
1900
1901 if (zoomfocus_tbl->ZoomSearchTbl)
1902 calib_free(zoomfocus_tbl->ZoomSearchTbl);
1903 if (zoomfocus_tbl->FocusSearchPlusRange)
1904 calib_free(zoomfocus_tbl->FocusSearchPlusRange);
1905 if (zoomfocus_tbl->ZoomInfoDir)
1906 calib_free(zoomfocus_tbl->ZoomInfoDir);
1907
1908 if (TuningPara->contrast_af.AdaptRangeTbl)
1909 calib_free(TuningPara->contrast_af.AdaptRangeTbl);
1910 if (TuningPara->contrast_af.TrigThers)
1911 calib_free(TuningPara->contrast_af.TrigThers);
1912 if (TuningPara->contrast_af.TrigThersFv)
1913 calib_free(TuningPara->contrast_af.TrigThersFv);
1914
1915 if (TuningPara->contrast_af.ZoomCfg.QuickFoundThersZoomIdx)
1916 calib_free(TuningPara->contrast_af.ZoomCfg.QuickFoundThersZoomIdx);
1917 if (TuningPara->contrast_af.ZoomCfg.QuickFoundThers)
1918 calib_free(TuningPara->contrast_af.ZoomCfg.QuickFoundThers);
1919 if (TuningPara->contrast_af.ZoomCfg.SearchStepZoomIdx)
1920 calib_free(TuningPara->contrast_af.ZoomCfg.SearchStepZoomIdx);
1921 if (TuningPara->contrast_af.ZoomCfg.SearchStep)
1922 calib_free(TuningPara->contrast_af.ZoomCfg.SearchStep);
1923 if (TuningPara->contrast_af.ZoomCfg.StopStepZoomIdx)
1924 calib_free(TuningPara->contrast_af.ZoomCfg.StopStepZoomIdx);
1925 if (TuningPara->contrast_af.ZoomCfg.StopStep)
1926 calib_free(TuningPara->contrast_af.ZoomCfg.StopStep);
1927
1928 if (TuningPara->video_contrast_af.AdaptRangeTbl)
1929 calib_free(TuningPara->video_contrast_af.AdaptRangeTbl);
1930 if (TuningPara->video_contrast_af.TrigThers)
1931 calib_free(TuningPara->video_contrast_af.TrigThers);
1932 if (TuningPara->video_contrast_af.TrigThersFv)
1933 calib_free(TuningPara->video_contrast_af.TrigThersFv);
1934
1935 if (TuningPara->video_contrast_af.ZoomCfg.QuickFoundThersZoomIdx)
1936 calib_free(TuningPara->video_contrast_af.ZoomCfg.QuickFoundThersZoomIdx);
1937 if (TuningPara->video_contrast_af.ZoomCfg.QuickFoundThers)
1938 calib_free(TuningPara->video_contrast_af.ZoomCfg.QuickFoundThers);
1939 if (TuningPara->video_contrast_af.ZoomCfg.SearchStepZoomIdx)
1940 calib_free(TuningPara->video_contrast_af.ZoomCfg.SearchStepZoomIdx);
1941 if (TuningPara->video_contrast_af.ZoomCfg.SearchStep)
1942 calib_free(TuningPara->video_contrast_af.ZoomCfg.SearchStep);
1943 if (TuningPara->video_contrast_af.ZoomCfg.StopStepZoomIdx)
1944 calib_free(TuningPara->video_contrast_af.ZoomCfg.StopStepZoomIdx);
1945 if (TuningPara->video_contrast_af.ZoomCfg.StopStep)
1946 calib_free(TuningPara->video_contrast_af.ZoomCfg.StopStep);
1947
1948 for (int i = 0; i < TuningPara->zoom_meas_len; i++) {
1949 CalibDbV2_AfV30_ZoomMeas_t *zoom_meas = TuningPara->zoom_meas + i;
1950
1951 if (zoom_meas->measiso)
1952 calib_free(zoom_meas->measiso);
1953 }
1954 if (TuningPara->zoom_meas)
1955 calib_free(TuningPara->zoom_meas);
1956 if (TuningPara->meascfg_tbl)
1957 calib_free(TuningPara->meascfg_tbl);
1958
1959 #if RKAIQ_HAVE_PDAF
1960 if (TuningPara->pdaf.pdIsoPara) {
1961 for (int i = 0; i < TuningPara->pdaf.pdIsoPara_len; i++) {
1962 if (TuningPara->pdaf.pdIsoPara[i].fineSearchTbl)
1963 calib_free(TuningPara->pdaf.pdIsoPara[i].fineSearchTbl);
1964 }
1965 calib_free(TuningPara->pdaf.pdIsoPara);
1966 }
1967 if (TuningPara->pdaf.pdResoInf)
1968 calib_free(TuningPara->pdaf.pdResoInf);
1969 #endif
1970
1971 return 0;
1972 }
1973 #endif
1974
CamCalibDbFreeThumbnailsCtx(CalibDbV2_Thumbnails_t * thumbnails)1975 int RkAiqCalibDbV2::CamCalibDbFreeThumbnailsCtx(CalibDbV2_Thumbnails_t* thumbnails)
1976 {
1977 CalibDbV2_Thumbnails_Param_t* param = &thumbnails->param;
1978 if (param->thumbnail_configs)
1979 calib_free(param->thumbnail_configs);
1980
1981 return 0;
1982 }
1983 #if RKAIQ_HAVE_BAYERNR_V2
CamCalibDbFreeBayerNrV2Ctx(CalibDbV2_BayerNrV2_t * bayernr_v1)1984 int RkAiqCalibDbV2::CamCalibDbFreeBayerNrV2Ctx(CalibDbV2_BayerNrV2_t* bayernr_v1)
1985 {
1986 if (bayernr_v1->Version)
1987 calib_free(bayernr_v1->Version);
1988
1989 CalibDbV2_BayerNrV2_Calib_t* CalibPara = &bayernr_v1->CalibPara;
1990 for (int i = 0; i < CalibPara->Setting_len; i++) {
1991 CalibDbV2_BayerNrV2_C_Set_t *Setting = CalibPara->Setting + i;
1992
1993 if (Setting->SNR_Mode)
1994 calib_free(Setting->SNR_Mode);
1995 if (Setting->Sensor_Mode)
1996 calib_free(Setting->Sensor_Mode);
1997 if (Setting->Calib_ISO)
1998 calib_free(Setting->Calib_ISO);
1999 }
2000 if (CalibPara->Setting)
2001 calib_free(CalibPara->Setting);
2002
2003 CalibDbV2_BayerNrV2_2d_t* Bayernr2D = &bayernr_v1->Bayernr2D;
2004 for (int i = 0; i < CalibPara->Setting_len; i++) {
2005 CalibDbV2_BayerNrV2_2d_Set_t *Setting = Bayernr2D->Setting + i;
2006
2007 if (Setting->SNR_Mode)
2008 calib_free(Setting->SNR_Mode);
2009 if (Setting->Sensor_Mode)
2010 calib_free(Setting->Sensor_Mode);
2011 if (Setting->Tuning_ISO)
2012 calib_free(Setting->Tuning_ISO);
2013 }
2014 if (Bayernr2D->Setting)
2015 calib_free(Bayernr2D->Setting);
2016
2017 CalibDbV2_BayerNrV2_3d_t * Bayernr3D = &bayernr_v1->Bayernr3D;
2018 for (int i = 0; i < CalibPara->Setting_len; i++) {
2019 CalibDbV2_BayerNrV2_3d_Set_t *Setting = Bayernr3D->Setting + i;
2020
2021 if (Setting->SNR_Mode)
2022 calib_free(Setting->SNR_Mode);
2023 if (Setting->Sensor_Mode)
2024 calib_free(Setting->Sensor_Mode);
2025 if (Setting->Tuning_ISO)
2026 calib_free(Setting->Tuning_ISO);
2027 }
2028 if (Bayernr3D->Setting)
2029 calib_free(Bayernr3D->Setting);
2030
2031 return 0;
2032 }
2033 #endif
2034
2035 #if RKAIQ_HAVE_BAYER2DNR_V23
CamCalibDbFreeBayer2dnrV23Ctx(CalibDbV2_Bayer2dnrV23_t * bayer2dnr_v23)2036 int RkAiqCalibDbV2::CamCalibDbFreeBayer2dnrV23Ctx(CalibDbV2_Bayer2dnrV23_t* bayer2dnr_v23)
2037 {
2038 if (bayer2dnr_v23->Version)
2039 calib_free(bayer2dnr_v23->Version);
2040
2041 CalibDbV2_Bayer2dnrV23_Calib_t* CalibPara = &bayer2dnr_v23->CalibPara;
2042 for (int i = 0; i < CalibPara->Setting_len; i++) {
2043 CalibDbV2_Bayer2dnrV23_C_Set_t *Setting = CalibPara->Setting + i;
2044
2045 if (Setting->SNR_Mode)
2046 calib_free(Setting->SNR_Mode);
2047 if (Setting->Sensor_Mode)
2048 calib_free(Setting->Sensor_Mode);
2049 if (Setting->Calib_ISO)
2050 calib_free(Setting->Calib_ISO);
2051 }
2052 if (CalibPara->Setting)
2053 calib_free(CalibPara->Setting);
2054
2055 CalibDbV2_Bayer2dnrV23_Tuning_t* TuningPara = &bayer2dnr_v23->TuningPara;
2056 for (int i = 0; i < TuningPara->Setting_len; i++) {
2057 CalibDbV2_Bayer2dnrV23_T_Set_t *Setting = TuningPara->Setting + i;
2058
2059 if (Setting->SNR_Mode)
2060 calib_free(Setting->SNR_Mode);
2061 if (Setting->Sensor_Mode)
2062 calib_free(Setting->Sensor_Mode);
2063 if (Setting->Tuning_ISO)
2064 calib_free(Setting->Tuning_ISO);
2065 }
2066 if (CalibPara->Setting)
2067 calib_free(CalibPara->Setting);
2068
2069 return 0;
2070 }
2071 #endif
2072
2073 #if RKAIQ_HAVE_UVNR_V1
CamCalibDbFreeCnrCtx(CalibDbV2_CNR_t * cnr)2074 int RkAiqCalibDbV2::CamCalibDbFreeCnrCtx(CalibDbV2_CNR_t* cnr)
2075 {
2076 if (cnr->Version)
2077 calib_free(cnr->Version);
2078
2079 CalibDbV2_CNR_Tuning_t* TuningPara = &cnr->TuningPara;
2080 for (int i = 0; i < TuningPara->Setting_len; i++) {
2081 CalibDbV2_CNR_T_Set_t *Setting = TuningPara->Setting + i;
2082
2083 if (Setting->SNR_Mode)
2084 calib_free(Setting->SNR_Mode);
2085 if (Setting->Sensor_Mode)
2086 calib_free(Setting->Sensor_Mode);
2087 if (Setting->Tuning_ISO)
2088 calib_free(Setting->Tuning_ISO);
2089 }
2090 if (TuningPara->Setting)
2091 calib_free(TuningPara->Setting);
2092
2093 return 0;
2094 }
2095 #endif
2096
2097 #if RKAIQ_HAVE_YNR_V2
CamCalibDbFreeYnrV2Ctx(CalibDbV2_YnrV2_t * ynr_v2)2098 int RkAiqCalibDbV2::CamCalibDbFreeYnrV2Ctx(CalibDbV2_YnrV2_t* ynr_v2)
2099 {
2100 if (ynr_v2->Version)
2101 calib_free(ynr_v2->Version);
2102
2103 CalibDbV2_YnrV2_Calib_t* CalibPara = &ynr_v2->CalibPara;
2104 for (int i = 0; i < CalibPara->Setting_len; i++) {
2105 CalibDbV2_YnrV2_C_Set_t *Setting = CalibPara->Setting + i;
2106
2107 if (Setting->SNR_Mode)
2108 calib_free(Setting->SNR_Mode);
2109 if (Setting->Sensor_Mode)
2110 calib_free(Setting->Sensor_Mode);
2111 if (Setting->Calib_ISO)
2112 calib_free(Setting->Calib_ISO);
2113 }
2114 if (CalibPara->Setting)
2115 calib_free(CalibPara->Setting);
2116
2117 CalibDbV2_YnrV2_Tuning_t* TuningPara = &ynr_v2->TuningPara;
2118 for (int i = 0; i < TuningPara->Setting_len; i++) {
2119 CalibDbV2_YnrV2_T_Set_t *Setting = TuningPara->Setting + i;
2120
2121 if (Setting->SNR_Mode)
2122 calib_free(Setting->SNR_Mode);
2123 if (Setting->Sensor_Mode)
2124 calib_free(Setting->Sensor_Mode);
2125 if (Setting->Tuning_ISO)
2126 calib_free(Setting->Tuning_ISO);
2127 }
2128 if (TuningPara->Setting)
2129 calib_free(TuningPara->Setting);
2130
2131 return 0;
2132 }
2133 #endif
2134
2135 #if RKAIQ_HAVE_SHARP_V3
CamCalibDbFreeSharpV3Ctx(CalibDbV2_SharpV3_t * sharp_v3)2136 int RkAiqCalibDbV2::CamCalibDbFreeSharpV3Ctx(CalibDbV2_SharpV3_t* sharp_v3)
2137 {
2138 if (sharp_v3->Version)
2139 calib_free(sharp_v3->Version);
2140
2141 CalibDbV2_SharpV3_Tuning_t* TuningPara = &sharp_v3->TuningPara;
2142 for (int i = 0; i < TuningPara->Setting_len; i++) {
2143 CalibDbV2_SharpV3_T_Set_t *Setting = TuningPara->Setting + i;
2144
2145 if (Setting->SNR_Mode)
2146 calib_free(Setting->SNR_Mode);
2147 if (Setting->Sensor_Mode)
2148 calib_free(Setting->Sensor_Mode);
2149 if (Setting->Tuning_ISO)
2150 calib_free(Setting->Tuning_ISO);
2151 }
2152 if (TuningPara->Setting)
2153 calib_free(TuningPara->Setting);
2154
2155 return 0;
2156 }
2157 #endif
2158
2159 #if RKAIQ_HAVE_BAYER2DNR_V2
CamCalibDbFreeBayer2dnrV2Ctx(CalibDbV2_Bayer2dnrV2_t * bayer2dnr_v2)2160 int RkAiqCalibDbV2::CamCalibDbFreeBayer2dnrV2Ctx(CalibDbV2_Bayer2dnrV2_t* bayer2dnr_v2)
2161 {
2162 if (bayer2dnr_v2->Version)
2163 calib_free(bayer2dnr_v2->Version);
2164
2165 CalibDbV2_Bayer2dnrV2_Calib_t* CalibPara = &bayer2dnr_v2->CalibPara;
2166 for (int i = 0; i < CalibPara->Setting_len; i++) {
2167 CalibDbV2_Bayer2dnrV2_C_Set_t *Setting = CalibPara->Setting + i;
2168
2169 if (Setting->SNR_Mode)
2170 calib_free(Setting->SNR_Mode);
2171 if (Setting->Sensor_Mode)
2172 calib_free(Setting->Sensor_Mode);
2173 if (Setting->Calib_ISO)
2174 calib_free(Setting->Calib_ISO);
2175 }
2176 if (CalibPara->Setting)
2177 calib_free(CalibPara->Setting);
2178
2179 CalibDbV2_Bayer2dnrV2_Tuning_t* TuningPara = &bayer2dnr_v2->TuningPara;
2180 for (int i = 0; i < TuningPara->Setting_len; i++) {
2181 CalibDbV2_Bayer2dnrV2_T_Set_t *Setting = TuningPara->Setting + i;
2182
2183 if (Setting->SNR_Mode)
2184 calib_free(Setting->SNR_Mode);
2185 if (Setting->Sensor_Mode)
2186 calib_free(Setting->Sensor_Mode);
2187 if (Setting->Tuning_ISO)
2188 calib_free(Setting->Tuning_ISO);
2189 }
2190 if (TuningPara->Setting)
2191 calib_free(TuningPara->Setting);
2192
2193
2194 return 0;
2195 }
2196 #endif
2197
2198 #if RKAIQ_HAVE_BAYERTNR_V2
CamCalibDbFreeBayertnrV2Ctx(CalibDbV2_BayerTnrV2_t * bayertnr_v2)2199 int RkAiqCalibDbV2::CamCalibDbFreeBayertnrV2Ctx(CalibDbV2_BayerTnrV2_t* bayertnr_v2)
2200 {
2201 if (bayertnr_v2->Version)
2202 calib_free(bayertnr_v2->Version);
2203
2204 CalibDbV2_BayerTnrV2_Calib_t* CalibPara = &bayertnr_v2->CalibPara;
2205 for (int i = 0; i < CalibPara->Setting_len; i++) {
2206 CalibDbV2_BayerTnrV2_C_Set_t *Setting = CalibPara->Setting + i;
2207
2208 if (Setting->SNR_Mode)
2209 calib_free(Setting->SNR_Mode);
2210 if (Setting->Sensor_Mode)
2211 calib_free(Setting->Sensor_Mode);
2212 if (Setting->Calib_ISO)
2213 calib_free(Setting->Calib_ISO);
2214 }
2215 if (CalibPara->Setting)
2216 calib_free(CalibPara->Setting);
2217
2218 CalibDbV2_BayerTnrV2_Tuning_t* TuningPara = &bayertnr_v2->TuningPara;
2219 for (int i = 0; i < TuningPara->Setting_len; i++) {
2220 CalibDbV2_BayerTnrV2_T_Set_t *Setting = TuningPara->Setting + i;
2221
2222 if (Setting->SNR_Mode)
2223 calib_free(Setting->SNR_Mode);
2224 if (Setting->Sensor_Mode)
2225 calib_free(Setting->Sensor_Mode);
2226 if (Setting->Tuning_ISO)
2227 calib_free(Setting->Tuning_ISO);
2228 }
2229 if (TuningPara->Setting)
2230 calib_free(TuningPara->Setting);
2231
2232
2233 return 0;
2234 }
2235 #endif
2236
2237 #if RKAIQ_HAVE_BAYERTNR_V23
CamCalibDbFreeBayertnrV23Ctx(CalibDbV2_BayerTnrV23_t * bayertnr_v23)2238 int RkAiqCalibDbV2::CamCalibDbFreeBayertnrV23Ctx(CalibDbV2_BayerTnrV23_t* bayertnr_v23)
2239 {
2240 if (bayertnr_v23->Version)
2241 calib_free(bayertnr_v23->Version);
2242
2243 CalibDbV2_BayerTnrV23_Calib_t* CalibPara = &bayertnr_v23->CalibPara;
2244 for (int i = 0; i < CalibPara->Setting_len; i++) {
2245 CalibDbV2_BayerTnrV23_C_Set_t *Setting = CalibPara->Setting + i;
2246
2247 if (Setting->SNR_Mode)
2248 calib_free(Setting->SNR_Mode);
2249 if (Setting->Sensor_Mode)
2250 calib_free(Setting->Sensor_Mode);
2251 if (Setting->Calib_ISO)
2252 calib_free(Setting->Calib_ISO);
2253 }
2254 if (CalibPara->Setting)
2255 calib_free(CalibPara->Setting);
2256
2257 CalibDbV2_BayerTnrV23_Tuning_t* TuningPara = &bayertnr_v23->TuningPara;
2258
2259 for (int i = 0; i < TuningPara->Setting_len; i++) {
2260 CalibDbV2_BayerTnrV23_T_Set_t *Setting = TuningPara->Setting + i;
2261
2262 if (Setting->SNR_Mode)
2263 calib_free(Setting->SNR_Mode);
2264 if (Setting->Sensor_Mode)
2265 calib_free(Setting->Sensor_Mode);
2266 if (Setting->Tuning_ISO)
2267 calib_free(Setting->Tuning_ISO);
2268 }
2269 if (TuningPara->Setting)
2270 calib_free(TuningPara->Setting);
2271
2272 return 0;
2273 }
2274 #endif
2275
2276 #if RKAIQ_HAVE_BAYERTNR_V23_LITE
CamCalibDbFreeBayertnrV23LiteCtx(CalibDbV2_BayerTnrV23Lite_t * bayertnr_v23_lite)2277 int RkAiqCalibDbV2::CamCalibDbFreeBayertnrV23LiteCtx(
2278 CalibDbV2_BayerTnrV23Lite_t* bayertnr_v23_lite) {
2279 if (bayertnr_v23_lite->Version) calib_free(bayertnr_v23_lite->Version);
2280
2281 CalibDbV2_BayerTnrV23_Calib_t* CalibPara = &bayertnr_v23_lite->CalibPara;
2282 for (int i = 0; i < CalibPara->Setting_len; i++) {
2283 CalibDbV2_BayerTnrV23_C_Set_t* Setting = CalibPara->Setting + i;
2284
2285 if (Setting->SNR_Mode) calib_free(Setting->SNR_Mode);
2286 if (Setting->Sensor_Mode) calib_free(Setting->Sensor_Mode);
2287 if (Setting->Calib_ISO) calib_free(Setting->Calib_ISO);
2288 }
2289 if (CalibPara->Setting) calib_free(CalibPara->Setting);
2290
2291 CalibDbV2_BayerTnrV23L_Tuning_t* TuningPara = &bayertnr_v23_lite->TuningPara;
2292
2293 for (int i = 0; i < TuningPara->Setting_len; i++) {
2294 CalibDbV2_BayerTnrV23L_T_Set_t* Setting = TuningPara->Setting + i;
2295
2296 if (Setting->SNR_Mode) calib_free(Setting->SNR_Mode);
2297 if (Setting->Sensor_Mode) calib_free(Setting->Sensor_Mode);
2298 if (Setting->Tuning_ISO) calib_free(Setting->Tuning_ISO);
2299 }
2300 if (TuningPara->Setting) calib_free(TuningPara->Setting);
2301
2302 return 0;
2303 }
2304 #endif
2305
2306 #if RKAIQ_HAVE_CNR_V2
CamCalibDbFreeCnrV2Ctx(CalibDbV2_CNRV2_t * cnr_v2)2307 int RkAiqCalibDbV2::CamCalibDbFreeCnrV2Ctx(CalibDbV2_CNRV2_t* cnr_v2)
2308 {
2309 if (cnr_v2->Version)
2310 calib_free(cnr_v2->Version);
2311
2312 CalibDbV2_CNRV2_Tuning_t* TuningPara = &cnr_v2->TuningPara;
2313 for (int i = 0; i < TuningPara->Setting_len; i++) {
2314 CalibDbV2_CNRV2_T_Set_t *Setting = TuningPara->Setting + i;
2315
2316 if (Setting->SNR_Mode)
2317 calib_free(Setting->SNR_Mode);
2318 if (Setting->Sensor_Mode)
2319 calib_free(Setting->Sensor_Mode);
2320 if (Setting->Tuning_ISO)
2321 calib_free(Setting->Tuning_ISO);
2322 }
2323 if (TuningPara->Setting)
2324 calib_free(TuningPara->Setting);
2325
2326 return 0;
2327 }
2328 #endif
2329
2330 #if (RKAIQ_HAVE_CNR_V30 || RKAIQ_HAVE_CNR_V30_LITE)
CamCalibDbFreeCnrV30Ctx(CalibDbV2_CNRV30_t * cnr_v30)2331 int RkAiqCalibDbV2::CamCalibDbFreeCnrV30Ctx(CalibDbV2_CNRV30_t* cnr_v30)
2332 {
2333 if (cnr_v30->Version)
2334 calib_free(cnr_v30->Version);
2335
2336 CalibDbV2_CNRV30_Tuning_t* TuningPara = &cnr_v30->TuningPara;
2337 for (int i = 0; i < TuningPara->Setting_len; i++) {
2338 CalibDbV2_CNRV30_T_Set_t *Setting = TuningPara->Setting + i;
2339
2340 if (Setting->SNR_Mode)
2341 calib_free(Setting->SNR_Mode);
2342 if (Setting->Sensor_Mode)
2343 calib_free(Setting->Sensor_Mode);
2344 if (Setting->Tuning_ISO)
2345 calib_free(Setting->Tuning_ISO);
2346 }
2347 if (TuningPara->Setting)
2348 calib_free(TuningPara->Setting);
2349
2350 return 0;
2351 }
2352 #endif
2353
2354 #if RKAIQ_HAVE_GAIN_V2
CamCalibDbFreeGainV2Ctx(CalibDbV2_GainV2_t * gain_v2)2355 int RkAiqCalibDbV2::CamCalibDbFreeGainV2Ctx(CalibDbV2_GainV2_t* gain_v2)
2356 {
2357 if (gain_v2->Version)
2358 calib_free(gain_v2->Version);
2359
2360 CalibDbV2_GainV2_Tuning_t* TuningPara = &gain_v2->TuningPara;
2361 for (int i = 0; i < TuningPara->Setting_len; i++) {
2362 CalibDbV2_GainV2_T_Set_t *Setting = TuningPara->Setting + i;
2363
2364 if (Setting->SNR_Mode)
2365 calib_free(Setting->SNR_Mode);
2366 if (Setting->Sensor_Mode)
2367 calib_free(Setting->Sensor_Mode);
2368 if (Setting->Tuning_ISO)
2369 calib_free(Setting->Tuning_ISO);
2370 }
2371 if (TuningPara->Setting)
2372 calib_free(TuningPara->Setting);
2373
2374 return 0;
2375 }
2376 #endif
2377
2378
2379 #if RKAIQ_HAVE_YNR_V3
CamCalibDbFreeYnrV3Ctx(CalibDbV2_YnrV3_t * ynr_v3)2380 int RkAiqCalibDbV2::CamCalibDbFreeYnrV3Ctx(CalibDbV2_YnrV3_t* ynr_v3)
2381 {
2382 if (ynr_v3->Version)
2383 calib_free(ynr_v3->Version);
2384
2385 CalibDbV2_YnrV3_Calib_t* CalibPara = &ynr_v3->CalibPara;
2386 for (int i = 0; i < CalibPara->Setting_len; i++) {
2387 CalibDbV2_YnrV3_C_Set_t *Setting = CalibPara->Setting + i;
2388
2389 if (Setting->SNR_Mode)
2390 calib_free(Setting->SNR_Mode);
2391 if (Setting->Sensor_Mode)
2392 calib_free(Setting->Sensor_Mode);
2393 if (Setting->Calib_ISO)
2394 calib_free(Setting->Calib_ISO);
2395 }
2396 if (CalibPara->Setting)
2397 calib_free(CalibPara->Setting);
2398
2399 CalibDbV2_YnrV3_Tuning_t* TuningPara = &ynr_v3->TuningPara;
2400 for (int i = 0; i < TuningPara->Setting_len; i++) {
2401 CalibDbV2_YnrV3_T_Set_t *Setting = TuningPara->Setting + i;
2402
2403 if (Setting->SNR_Mode)
2404 calib_free(Setting->SNR_Mode);
2405 if (Setting->Sensor_Mode)
2406 calib_free(Setting->Sensor_Mode);
2407 if (Setting->Tuning_ISO)
2408 calib_free(Setting->Tuning_ISO);
2409 }
2410 if (TuningPara->Setting)
2411 calib_free(TuningPara->Setting);
2412
2413 return 0;
2414 }
2415 #endif
2416
2417 #if RKAIQ_HAVE_YNR_V22
CamCalibDbFreeYnrV22Ctx(CalibDbV2_YnrV22_t * ynr_v22)2418 int RkAiqCalibDbV2::CamCalibDbFreeYnrV22Ctx(CalibDbV2_YnrV22_t* ynr_v22)
2419 {
2420 if (ynr_v22->Version)
2421 calib_free(ynr_v22->Version);
2422
2423 CalibDbV2_YnrV22_Calib_t* CalibPara = &ynr_v22->CalibPara;
2424 for (int i = 0; i < CalibPara->Setting_len; i++) {
2425 CalibDbV2_YnrV22_C_Set_t *Setting = CalibPara->Setting + i;
2426
2427 if (Setting->SNR_Mode)
2428 calib_free(Setting->SNR_Mode);
2429 if (Setting->Sensor_Mode)
2430 calib_free(Setting->Sensor_Mode);
2431 if (Setting->Calib_ISO)
2432 calib_free(Setting->Calib_ISO);
2433 }
2434 if (CalibPara->Setting)
2435 calib_free(CalibPara->Setting);
2436
2437 CalibDbV2_YnrV22_Tuning_t* TuningPara = &ynr_v22->TuningPara;
2438 for (int i = 0; i < TuningPara->Setting_len; i++) {
2439 CalibDbV2_YnrV22_T_Set_t *Setting = TuningPara->Setting + i;
2440
2441 if (Setting->SNR_Mode)
2442 calib_free(Setting->SNR_Mode);
2443 if (Setting->Sensor_Mode)
2444 calib_free(Setting->Sensor_Mode);
2445 if (Setting->Tuning_ISO)
2446 calib_free(Setting->Tuning_ISO);
2447 }
2448 if (TuningPara->Setting)
2449 calib_free(TuningPara->Setting);
2450
2451 return 0;
2452 }
2453 #endif
2454
2455 #if RKAIQ_HAVE_SHARP_V4
CamCalibDbFreeSharpV4Ctx(CalibDbV2_SharpV4_t * sharp_v4)2456 int RkAiqCalibDbV2::CamCalibDbFreeSharpV4Ctx(CalibDbV2_SharpV4_t* sharp_v4)
2457 {
2458 if (sharp_v4->Version)
2459 calib_free(sharp_v4->Version);
2460
2461 CalibDbV2_SharpV4_Tuning_t* TuningPara = &sharp_v4->TuningPara;
2462 for (int i = 0; i < TuningPara->Setting_len; i++) {
2463 CalibDbV2_SharpV4_Set_t *Setting = TuningPara->Setting + i;
2464
2465 if (Setting->SNR_Mode)
2466 calib_free(Setting->SNR_Mode);
2467 if (Setting->Sensor_Mode)
2468 calib_free(Setting->Sensor_Mode);
2469 if (Setting->Tuning_ISO)
2470 calib_free(Setting->Tuning_ISO);
2471 }
2472 if (TuningPara->Setting)
2473 calib_free(TuningPara->Setting);
2474
2475 return 0;
2476 }
2477 #endif
2478
2479 #if RKAIQ_HAVE_SHARP_V33
CamCalibDbFreeSharpV33Ctx(CalibDbV2_SharpV33_t * sharp_v33)2480 int RkAiqCalibDbV2::CamCalibDbFreeSharpV33Ctx(CalibDbV2_SharpV33_t* sharp_v33)
2481 {
2482 if (sharp_v33->Version)
2483 calib_free(sharp_v33->Version);
2484
2485 CalibDbV2_SharpV33_Tuning_t* TuningPara = &sharp_v33->TuningPara;
2486
2487 for (int i = 0; i < TuningPara->Setting_len; i++) {
2488 CalibDbV2_SharpV33_T_Set_t *Setting = TuningPara->Setting + i;
2489
2490 if (Setting->SNR_Mode)
2491 calib_free(Setting->SNR_Mode);
2492 if (Setting->Sensor_Mode)
2493 calib_free(Setting->Sensor_Mode);
2494 if (Setting->Tuning_ISO)
2495 calib_free(Setting->Tuning_ISO);
2496 }
2497 if (TuningPara->Setting)
2498 calib_free(TuningPara->Setting);
2499
2500 return 0;
2501 }
2502 #endif
2503
2504 #if RKAIQ_HAVE_SHARP_V33_LITE
CamCalibDbFreeSharpV33LiteCtx(CalibDbV2_SharpV33Lite_t * sharp_v33)2505 int RkAiqCalibDbV2::CamCalibDbFreeSharpV33LiteCtx(CalibDbV2_SharpV33Lite_t* sharp_v33) {
2506 if (sharp_v33->Version) calib_free(sharp_v33->Version);
2507
2508 CalibDbV2_SharpV33LT_Tuning_t* TuningPara = &sharp_v33->TuningPara;
2509
2510 for (int i = 0; i < TuningPara->Setting_len; i++) {
2511 CalibDbV2_SharpV33LT_T_Set_t* Setting = TuningPara->Setting + i;
2512
2513 if (Setting->SNR_Mode) calib_free(Setting->SNR_Mode);
2514 if (Setting->Sensor_Mode) calib_free(Setting->Sensor_Mode);
2515 if (Setting->Tuning_ISO) calib_free(Setting->Tuning_ISO);
2516 }
2517 if (TuningPara->Setting) calib_free(TuningPara->Setting);
2518
2519 return 0;
2520 }
2521 #endif
2522
2523 #if RKAIQ_HAVE_CAC_V03
CamCalibDbFreeCacV03Ctx(CalibDbV2_Cac_V03_t * cac_calib)2524 int RkAiqCalibDbV2::CamCalibDbFreeCacV03Ctx(CalibDbV2_Cac_V03_t* cac_calib) {
2525 if (cac_calib->TuningPara.SettingByIso) calib_free(cac_calib->TuningPara.SettingByIso);
2526
2527 return 0;
2528 }
2529 #endif
2530
2531 #if RKAIQ_HAVE_CAC_V10
CamCalibDbFreeCacV10Ctx(CalibDbV2_Cac_V10_t * cac_calib)2532 int RkAiqCalibDbV2::CamCalibDbFreeCacV10Ctx(CalibDbV2_Cac_V10_t* cac_calib) {
2533 if (cac_calib->TuningPara.SettingByIso) calib_free(cac_calib->TuningPara.SettingByIso);
2534
2535 return 0;
2536 }
2537 #endif
2538
2539 #if RKAIQ_HAVE_CAC_V11
CamCalibDbFreeCacV11Ctx(CalibDbV2_Cac_V11_t * cac_calib)2540 int RkAiqCalibDbV2::CamCalibDbFreeCacV11Ctx(CalibDbV2_Cac_V11_t* cac_calib) {
2541 if (cac_calib->TuningPara.SettingByIso) calib_free(cac_calib->TuningPara.SettingByIso);
2542
2543 return 0;
2544 }
2545 #endif
2546
FreeCalibByJ2S(void * ctx)2547 int RkAiqCalibDbV2::FreeCalibByJ2S(void* ctx) {
2548 const std::lock_guard<std::mutex> lock(RkAiqCalibDbV2::calib_mutex);
2549 if (!ctx) {
2550 return -1;
2551 }
2552 j2s_ctx temp_ctx;
2553 CamCalibDbV2Tuning_t tuning_base;
2554
2555 j2s_init(&temp_ctx);
2556 memset(&tuning_base, 0, sizeof(CamCalibDbV2Tuning_t));
2557 calibdbV2_to_tuningdb(&tuning_base, (CamCalibDbV2Context_t*)ctx);
2558 j2s_struct_free(&temp_ctx, "CamCalibDbV2Tuning_t", &tuning_base);
2559 j2s_deinit(&temp_ctx);
2560
2561 calibdbV2_ctx_delete((CamCalibDbV2Context_t*)ctx);
2562
2563 return 0;
2564 }
2565
CamCalibDbFreeSceneCtx(void * scene_ctx)2566 int RkAiqCalibDbV2::CamCalibDbFreeSceneCtx(void* scene_ctx) {
2567 CamCalibDbV2Context_t ctx_temp;
2568 ctx_temp.calib_scene = (char*)scene_ctx;
2569
2570 CamCalibDbV2Context_t* ctx = &ctx_temp;
2571 #if RKAIQ_HAVE_CCM_V1
2572 CalibDbV2_Ccm_Para_V2_t* ccm_calib =
2573 (CalibDbV2_Ccm_Para_V2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ccm_calib));
2574 if (ccm_calib) CamCalibDbFreeCcmV1Ctx(ccm_calib);
2575 #endif
2576
2577 #if RKAIQ_HAVE_CCM_V2
2578 CalibDbV2_Ccm_Para_V32_t* ccm_calib_v2 =
2579 (CalibDbV2_Ccm_Para_V32_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ccm_calib_v2));
2580 if (ccm_calib_v2) CamCalibDbFreeCcmV2Ctx(ccm_calib_v2);
2581 #endif
2582
2583 #if 0 // TODO: move out
2584 CalibDb_Module_ParaV2_t *module_calib =
2585 (CalibDb_Module_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, module_calib));
2586 CamCalibDbFreeModuleCtx(module_calib);
2587 #endif
2588 CalibDb_Aec_ParaV2_t* ae_calib =
2589 (CalibDb_Aec_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ae_calib));
2590 if (ae_calib) CamCalibDbFreeAeCtx(ae_calib);
2591
2592 #if RKAIQ_HAVE_AWB_V21
2593 CalibDbV2_Wb_Para_V21_t* wb_v21 =
2594 (CalibDbV2_Wb_Para_V21_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, wb_v21));
2595 if (wb_v21) CamCalibDbFreeAwbV21Ctx(wb_v21);
2596 #endif
2597 #if RKAIQ_HAVE_AWB_V32
2598 CalibDbV2_Wb_Para_V32_t* wb_v32 =
2599 (CalibDbV2_Wb_Para_V32_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, wb_v32));
2600 if (wb_v32) CamCalibDbFreeAwbV32Ctx(wb_v32);
2601 #endif
2602
2603 #if RKAIQ_HAVE_GAMMA_V10 || RKAIQ_HAVE_GAMMA_V11
2604 CalibDbV2_gamma_v10_t* agamma_calib =
2605 (CalibDbV2_gamma_v10_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, agamma_calib));
2606 if (agamma_calib) {
2607 #if RKAIQ_HAVE_GAMMA_V11
2608 CamCalibDbFreeGammaV2Ctx((CalibDbV2_gamma_v11_t*)agamma_calib);
2609 #endif
2610 #if RKAIQ_HAVE_GAMMA_V10
2611 CamCalibDbFreeGammaCtx(agamma_calib);
2612 #endif
2613 }
2614 #endif
2615
2616 #if RKAIQ_HAVE_BLC_V1
2617 CalibDbV2_Ablc_t* ablc_calib =
2618 (CalibDbV2_Ablc_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ablc_calib));
2619 if (ablc_calib) CamCalibDbFreeBlcCtx(ablc_calib);
2620 #endif
2621
2622 #if RKAIQ_HAVE_BLC_V32
2623 CalibDbV2_Blc_V32_t* ablcV32_calib =
2624 (CalibDbV2_Blc_V32_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ablcV32_calib));
2625 if (ablcV32_calib) CamCalibDbFreeBlcV32Ctx(ablcV32_calib);
2626 #endif
2627
2628 #if RKAIQ_HAVE_GIC_V21
2629 CalibDbV2_Gic_V21_t *agic_calib_v21 =
2630 (CalibDbV2_Gic_V21_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, agic_calib_v21));
2631 if (agic_calib_v21)
2632 CamCalibDbFreeGicV21Ctx(agic_calib_v21);
2633 #endif
2634
2635 CalibDbV2_Dpcc_t *adpcc_calib =
2636 (CalibDbV2_Dpcc_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, adpcc_calib));
2637 if (adpcc_calib)
2638 CamCalibDbFreeDpccCtx(adpcc_calib);
2639
2640 #if RKAIQ_HAVE_ORB_V1
2641 CalibDbV2_Orb_t* orb = (CalibDbV2_Orb_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, orb));
2642 if (orb) CamCalibDbFreeOrbCtx(orb);
2643 #endif
2644
2645
2646 #if RKAIQ_HAVE_DEBAYER_V1
2647 CalibDbV2_Debayer_t* debayer =
2648 (CalibDbV2_Debayer_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, debayer));
2649 if (debayer) CamCalibDbFreeDebayerCtx(debayer);
2650 #endif
2651
2652 #if RKAIQ_HAVE_DEBAYER_V2
2653 CalibDbV2_Debayer_v2_t* debayer =
2654 (CalibDbV2_Debayer_v2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, debayer));
2655 if (debayer) CamCalibDbFreeDebayerV2Ctx(debayer);
2656 #endif
2657
2658 #if RKAIQ_HAVE_DEBAYER_V2_LITE
2659 CalibDbV2_Debayer_v2_lite_t* debayer =
2660 (CalibDbV2_Debayer_v2_lite_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, debayer));
2661 if (debayer) CamCalibDbFreeDebayerV2Ctx(debayer);
2662 #endif
2663
2664 #if RKAIQ_HAVE_ACP_V10
2665 CalibDbV2_Cproc_t* cproc = (CalibDbV2_Cproc_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, cproc));
2666 if (cproc) CamCalibDbFreeCprocCtx(cproc);
2667 #endif
2668 #if RKAIQ_HAVE_AIE_V10
2669 CalibDbV2_IE_t* ie = (CalibDbV2_IE_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ie));
2670 if (ie) CamCalibDbFreeIeCtx(ie);
2671 #endif
2672
2673 CalibDbV2_LSC_t* lsc_v2 = (CalibDbV2_LSC_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, lsc_v2));
2674 if (lsc_v2) CamCalibDbFreeLscCtx(lsc_v2);
2675
2676 CalibDbV2_ColorAsGrey_t* colorAsGrey =
2677 (CalibDbV2_ColorAsGrey_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, colorAsGrey));
2678 if (colorAsGrey) CamCalibDbFreeColorAsGreyCtx(colorAsGrey);
2679
2680 CalibDbV2_LUMA_DETECT_t* lumaDetect =
2681 (CalibDbV2_LUMA_DETECT_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, lumaDetect));
2682 if (lumaDetect) CamCalibDbFreeLumaDetectCtx(lumaDetect);
2683
2684 #if (RKAIQ_HAVE_LDCH_V10 || RKAIQ_HAVE_LDCH_V21)
2685 CalibDbV2_LDCH_t* aldch = (CalibDbV2_LDCH_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, aldch));
2686 if (aldch) CamCalibDbFreeLdchCtx(aldch);
2687 #endif
2688 #if RKAIQ_HAVE_3DLUT_V1
2689 CalibDbV2_Lut3D_Para_V2_t* lut3d_calib =
2690 (CalibDbV2_Lut3D_Para_V2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, lut3d_calib));
2691 if (lut3d_calib) CamCalibDbFreeLut3dCtx(lut3d_calib);
2692 #endif
2693 #if RKAIQ_HAVE_AF_V32_LITE
2694 CalibDbV2_AFV32_t* af_v32 = (CalibDbV2_AFV32_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, af_v32));
2695 if (af_v32) CamCalibDbFreeAfV32Ctx(af_v32);
2696 #endif
2697 #if RKAIQ_HAVE_AF_V31
2698 CalibDbV2_AFV31_t* af_v31 = (CalibDbV2_AFV31_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, af_v31));
2699 if (af_v31) CamCalibDbFreeAfV31Ctx(af_v31);
2700 #endif
2701 #if RKAIQ_HAVE_AF_V30
2702 CalibDbV2_AFV30_t* af_v30 = (CalibDbV2_AFV30_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, af_v30));
2703 if (af_v30) CamCalibDbFreeAfV30Ctx(af_v30);
2704 #endif
2705 #if RKAIQ_HAVE_AF_V20
2706 CalibDbV2_AF_t* af = (CalibDbV2_AF_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, af));
2707 if (af) CamCalibDbFreeAfV2xCtx(af);
2708 #endif
2709 CalibDbV2_Thumbnails_t* thumbnails =
2710 (CalibDbV2_Thumbnails_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, thumbnails));
2711 if (thumbnails) CamCalibDbFreeThumbnailsCtx(thumbnails);
2712
2713 #if RKAIQ_HAVE_BAYER2DNR_V2
2714 CalibDbV2_Bayer2dnrV2_t* bayer2dnr_v2 =
2715 (CalibDbV2_Bayer2dnrV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, bayer2dnr_v2));
2716 if (bayer2dnr_v2) CamCalibDbFreeBayer2dnrV2Ctx(bayer2dnr_v2);
2717 #endif
2718
2719 #if RKAIQ_HAVE_BAYER2DNR_V23
2720 CalibDbV2_Bayer2dnrV23_t* bayer2dnr_v23 =
2721 (CalibDbV2_Bayer2dnrV23_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, bayer2dnr_v23));
2722 if (bayer2dnr_v23) CamCalibDbFreeBayer2dnrV23Ctx(bayer2dnr_v23);
2723 #endif
2724
2725 #if RKAIQ_HAVE_BAYERTNR_V2
2726 CalibDbV2_BayerTnrV2_t* bayertnr_v2 =
2727 (CalibDbV2_BayerTnrV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, bayertnr_v2));
2728 if (bayertnr_v2) CamCalibDbFreeBayertnrV2Ctx(bayertnr_v2);
2729 #endif
2730
2731 #if RKAIQ_HAVE_BAYERTNR_V23
2732 CalibDbV2_BayerTnrV23_t* bayertnr_v23 =
2733 (CalibDbV2_BayerTnrV23_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, bayertnr_v23));
2734 if (bayertnr_v23) CamCalibDbFreeBayertnrV23Ctx(bayertnr_v23);
2735 #endif
2736
2737 #if RKAIQ_HAVE_BAYERTNR_V23_LITE
2738 CalibDbV2_BayerTnrV23Lite_t* bayertnr_v23_lite =
2739 (CalibDbV2_BayerTnrV23Lite_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, bayertnr_v23_lite));
2740 if (bayertnr_v23_lite) CamCalibDbFreeBayertnrV23LiteCtx(bayertnr_v23_lite);
2741 #endif
2742
2743 #if RKAIQ_HAVE_CNR_V2
2744 CalibDbV2_CNRV2_t* cnr_v2 = (CalibDbV2_CNRV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, cnr_v2));
2745 if (cnr_v2) CamCalibDbFreeCnrV2Ctx(cnr_v2);
2746 #endif
2747
2748 #if (RKAIQ_HAVE_CNR_V30 || RKAIQ_HAVE_CNR_V30_LITE)
2749 CalibDbV2_CNRV30_t* cnr_v30 = (CalibDbV2_CNRV30_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, cnr_v30));
2750 if (cnr_v30) CamCalibDbFreeCnrV30Ctx(cnr_v30);
2751 #endif
2752
2753 #if RKAIQ_HAVE_YNR_V3
2754 CalibDbV2_YnrV3_t* ynr_v3 = (CalibDbV2_YnrV3_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ynr_v3));
2755 if (ynr_v3) CamCalibDbFreeYnrV3Ctx(ynr_v3);
2756 #endif
2757
2758 #if RKAIQ_HAVE_YNR_V22
2759 CalibDbV2_YnrV22_t* ynr_v22 = (CalibDbV2_YnrV22_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ynr_v22));
2760 if (ynr_v22) CamCalibDbFreeYnrV22Ctx(ynr_v22);
2761 #endif
2762
2763 #if RKAIQ_HAVE_SHARP_V4
2764 CalibDbV2_SharpV4_t* sharp_v4 =
2765 (CalibDbV2_SharpV4_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, sharp_v4));
2766 if (sharp_v4) CamCalibDbFreeSharpV4Ctx(sharp_v4);
2767 #endif
2768
2769 #if RKAIQ_HAVE_SHARP_V33
2770 CalibDbV2_SharpV33_t* sharp_v33 =
2771 (CalibDbV2_SharpV33_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, sharp_v33));
2772 if (sharp_v33) CamCalibDbFreeSharpV33Ctx(sharp_v33);
2773 #endif
2774 #if RKAIQ_HAVE_SHARP_V33_LITE
2775 CalibDbV2_SharpV33Lite_t* sharp_v33 =
2776 (CalibDbV2_SharpV33Lite_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, sharp_v33));
2777 if (sharp_v33) CamCalibDbFreeSharpV33LiteCtx(sharp_v33);
2778 #endif
2779 #if RKAIQ_HAVE_CAC_V03
2780 CalibDbV2_Cac_V03_t* cac_calib =
2781 (CalibDbV2_Cac_V03_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, cac_v03));
2782 if (cac_calib) CamCalibDbFreeCacV03Ctx(cac_calib);
2783 #endif
2784
2785 #if RKAIQ_HAVE_CAC_V10
2786 CalibDbV2_Cac_V10_t* cac_calib =
2787 (CalibDbV2_Cac_V10_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, cac_v10));
2788 if (cac_calib) CamCalibDbFreeCacV10Ctx(cac_calib);
2789 #endif
2790
2791 #if RKAIQ_HAVE_CAC_V11
2792 CalibDbV2_Cac_V11_t* cac_calib =
2793 (CalibDbV2_Cac_V11_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, cac_v11));
2794 if (cac_calib) CamCalibDbFreeCacV11Ctx(cac_calib);
2795 #endif
2796
2797 #if RKAIQ_HAVE_BAYERNR_V2
2798 CalibDbV2_BayerNrV2_t* bayernr_v2 =
2799 (CalibDbV2_BayerNrV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, bayernr_v2));
2800 if (bayernr_v2) CamCalibDbFreeBayerNrV2Ctx(bayernr_v2);
2801 #endif
2802
2803 #if RKAIQ_HAVE_UVNR_V1
2804 CalibDbV2_CNR_t* cnr_v1 = (CalibDbV2_CNR_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, cnr_v1));
2805 if (cnr_v1) CamCalibDbFreeCnrCtx(cnr_v1);
2806 #endif
2807
2808 #if RKAIQ_HAVE_YNR_V2
2809 CalibDbV2_YnrV2_t* ynr_v2 = (CalibDbV2_YnrV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, ynr_v2));
2810 if (ynr_v2) CamCalibDbFreeYnrV2Ctx(ynr_v2);
2811 #endif
2812
2813 #if RKAIQ_HAVE_SHARP_V3
2814 CalibDbV2_SharpV3_t* sharp_v3 =
2815 (CalibDbV2_SharpV3_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, sharp_v3));
2816 if (sharp_v3) CamCalibDbFreeSharpV3Ctx(sharp_v3);
2817 #endif
2818 #if RKAIQ_HAVE_GAIN_V2
2819 CalibDbV2_GainV2_t* gain_v2 = (CalibDbV2_GainV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)ctx, gain_v2));
2820 if (gain_v2) CamCalibDbFreeGainV2Ctx(gain_v2);
2821 #endif
2822
2823 return 0;
2824 }
2825
loadWholeFile(const char * fpath,size_t * fsize)2826 void* RkAiqCalibDbV2::loadWholeFile(const char *fpath, size_t *fsize)
2827 {
2828 struct stat st;
2829 void* buf;
2830 int fd;
2831
2832 if (!fpath || (0 != ::stat(fpath, &st))) {
2833 LOGE("load bin file error!\n");
2834 return NULL;
2835 }
2836
2837 fd = open(fpath, O_RDONLY);
2838 if (fd < 0) {
2839 LOGE("failed to open: '%s'\n", fpath);
2840 return NULL;
2841 }
2842
2843 buf = malloc(st.st_size);
2844 if (!buf) {
2845 LOGE("read file oom!\n");
2846 close(fd);
2847 return NULL;
2848 }
2849
2850 if (read(fd, buf, st.st_size) != st.st_size) {
2851 LOGE("failed to read: '%s'\n", fpath);
2852 free(buf);
2853 close(fd);
2854 return NULL;
2855 }
2856
2857 *fsize = st.st_size;
2858
2859 close(fd);
2860
2861 return buf;
2862 }
2863
parseBinStructMap(uint8_t * data,size_t len)2864 int RkAiqCalibDbV2::parseBinStructMap(uint8_t *data, size_t len)
2865 {
2866 size_t map_len = *(size_t *)(data + (len - sizeof(size_t)));
2867 size_t map_offset = *(size_t *)(data + (len - sizeof(size_t) * 2));
2868 size_t map_index = 0;
2869 map_index_t *map_addr = NULL;
2870
2871 map_addr = (map_index_t *)(data + map_offset);
2872
2873 for (map_index = 0; map_index < map_len; map_index++) {
2874 map_index_t tmap = (map_addr[map_index]);
2875 void** dst_obj_addr = (void**)(data + (size_t)tmap.dst_offset);
2876 *dst_obj_addr = data + (uintptr_t)tmap.ptr_offset;
2877 }
2878
2879 return 0;
2880 }
2881
2882 } // namespace RkCam
2883