1 /*
2 * Copyright (c) 2019 Rockchip Corporation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *
16 */
17
18
19 #include "RkAiqCalibDb.h"
20 #include <unistd.h>
21 #include <sys/types.h>
22 #include <sys/stat.h>
23 #include <fcntl.h>
24 #include <stdio.h>
25 #include "RkAiqCalibApi.h"
26
27
28 #define FUNC_ENTER LOG1("%s enter", __FUNCTION__);
29 #define FUNC_EXIT LOG1("%s exit", __FUNCTION__);
30 #define CALIBDB_PATH_LEN 256
31 #define CALIBDB_ENV_PATH_STR "rkaiq_calibdb_path"
32
33 namespace RkCam {
34
35 namespace {
36 // TODO: implement ops for different isp hw
calibdbV1_ctx_size(CamCalibDbContext_t * ctx)37 static inline size_t calibdbV1_ctx_size(CamCalibDbContext_t* ctx) {
38 if (CHECK_ISP_HW_V20())
39 return sizeof(CamCalibDbContextIsp20_t);
40 else if (CHECK_ISP_HW_V21())
41 return sizeof(CamCalibDbContextIsp21_t);
42 else
43 return sizeof(CamCalibDbContextIsp20_t);
44 }
45
calibdbV1_ctx_new()46 static inline CamCalibDbContext_t* calibdbV1_ctx_new() {
47 if (CHECK_ISP_HW_V20())
48 return new (CamCalibDbContextIsp20_t);
49 else if (CHECK_ISP_HW_V21())
50 return new (CamCalibDbContextIsp21_t);
51 else
52 return NULL;
53 }
54
calibdbV1_ctx_delete(CamCalibDbContext_t * ctx)55 static inline void calibdbV1_ctx_delete(CamCalibDbContext_t* ctx) {
56 if (CHECK_ISP_HW_V20())
57 delete (CamCalibDbContextIsp20_t*)ctx;
58 else if (CHECK_ISP_HW_V21())
59 delete (CamCalibDbContextIsp21_t*)ctx;
60 }
61
62 } // namespace
63
64 map<string, CamCalibDbContext_t*> RkAiqCalibDb::mCalibDbsMap;
65 XCam::Mutex RkAiqCalibDb::mMutex{false};
66
calibGetEnviromentPath(const char * variable,char * value)67 static bool calibGetEnviromentPath(const char* variable, char* value)
68 {
69 if (!variable || !value) {
70 return false;
71 }
72
73 char* valueStr = getenv(variable);
74 if (valueStr) {
75 strncpy(value, valueStr, CALIBDB_PATH_LEN - 100 - 2);
76 return true;
77 }
78 return false;
79 }
80
getFilePathName(char * iqFile,char * location)81 static void getFilePathName(char* iqFile, char *location)
82 {
83 char dir[CALIBDB_PATH_LEN - 100 - 1];
84 char name[100 - 1 - 5];
85 char *srcfile = strdup(iqFile);
86 char *pstart = strrchr(srcfile, '/');
87 char *pend = strrchr(srcfile, '.');
88 *pend = '\0';
89 strcpy(name, pstart + 1);
90 if (calibGetEnviromentPath(CALIBDB_ENV_PATH_STR, dir)) {
91 snprintf(location, CALIBDB_PATH_LEN, "%s/%s.bin", dir, name);
92 } else {
93 snprintf(location, CALIBDB_PATH_LEN, "%s.bin", srcfile);
94 }
95 free(srcfile);
96 LOGD("calibdb file is %s", location);
97 }
98
getFilePathName2(char * iqFile,char * newName)99 static void getFilePathName2(char* iqFile, char *newName)
100 {
101 char dir[CALIBDB_PATH_LEN - 100 - 1];
102 char name[100 - 1 - 10];
103 char *srcfile = strdup(iqFile);
104 char *pstart = strrchr(srcfile, '/');
105 char *pend = strrchr(srcfile, '.');
106 *pend = '\0';
107 strcpy(name, pstart + 1);
108 if (calibGetEnviromentPath(CALIBDB_ENV_PATH_STR, dir)) {
109 snprintf(newName, CALIBDB_PATH_LEN, "%s/%s_write.xml", dir, name);
110 } else {
111 snprintf(newName, CALIBDB_PATH_LEN, "%s_write.xml", srcfile);
112 }
113 free(srcfile);
114 LOGD("calibdb file is %s", newName);
115 }
116
isDataBinExist(char * iqFile)117 static bool isDataBinExist(char* iqFile) {
118 char path[CALIBDB_PATH_LEN];
119
120 getFilePathName(iqFile, path);
121 if (0 == access(path, F_OK))
122 return true;
123 else
124 return false;
125 }
126
persist(int fd,int payload_size,char * payload_ptr)127 static int persist(int fd, int payload_size, char* payload_ptr) {
128 int ret = true;
129
130 LOGD("persist payload_size %d bytes", payload_size);
131 if (write(fd, payload_ptr, payload_size) <= 0) {
132 LOGE("persist cell failed\n");
133 return -1;
134 }
135
136 return 0;
137 }
138
reconstruct(int fd,int payload_size,char ** payload_ptr)139 static int reconstruct(int fd, int payload_size, char** payload_ptr) {
140 *payload_ptr = (char*)malloc(payload_size);
141 if (*payload_ptr == NULL)
142 return -1;
143 LOGD("malloc payload_ptr %p, size %d bytes", *payload_ptr, payload_size);
144 if (read(fd, *payload_ptr, payload_size) <= 0) {
145 LOGE("reconstruct cell failed %s!\n", strerror(errno));
146 free(*payload_ptr);
147 return -1;
148 }
149
150 return 0;
151 }
152
persistCalib(int fd,CamCalibDbContext_t * pcalib)153 static int persistCalib(int fd, CamCalibDbContext_t* pcalib) {
154 int ret = 0;
155
156 if (!CHECK_ISP_HW_V20()) {
157 LOGE("only support isp20 calibv1 !");
158 return -1;
159 }
160 CamCalibDbContextIsp20_t* calib = TO_CALIBDBV1_ISP20(pcalib);
161 ret |= persist(fd, sizeof(CamCalibDbContextIsp20_t), (char*)calib);
162 LOGD("CamCalibDbContextIsp20_t size %d bytes", sizeof(CamCalibDbContextIsp20_t));
163 // points
164 ret |= persist(fd,
165 sizeof(CalibDb_BayerNr_ModeCell_t) * calib->bayerNr.mode_num,
166 (char*)(calib->bayerNr.mode_cell));
167 ret |= persist(fd,
168 sizeof(CalibDb_LscTableProfile_t) * calib->lsc.tableAllNum,
169 (char*)(calib->lsc.tableAll));
170 ret |= persist(fd,
171 sizeof(CalibDb_UVNR_ModeCell_t) * calib->uvnr.mode_num,
172 (char*)(calib->uvnr.mode_cell));
173 ret |= persist(fd,
174 sizeof(CalibDb_YNR_ModeCell_t) * calib->ynr.mode_num,
175 (char*)(calib->ynr.mode_cell));
176 ret |= persist(fd,
177 sizeof(CalibDb_MFNR_ModeCell_t) * calib->mfnr.mode_num,
178 (char*)(calib->mfnr.mode_cell));
179 ret |= persist(fd,
180 sizeof(CalibDb_Sharp_ModeCell_t) * calib->sharp.mode_num,
181 (char*)(calib->sharp.mode_cell));
182 ret |= persist(fd,
183 sizeof(CalibDb_EdgeFilter_ModeCell_t) * calib->edgeFilter.mode_num,
184 (char*)(calib->edgeFilter.mode_cell));
185
186 return ret;
187 }
188
reconstructCalib(int fd,CamCalibDbContext_t * pcalib)189 static int reconstructCalib(int fd, CamCalibDbContext_t* pcalib) {
190 int ret = 0;
191
192 if (!CHECK_ISP_HW_V20()) {
193 LOGE("only support isp20 calibv1 !");
194 return -1;
195 }
196 CamCalibDbContextIsp20_t* calib = TO_CALIBDBV1_ISP20(pcalib);
197 if (read(fd, calib, sizeof(CamCalibDbContextIsp20_t)) <= 0)
198 return -1;
199 LOGD("CamCalibDbContextIsp20_t size %d bytes", sizeof(CamCalibDbContextIsp20_t));
200 // reconstruct points
201 ret |= reconstruct(fd,
202 sizeof(CalibDb_BayerNr_ModeCell_t) * calib->bayerNr.mode_num,
203 (char**)(&calib->bayerNr.mode_cell));
204 ret |= reconstruct(fd,
205 sizeof(CalibDb_LscTableProfile_t) * calib->lsc.tableAllNum,
206 (char**)(&calib->lsc.tableAll));
207 ret |= reconstruct(fd,
208 sizeof(CalibDb_UVNR_ModeCell_t) * calib->uvnr.mode_num,
209 (char**)(&calib->uvnr.mode_cell));
210 ret |= reconstruct(fd,
211 sizeof(CalibDb_YNR_ModeCell_t) * calib->ynr.mode_num,
212 (char**)(&calib->ynr.mode_cell));
213 ret |= reconstruct(fd,
214 sizeof(CalibDb_MFNR_ModeCell_t) * calib->mfnr.mode_num,
215 (char**)(&calib->mfnr.mode_cell));
216 ret |= reconstruct(fd,
217 sizeof(CalibDb_Sharp_ModeCell_t) * calib->sharp.mode_num,
218 (char**)(&calib->sharp.mode_cell));
219 ret |= reconstruct(fd,
220 sizeof(CalibDb_EdgeFilter_ModeCell_t) * calib->edgeFilter.mode_num,
221 (char**)(&calib->edgeFilter.mode_cell));
222
223 return ret;
224 }
225
calibSaveToFile(char * iqFile,CamCalibDbContext_t * calib)226 static bool calibSaveToFile(char* iqFile, CamCalibDbContext_t* calib)
227 {
228 int fd;
229 bool ret = true;
230 char path[CALIBDB_PATH_LEN];
231
232 getFilePathName(iqFile, path);
233 fd = open(path, O_CREAT | O_TRUNC | O_RDWR | O_SYNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
234 if (fd < 0) {
235 ret = false;
236 LOGE("open %s failed!", path);
237 } else {
238 lseek(fd, 0, SEEK_SET);
239 if (persistCalib(fd, calib)) {
240 LOGE("write %s failed!\n", path);
241 remove(path);
242 ret = false;
243 }
244 close(fd);
245 }
246 return ret;
247 }
248
calibReadFromFile(char * iqFile,CamCalibDbContext_t * calib)249 static bool calibReadFromFile(char* iqFile, CamCalibDbContext_t* calib)
250 {
251 int fd;
252 bool ret = true;
253 char path[CALIBDB_PATH_LEN];
254
255 getFilePathName(iqFile, path);
256 fd = open(path, O_RDONLY | O_SYNC);
257 if (fd < 0) {
258 ret = false;
259 } else {
260 lseek(fd, 0, SEEK_SET);
261 if (reconstructCalib(fd, calib)) {
262 LOGE("read %s failed!\n", path);
263 ret = false;
264 }
265 close(fd);
266 }
267
268 return ret;
269 }
270
_calc_checksum(CamCalibDbContext_t * CalibDb)271 static uint32_t _calc_checksum(CamCalibDbContext_t *CalibDb) {
272
273 uint32_t checkSum = 0;
274 uint32_t i = 0;
275 uint32_t *data = NULL;
276 uint32_t size = 0;
277
278 if (!CHECK_ISP_HW_V20()) {
279 LOGE("only support isp20 calibv1 !");
280 return -1;
281 }
282 CamCalibDbContextIsp20_t* pCalibDb = TO_CALIBDBV1_ISP20(CalibDb);
283
284 #define CALC_SUM(data,size) \
285 for(i = 0; i < sizeof(size) / 4; i++) { \
286 checkSum += *data; \
287 data++; \
288 }
289
290 // header
291 data = (uint32_t*)(&pCalibDb->header);
292 size = sizeof(CalibDb_Header_t) ;
293 CALC_SUM(data, size);
294 #if 0 // TODO Merge
295 // awb
296 data = (uint32_t*)(&pCalibDb->awb);
297 size = sizeof(CalibDb_Awb_Para_t) ;
298 CALC_SUM(data, size);
299 #endif
300 // lut3d
301 data = (uint32_t*)(&pCalibDb->lut3d);
302 size = sizeof(CalibDb_Lut3d_t) ;
303 CALC_SUM(data, size);
304
305 // aec
306 data = (uint32_t*)(&pCalibDb->aec);
307 size = sizeof(CalibDb_Aec_Para_t) ;
308 CALC_SUM(data, size);
309
310 // af
311 data = (uint32_t*)(&pCalibDb->af);
312 size = sizeof(CalibDb_AF_t) ;
313 CALC_SUM(data, size);
314
315 // ahdr
316 data = (uint32_t*)(&pCalibDb->atmo);
317 size = sizeof(CalibDb_Atmo_Para_t) ;
318 CALC_SUM(data, size);
319
320 // ahdr
321 data = (uint32_t*)(&pCalibDb->amerge);
322 size = sizeof(CalibDb_Amerge_Para_t) ;
323 CALC_SUM(data, size);
324
325 // ablc
326 data = (uint32_t*)(&pCalibDb->blc);
327 size = sizeof(CalibDb_Blc_t) ;
328 CALC_SUM(data, size);
329
330 // dpcc
331 data = (uint32_t*)(&pCalibDb->dpcc);
332 size = sizeof(CalibDb_Dpcc_t) ;
333 CALC_SUM(data, size);
334
335 // bayer nr
336 data = (uint32_t*)(pCalibDb->bayerNr.mode_cell);
337 size = pCalibDb->bayerNr.mode_num * sizeof(CalibDb_BayerNr_ModeCell_t);
338 CALC_SUM(data, size);
339
340 // lsc
341 data = (uint32_t*)(&pCalibDb->lsc.aLscCof);
342 size = sizeof(CalibDb_AlscCof_t);
343 CALC_SUM(data, size);
344 data = (uint32_t*)(pCalibDb->lsc.tableAll);
345 size = pCalibDb->lsc.tableAllNum * sizeof(CalibDb_LscTableProfile_t);
346 CALC_SUM(data, size);
347
348 // rkdm
349 data = (uint32_t*)(&pCalibDb->dm);
350 size = sizeof(CalibDb_RKDM_t) ;
351 CALC_SUM(data, size);
352
353 // ccm
354 data = (uint32_t*)(&pCalibDb->ccm);
355 size = sizeof(CalibDb_Ccm_t) ;
356 CALC_SUM(data, size);
357
358 // uvnr
359 data = (uint32_t*)(pCalibDb->uvnr.mode_cell);
360 size = pCalibDb->uvnr.mode_num * sizeof(CalibDb_UVNR_ModeCell_t);
361 CALC_SUM(data, size);
362
363 // gamma
364 data = (uint32_t*)(&pCalibDb->gamma);
365 size = sizeof(CalibDb_Gamma_t ) ;
366 CALC_SUM(data, size);
367
368 // ynr
369 data = (uint32_t*)(pCalibDb->ynr.mode_cell);
370 size = pCalibDb->ynr.mode_num * sizeof(CalibDb_YNR_ModeCell_t);
371 CALC_SUM(data, size);
372
373 // gamma
374 data = (uint32_t*)(&pCalibDb->gic);
375 size = sizeof(CalibDb_Gic_t) ;
376 CALC_SUM(data, size);
377
378 // mfnr
379 data = (uint32_t*)(pCalibDb->mfnr.mode_cell);
380 size = pCalibDb->mfnr.mode_num * sizeof(CalibDb_MFNR_ModeCell_t);
381 CALC_SUM(data, size);
382
383 // sharp
384 data = (uint32_t*)(pCalibDb->sharp.mode_cell);
385 size = pCalibDb->sharp.mode_num * sizeof(CalibDb_Sharp_ModeCell_t);
386 CALC_SUM(data, size);
387
388 // edgefilter
389 data = (uint32_t*)(pCalibDb->edgeFilter.mode_cell);
390 size = pCalibDb->edgeFilter.mode_num * sizeof(CalibDb_EdgeFilter_ModeCell_t);
391 CALC_SUM(data, size);
392
393 // dehaze
394 data = (uint32_t*)(&pCalibDb->dehaze);
395 size = sizeof(CalibDb_Dehaze_t) ;
396 CALC_SUM(data, size);
397
398 // fec
399 data = (uint32_t*)(&pCalibDb->afec);
400 size = sizeof(CalibDb_FEC_t );
401 CALC_SUM(data, size);
402
403 // ldch
404 data = (uint32_t*)(&pCalibDb->aldch);
405 size = sizeof(CalibDb_LDCH_t );
406 CALC_SUM(data, size);
407
408 // lumaDetect
409 data = (uint32_t*)(&pCalibDb->lumaDetect);
410 size = sizeof(CalibDb_LUMA_DETECT_t);
411 CALC_SUM(data, size);
412
413 // orb
414 data = (uint32_t*)(&pCalibDb->orb);
415 size = sizeof(CalibDb_ORB_t);
416 CALC_SUM(data, size);
417
418 // sensor
419 data = (uint32_t*)(&pCalibDb->sensor);
420 size = sizeof(CalibDb_Sensor_Para_t);
421 CALC_SUM(data, size);
422
423 // module
424 data = (uint32_t*)(&pCalibDb->module);
425 size = sizeof(CalibDb_Module_Info_t );
426 CALC_SUM(data, size);
427
428 // cpsl
429 data = (uint32_t*)(&pCalibDb->cpsl);
430 size = sizeof(CalibDb_Cpsl_t );
431 CALC_SUM(data, size);
432
433 // colorAsGrey
434 data = (uint32_t*)(&pCalibDb->colorAsGrey);
435 size = sizeof(CalibDb_ColorAsGrey_t );
436 CALC_SUM(data, size);
437
438 // ie
439 data = (uint32_t*)(&pCalibDb->ie);
440 size = sizeof(CalibDb_IE_t);
441 CALC_SUM(data, size);
442
443 // sysContrl
444 data = (uint32_t*)(&pCalibDb->sysContrl);
445 size = sizeof(CalibDb_System_t);
446 CALC_SUM(data, size);
447
448 LOGD("%s(%d): iq data checksum:%u \n", __FUNCTION__, __LINE__, checkSum);
449
450 LOGD("%s(%d): exit\n", __FUNCTION__, __LINE__);
451 return checkSum;
452 }
453
createCalibDb(char * iqFile)454 CamCalibDbContext_t* RkAiqCalibDb::createCalibDb(char* iqFile)
455 {
456 map<string, CamCalibDbContext_t*>::iterator it;
457
458 string str(iqFile);
459
460 it = mCalibDbsMap.find(str);
461 if (it != mCalibDbsMap.end()) {
462 LOGD("use cached calibdb for %s!", iqFile);
463 return it->second;
464 } else {
465 CamCalibDbContext_t *pCalibDb = calibdbV1_ctx_new();
466 if (!pCalibDb)
467 LOGE("not support isp hw ver %d", g_rkaiq_isp_hw_ver);
468 if (pCalibDb) {
469 initCalibDb(pCalibDb);
470 if (0 == access(iqFile, F_OK)) {
471 RkAiqCalibParser parser(pCalibDb);
472 mMutex.lock();
473 bool ret = parser.doParse(iqFile);
474 mMutex.unlock();
475 if (ret) {
476 uint32_t magicCode = calib_check_calc_checksum();
477 if (magicCode != ((CalibDb_Header_t*)pCalibDb)->magic_code)
478 LOGW("magic code is not matched! calculated:%u, readed:%u", magicCode,
479 ((CalibDb_Header_t*)pCalibDb)->magic_code);
480 mCalibDbsMap[str] = pCalibDb;
481 LOGD("create calibdb from %s success.", iqFile);
482 _calc_checksum(pCalibDb);
483 return pCalibDb;
484 } else {
485 LOGE("parse %s failed.", iqFile);
486 }
487 } else if(isDataBinExist(iqFile)) {
488 if (calibReadFromFile(iqFile, pCalibDb)) {
489 uint32_t magicCode = calib_check_calc_checksum();
490 if (magicCode != ((CalibDb_Header_t*)pCalibDb)->magic_code)
491 LOGE("magic code is not matched! calculated:%u, readed:%u", magicCode,
492 ((CalibDb_Header_t*)pCalibDb)->magic_code);
493 mCalibDbsMap[str] = pCalibDb;
494 LOGD("get calibdb from bin success.");
495 _calc_checksum(pCalibDb);
496 return pCalibDb;
497 } else {
498 LOGE("get calibdb from bin failed.");
499 }
500 } else {
501 LOGE("calibdb %s and bin are all not exist!", iqFile);
502 }
503 } else {
504 LOGE("alloc calibdb memory failed.");
505 }
506 }
507 return NULL;
508 }
509
generateCalibDb(char * iqFileRef,char * iqFileOutput,CamCalibDbContext_t * pCalibDb)510 bool RkAiqCalibDb::generateCalibDb(char* iqFileRef, char* iqFileOutput, CamCalibDbContext_t* pCalibDb)
511 {
512 //map<string, CamCalibDbContext_t*>::iterator it;
513
514 string str(iqFileRef);
515
516 //it = mCalibDbsMap.find(str);
517 if (pCalibDb) {
518 RkAiqCalibParser parser(pCalibDb);
519 if (parser.doGenerate(iqFileRef, iqFileOutput)) {
520 mCalibDbsMap[str] = pCalibDb;
521 LOGD("generate calibdb from %s to %s success.", iqFileRef, iqFileOutput);
522 return true;
523 }
524 else {
525 LOGE("generate %s to %s failed.", iqFileRef, iqFileOutput);
526 }
527 }
528 else {
529 LOGE("alloc generate memory failed.");
530 }
531 return false;
532 }
533
releaseCalibDb()534 void RkAiqCalibDb::releaseCalibDb()
535 {
536 std::map<string, CamCalibDbContext_t*>::iterator it;
537 for (it = mCalibDbsMap.begin(); it != mCalibDbsMap.end(); it++) {
538 CamCalibDbContext_t *pCalibDb = it->second;
539 if(pCalibDb) {
540 CalibDb_Lsc_t* lsc =
541 (CalibDb_Lsc_t*)CALIBDB_GET_MODULE_PTR(pCalibDb, lsc);
542 if(lsc && lsc->tableAll != NULL) {
543 free(lsc->tableAll);
544
545 }
546
547 list_head* list = (list_head*)CALIBDB_GET_MODULE_PTR(pCalibDb, awb_adjust_para);
548 if (list)
549 clear_list(list);
550
551 list = (list_head*)CALIBDB_GET_MODULE_PTR(pCalibDb, awb_calib_para_v200);
552 if (list)
553 clear_list(list);
554
555 list = (list_head*)CALIBDB_GET_MODULE_PTR(pCalibDb, awb_calib_para_v201);
556 if (list)
557 clear_list(list);
558
559 if(CHECK_ISP_HW_V21()) {
560
561 list_head* ae_list = (list_head*)CALIBDB_GET_MODULE_PTR(pCalibDb, ae_calib_para);
562 if (ae_list)
563 clear_list(ae_list);
564
565 ae_list = (list_head*)CALIBDB_GET_MODULE_PTR(pCalibDb, ae_tuning_para);
566 if (ae_list)
567 clear_list(ae_list);
568 }
569
570 LOGI("releaseCalibDb!");
571 CalibDb_BayerNr_2_t* bayerNr =
572 (CalibDb_BayerNr_2_t*)CALIBDB_GET_MODULE_PTR(pCalibDb, bayerNr);
573 if(bayerNr && bayerNr->mode_cell != NULL) {
574 free(bayerNr->mode_cell);
575 bayerNr->mode_cell = NULL;
576 bayerNr->mode_num = 0;
577 }
578 CalibDb_UVNR_2_t *uvnr =
579 (CalibDb_UVNR_2_t*)CALIBDB_GET_MODULE_PTR(pCalibDb, uvnr);
580 if(uvnr && uvnr->mode_cell != NULL) {
581 free(uvnr->mode_cell);
582 uvnr->mode_cell = NULL;
583 uvnr->mode_num = 0;
584 }
585 CalibDb_YNR_2_t *ynr =
586 (CalibDb_YNR_2_t*)CALIBDB_GET_MODULE_PTR(pCalibDb, ynr);
587 if(ynr && ynr->mode_cell != NULL) {
588 free(ynr->mode_cell);
589 ynr->mode_cell = NULL;
590 ynr->mode_num = 0;
591
592 }
593 CalibDb_MFNR_2_t *mfnr =
594 (CalibDb_MFNR_2_t*)CALIBDB_GET_MODULE_PTR(pCalibDb, mfnr);
595 if(mfnr && mfnr->mode_cell != NULL) {
596 free(mfnr->mode_cell);
597 mfnr->mode_cell = NULL;
598 mfnr->mode_num = 0;
599 }
600 CalibDb_Sharp_2_t *sharp =
601 (CalibDb_Sharp_2_t*)CALIBDB_GET_MODULE_PTR(pCalibDb, sharp);
602 if(sharp && sharp->mode_cell != NULL) {
603 free(sharp->mode_cell);
604 sharp->mode_cell = NULL;
605 sharp->mode_num = 0;
606 }
607 CalibDb_EdgeFilter_2_t *edgeFilter =
608 (CalibDb_EdgeFilter_2_t*)CALIBDB_GET_MODULE_PTR(pCalibDb, edgeFilter);
609 if(edgeFilter && edgeFilter->mode_cell != NULL) {
610 free(edgeFilter->mode_cell);
611 edgeFilter->mode_cell = NULL;
612 edgeFilter->mode_num = 0;
613 }
614 calibdbV1_ctx_delete(pCalibDb);
615 }
616 }
617 mCalibDbsMap.clear();
618 }
619
getCalibDb(char * iqFile)620 CamCalibDbContext_t* RkAiqCalibDb::getCalibDb(char* iqFile)
621 {
622 std::map<string, CamCalibDbContext_t*>::iterator it;
623
624 std::string str(iqFile);
625
626 it = mCalibDbsMap.find(str);
627 if (it != mCalibDbsMap.end()) {
628 return it->second;
629 } else {
630 LOGE("calibDb not found!");
631 return NULL;
632 }
633 }
634
createCalibDbBinFromXml(char * iqFile)635 void RkAiqCalibDb::createCalibDbBinFromXml(char* iqFile)
636 {
637 CamCalibDbContext_t *pCalibDb = calibdbV1_ctx_new();
638 if (pCalibDb) {
639 if (0 == access(iqFile, F_OK)) {
640 RkAiqCalibParser parser(pCalibDb);
641 if (parser.doParse(iqFile)) {
642 uint32_t magicCode = calib_check_calc_checksum();
643 if (magicCode != ((CalibDb_Header_t*)pCalibDb)->magic_code)
644 LOGW("magic code is not matched! calculated:%u, readed:%u", magicCode,
645 ((CalibDb_Header_t*)pCalibDb)->magic_code);
646 LOGI("create calibdb from %s success, magic code %u.", iqFile, magicCode);
647 if (calibSaveToFile(iqFile, pCalibDb))
648 LOGD("save to bin success.");
649 else
650 LOGE("save to bin failed.");
651 } else {
652 LOGE("parse %s failed.", iqFile);
653 }
654 } else {
655 LOGE("%s is not found!", iqFile);
656 }
657 calibdbV1_ctx_delete(pCalibDb);
658 }
659 }
660
initCalibDb(CamCalibDbContext_t * pCalibDb)661 void RkAiqCalibDb::initCalibDb(CamCalibDbContext_t* pCalibDb)
662 {
663 if (pCalibDb) {
664 memset(pCalibDb, 0, calibdbV1_ctx_size(pCalibDb));
665 CalibDb_cProc_t *cProc =
666 (CalibDb_cProc_t *)CALIBDB_GET_MODULE_PTR(pCalibDb, cProc);
667 /* initialize cproc */
668 if (cProc) {
669 cProc->enable = 1;
670 cProc->brightness = 128;
671 cProc->contrast = 128;
672 cProc->saturation = 128;
673 cProc->hue = 128;
674 }
675 }
676 }
parseXmlandWriteXml(char * iqFile)677 void RkAiqCalibDb::parseXmlandWriteXml(char* iqFile)
678 {
679 CamCalibDbContext_t *pCalibDb = calibdbV1_ctx_new();
680 if (pCalibDb) {
681 if (0 == access(iqFile, F_OK)) {
682 RkAiqCalibParser parser(pCalibDb);
683 if (parser.doParse(iqFile)) {
684 uint32_t magicCode = calib_check_calc_checksum();
685 if (magicCode != ((CalibDb_Header_t*)pCalibDb)->magic_code) {
686 LOGW("magic code is not matched! calculated:%u, readed:%u", magicCode,
687 ((CalibDb_Header_t*)pCalibDb)->magic_code);
688 } else {
689 printf("create calibdb from %s success, magic code %u.", iqFile, magicCode);
690 char iqFileOutput[CALIBDB_PATH_LEN];
691 getFilePathName2(iqFile, iqFileOutput);
692 parser.updateXmlParseReadWriteFlag(XML_PARSER_WRITE);
693 if (parser.doGenerate(iqFile, iqFileOutput)) {
694 string str(iqFile);
695 mCalibDbsMap[str] = pCalibDb;
696 LOGD("generate calibdb from %s to %s success.", iqFile, iqFileOutput);
697 }
698 else {
699 LOGE("generate %s to %s failed.", iqFile, iqFileOutput);
700 }
701 }
702 } else {
703 LOGE("parse %s failed.", iqFile);
704 }
705 } else {
706 LOGE("%s is not found!", iqFile);
707 }
708 calibdbV1_ctx_delete(pCalibDb);
709 }
710 }
711
712
713 } //namespace RkCam
714
715
716
717
718
719
720
721