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 #include <stdio.h>
18 #include <stdlib.h>
19 #include <string>
20
21 #include "RkAiqCalibParser.h"
22 #include "calibtags.h"
23 #include "xmltags.h"
24 #include <fstream>
25 #include <iostream>
26
27 using namespace std;
28 namespace RkCam {
29
30 #define MEMSET( TARGET, C, LEN) memset(TARGET,C,LEN)
31 #define MEMCPY( DST, SRC, LEN) memcpy(DST,SRC,LEN)
32
33 //#define DEBUG_LOG
34 //#define INFO_LOG
35
36 #ifdef INFO_LOG
37 #define INFO_PRINT(TAG_NAME) LOG1("[Line:%d, Tag: %s]\n",__LINE__,TAG_NAME.c_str())
38 #else
39 #define INFO_PRINT(TAG_NAME)
40 #endif
41
42 #define redirectOut std::cout
43
44 #define CALIBDB_MODULE_PTR_HELPER_BRANCH(type, module, clause) \
45 type* module = (type*)CALIBDB_GET_MODULE_PTR(mCalibDb, module); \
46 if (!module) { \
47 LOGE("no" #module "struct exist !"); \
48 clause; \
49 }
50
51 #define CALIBDB_MODULE_PTR_HELPER_RET(type, module) \
52 CALIBDB_MODULE_PTR_HELPER_BRANCH(type, module, return true)
53
54 #define CALIBDB_MODULE_PTR_HELPER_CON(type, module) \
55 CALIBDB_MODULE_PTR_HELPER_BRANCH(type, module, pchild = pchild->NextSibling(); continue)
56
57 #define CALIBDB_MODULE_PTR_HELPER(type, module) \
58 CALIBDB_MODULE_PTR_HELPER_BRANCH(type, module, ;)
59
60 /******************************************************************************
61 * Toupper
62 *****************************************************************************/
Toupper(const char * s)63 char* Toupper(const char* s) {
64 int i = 0;
65 char* p = (char*)s;
66 char tmp;
67 int len = 0;
68
69 if (p) {
70 len = strlen(p);
71 for (i = 0; i < len; i++) {
72 tmp = p[i];
73
74 if (tmp >= 'a' && tmp <= 'z')
75 tmp = tmp - 32;
76
77 p[i] = tmp;
78 }
79 }
80 return p;
81 }
82
ParseCharToHex(XmlTag * tag,uint32_t * reg_value)83 int RkAiqCalibParser::ParseCharToHex
84 (
85 XmlTag* tag, /**< trimmed c string */
86 uint32_t* reg_value
87 ) {
88 bool ok;
89
90 *reg_value = tag->ValueToUInt(&ok);
91 if (!ok) {
92 LOGE( "%s(%d): parse error: invalid register value:\n", __FUNCTION__, __LINE__, tag->Value());
93 return (false);
94 } else {
95 #ifdef DEBUG_LOG
96 LOGD( "%s(%d): parse reg valevalue:\n", __FUNCTION__, __LINE__, *reg_value);
97 #endif
98 }
99
100 return 0;
101 }
102
parseReadWriteCtrl(bool ctrl)103 void RkAiqCalibParser::parseReadWriteCtrl(bool ctrl)
104 {
105 xmlParseReadWrite = ctrl;
106 }
107
108 /******************************************************************************
109 * ParseFloatArray
110 *****************************************************************************/
ParseFloatArray(const XMLNode * pNode,float * values,const int num,int printAccuracy)111 int RkAiqCalibParser::ParseFloatArray
112 (
113 const XMLNode* pNode, /**< trimmed c string */
114 float* values, /**< pointer to memory */
115 const int num, /**< number of expected float values */
116 int printAccuracy /**< accuracy of XML write */
117 ) {
118
119 if (!xmlParseReadWrite) // read
120 {
121 const char* c_string = XmlTag(pNode->ToElement()).Value();
122 float* value = values;
123 char* str = (char*)c_string;
124 int last = strlen(str);
125 /* calc. end adress of string */
126 char* str_last = str + (last - 1);
127
128 std::string s_string(str);
129 size_t find_start = s_string.find("[", 0);
130 size_t find_end = s_string.find("]", 0);
131
132 if ((find_start == std::string::npos) || (find_end == std::string::npos)) {
133 #ifdef DEBUG_LOG
134 LOGD( "%s(%d): start=%d,end=%d\n", __FUNCTION__, __LINE__, find_start, find_end);
135 #endif
136 return -1;
137 }
138
139 str = (char*)c_string + find_start;
140 str_last = (char*)c_string + find_end;
141
142 /* skipped left parenthesis */
143 str++;
144
145 /* skip spaces */
146 while (*str == 0x20 || *str == 0x09 || (*str == 0x0a) || (*str == 0x0d)) {
147 str++;
148 }
149
150 int cnt = 0;
151 int scanned;
152 float f;
153
154 /* parse the c-string */
155 while ((str != str_last) && (cnt < num)) {
156 scanned = sscanf(str, "%f", &f);
157 if (scanned != 1) {
158 LOGE( "%s(%d): %f err\n", __FUNCTION__, __LINE__, f);
159 goto err1;
160 }
161 else {
162 value[cnt] = f;
163 cnt++;
164 }
165
166 /* remove detected float */
167 while ((*str != 0x20) && (*str != 0x09) && (*str != ',') && (*str != ']')) {
168 str++;
169 }
170
171 /* skip spaces and comma */
172 while ((*str == 0x20) || (*str == ',') || (*str == 0x09) || (*str == 0x0a) || (*str == 0x0d)) {
173 str++;
174 }
175 }
176
177 #ifdef DEBUG_LOG
178 for (int i = 0; i < cnt; i++) {
179 LOGD( "%f,\n", value[i]);
180 }
181 #endif
182
183 return (cnt);
184 }
185 else if (xmlParseReadWrite == XML_PARSER_WRITE) // write
186 {
187 char cmd[16] = {"%s%.0f "};
188 if (printAccuracy > 9)
189 printAccuracy = 9;
190 cmd[4] = '0' + printAccuracy;
191 autoTabForward();
192 autoTabForward();
193 int cols = XmlTag(pNode->ToElement()).SizeCol();
194 int rows = XmlTag(pNode->ToElement()).SizeRow();
195 char str[8192];
196 char* strp = str;
197 snprintf(str, sizeof(str), "\n%s[", autoTabStr);
198 for (int i = 0; i < rows; i++)
199 {
200 for (int k = 0; k < cols; k++)
201 snprintf(str, sizeof(str), cmd, strp, values[i * cols + k]);
202 if (i < rows - 1) {
203 strcat(str, "\n");
204 strcat(str, autoTabStr);
205 }
206 }
207 autoTabBackward();
208 strcat(str, "]\n");
209 strcat(str, autoTabStr);
210
211 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
212 pComment->SetValue((const char *)str);
213
214 autoTabBackward();
215 return (num);
216 }
217
218
219
220 err1:
221 MEMSET(values, 0, (sizeof(float)* num));
222
223 return (0);
224
225 }
226
227 /******************************************************************************
228 * ParseDoubleArray
229 *****************************************************************************/
ParseDoubleArray(const XMLNode * pNode,double * values,const int num)230 int RkAiqCalibParser::ParseDoubleArray
231 (
232 const XMLNode *pNode, /**< trimmed c string */
233 double* values, /**< pointer to memory */
234 const int num /**< number of expected float values */
235 ) {
236 if (xmlParseReadWrite == XML_PARSER_READ) // read
237 {
238 const char* c_string = XmlTag(pNode->ToElement()).Value();
239 double* value = values;
240 char* str = (char*)c_string;
241 int last = strlen(str);
242 /* calc. end adress of string */
243 char* str_last = str + (last - 1);
244
245 std::string s_string(str);
246 size_t find_start = s_string.find("[", 0);
247 size_t find_end = s_string.find("]", 0);
248
249 if ((find_start == std::string::npos) || (find_end == std::string::npos)) {
250 #ifdef DEBUG_LOG
251 LOGD( "%s(%d): start=%d,end=%d\n", __FUNCTION__, __LINE__, find_start, find_end);
252 #endif
253 return -1;
254 }
255
256 str = (char*)c_string + find_start;
257 str_last = (char*)c_string + find_end;
258
259 /* skipped left parenthesis */
260 str++;
261
262 /* skip spaces */
263 while (*str == 0x20 || *str == 0x09 || (*str == 0x0a) || (*str == 0x0d)) {
264 str++;
265 }
266
267 int cnt = 0;
268 int scanned;
269 double d;
270
271 /* parse the c-string */
272 while ((str != str_last) && (cnt < num)) {
273 scanned = sscanf(str, "%lf", &d);
274 if (scanned != 1) {
275 LOGE( "%s(%d): %f err\n", __FUNCTION__, __LINE__, d);
276 goto err2;
277 }
278 else {
279 value[cnt] = d;
280 cnt++;
281 }
282
283 /* remove detected float */
284 while ((*str != 0x20) && (*str != 0x09) && (*str != ',') && (*str != ']')) {
285 str++;
286 }
287
288 /* skip spaces and comma */
289 while ((*str == 0x20) || (*str == ',') || (*str == 0x09) || (*str == 0x0a) || (*str == 0x0d)) {
290 str++;
291 }
292 }
293
294 #ifdef DEBUG_LOG
295 for (int i = 0; i < cnt; i++) {
296 LOGD( "%f,\n", value[i]);
297 }
298 #endif
299
300 return (cnt);
301 }
302 else if (xmlParseReadWrite == XML_PARSER_WRITE) // write
303 {
304 autoTabForward();
305 autoTabForward();
306 int cols = XmlTag(pNode->ToElement()).SizeCol();
307 int rows = XmlTag(pNode->ToElement()).SizeRow();
308 char str[8192];
309 snprintf(str, sizeof(str), "\n%s[", autoTabStr);
310 char tmp_val_str[64];
311 for (int i = 0; i < rows; i++)
312 {
313 for (int k = 0; k < cols; k++) {
314 snprintf(tmp_val_str, sizeof(tmp_val_str), "%.16e ", values[i * cols + k]);
315 strcat(str, tmp_val_str);
316 }
317 if (i < rows - 1) {
318 strcat(str, "\n");
319 strcat(str, autoTabStr);
320 }
321 }
322 autoTabBackward();
323 strcat(str, "]\n");
324 strcat(str, autoTabStr);
325
326 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
327 pComment->SetValue((const char *)str);
328 autoTabBackward();
329
330 return (num);
331 }
332
333
334 err2:
335 MEMSET(values, 0, (sizeof(float)* num));
336
337 return (0);
338
339 }
340
341 /******************************************************************************
342 * ParseUintArray
343 *****************************************************************************/
ParseUintArray(const XMLNode * pNode,uint32_t * values,const int num)344 int RkAiqCalibParser::ParseUintArray
345 (
346 const XMLNode *pNode, /**< trimmed c string */
347 uint32_t* values, /**< pointer to memory */
348 const int num /**< number of expected float values */
349 ) {
350 if (!xmlParseReadWrite) // read
351 {
352 uint32_t* value = values;
353 const char* c_string = XmlTag(pNode->ToElement()).Value();
354 char* str = (char*)c_string;
355
356 int last = strlen(str);
357 char* str_last = str + (last - 1);
358
359 std::string s_string(str);
360 size_t find_start = s_string.find("[", 0);
361 size_t find_end = s_string.find("]", 0);
362
363 if ((find_start == std::string::npos) || (find_end == std::string::npos)) {
364 #ifdef DEBUG_LOG
365 LOGE( "%s(%d): start=%d,end=%d\n", __FUNCTION__, __LINE__, find_start, find_end);
366 #endif
367 return -1;
368 }
369
370 str = (char*)c_string + find_start;
371 str_last = (char*)c_string + find_end;
372
373 /* calc. end adress of string */
374 // char *str_last = str + (last-1);
375
376 /* skipped left parenthesis */
377 str++;
378
379 /* skip spaces */
380 while (*str == 0x20 || *str == 0x09 || (*str == 0x0a) || (*str == 0x0d)) {
381 str++;
382 }
383
384 int cnt = 0;
385 int scanned;
386 uint32_t f;
387
388 /* parse the c-string */
389 while ((str != str_last) && (cnt < num)) {
390 scanned = sscanf(str, "%u", &f);
391 if (scanned != 1) {
392 LOGE( "%s(%d): f:%f error\n", __FUNCTION__, __LINE__, f);
393 goto err1;
394 }
395 else {
396 value[cnt] = f;
397 cnt++;
398 }
399
400 /* remove detected float */
401 while ((*str != 0x20) && (*str != 0x09) && (*str != ',') && (*str != ']')) {
402 str++;
403 }
404
405 /* skip spaces and comma */
406 while ((*str == 0x20) || (*str == ',') || (*str == 0x09) || (*str == 0x0a) || (*str == 0x0d)) {
407 str++;
408 }
409 }
410
411 #ifdef DEBUG_LOG
412 for (int i = 0; i < cnt; i++) {
413 LOGD( "%u,\n", value[i]);
414 }
415 #endif
416 return (cnt);
417 }
418 else if (xmlParseReadWrite == XML_PARSER_WRITE) // write
419 {
420 autoTabForward();
421 autoTabForward();
422 int cols = XmlTag(pNode->ToElement()).SizeCol();
423 int rows = XmlTag(pNode->ToElement()).SizeRow();
424 char str[8192];
425 snprintf(str, sizeof(str), "\n%s[", autoTabStr);
426 char tmp_val_str[25];
427 for (int i = 0; i < rows; i++)
428 {
429 for (int k = 0; k < cols; k++) {
430 snprintf(tmp_val_str, sizeof(tmp_val_str), "%d ", values[i * cols + k]);
431 strcat(str, tmp_val_str);
432 }
433 if (i < rows - 1) {
434 strcat(str, "\n");
435 strcat(str, autoTabStr);
436 }
437 }
438 autoTabBackward();
439 strcat(str, "]\n");
440 strcat(str, autoTabStr);
441
442 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
443 pComment->SetValue((const char *)str);
444 autoTabBackward();
445
446 return num;
447 }
448
449
450 err1:
451 MEMSET(values, 0, (sizeof(uint32_t)* num));
452
453 return (0);
454 }
455
456 /******************************************************************************
457 * ParseIntArray
458 *****************************************************************************/
ParseIntArray(const XMLNode * pNode,int32_t * values,const int num)459 int RkAiqCalibParser::ParseIntArray
460 (
461 const XMLNode *pNode, /**< trimmed c string */
462 int32_t* values, /**< pointer to memory */
463 const int num /**< number of expected float values */
464 ) {
465
466 if (!xmlParseReadWrite) // read
467 {
468 int32_t* value = values;
469 const char* c_string = XmlTag(pNode->ToElement()).Value();
470 char* str = (char*)c_string;
471
472 int last = strlen(str);
473 char* str_last = str + (last - 1);
474
475 std::string s_string(str);
476 size_t find_start = s_string.find("[", 0);
477 size_t find_end = s_string.find("]", 0);
478
479 if ((find_start == std::string::npos) || (find_end == std::string::npos)) {
480
481 return -1;
482 }
483
484 str = (char*)c_string + find_start;
485 str_last = (char*)c_string + find_end;
486
487 /* calc. end adress of string */
488 // char *str_last = str + (last-1);
489
490 /* skipped left parenthesis */
491 str++;
492
493 /* skip spaces */
494 while (*str == 0x20 || *str == 0x09 || (*str == 0x0a) || (*str == 0x0d)) {
495 str++;
496 }
497
498 int cnt = 0;
499 int scanned;
500 int32_t f;
501
502 /* parse the c-string */
503 while ((str != str_last) && (cnt < num)) {
504 scanned = sscanf(str, "%d", &f);
505 if (scanned != 1) {
506 LOGE( "%s(%d): f:%f error\n", __FUNCTION__, __LINE__, f);
507 goto err1;
508 }
509 else {
510 value[cnt] = f;
511 cnt++;
512 }
513
514 /* remove detected float */
515 while ((*str != 0x20) && (*str != 0x09) && (*str != ',') && (*str != ']')) {
516 str++;
517 }
518
519 /* skip spaces and comma */
520 while ((*str == 0x20) || (*str == ',') || (*str == 0x09) || (*str == 0x0a) || (*str == 0x0d)) {
521 str++;
522 }
523 }
524
525 #ifdef DEBUG_LOG
526 for (int i = 0; i < cnt; i++) {
527 LOGD( "%d,\n", value[i]);
528 }
529 #endif
530 return (cnt);
531 }
532 else if (xmlParseReadWrite == XML_PARSER_WRITE) // write
533 {
534 autoTabForward();
535 autoTabForward();
536 int cols = XmlTag(pNode->ToElement()).SizeCol();
537 int rows = XmlTag(pNode->ToElement()).SizeRow();
538 char str[8192];
539 snprintf(str, sizeof(str), "\n%s[", autoTabStr);
540 char tmp_val_str[25];
541 for (int i = 0; i < rows; i++)
542 {
543 for (int k = 0; k < cols; k++) {
544 snprintf(tmp_val_str, sizeof(tmp_val_str), "%d ", values[i * cols + k]);
545 strcat(str, tmp_val_str);
546 }
547
548 if (i < rows - 1) {
549 strcat(str, "\n");
550 strcat(str, autoTabStr);
551 }
552 }
553 autoTabBackward();
554 strcat(str, "]\n");
555 strcat(str, autoTabStr);
556
557 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
558 pComment->SetValue((const char *)str);
559 autoTabBackward();
560
561 return num;
562 }
563
564
565 err1:
566 MEMSET(values, 0, (sizeof(int32_t)* num));
567
568 return (0);
569 }
570
571 /******************************************************************************
572 * ParseUchartArray//cxf
573 *****************************************************************************/
ParseUcharArray(const XMLNode * pNode,uint8_t * values,const int num)574 int RkAiqCalibParser::ParseUcharArray
575 (
576 const XMLNode *pNode, /**< trimmed c string */
577 uint8_t* values, /**< pointer to memory */
578 const int num /**< number of expected float values */
579 ) {
580
581 if (!xmlParseReadWrite) // read
582 {
583 uint8_t* value = values;
584 const char* c_string = XmlTag(pNode->ToElement()).Value();
585 char* str = (char*)c_string;
586
587 int last = strlen(str);
588 char* str_last = str + (last - 1);
589
590 std::string s_string(str);
591 size_t find_start = s_string.find("[", 0);
592 size_t find_end = s_string.find("]", 0);
593
594 if ((find_start == std::string::npos) || (find_end == std::string::npos)) {
595
596 return -1;
597 }
598
599 str = (char*)c_string + find_start;
600 str_last = (char*)c_string + find_end;
601
602
603 /* calc. end adress of string */
604 // char *str_last = str + (last-1);
605
606 /* skipped left parenthesis */
607 str++;
608
609 /* skip spaces */
610 while (*str == 0x20 || *str == 0x09 || (*str == 0x0a) || (*str == 0x0d)) {
611 str++;
612 }
613
614 int cnt = 0;
615 int scanned;
616 uint16_t f; // uint8_t f;
617
618 /* parse the c-string */
619 while ((str != str_last) && (cnt < num)) {
620 scanned = sscanf(str, "%hu", &f); // %hhu
621 if (scanned != 1) {
622 LOGD( "%s(%d):f:%f\n", __FUNCTION__, __LINE__, f);
623 goto err1;
624 }
625 else {
626 value[cnt] = f;
627 cnt++;
628 }
629
630 /* remove detected float */
631 while ((*str != 0x20) && (*str != 0x09) && (*str != ',') && (*str != ']')) {
632 str++;
633 }
634
635 /* skip spaces and comma */
636 while ((*str == 0x20) || (*str == ',') || (*str == 0x09) || (*str == 0x0a) || (*str == 0x0d)) {
637 str++;
638 }
639
640 }
641
642 #ifdef DEBUG_LOG
643 for (int i = 0; i < cnt; i++) {
644 LOGD( "%u,\n", value[i]);
645 }
646 #endif
647
648 return (cnt);
649 }
650 else if (xmlParseReadWrite == XML_PARSER_WRITE) // write
651 {
652 autoTabForward();
653 autoTabForward();
654 int cols = XmlTag(pNode->ToElement()).SizeCol();
655 int rows = XmlTag(pNode->ToElement()).SizeRow();
656 char str[8192];
657 snprintf(str, sizeof(str), "\n%s[", autoTabStr);
658 char tmp_val_str[25];
659 for (int i = 0; i < rows; i++)
660 {
661 for (int k = 0; k < cols; k++) {
662 snprintf(tmp_val_str, sizeof(tmp_val_str), "%d ", values[i * cols + k]);
663 strcat(str, tmp_val_str);
664 }
665
666 if (i < rows - 1) {
667 strcat(str, "\n");
668 strcat(str, autoTabStr);
669 }
670 }
671 autoTabBackward();
672 strcat(str, "]\n");
673 strcat(str, autoTabStr);
674
675 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
676 pComment->SetValue((const char *)str);
677 autoTabBackward();
678
679 return num;
680 }
681
682 err1:
683 MEMSET(values, 0, (sizeof(uint8_t)* num));
684
685 return (0);
686 }
687 /******************************************************************************
688 * ParseUchartArray
689 *****************************************************************************/
ParseCharArray(const XMLNode * pNode,int8_t * values,const int num)690 int RkAiqCalibParser::ParseCharArray
691 (
692 const XMLNode *pNode, /**< trimmed c string */
693 int8_t* values, /**< pointer to memory */
694 const int num /**< number of expected float values */
695 ) {
696
697 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
698
699 if (!xmlParseReadWrite) // read
700 {
701 int8_t* value = values;
702 const char* c_string = XmlTag(pNode->ToElement()).Value();
703 char* str = (char*)c_string;
704
705 int last = strlen(str);
706 char* str_last = str + (last - 1);
707
708 std::string s_string(str);
709 size_t find_start = s_string.find("[", 0);
710 size_t find_end = s_string.find("]", 0);
711
712 if ((find_start == std::string::npos) || (find_end == std::string::npos)) {
713 #ifdef DEBUG_LOG
714 LOGE( "%s(%d): start=%d,end=%d\n", __FUNCTION__, __LINE__, find_start, find_end);
715 #endif
716 return -1;
717 }
718
719 str = (char*)c_string + find_start;
720 str_last = (char*)c_string + find_end;
721
722 /* calc. end adress of string */
723 // char *str_last = str + (last-1);
724
725 /* skipped left parenthesis */
726 str++;
727
728 /* skip spaces */
729 while (*str == 0x20 || *str == 0x09 || (*str == 0x0a) || (*str == 0x0d)) {
730 str++;
731 }
732
733 int cnt = 0;
734 int scanned;
735 int16_t f;
736
737 /* parse the c-string */
738 while ((str != str_last) && (cnt < num)) {
739 scanned = sscanf(str, "%hd", &f);
740 if (scanned != 1) {
741 LOGE("%s(%d): error", __FUNCTION__, __LINE__);
742 goto err1;
743 }
744 else {
745 value[cnt] = f;
746 cnt++;
747 }
748
749 /* remove detected float */
750 while ((*str != 0x20) && (*str != 0x09) && (*str != ',') && (*str != ']')) {
751 str++;
752 }
753
754 /* skip spaces and comma */
755 while ((*str == 0x20) || (*str == ',') || (*str == 0x09) || (*str == 0x0a) || (*str == 0x0d)) {
756 str++;
757 }
758 }
759
760 #ifdef DEBUG_LOG
761 for (int i = 0; i < cnt; i++) {
762 LOGD( "%d,\n", value[i]);
763 }
764 #endif
765 return (cnt);
766 }
767 else if (xmlParseReadWrite == XML_PARSER_WRITE) // write
768 {
769 autoTabForward();
770 autoTabForward();
771 int cols = XmlTag(pNode->ToElement()).SizeCol();
772 int rows = XmlTag(pNode->ToElement()).SizeRow();
773
774 char str[8192];
775 snprintf(str, sizeof(str), "\n%s[", autoTabStr);
776 char tmp_val_str[25];
777 for (int i = 0; i < rows; i++)
778 {
779 for (int k = 0; k < cols; k++) {
780 snprintf(tmp_val_str, sizeof(tmp_val_str), "%d ", values[i * cols + k]);
781 strcat(str, tmp_val_str);
782 }
783
784 if (i < rows - 1) {
785 strcat(str, "\n");
786 strcat(str, autoTabStr);
787 }
788 }
789 autoTabBackward();
790 strcat(str, "]\n");
791 strcat(str, autoTabStr);
792
793 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
794 pComment->SetValue((const char *)str);
795 autoTabBackward();
796
797 return num;
798 }
799
800 err1:
801 MEMSET(values, 0, (sizeof(uint8_t)* num));
802
803 return (0);
804 }
805
806
807 /******************************************************************************
808 * ParseUshortArray
809 *****************************************************************************/
ParseUshortArray(const XMLNode * pNode,uint16_t * values,const int num)810 int RkAiqCalibParser::ParseUshortArray
811 (
812 const XMLNode *pNode, /**< trimmed c string */
813 uint16_t* values, /**< pointer to memory */
814 const int num /**< number of expected float values */
815 ) {
816
817 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
818
819 if (!xmlParseReadWrite) // read
820 {
821 uint16_t* value = values;
822 const char* c_string = XmlTag(pNode->ToElement()).Value();
823 char* str = (char*)c_string;
824 int last = strlen(str);
825 char* str_last = str + (last - 1);
826
827 std::string s_string(str);
828 size_t find_start = s_string.find("[", 0);
829 size_t find_end = s_string.find("]", 0);
830
831 if ((find_start == std::string::npos) || (find_end == std::string::npos)) {
832 #ifdef DEBUG_LOG
833 LOGE( "%s(%d): parse error! start:%s end:%s\n",
834 __FUNCTION__, __LINE__, find_start, find_end);
835 #endif
836 return -1;
837 }
838
839 str = (char*)c_string + find_start;
840 str_last = (char*)c_string + find_end;
841
842
843 /* calc. end adress of string */
844 //char *str_last = str + (last-1);
845
846 /* skipped left parenthesis */
847 str++;
848
849 /* skip spaces */
850 while (*str == 0x20 || *str == 0x09 || (*str == 0x0a) || (*str == 0x0d)) {
851 str++;
852 }
853
854 int cnt = 0;
855 int scanned;
856 uint16_t f;
857
858 /* parse the c-string */
859 while ((str != str_last) && (cnt < num)) {
860 scanned = sscanf(str, "%hu", &f);
861 if (scanned != 1) {
862 LOGD( "%s(%d): parse error!\n", __FUNCTION__, __LINE__);
863 goto err1;
864 }
865 else {
866 value[cnt] = f;
867 cnt++;
868 }
869
870 /* remove detected float */
871 while ((*str != 0x20) && (*str != 0x09) && (*str != ',') && (*str != ']')) {
872 str++;
873 }
874
875 /* skip spaces and comma */
876 while ((*str == 0x20) || (*str == ',') || (*str == 0x09) || (*str == 0x0a) || (*str == 0x0d)) {
877 str++;
878 }
879 }
880
881 #ifdef DEBUG_LOG
882 for (int i = 0; i < cnt; i++) {
883 LOGD( "%u,\n", value[i]);
884 }
885 #endif
886 return (cnt);
887 }
888 else if (xmlParseReadWrite == XML_PARSER_WRITE) // write
889 {
890 autoTabForward();
891 autoTabForward();
892 int cols = XmlTag(pNode->ToElement()).SizeCol();
893 int rows = XmlTag(pNode->ToElement()).SizeRow();
894 char str[8192];
895 snprintf(str, sizeof(str), "\n%s[", autoTabStr);
896 char tmp_val_str[25];
897 for (int i = 0; i < rows; i++)
898 {
899 for (int k = 0; k < cols; k++) {
900 snprintf(tmp_val_str, sizeof(tmp_val_str), "%d ", values[i * cols + k]);
901 strcat(str, tmp_val_str);
902 }
903
904 if (i < rows - 1) {
905 strcat(str, "\n");
906 strcat(str, autoTabStr);
907 }
908 }
909 autoTabBackward();
910 strcat(str, "]\n");
911 strcat(str, autoTabStr);
912
913 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
914 pComment->SetValue((const char *)str);
915 autoTabBackward();
916
917 return num;
918 }
919
920
921 err1:
922 MEMSET(values, 0, (sizeof(uint16_t)* num));
923
924 return (0);
925
926 }
927
928
929 /******************************************************************************
930 * ParseShortArray
931 *****************************************************************************/
ParseShortArray(const XMLNode * pNode,int16_t * values,const int num)932 int RkAiqCalibParser::ParseShortArray
933 (
934 const XMLNode *pNode, /**< trimmed c string */
935 int16_t* values, /**< pointer to memory */
936 const int num /**< number of expected float values */
937 ) {
938 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
939
940 if (!xmlParseReadWrite) // read
941 {
942 int16_t* value = values;
943 const char* c_string = XmlTag(pNode->ToElement()).Value();
944 char* str = (char*)c_string;
945
946 int last = strlen(str);
947 char* str_last = str + (last - 1);
948
949 std::string s_string(str);
950 size_t find_start = s_string.find("[", 0);
951 size_t find_end = s_string.find("]", 0);
952
953 if ((find_start == std::string::npos) || (find_end == std::string::npos)) {
954 #ifdef DEBUG_LOG
955 LOGE( "%s(%d): parse error!\n", __FUNCTION__, __LINE__);
956 #endif
957 return -1;
958 }
959
960 str = (char*)c_string + find_start;
961 str_last = (char*)c_string + find_end;
962
963 /* calc. end adress of string */
964 // char *str_last = str + (last-1);
965
966 /* skipped left parenthesis */
967 str++;
968
969 /* skip spaces */
970 while (*str == 0x20 || *str == 0x09 || (*str == 0x0a) || (*str == 0x0d)) {
971 str++;
972 }
973
974 int cnt = 0;
975 int scanned;
976 int16_t f;
977
978 /* parse the c-string */
979 while ((str != str_last) && (cnt < num)) {
980 scanned = sscanf(str, "%hd", &f);
981 if (scanned != 1) {
982 LOGE( "%s(%d): parse error!\n", __FUNCTION__, __LINE__);
983 goto err1;
984 }
985 else {
986 value[cnt] = f;
987 cnt++;
988 }
989
990 /* remove detected float */
991 while ((*str != 0x20) && (*str != 0x09) && (*str != ',') && (*str != ']')) {
992 str++;
993 }
994
995 /* skip spaces and comma */
996 while ((*str == 0x20) || (*str == ',') || (*str == 0x09) || (*str == 0x0a) || (*str == 0x0d)) {
997 str++;
998 }
999 }
1000
1001 #ifdef DEBUG_LOG
1002 for (int i = 0; i < cnt; i++) {
1003 LOGD( "%d,\n", value[i]);
1004 }
1005 #endif
1006 return (cnt);
1007 }
1008 else if (xmlParseReadWrite == XML_PARSER_WRITE) // write
1009 {
1010 autoTabForward();
1011 autoTabForward();
1012 int cols = XmlTag(pNode->ToElement()).SizeCol();
1013 int rows = XmlTag(pNode->ToElement()).SizeRow();
1014 char str[8192];
1015 snprintf(str, sizeof(str), "\n%s[", autoTabStr);
1016 char tmp_val_str[25];
1017 for (int i = 0; i < rows; i++)
1018 {
1019 for (int k = 0; k < cols; k++) {
1020 snprintf(tmp_val_str, sizeof(tmp_val_str), "%d ", values[i * cols + k]);
1021 strcat(str, tmp_val_str);
1022 }
1023
1024 if (i < rows - 1) {
1025 strcat(str, "\n");
1026 strcat(str, autoTabStr);
1027 }
1028 }
1029 autoTabBackward();
1030 strcat(str, "]\n");
1031 strcat(str, autoTabStr);
1032
1033 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
1034 pComment->SetValue((const char *)str);
1035 autoTabBackward();
1036
1037 return num;
1038 }
1039
1040
1041 err1:
1042 MEMSET(values, 0, (sizeof(uint16_t)* num));
1043
1044 return (0);
1045
1046 }
1047
1048
1049 /******************************************************************************
1050 * ParseByteArray
1051 *****************************************************************************/
ParseByteArray(const XMLNode * pNode,uint8_t * values,const int num)1052 int RkAiqCalibParser::ParseByteArray
1053 (
1054 const XMLNode *pNode, /**< trimmed c string */
1055 uint8_t* values, /**< pointer to memory */
1056 const int num /**< number of expected float values */
1057 ) {
1058
1059 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
1060
1061 if (!xmlParseReadWrite) // read
1062 {
1063 uint8_t* value = values;
1064 const char* c_string = XmlTag(pNode->ToElement()).Value();
1065
1066 char* str = (char*)c_string;
1067 int last = strlen(str);
1068 char* str_last = str + (last - 1);
1069
1070 std::string s_string(str);
1071 size_t find_start = s_string.find("[", 0);
1072 size_t find_end = s_string.find("]", 0);
1073
1074 if ((find_start == std::string::npos) || (find_end == std::string::npos)) {
1075 #ifdef DEBUG_LOG
1076 LOGE( "%s(%d): parse error!\n", __FUNCTION__, __LINE__);
1077 #endif
1078 return -1;
1079 }
1080
1081 str = (char*)c_string + find_start;
1082 str_last = (char*)c_string + find_end;
1083
1084 /* calc. end adress of string */
1085 //char *str_last = str + (last-1);
1086
1087 /* skipped left parenthesis */
1088 str++;
1089
1090 /* skip spaces */
1091 while (*str == 0x20 || *str == 0x09 || (*str == 0x0a) || (*str == 0x0d)) {
1092 str++;
1093 }
1094
1095 int cnt = 0;
1096 int scanned;
1097 uint16_t f;
1098
1099 /* parse the c-string */
1100 while ((str != str_last) && (cnt < num)) {
1101 scanned = sscanf(str, "%hu", &f);
1102 if (scanned != 1) {
1103 LOGE( "%s(%d): parse error!\n", __FUNCTION__, __LINE__);
1104 goto err1;
1105 }
1106 else {
1107 value[cnt] = (uint8_t)f;
1108 cnt++;
1109 }
1110
1111 /* remove detected float */
1112 while ((*str != 0x20) && (*str != 0x09) && (*str != ',') && (*str != ']')) {
1113 str++;
1114 }
1115
1116 /* skip spaces and comma */
1117 while ((*str == 0x20) || (*str == ',') || (*str == 0x09) || (*str == 0x0a) || (*str == 0x0d)) {
1118 str++;
1119 }
1120 }
1121
1122 #ifdef DEBUG_LOG
1123 for (int i = 0; i < cnt; i++) {
1124 LOGD( "%u,\n", value[i]);
1125 }
1126 #endif
1127 return (cnt);
1128
1129 }
1130 else if (xmlParseReadWrite == XML_PARSER_WRITE) // write
1131 {
1132 autoTabForward();
1133 autoTabForward();
1134 int cols = XmlTag(pNode->ToElement()).SizeCol();
1135 int rows = XmlTag(pNode->ToElement()).SizeRow();
1136 char str[8192];
1137 snprintf(str, sizeof(str), "\n%s[", autoTabStr);
1138 char tmp_val_str[25];
1139 for (int i = 0; i < rows; i++)
1140 {
1141 for (int k = 0; k < cols; k++) {
1142 snprintf(tmp_val_str, sizeof(tmp_val_str), "%d ", values[i * cols + k]);
1143 strcat(str, tmp_val_str);
1144 }
1145
1146 if (i < rows - 1) {
1147 strcat(str, "\n");
1148 strcat(str, autoTabStr);
1149 }
1150 }
1151 autoTabBackward();
1152 strcat(str, "]\n");
1153 strcat(str, autoTabStr);
1154
1155 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
1156 pComment->SetValue((const char *)str);
1157 autoTabBackward();
1158 return num;
1159 }
1160
1161 err1:
1162 MEMSET(values, 0, (sizeof(uint8_t)* num));
1163
1164 return (0);
1165
1166 }
1167
1168
1169 /******************************************************************************
1170 * ParseString
1171 *****************************************************************************/
ParseString(const XMLNode * pNode,char * values,const int size)1172 int RkAiqCalibParser::ParseString
1173 (
1174 const XMLNode *pNode, /**< trimmed c string */
1175 char* values, /**< pointer to memory */
1176 const int size /**< size of memory */
1177 ) {
1178 if (xmlParseReadWrite == XML_PARSER_READ) // read
1179 {
1180 const char* c_string = XmlTag(pNode->ToElement()).Value();
1181 char* str = (char*)c_string;
1182 int last = strlen(str);
1183 char* str_last = str + (last - 1);
1184
1185 if (*str == '[')
1186 str += 1;
1187 if (*str_last == ']')
1188 *str_last = '\0';
1189
1190 memset(values, 0, size);
1191 strncpy(values, str, size - 1);
1192 //values[size] = '';
1193
1194 return 0;
1195 }
1196 else if (xmlParseReadWrite == XML_PARSER_WRITE)
1197 {
1198 char str[8192];
1199 //sprintf(str, "[%s]", values);
1200 autoTabForward();
1201 autoTabForward();
1202 snprintf(str, sizeof(str), "\n%s%s", autoTabStr, values);
1203 autoTabBackward();
1204 strcat(str, "\n");
1205 strcat(str, autoTabStr);
1206 autoTabBackward();
1207 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
1208 pComment->SetValue((const char *)str);
1209 snprintf(str, sizeof(str), "[1 %u]", (unsigned int)(strlen(values)));
1210 XMLElement* pElement = (((XMLNode*)pNode)->ToElement());
1211 pElement->SetAttribute(CALIB_ATTRIBUTE_SIZE, str);
1212 return 0;
1213 }
1214 return 0;
1215 }
1216
1217
1218 /******************************************************************************
1219 * ParseLscProfileArray
1220 *****************************************************************************/
ParseLscProfileArray(const XMLNode * pNode,CalibDb_Lsc_ProfileName_t values[],const int num)1221 int RkAiqCalibParser::ParseLscProfileArray
1222 (
1223 const XMLNode *pNode, /**< trimmed c string */
1224 CalibDb_Lsc_ProfileName_t values[], /**< pointer to memory */
1225 const int num /**< number of expected float values */
1226 ) {
1227
1228 if (!xmlParseReadWrite) // read
1229 {
1230 for (int i = 0; i < LSC_PROFILES_NUM_MAX; i++)
1231 memset(values[i], 0, LSC_PROFILE_NAME);
1232
1233 const char *c_string = XmlTag(pNode->ToElement()).Value();
1234
1235 Toupper(c_string);
1236 char *str = (char *)c_string;
1237
1238 int last = strlen(str);
1239
1240 /* calc. end adress of string */
1241 char *str_last = str + (last - 1);
1242
1243 /* skip beginning spaces */
1244 while (*str == 0x20 || *str == 0x09)
1245 {
1246 str++;
1247 }
1248
1249 /* skip ending spaces */
1250 while (*str_last == 0x20 || *str_last == 0x09)
1251 {
1252 str_last--;
1253 }
1254
1255 int cnt = 0;
1256 int scanned;
1257 CalibDb_Lsc_ProfileName_t f;
1258 memset(f, 0, sizeof(f));
1259
1260 /* parse the c-string */
1261 while ((str != str_last) && (cnt < num))
1262 {
1263 scanned = sscanf(str, "%s", f);
1264 if (scanned != 1)
1265 {
1266 LOGE("%s(%d): parse error!\n", __FUNCTION__, __LINE__);
1267 goto err1;
1268 }
1269 else
1270 {
1271 strncpy(values[cnt], f, LSC_PROFILE_NAME);
1272 values[cnt][strlen(f)] = '\0';
1273 cnt++;
1274 }
1275
1276 /* remove detected string */
1277 while ((*str != 0x20) && (*str != ',') && (*str != ']') && (str != str_last))
1278 {
1279 str++;
1280 }
1281
1282 if (str != str_last)
1283 {
1284 /* skip spaces and comma */
1285 while ((*str == 0x20) || (*str == ','))
1286 {
1287 str++;
1288 }
1289 }
1290
1291 memset(f, 0, sizeof(f));
1292 }
1293
1294 return (cnt);
1295 }
1296 else if (xmlParseReadWrite == XML_PARSER_WRITE) // write
1297 {
1298 autoTabForward();
1299 autoTabForward();
1300 char str[8192];
1301 snprintf(str, sizeof(str), "\n%s", autoTabStr);
1302 int i = 0;
1303 size_t str_len = 0;
1304 while (values[i][0] != 0)
1305 {
1306 str_len += strlen(values[i]);
1307 strcat(str, values[i++]);
1308 strcat(str, " ");
1309 str_len++;
1310 }
1311 autoTabBackward();
1312 strcat(str, "\n");
1313 strcat(str, autoTabStr);
1314 XMLNode* pComment = (XMLNode*)pNode->ToElement()->FirstChild();
1315 pComment->SetValue((const char *)str);
1316
1317 snprintf(str, sizeof(str), "[1 %u]", (unsigned int)(str_len - 1));
1318 pComment = (XMLNode *)pNode;
1319 pComment->ToElement()->SetAttribute(CALIB_ATTRIBUTE_SIZE, str);
1320 autoTabBackward();
1321
1322 return num;
1323 }
1324
1325
1326
1327 err1:
1328 memset(values, 0, (sizeof(uint16_t)* num));
1329
1330 return (0);
1331 }
1332
autoTabForward()1333 void RkAiqCalibParser::autoTabForward()
1334 {
1335 if (autoTabIdx == 124)
1336 return;
1337 autoTabStr[autoTabIdx] = ' ';
1338 autoTabIdx += 4;
1339 autoTabStr[autoTabIdx] = '\0';
1340 }
1341
autoTabBackward()1342 void RkAiqCalibParser::autoTabBackward()
1343 {
1344 if (autoTabIdx == 0)
1345 return;
1346 autoTabStr[autoTabIdx] = ' ';
1347 autoTabIdx -= 4;
1348 autoTabStr[autoTabIdx] = '\0';
1349 }
1350
RkAiqCalibParser(CamCalibDbContext_t * pCalibDb)1351 RkAiqCalibParser::RkAiqCalibParser(CamCalibDbContext_t *pCalibDb)
1352 {
1353 mCalibDb = pCalibDb;
1354
1355 if(mCalibDb != NULL) {
1356 CamCalibDbCreate(mCalibDb);
1357 }
1358
1359 CALIBDB_MODULE_PTR_HELPER(list_head, awb_adjust_para);
1360 if (awb_adjust_para)
1361 INIT_LIST_HEAD(awb_adjust_para);
1362
1363 CALIBDB_MODULE_PTR_HELPER(list_head, awb_calib_para_v200);
1364 if (awb_calib_para_v200)
1365 INIT_LIST_HEAD(awb_calib_para_v200);
1366
1367 CALIBDB_MODULE_PTR_HELPER(list_head, awb_calib_para_v201);
1368 if (awb_calib_para_v201)
1369 INIT_LIST_HEAD(awb_calib_para_v201);
1370
1371 if(CHECK_ISP_HW_V21()) {
1372 CALIBDB_MODULE_PTR_HELPER(list_head, ae_calib_para);
1373 if (ae_calib_para)
1374 INIT_LIST_HEAD(ae_calib_para);
1375
1376 CALIBDB_MODULE_PTR_HELPER(list_head, ae_tuning_para);
1377 if (ae_tuning_para)
1378 INIT_LIST_HEAD(ae_tuning_para);
1379 }
1380 xmlParseReadWrite = XML_PARSER_READ;
1381 memset(autoTabStr, ' ', sizeof(autoTabStr));
1382 autoTabIdx = 0;
1383 autoTabStr[0] = '\0';
1384 }
1385
~RkAiqCalibParser()1386 RkAiqCalibParser::~RkAiqCalibParser()
1387 {
1388 }
1389
doParse(const char * device)1390 bool RkAiqCalibParser::doParse
1391 (
1392 const char* device
1393 )
1394 {
1395 int errorID;
1396 XMLDocument doc;
1397
1398 bool res = true;
1399
1400 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
1401
1402 errorID = doc.LoadFile(device);
1403
1404 LOGD("%s(%d): doc.LoadFile filename:%s errorID:%d\n",
1405 __FUNCTION__, __LINE__, device, errorID);
1406
1407 if (doc.Error()) {
1408 LOGE("%s(%d): Error: Parse error errorID %d\n",
1409 __FUNCTION__, __LINE__, errorID);
1410 return (false);
1411 }
1412 XMLElement* proot = doc.RootElement();
1413 std::string tagname(proot->Name());
1414 if (tagname != CALIB_FILESTART_TAG) {
1415 LOGE("Error: Not a calibration data file");
1416
1417 return (false);
1418 }
1419 // parse Read Mode
1420 parseReadWriteCtrl(XML_PARSER_READ);
1421
1422 XML_CHECK_START(CALIB_FILESTART_TAG_ID, CALIB_FILESTART_TAG_ID);
1423
1424
1425 // parse header section
1426 XMLElement* pheader = proot->FirstChildElement(TAG_NAME(CALIB_HEADER_TAG_ID));
1427 XmlTag tag = XmlTag(pheader);
1428 if (pheader) {
1429 res = parseEntryHeader(pheader->ToElement(), NULL);
1430 if (!res) {
1431 return (res);
1432 }
1433 XML_CHECK_TOPTAG_MARK(CALIB_HEADER_TAG_ID, tag.Type(), tag.Size());
1434 }
1435
1436 // parse sensor section
1437 XMLElement* psensor = proot->FirstChildElement(TAG_NAME(CALIB_SENSOR_TAG_ID));
1438 XmlTag tag1 = XmlTag(psensor);
1439 if (psensor) {
1440 res = parseEntrySensor(psensor->ToElement(), NULL);
1441 if (!res) {
1442 return (res);
1443 }
1444 XML_CHECK_TOPTAG_MARK(CALIB_SENSOR_TAG_ID, tag1.Type(), tag1.Size());
1445 }
1446 if(CHECK_ISP_HW_V20()) {
1447 // parse system section
1448 XMLElement* psystem = proot->FirstChildElement(TAG_NAME(CALIB_SYSTEM_TAG_ID));
1449 XmlTag tag2 = XmlTag(psystem);
1450 if (psystem) {
1451 res = parseEntrySystem(psystem->ToElement(), NULL);
1452 if (!res) {
1453 return (res);
1454 }
1455 XML_CHECK_TOPTAG_MARK(CALIB_SYSTEM_TAG_ID, tag2.Type(), tag2.Size());
1456 }
1457 }
1458 if(CHECK_ISP_HW_V21()) {
1459 // parse expset section
1460 XMLElement* pexpset = proot->FirstChildElement(TAG_NAME(CALIB_EXPSET_TAG_ID));
1461 XmlTag tag2 = XmlTag(pexpset);
1462 if (pexpset) {
1463 res = parseEntryExpSet(pexpset->ToElement(), NULL);
1464 if (!res) {
1465 return (res);
1466 }
1467 XML_CHECK_TOPTAG_MARK(CALIB_EXPSET_TAG_ID, tag2.Type(), tag2.Size());
1468 }
1469
1470 // parse moduleinfo section
1471 XMLElement* pmodule = proot->FirstChildElement(TAG_NAME(CALIB_MODULEINFO_TAG_ID));
1472 XmlTag tag3 = XmlTag(pmodule);
1473 if (pmodule) {
1474 res = parseEntryModuleInfo(pmodule->ToElement(), NULL);
1475 if (!res) {
1476 return (res);
1477 }
1478 XML_CHECK_TOPTAG_MARK(CALIB_MODULEINFO_TAG_ID, tag3.Type(), tag3.Size());
1479 }
1480 }
1481
1482 XML_CHECK_END();
1483
1484 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
1485
1486 return (res);
1487 }
1488
doGenerate(const char * deviceRef,const char * deviceOutput)1489 bool RkAiqCalibParser::doGenerate
1490 (
1491 const char* deviceRef,
1492 const char* deviceOutput
1493 )
1494 {
1495 int errorID;
1496 XMLDocument doc;
1497
1498 bool res = true;
1499
1500 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
1501
1502 errorID = doc.LoadFile(deviceRef);
1503
1504 LOGD("%s(%d): doc.LoadFile filename:%s errorID:%d\n",
1505 __FUNCTION__, __LINE__, deviceRef, errorID);
1506
1507 if (doc.Error()) {
1508 LOGE("%s(%d): Error: Parse error errorID %d\n",
1509 __FUNCTION__, __LINE__, errorID);
1510 return (false);
1511 }
1512 XMLElement* proot = doc.RootElement();
1513 std::string tagname(proot->Name());
1514 if (tagname != CALIB_FILESTART_TAG) {
1515 LOGE("Error: Not a calibration data file");
1516
1517 return (false);
1518 }
1519 // parse Read Mode
1520 parseReadWriteCtrl(XML_PARSER_WRITE);
1521
1522 XML_CHECK_START(CALIB_FILESTART_TAG_ID, CALIB_FILESTART_TAG_ID);
1523
1524 // parse header section
1525 XMLElement* pheader = proot->FirstChildElement(TAG_NAME(CALIB_HEADER_TAG_ID));
1526 XmlTag tag = XmlTag(pheader);
1527 if (pheader) {
1528 res = parseEntryHeader(pheader->ToElement(), NULL);
1529 if (!res) {
1530 return (res);
1531 }
1532 XML_CHECK_TOPTAG_MARK(CALIB_HEADER_TAG_ID, tag.Type(), tag.Size());
1533 }
1534
1535 // parse sensor section
1536 XMLElement* psensor = proot->FirstChildElement(TAG_NAME(CALIB_SENSOR_TAG_ID));
1537 XmlTag tag1 = XmlTag(psensor);
1538 if (psensor) {
1539 res = parseEntrySensor(psensor->ToElement(), NULL);
1540 if (!res) {
1541 return (res);
1542 }
1543 XML_CHECK_TOPTAG_MARK(CALIB_SENSOR_TAG_ID, tag1.Type(), tag1.Size());
1544 }
1545
1546 // parse system section
1547 XMLElement* psystem = proot->FirstChildElement(TAG_NAME(CALIB_SYSTEM_TAG_ID));
1548 XmlTag tag2 = XmlTag(psystem);
1549 if (psystem) {
1550 res = parseEntrySystem(psystem->ToElement(), NULL);
1551 if (!res) {
1552 return (res);
1553 }
1554 XML_CHECK_TOPTAG_MARK(CALIB_SYSTEM_TAG_ID, tag2.Type(), tag2.Size());
1555 }
1556
1557 XML_CHECK_END();
1558
1559 errorID = doc.SaveFile(deviceOutput);
1560
1561 LOGD("%s(%d): doc.SaveFile filename:%s errorID:%d\n",
1562 __FUNCTION__, __LINE__, deviceRef, errorID);
1563
1564 if (doc.Error()) {
1565 LOGE("%s(%d): Error: Generate error ID %d\n",
1566 __FUNCTION__, __LINE__, errorID);
1567 return (false);
1568 }
1569
1570 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
1571
1572 return (res);
1573 }
1574
parseCellNoElement(const XMLElement * pelement,int noElements,int & RealNo)1575 bool RkAiqCalibParser::parseCellNoElement
1576 (
1577 const XMLElement* pelement,
1578 int noElements,
1579 int &RealNo
1580 ) {
1581 int cnt = 0;
1582
1583 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
1584
1585 const XMLNode* pchild = pelement->FirstChild();
1586 while (pchild && (cnt < noElements)) {
1587 pchild = pchild->NextSibling();
1588 cnt ++;
1589 }
1590
1591 RealNo = cnt;
1592
1593 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
1594
1595 return true;
1596 }
1597
parseEntryCell(const XMLElement * pelement,int noElements,parseCellContent func,void * param,uint32_t cur_id,uint32_t parent_id)1598 bool RkAiqCalibParser::parseEntryCell
1599 (
1600 const XMLElement* pelement,
1601 int noElements,
1602 parseCellContent func,
1603 void* param,
1604 uint32_t cur_id,
1605 uint32_t parent_id
1606 ) {
1607 int cnt = 0;
1608
1609 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
1610 autoTabForward();
1611
1612 int cell_size = 0;
1613 CALIB_IQ_TAG_ID_T cur_tag_id = (CALIB_IQ_TAG_ID_T)cur_id;
1614 CALIB_IQ_TAG_ID_T parent_tag_id = (CALIB_IQ_TAG_ID_T)parent_id;
1615 parseCellNoElement(pelement, noElements, cell_size);
1616 XML_CHECK_CELL_SET_SIZE(cell_size);
1617 if(cell_size != noElements) {
1618 LOGD("%s(%d): Warning: parent_tagname:%s tag_name:%s define %d cell, but only use %d cells !!!!\n",
1619 __FUNCTION__, __LINE__,
1620 TAG_NAME(parent_tag_id), TAG_NAME(cur_tag_id),
1621 noElements, cell_size);
1622 }
1623
1624 LOGD("####@@@@@ cur_tag_id %d parent_tag_id %d cell_size %d\n",
1625 cur_tag_id, parent_tag_id, cell_size);
1626
1627 const XMLNode* pchild = pelement->FirstChild();
1628 while (pchild && (cnt < noElements)) {
1629 XmlCellTag tag = XmlCellTag(pchild->ToElement());
1630 std::string tagname(pchild->ToElement()->Name());
1631 if (tagname == TAG_NAME(CALIB_CELL_TAG_ID)) {
1632 autoTabForward();
1633 bool result = (this->*func)(pchild->ToElement(), /*param*/(void*)&cnt);
1634 autoTabBackward();
1635 if (!result) {
1636 return (result);
1637 }
1638 }
1639 else {
1640 LOGW("unknown cell tag: %s", tagname.c_str());
1641
1642 //return (false);
1643 }
1644
1645 pchild = pchild->NextSibling();
1646 cnt++;
1647 }
1648
1649 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
1650 autoTabBackward();
1651
1652 return (true);
1653 }
1654
parseEntryCell2(const XMLElement * pelement,int noElements,parseCellContent2 func,void * param,uint32_t cur_id,uint32_t parent_id)1655 bool RkAiqCalibParser::parseEntryCell2
1656 (
1657 const XMLElement* pelement,
1658 int noElements,
1659 parseCellContent2 func,
1660 void* param,
1661 uint32_t cur_id,
1662 uint32_t parent_id
1663 ) {
1664 int cnt = 0;
1665
1666 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
1667 autoTabForward();
1668
1669 int cell_size = 0;
1670 CALIB_IQ_TAG_ID_T cur_tag_id = (CALIB_IQ_TAG_ID_T)cur_id;
1671 CALIB_IQ_TAG_ID_T parent_tag_id = (CALIB_IQ_TAG_ID_T)parent_id;
1672 parseCellNoElement(pelement, noElements, cell_size);
1673 XML_CHECK_CELL_SET_SIZE(cell_size);
1674 if(cell_size != noElements) {
1675 LOGD("%s(%d): Warning: parent_tagname:%s tag_name:%s define %d cell, but only use %d cells !!!!\n",
1676 __FUNCTION__, __LINE__,
1677 TAG_NAME(parent_tag_id), TAG_NAME(cur_tag_id),
1678 noElements, cell_size);
1679 }
1680
1681 const XMLNode* pchild = pelement->FirstChild();
1682 while (pchild && (cnt < noElements)) {
1683 XmlCellTag tag = XmlCellTag(pchild->ToElement());
1684 std::string tagname(pchild->ToElement()->Name());
1685 if (tagname == TAG_NAME(CALIB_CELL_TAG_ID)) {
1686 autoTabForward();
1687 bool result = (this->*func)(pchild->ToElement(), param, cnt);
1688 autoTabBackward();
1689 if (!result) {
1690 return (result);
1691 }
1692 }
1693 else {
1694 LOGW("unknown cell tag: %s", tagname.c_str());
1695
1696 //return (false);
1697 }
1698
1699 pchild = pchild->NextSibling();
1700 cnt++;
1701 }
1702
1703 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
1704 autoTabBackward();
1705
1706 return (true);
1707 }
1708
parseEntryCell3(XMLElement * pelement,int noElements,int noOutElements,parseCellContent func,void * param,uint32_t cur_id,uint32_t parent_id)1709 bool RkAiqCalibParser::parseEntryCell3
1710 (
1711 XMLElement* pelement,
1712 int noElements,
1713 int noOutElements,
1714 parseCellContent func,
1715 void* param,
1716 uint32_t cur_id,
1717 uint32_t parent_id
1718 ) {
1719 int cnt = 0;
1720
1721 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
1722 autoTabForward();
1723
1724 int cell_size = 0;
1725 CALIB_IQ_TAG_ID_T cur_tag_id = (CALIB_IQ_TAG_ID_T)cur_id;
1726 CALIB_IQ_TAG_ID_T parent_tag_id = (CALIB_IQ_TAG_ID_T)parent_id;
1727 parseCellNoElement(pelement, noElements, cell_size);
1728 XML_CHECK_CELL_SET_SIZE(noOutElements);
1729
1730 LOGD("####@@@@@ cur_tag_id %d parent_tag_id %d cell_size %d\n",
1731 cur_tag_id, parent_tag_id, cell_size);
1732
1733 if (noOutElements > noElements)
1734 {
1735 //noOutElements = noElements;
1736 XMLNode* pchild_ref = pelement->FirstChild();
1737 while (pchild_ref->NextSibling() != NULL)
1738 pchild_ref = pchild_ref->NextSibling();
1739 for (; noElements < noOutElements; noElements++)
1740 {
1741 XMLNode* copy = pchild_ref->DeepClone(NULL);
1742 pelement->InsertEndChild(copy);
1743 }
1744 }
1745
1746 const XMLNode* pchild = pelement->FirstChild();
1747 while (pchild && (cnt < noOutElements)) {
1748 XmlCellTag tag = XmlCellTag(pchild->ToElement());
1749 std::string tagname(pchild->ToElement()->Name());
1750 if (tagname == TAG_NAME(CALIB_CELL_TAG_ID)) {
1751 autoTabForward();
1752 bool result = (this->*func)(pchild->ToElement(), /*param*/(void*)&cnt);
1753 autoTabBackward();
1754 if (!result) {
1755 return (result);
1756 }
1757 }
1758 else {
1759 LOG1("unknown cell tag: %s", tagname.c_str());
1760
1761 return (false);
1762 }
1763
1764 pchild = pchild->NextSibling();
1765 cnt++;
1766 }
1767
1768 XMLNode *pchild_del[100];
1769 int del_cnt = 0;
1770 while (pchild)
1771 {
1772 pchild_del[del_cnt] = (XMLNode *)pchild;
1773 pchild = pchild->NextSibling();
1774 cnt++;
1775 del_cnt++;
1776 }
1777
1778 for (int i = 0; i < del_cnt; i++)
1779 {
1780 pelement->DeleteChild(pchild_del[i]);
1781 }
1782
1783 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
1784 autoTabBackward();
1785
1786 char str[20];
1787 snprintf(str, sizeof(str), "[1 %u]", (unsigned int)noOutElements);
1788 pelement->SetAttribute(CALIB_ATTRIBUTE_SIZE, str);
1789
1790 return (true);
1791 }
1792
parseEntryCell4(XMLElement * pelement,int noElements,int noOutElements,parseCellContent2 func,void * param,uint32_t cur_id,uint32_t parent_id)1793 bool RkAiqCalibParser::parseEntryCell4
1794 (
1795 XMLElement* pelement,
1796 int noElements,
1797 int noOutElements,
1798 parseCellContent2 func,
1799 void* param,
1800 uint32_t cur_id,
1801 uint32_t parent_id
1802 ) {
1803 int cnt = 0;
1804
1805 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
1806 autoTabForward();
1807
1808 int cell_size = 0;
1809 CALIB_IQ_TAG_ID_T cur_tag_id = (CALIB_IQ_TAG_ID_T)cur_id;
1810 CALIB_IQ_TAG_ID_T parent_tag_id = (CALIB_IQ_TAG_ID_T)parent_id;
1811 parseCellNoElement(pelement, noElements, cell_size);
1812 XML_CHECK_CELL_SET_SIZE(noOutElements);
1813
1814 LOGD("####@@@@@ cur_tag_id %d parent_tag_id %d cell_size %d\n",
1815 cur_tag_id, parent_tag_id, cell_size);
1816
1817 if (noOutElements > noElements)
1818 {
1819 //noOutElements = noElements;
1820 XMLNode* pchild_ref = pelement->FirstChild();
1821 while (pchild_ref->NextSibling() != NULL)
1822 pchild_ref = pchild_ref->NextSibling();
1823 for (; noElements < noOutElements; noElements++)
1824 {
1825 XMLNode* copy = pchild_ref->DeepClone(NULL);
1826 pelement->InsertEndChild(copy);
1827 }
1828 }
1829
1830 const XMLNode* pchild = pelement->FirstChild();
1831 while (pchild && (cnt < noOutElements)) {
1832 XmlCellTag tag = XmlCellTag(pchild->ToElement());
1833 std::string tagname(pchild->ToElement()->Name());
1834 if (tagname == TAG_NAME(CALIB_CELL_TAG_ID)) {
1835 autoTabForward();
1836 bool result = (this->*func)(pchild->ToElement(), param, cnt);
1837 autoTabBackward();
1838 if (!result) {
1839 return (result);
1840 }
1841 }
1842 else {
1843 LOG1("unknown cell tag: %s", tagname.c_str());
1844
1845 return (false);
1846 }
1847
1848 pchild = pchild->NextSibling();
1849 cnt++;
1850 }
1851
1852 XMLNode *pchild_del[100];
1853 int del_cnt = 0;
1854 while (pchild)
1855 {
1856 pchild_del[del_cnt] = (XMLNode *)pchild;
1857 pchild = pchild->NextSibling();
1858 cnt++;
1859 del_cnt++;
1860 }
1861
1862 for (int i = 0; i < del_cnt; i++)
1863 {
1864 pelement->DeleteChild(pchild_del[i]);
1865 }
1866
1867 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
1868 autoTabBackward();
1869
1870 char str[20];
1871 snprintf(str, sizeof(str), "[1 %u]", (unsigned int)noOutElements);
1872 pelement->SetAttribute(CALIB_ATTRIBUTE_SIZE, str);
1873
1874 return (true);
1875 }
1876
1877
parseEntryHeader(const XMLElement * pelement,void * param)1878 bool RkAiqCalibParser::parseEntryHeader
1879 (
1880 const XMLElement* pelement,
1881 void* param
1882 ) {
1883 (void)param;
1884
1885 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
1886 autoTabForward();
1887
1888 XML_CHECK_START(CALIB_HEADER_TAG_ID, CALIB_FILESTART_TAG_ID);
1889 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Header_t, header);
1890
1891 const XMLNode* pchild = pelement->FirstChild();
1892 while (pchild) {
1893 XmlTag tag = XmlTag(pchild->ToElement());
1894 const char* value = tag.Value();
1895 std::string tagname(pchild->ToElement()->Name());
1896
1897 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
1898
1899 #ifdef DEBUG_LOG
1900 LOG1("tag: %s", tagname.c_str());
1901 #endif
1902 if (XML_CHECK_TAGID_COMPARE(CALIB_HEADER_CODE_XML_PARSE_VERSION_TAG_ID)) {
1903 ParseString(pchild, header->parse_version,
1904 sizeof(header->parse_version));
1905 }
1906 else if (XML_CHECK_TAGID_COMPARE(CALIB_HEADER_CREATION_DATE_TAG_ID)) {
1907 ParseString(pchild, header->date,
1908 sizeof(header->date));
1909 }
1910 else if (XML_CHECK_TAGID_COMPARE(CALIB_HEADER_CREATOR_TAG_ID)) {
1911 ParseString(pchild, header->author,
1912 sizeof(header->author));
1913 }
1914 else if (XML_CHECK_TAGID_COMPARE(CALIB_HEADER_GENERATOR_VERSION_TAG_ID)) {
1915 ParseString(pchild, header->gen_verion,
1916 sizeof(header->gen_verion));
1917 }
1918 else if (XML_CHECK_TAGID_COMPARE(CALIB_HEADER_SENSOR_NAME_TAG_ID)) {
1919 ParseString(pchild, header->sensor_name,
1920 sizeof(header->sensor_name));
1921 }
1922 else if (XML_CHECK_TAGID_COMPARE(CALIB_HEADER_SAMPLE_NAME_TAG_ID)) {
1923 ParseString(pchild, header->sample_name,
1924 sizeof(header->sample_name));
1925 }
1926 else if (XML_CHECK_TAGID_COMPARE(CALIB_HEADER_MAGIC_CODE_TAG_ID)) {
1927 ParseUintArray(pchild, &header->magic_code, 1);
1928 }
1929 else {
1930
1931 LOGW("parse error in header section (unknow tag: %s)", tagname.c_str());
1932 //return (false);
1933 }
1934
1935 pchild = pchild->NextSibling();
1936 }
1937
1938 XML_CHECK_END();
1939 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
1940 autoTabBackward();
1941
1942 return (true);
1943
1944 }
1945
parseEntrySensor(const XMLElement * pelement,void * param)1946 bool RkAiqCalibParser::parseEntrySensor
1947 (
1948 const XMLElement* pelement,
1949 void* param
1950 ) {
1951 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
1952 autoTabForward();
1953
1954 (void)param;
1955
1956 XML_CHECK_START(CALIB_SENSOR_TAG_ID, CALIB_FILESTART_TAG_ID);
1957
1958 const XMLNode* pchild = pelement->FirstChild();
1959 while (pchild) {
1960 XmlTag tag = XmlTag(pchild->ToElement());
1961 std::string tagname(pchild->ToElement()->Name());
1962 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
1963
1964 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_TAG_ID)) {
1965 if (!parseEntrySensorAwb(pchild->ToElement())) {
1966 return (false);
1967 }
1968 }
1969 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_TAG_ID) && CHECK_ISP_HW_V20()) {
1970 if (!parseEntrySensorAec(pchild->ToElement())) {
1971 return (false);
1972 }
1973 }
1974 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_TAG_ID) && CHECK_ISP_HW_V21()) {
1975 if (!parseEntrySensorAecV21(pchild->ToElement())) {
1976 return (false);
1977 }
1978 }
1979 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_MERGE_TAG_ID)) {
1980 if (!parseEntrySensorAhdrMerge(pchild->ToElement())) {
1981 return (false);
1982 }
1983 }
1984 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_TAG_ID)) {
1985 if (!parseEntrySensorAhdrTmo(pchild->ToElement())) {
1986 return (false);
1987 }
1988 }
1989 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_TAG_ID)) {
1990 if (!parseEntrySensorDrc(pchild->ToElement())) {
1991 return (false);
1992 }
1993 }
1994 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BLC_TAG_ID)) {
1995 if (!parseEntrySensorBlc(pchild->ToElement())) {
1996 return (false);
1997 }
1998 }
1999 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LUT3D_TAG_ID)) {
2000 if (!parseEntrySensorLut3d(pchild->ToElement())) {
2001 return (false);
2002 }
2003 }
2004 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_TAG_ID)) {
2005 if (!parseEntrySensorDpcc(pchild->ToElement())) {
2006 return (false);
2007 }
2008 }
2009 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_TAG_ID)) {
2010 if (!parseEntrySensorBayerNr(pchild->ToElement())) {
2011 return (false);
2012 }
2013 }
2014 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TAG_ID)) {
2015 if (!parseEntrySensorLsc(pchild->ToElement())) {
2016 return (false);
2017 }
2018 }
2019 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_TAG_ID)) {
2020 if (!parseEntrySensorRKDM(pchild->ToElement())) {
2021 return (false);
2022 }
2023 }
2024 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_TAG_ID)) {
2025 if (!parseEntrySensorCCM(pchild->ToElement())) {
2026 return (false);
2027 }
2028 }
2029 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_TAG_ID)) {
2030 if (!parseEntrySensorUVNR(pchild->ToElement())) {
2031 return (false);
2032 }
2033 }
2034 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GAMMA_TAG_ID)) {
2035 if (!parseEntrySensorGamma(pchild->ToElement())) {
2036 return (false);
2037 }
2038 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEGAMMA_TAG_ID)) {
2039 if (!parseEntrySensorDegamma(pchild->ToElement())) {
2040 return (false);
2041 }
2042 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_TAG_ID)) {
2043 if (!parseEntrySensorYnr(pchild->ToElement()))
2044 {
2045 return (false);
2046 }
2047 }
2048 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_TAG_ID)) {
2049 if (!parseEntrySensorGic(pchild->ToElement())) {
2050 return (false);
2051 }
2052 }
2053 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_TAG_ID)) {
2054 if (!parseEntrySensorMFNR(pchild->ToElement())) {
2055 return (false);
2056 }
2057 }
2058 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_TAG_ID)) {
2059 if (!parseEntrySensorSharp(pchild->ToElement())) {
2060 return (false);
2061 }
2062 }
2063 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_TAG_ID)) {
2064 if (!parseEntrySensorEdgeFilter(pchild->ToElement())) {
2065 return (false);
2066 }
2067 }
2068 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_TAG_ID)) {
2069 if (!parseEntrySensorDehaze(pchild->ToElement())) {
2070 return (false);
2071 }
2072 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_TAG_ID)) {
2073 if (!parseEntrySensorAf(pchild->ToElement())) {
2074 return (false);
2075 }
2076 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LDCH_TAG_ID)) {
2077 if (!parseEntrySensorLdch(pchild->ToElement())) {
2078 return (false);
2079 }
2080 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_FEC_TAG_ID)) {
2081 if (!parseEntrySensorFec(pchild->ToElement())) {
2082 return (false);
2083 }
2084 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EIS_TAG_ID)) {
2085 if (!parseEntrySensorEis(pchild->ToElement())) {
2086 return (false);
2087 }
2088 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LUMA_DETECT_TAG_ID)) {
2089 if (!parseEntrySensorLumaDetect(pchild->ToElement())) {
2090 return (false);
2091 }
2092 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ORB_TAG_ID)) {
2093
2094 if (!parseEntrySensorOrb(pchild->ToElement())) {
2095 return (false);
2096 }
2097 }
2098 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_TAG_ID)) {
2099 if (!parseEntrySensorInfo(pchild->ToElement())) {
2100 return (false);
2101 }
2102 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MODULEINFO_TAG_ID)) {
2103 if (!parseEntrySensorModuleInfo(pchild->ToElement())) {
2104 return (false);
2105 }
2106 }
2107 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPSL_TAG_ID)) {
2108 if (!parseEntrySensorCpsl(pchild->ToElement())) {
2109 return (false);
2110 }
2111 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_COLOR_AS_GREY_TAG_ID)) {
2112 if (!parseEntrySensorColorAsGrey(pchild->ToElement())) {
2113 return (false);
2114 }
2115 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_TAG_ID)) {
2116 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
2117 &RkAiqCalibParser::parseEntrySensorBayernrV2,
2118 NULL,
2119 (uint32_t)CALIB_SENSOR_BAYERNR_V2_TAG_ID,
2120 (uint32_t)CALIB_SENSOR_TAG_ID)) {
2121 LOGE("parse error in bayernrV2 (%s)", tagname.c_str());
2122 return (false);
2123 }
2124 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_TAG_ID)) {
2125 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
2126 &RkAiqCalibParser::parseEntrySensorYnrV2,
2127 NULL,
2128 (uint32_t)CALIB_SENSOR_YNR_V2_TAG_ID,
2129 (uint32_t)CALIB_SENSOR_TAG_ID)) {
2130 LOGE("parse error in bayernrV2 (%s)", tagname.c_str());
2131 return (false);
2132 }
2133 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_TAG_ID)) {
2134 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
2135 &RkAiqCalibParser::parseEntrySensorCnrV1,
2136 NULL,
2137 (uint32_t)CALIB_SENSOR_CNR_V1_TAG_ID,
2138 (uint32_t)CALIB_SENSOR_TAG_ID)) {
2139 LOGE("parse error in bayernrV2 (%s)", tagname.c_str());
2140 return (false);
2141 }
2142 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_TAG_ID)) {
2143 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
2144 &RkAiqCalibParser::parseEntrySensorSharpV3,
2145 NULL,
2146 (uint32_t)CALIB_SENSOR_SHARP_V3_TAG_ID,
2147 (uint32_t)CALIB_SENSOR_TAG_ID)) {
2148 LOGE("parse error in bayernrV2 (%s)", tagname.c_str());
2149 return (false);
2150 }
2151 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPROC_TAG_ID)) {
2152 if (!parseEntrySensorCproc(pchild->ToElement())) {
2153 return (false);
2154 }
2155 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IE_TAG_ID)) {
2156 if (!parseEntrySensorIE(pchild->ToElement())) {
2157 return (false);
2158 }
2159 }
2160
2161 pchild = pchild->NextSibling();
2162 }
2163
2164 XML_CHECK_END();
2165
2166 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
2167 autoTabBackward();
2168 return (true);
2169 }
2170
2171
2172
2173 /******************************************************************************
2174 * RkAiqCalibParser::parseEntryAwb
2175 *****************************************************************************/
parseEntrySensorAwb(const XMLElement * pelement,void * param)2176 bool RkAiqCalibParser::parseEntrySensorAwb
2177 (
2178 const XMLElement* pelement,
2179 void* param
2180 ) {
2181 (void)param;
2182
2183 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2184 autoTabForward();
2185
2186 XML_CHECK_START(CALIB_SENSOR_AWB_TAG_ID, CALIB_SENSOR_TAG_ID);
2187 const XMLNode* pchild = pelement->FirstChild();
2188 while (pchild) {
2189 XmlTag tag = XmlTag(pchild->ToElement());
2190 std::string tagname(pchild->ToElement()->Name());
2191
2192 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
2193
2194 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_V200_TAG_ID)) {
2195 CALIBDB_MODULE_PTR_HELPER_CON(list_head, awb_calib_para_v200);
2196 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
2197 &RkAiqCalibParser::parseEntrySensorAwbCalibParaV200,
2198 awb_calib_para_v200,
2199 (uint32_t)CALIB_SENSOR_AWB_V200_TAG_ID,
2200 (uint32_t)CALIB_SENSOR_AWB_TAG_ID)) {
2201 LOGE("parse error in AWB (%s)", tagname.c_str());
2202 return (false);
2203 }
2204
2205 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_V201_TAG_ID)) {
2206 CALIBDB_MODULE_PTR_HELPER_CON(list_head, awb_calib_para_v201);
2207 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
2208 &RkAiqCalibParser::parseEntrySensorAwbCalibParaV201,
2209 awb_calib_para_v201,
2210 (uint32_t)CALIB_SENSOR_AWB_V201_TAG_ID,
2211 (uint32_t)CALIB_SENSOR_AWB_TAG_ID)) {
2212 LOGE("parse error in AWB (%s)", tagname.c_str());
2213 return (false);
2214 }
2215 }
2216 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_ADJUSTPARA_TAG_ID)) {
2217 CALIBDB_MODULE_PTR_HELPER_CON(list_head, awb_adjust_para);
2218 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
2219 &RkAiqCalibParser::parseEntrySensorAwbAdjustPara,
2220 awb_adjust_para,
2221 (uint32_t)CALIB_SENSOR_AWB_ADJUSTPARA_TAG_ID,
2222 (uint32_t)CALIB_SENSOR_AWB_TAG_ID)) {
2223 LOGE("parse error in AWB (%s)", tagname.c_str());
2224 return (false);
2225 }
2226 }
2227 else {
2228 LOGW("parse error in AWB section (unknow tag:%s)", tagname.c_str());
2229 //return (false);
2230 }
2231
2232 pchild = pchild->NextSibling();
2233 }
2234
2235 XML_CHECK_END();
2236
2237 /*DCT_ASSERT((awb.adjust_para.lightNum == awb.calib_para_v200.lightNum));
2238 DCT_ASSERT((awb.adjust_para.lightNum == awb.calib_para_v201.lightNum));*/
2239 //v201 to do
2240 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
2241 autoTabBackward();
2242 return (true);
2243 }
2244
parseEntrySensorAwbCalibParaV200(const XMLElement * pelement,void * param,int index)2245 bool RkAiqCalibParser::parseEntrySensorAwbCalibParaV200
2246 (
2247 const XMLElement* pelement,
2248 void* param,
2249 int index
2250 ) {
2251 (void)param;
2252 if(param == NULL) {
2253 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2254 }
2255 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2256 autoTabForward();
2257
2258 XML_CHECK_START(CALIB_SENSOR_AWB_V200_TAG_ID, CALIB_SENSOR_AWB_TAG_ID);
2259 list_head* calib_para_v200_list = (list_head* )param;
2260 CalibDb_Awb_Calib_Para_V200_t calib_para_v200;
2261 memset(&calib_para_v200, 0, sizeof(calib_para_v200));
2262 bool ret;
2263 if (xmlParseReadWrite == XML_PARSER_WRITE) {
2264 const CalibDb_Awb_Calib_Para_V200_t *calib_para_v200_2 = NULL;
2265 ret = GetAwbProfileFromAwbCalibV200ListByIdx(calib_para_v200_list, index, &calib_para_v200_2);
2266 DCT_ASSERT(ret == true);
2267 DCT_ASSERT(calib_para_v200_2 != NULL);
2268 memcpy(&calib_para_v200, calib_para_v200_2, sizeof(CalibDb_Awb_Calib_Para_V200_t));
2269 }
2270
2271 const XMLNode* pchild = pelement->FirstChild();
2272 while (pchild) {
2273 XmlTag tag = XmlTag(pchild->ToElement());
2274 std::string tagname(pchild->ToElement()->Name());
2275
2276 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
2277 if (XML_CHECK_TAGID_COMPARE(CALIIB_SCENE_TAG_ID)) {
2278 ParseString(pchild, calib_para_v200.scene, sizeof(calib_para_v200.scene));
2279 }
2280 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID)) {
2281 if (!parseEntrySensorAwbMeasureGlobalsV200(pchild->ToElement(), &calib_para_v200)) {
2282 LOGE("parse error in AWB globals (%s)", tagname.c_str());
2283 return (false);
2284 }
2285 }
2286 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_V200_LIGHTSOURCES_TAG_ID)) {
2287 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
2288 &RkAiqCalibParser::parseEntrySensorAwbMeasureLightSourcesV200,
2289 &calib_para_v200,
2290 (uint32_t)CALIB_SENSOR_AWB_V200_LIGHTSOURCES_TAG_ID,
2291 (uint32_t)CALIB_SENSOR_AWB_V200_TAG_ID)) {
2292 LOGE("parse error in AWB light sources (%s)", tagname.c_str());
2293 return (false);
2294 }
2295 }
2296 else {
2297 LOGW("parse error in AWB section (unknow tag:%s)", tagname.c_str());
2298 //return (false);
2299 }
2300
2301 pchild = pchild->NextSibling();
2302 }
2303
2304 XML_CHECK_END();
2305 if (xmlParseReadWrite == XML_PARSER_READ) {
2306 ret = AddAwbCalibV200Profile2AwbCalibV200List(calib_para_v200_list, &calib_para_v200);
2307 DCT_ASSERT(ret == true);
2308 }
2309 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
2310 autoTabBackward();
2311
2312 return (true);
2313 }
2314
parseEntrySensorAwbAdjustPara(const XMLElement * pelement,void * param,int index)2315 bool RkAiqCalibParser::parseEntrySensorAwbAdjustPara
2316 (
2317 const XMLElement* pelement,
2318 void* param,
2319 int index
2320 ) {
2321 (void)param;
2322 if(param == NULL) {
2323 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2324 }
2325 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2326 autoTabForward();
2327
2328 XML_CHECK_START(CALIB_SENSOR_AWB_ADJUSTPARA_TAG_ID, CALIB_SENSOR_AWB_TAG_ID);
2329 list_head* adjust_para_list = (list_head* )param;
2330 CalibDb_Awb_Adjust_Para_t adjust_para;
2331 memset(&adjust_para, 0, sizeof(adjust_para));
2332 bool ret;
2333 if (xmlParseReadWrite == XML_PARSER_WRITE) {
2334 const CalibDb_Awb_Adjust_Para_t *adjust_para_2 = NULL;
2335 ret = GetAwbProfileFromAwbAdjustListByIdx(adjust_para_list, index, &adjust_para_2);
2336 DCT_ASSERT(ret == true);
2337 DCT_ASSERT(adjust_para_2 != NULL);
2338 memcpy(&adjust_para, adjust_para_2, sizeof(CalibDb_Awb_Adjust_Para_t));
2339 }
2340 const XMLNode* pchild = pelement->FirstChild();
2341 while (pchild) {
2342 XmlTag tag = XmlTag(pchild->ToElement());
2343 std::string tagname(pchild->ToElement()->Name());
2344
2345 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
2346 if (XML_CHECK_TAGID_COMPARE(CALIIB_SCENE_TAG_ID)) {
2347 ParseString(pchild, adjust_para.scene, sizeof(adjust_para.scene));
2348 }
2349 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_ADJUSTPARA_GLOBALS_TAG_ID)) {
2350 if (!parseEntrySensorAwbStrategyGlobals(pchild->ToElement(), &adjust_para)) {
2351 LOGE("parse error in AWB globals (%s)", tagname.c_str());
2352 return (false);
2353 }
2354 }
2355 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_ADJUSTPARA_LIGHTSOURCES_TAG_ID)) {
2356 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
2357 &RkAiqCalibParser::parseEntrySensorAwbStrategyLightSources,
2358 &adjust_para,
2359 (uint32_t)CALIB_SENSOR_AWB_ADJUSTPARA_LIGHTSOURCES_TAG_ID,
2360 (uint32_t)CALIB_SENSOR_AWB_ADJUSTPARA_TAG_ID)) {
2361 LOGE("parse error in AWB light sources (%s)", tagname.c_str());
2362 return (false);
2363 }
2364 }
2365 else {
2366 LOGW("parse error in AWB section (unknow tag:%s)", tagname.c_str());
2367 //return (false);
2368 }
2369
2370 pchild = pchild->NextSibling();
2371 }
2372
2373 XML_CHECK_END();
2374 if (xmlParseReadWrite == XML_PARSER_READ) {
2375 ret = AddAwbAdjustProfile2AwbAdjustList(adjust_para_list, &adjust_para);
2376 DCT_ASSERT(ret == true);
2377 }
2378 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
2379 autoTabBackward();
2380
2381 return (true);
2382 }
2383
parseEntrySensorAwbMeasureGlobalsV200(const XMLElement * pelement,void * param)2384 bool RkAiqCalibParser::parseEntrySensorAwbMeasureGlobalsV200
2385 (
2386 const XMLElement* pelement,
2387 void* param
2388 ) {
2389 (void)param;
2390 if(param == NULL) {
2391 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2392 }
2393 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2394 autoTabForward();
2395
2396 XML_CHECK_START(CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID, CALIB_SENSOR_AWB_V200_TAG_ID);
2397 CalibDb_Awb_Calib_Para_V200_t *calib_para_v200 = (CalibDb_Awb_Calib_Para_V200_t*)param;
2398 const XMLNode* pchild = pelement->FirstChild();
2399 while (pchild) {
2400 XmlTag tag = XmlTag(pchild->ToElement());
2401 std::string tagname(pchild->ToElement()->Name());
2402 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
2403
2404 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_HDRFRAMECHOOSE_TAG_ID)) {
2405 if (!parseEntrySensorAwbFrameChoose(pchild->ToElement(), param)) {
2406 LOGE("parse error in AWB (%s)", tagname.c_str());
2407 return (false);
2408 }
2409 }
2410 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LSCBYPASSENABLE_TAG_ID)) {
2411 unsigned char tempVal = calib_para_v200->lscBypEnable;
2412 int no = ParseUcharArray(pchild, &tempVal, 1);
2413 DCT_ASSERT((no == tag.Size()));
2414 calib_para_v200->lscBypEnable = (tempVal == 0 ? false : true);
2415 }
2416 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_UVDETECTIONENABLE_TAG_ID)) {
2417 unsigned char tempVal = calib_para_v200->uvDetectionEnable;
2418 int no = ParseUcharArray(pchild, &tempVal, 1);
2419 DCT_ASSERT((no == tag.Size()));
2420 calib_para_v200->uvDetectionEnable = (tempVal == 0 ? false : true);
2421 }
2422 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_XYDETECTIONENABLE_TAG_ID)) {
2423 unsigned char tempVal = calib_para_v200->xyDetectionEnable;
2424 int no = ParseUcharArray(pchild, &tempVal, 1);
2425 DCT_ASSERT((no == tag.Size()));
2426 calib_para_v200->xyDetectionEnable = (tempVal == 0 ? false : true);
2427 }
2428 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_YUVDETECTIONENABLE_TAG_ID)) {
2429 unsigned char tempVal = calib_para_v200->yuvDetectionEnable;
2430 int no = ParseUcharArray(pchild, &tempVal, 1);
2431 DCT_ASSERT((no == tag.Size()));
2432 calib_para_v200->yuvDetectionEnable = (tempVal == 0 ? false : true);
2433 }
2434 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WBGAINDAYLIGHTCLIPENABLE_TAG_ID)) {
2435 unsigned char tempVal = calib_para_v200->wbGainDaylightClipEn;
2436 int no = ParseUcharArray(pchild, &tempVal, 1);
2437 DCT_ASSERT((no == tag.Size()));
2438 calib_para_v200->wbGainDaylightClipEn = (tempVal == 0 ? false : true);
2439 }
2440 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WBGAINCLIPEANBLE_TAG_ID)) {
2441 unsigned char tempVal = calib_para_v200->wbGainClipEn;
2442 int no = ParseUcharArray(pchild, &tempVal, 1);
2443 DCT_ASSERT((no == tag.Size()));
2444 calib_para_v200->wbGainClipEn = (tempVal == 0 ? false : true);
2445 }
2446 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LSUSEDFORYUVDET_TAG_ID)) {
2447 calib_para_v200->lsUsedForYuvDetNum = 0;
2448 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
2449 &RkAiqCalibParser::parseEntrySensorAwbLsForYuvDet,
2450 param,
2451 (uint32_t)CALIB_SENSOR_AWB_LSUSEDFORYUVDET_TAG_ID,
2452 (uint32_t)CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID)) {
2453 LOGE("parse error in AWB (%s)", tagname.c_str());
2454 return (false);
2455 }
2456 }
2457 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_DOWNSCALEMODE_TAG_ID)) {
2458 int no = ParseUcharArray(pchild, &calib_para_v200->dsMode, 1);
2459 DCT_ASSERT((no == tag.Size()));
2460 }
2461 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_BLCKMEASUREMODE_TAG_ID)) {
2462 int no = ParseUcharArray(pchild, &calib_para_v200->blkMeasureMode, 1);
2463 DCT_ASSERT((no == tag.Size()));
2464 }
2465 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MEASUREWINDOW_TAG_ID)) {
2466 if (!parseEntrySensorAwbMeasureWindow(pchild->ToElement(), param)) {
2467 LOGE("parse error in AWB (%s)", tagname.c_str());
2468 return (false);
2469 }
2470 }
2471 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MULTIWINDOWENABLE_TAG_ID)) {
2472 unsigned char tempVal = calib_para_v200->multiwindow_en;
2473 int no = ParseUcharArray(pchild, &tempVal, 1);
2474 DCT_ASSERT((no == tag.Size()));
2475 calib_para_v200->multiwindow_en = (tempVal == 0 ? false : true);
2476 }
2477 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_TAG_ID)) {
2478 if (!parseEntrySensorAwbLimitRange(pchild->ToElement(), param)) {
2479 LOGE("parse error in AWB (%s)", tagname.c_str());
2480 return (false);
2481 }
2482 }
2483 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_CELL_TAG_ID)) {
2484 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
2485 &RkAiqCalibParser::parseEntrySensorAwbLimitRangeCell,
2486 param,
2487 (uint32_t)CALIB_SENSOR_AWB_LIMITRANGE_CELL_TAG_ID,
2488 (uint32_t)CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID)) {
2489 LOGE("parse error in AWB (%s)", tagname.c_str());
2490 return (false);
2491 }
2492 }
2493 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_PSEUDOLUMWEIGHT_TAG_ID)) {
2494 int no = ParseFloatArray(pchild, calib_para_v200->rgb2tcs_param.pseudoLuminanceWeight, tag.Size(), 6);
2495 DCT_ASSERT((no == tag.Size()));
2496 }
2497 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_ROTATIONMAT_TAG_ID)) {
2498 int no = ParseFloatArray(pchild, calib_para_v200->rgb2tcs_param.rotationMat, tag.Size(), 6);
2499 DCT_ASSERT((no == tag.Size()));
2500 }
2501 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MULTIWINDOW_TAG_ID)) {
2502 //unsigned short tempVal[32];
2503 int no = ParseUshortArray(pchild, calib_para_v200->multiwindow[0], tag.Size());
2504 DCT_ASSERT((no == tag.Size()));
2505 DCT_ASSERT((no <= CALD_AWB_WINDOW_NUM_MAX * 4));
2506 //MEMCPY(calib_para_v200->multiwindow, tempVal, sizeof(short)*no);
2507 }
2508 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_EXCLUDERANGE_TAG_ID)) {
2509 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
2510 &RkAiqCalibParser::parseEntrySensorAwbGlobalsExclude,
2511 param,
2512 (uint32_t)CALIB_SENSOR_AWB_EXCLUDERANGE_TAG_ID,
2513 (uint32_t)CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID)) {
2514 LOGE("parse error in AWB globals excluderange (%s)", tagname.c_str());
2515 return (false);
2516 }
2517
2518 }
2519 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_SPATIALGAIN_L_TAG_ID)) {
2520 int no = ParseFloatArray(pchild, calib_para_v200->spatialGain_L, tag.Size());
2521 DCT_ASSERT((no == tag.Size()));
2522 DCT_ASSERT((no == 4));
2523 }
2524 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_SPATIALGAIN_H_TAG_ID)) {
2525 int no = ParseFloatArray(pchild, calib_para_v200->spatialGain_H, tag.Size());
2526 DCT_ASSERT((no == tag.Size()));
2527 DCT_ASSERT((no == 4));
2528 }
2529 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_TEMPORALDEFAULTGAIN_TAG_ID)) {
2530 int no = ParseFloatArray(pchild, calib_para_v200->temporalDefaultGain, tag.Size());
2531 DCT_ASSERT((no == tag.Size()));
2532 DCT_ASSERT((no == 4));
2533 }
2534 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CA_TARGETGAIN_TAG_ID)) {
2535 int no = ParseFloatArray(pchild, calib_para_v200->ca_targetGain, tag.Size());
2536 DCT_ASSERT((no == tag.Size()));
2537 }
2538 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_SINGLECOLORPROCESS_TAG_ID)) {
2539 if (!parseEntrySensorAwbSingleColorV200(pchild->ToElement(), param)) {
2540 LOGE("parse error in AWB (%s)", tagname.c_str());
2541 return (false);
2542 }
2543 }
2544 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LINERGBG_TAG_ID)) {
2545 int no = ParseFloatArray(pchild, calib_para_v200->lineRgBg, tag.Size());
2546 DCT_ASSERT((no == tag.Size()));
2547 }
2548 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LINERGBGPROJCCT_TAG_ID)) {
2549 int no = ParseFloatArray(pchild, calib_para_v200->lineRgProjCCT, tag.Size());
2550 DCT_ASSERT((no == tag.Size()));
2551 }
2552 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WBGAINDAYLIGHTCLIP_TAG_ID)) {
2553 if (!parseEntrySensorAwbwbGainDaylightClipV200(pchild->ToElement(), &calib_para_v200->cct_clip_cfg)) {
2554 LOGE("parse error in AWB (%s)", tagname.c_str());
2555 return (false);
2556 }
2557 }
2558 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WBGAINCLIP_TAG_ID)) {
2559 if (!parseEntrySensorAwbwbGainClipV200(pchild->ToElement(), &calib_para_v200->cct_clip_cfg)) {
2560 LOGE("parse error in AWB (%s)", tagname.c_str());
2561 return (false);
2562 }
2563 }
2564 else {
2565 LOGE("parse error in AWB section (unknow tag:%s)", tagname.c_str());
2566 //return ( false );
2567 }
2568
2569 pchild = pchild->NextSibling();
2570 }
2571
2572 XML_CHECK_END();
2573
2574 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
2575 autoTabBackward();
2576
2577
2578 return (true);
2579 }
2580
parseEntrySensorAwbDampFactor(const XMLElement * pelement,void * param)2581 bool RkAiqCalibParser::parseEntrySensorAwbDampFactor
2582 (
2583 const XMLElement* pelement,
2584 void* param
2585 ) {
2586 (void)param;
2587
2588 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2589 autoTabForward();
2590
2591 XML_CHECK_START(CALIB_SENSOR_AWB_DAMPFACTOR_TAG_ID, CALIB_SENSOR_AWB_ADJUSTPARA_GLOBALS_TAG_ID);
2592 CalibDb_Awb_Adjust_Para_t *adjust_para = (CalibDb_Awb_Adjust_Para_t*)param;
2593
2594 const XMLNode* psubchild = pelement->FirstChild();
2595 while (psubchild) {
2596 XmlTag subTag = XmlTag(psubchild->ToElement());
2597 std::string subTagname(psubchild->ToElement()->Name());
2598 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
2599
2600 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_DFSTEP_TAG_ID)) {
2601 int no = ParseFloatArray(psubchild, &adjust_para->dFStep, subTag.Size());
2602 DCT_ASSERT((no == subTag.Size()));
2603 }
2604 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_DFMIN_TAG_ID)) {
2605 int no = ParseFloatArray(psubchild, &adjust_para->dFMin, subTag.Size());
2606 DCT_ASSERT((no == subTag.Size()));
2607 }
2608 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_DFMAX_TAG_ID)) {
2609 int no = ParseFloatArray(psubchild, &adjust_para->dFMax, subTag.Size());
2610 DCT_ASSERT((no == subTag.Size()));
2611 }
2612 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LVIIRSIZE_TAG_ID)) {
2613 int no = ParseIntArray(psubchild, &adjust_para->LvIIRsize, subTag.Size());
2614 DCT_ASSERT((no == subTag.Size()));
2615 }
2616 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LVVARTH_TAG_ID)) {
2617 int no = ParseFloatArray(psubchild, &adjust_para->LvVarTh, subTag.Size());
2618 DCT_ASSERT((no == subTag.Size()));
2619 }
2620 psubchild = psubchild->NextSibling();
2621 }
2622
2623
2624 XML_CHECK_END();
2625
2626 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
2627 autoTabBackward();
2628
2629 return (true);
2630
2631 }
2632
parseEntrySensorAwbXyRegionWpnumthCell(const XMLElement * pelement,void * param,int index)2633 bool RkAiqCalibParser::parseEntrySensorAwbXyRegionWpnumthCell
2634 (
2635 const XMLElement* pelement,
2636 void* param,
2637 int index
2638 ) {
2639 (void)param;
2640
2641 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2642 autoTabForward();
2643
2644 XML_CHECK_START(CALIB_SENSOR_AWB_XYREGION_WPNUMTH_CELL_TAG_ID, CALIB_SENSOR_AWB_XYREGIONSTABLESELECTION_TAG_ID);
2645 CalibDb_Awb_Adjust_Para_t *adjust_para = (CalibDb_Awb_Adjust_Para_t*)param;
2646 const XMLNode* pchild = pelement->FirstChild();
2647 while (pchild) {
2648 XmlTag tag = XmlTag(pchild->ToElement());
2649 std::string tagname(pchild->ToElement()->Name());
2650 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
2651 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_XYREGION_LV_TAG_ID)) {
2652 float tmpValue = adjust_para->wpNumTh.lumaValue[index];
2653 int no = ParseFloatArray(pchild, &tmpValue, tag.Size());
2654 DCT_ASSERT((no == tag.Size()));
2655 adjust_para->wpNumTh.lumaValue[index] = tmpValue;
2656 }
2657 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_XYREGION_WPNUMTHFORBIGTYPE_TAG_ID)) {
2658 float tmpValue = adjust_para->wpNumTh.wpNumThForBigType[index];
2659 int no = ParseFloatArray(pchild, &tmpValue, tag.Size());
2660 DCT_ASSERT((no == tag.Size()));
2661 adjust_para->wpNumTh.wpNumThForBigType[index] = tmpValue;
2662 }
2663 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_XYREGION_WPNUMTHFOREXTRATYPE_TAG_ID)) {
2664 float tmpValue = adjust_para->wpNumTh.wpNumThForExtraType[index];
2665 int no = ParseFloatArray(pchild, &tmpValue, tag.Size());
2666 DCT_ASSERT((no == tag.Size()));
2667 adjust_para->wpNumTh.wpNumThForExtraType[index] = tmpValue;
2668 }
2669 else {
2670 LOGW("unknown tag %s", tagname.c_str());
2671 }
2672 pchild = pchild->NextSibling();
2673 }
2674
2675 adjust_para->wpNumTh.num++;
2676 DCT_ASSERT((adjust_para->wpNumTh.num <= CALD_AWB_LV_NUM_MAX));
2677 XML_CHECK_END();
2678 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
2679 autoTabBackward();
2680 return (true);
2681 }
parseEntrySensorAwbwbWpTh(const XMLElement * pelement,void * param,int index)2682 bool RkAiqCalibParser::parseEntrySensorAwbwbWpTh
2683 (
2684 const XMLElement* pelement,
2685 void* param,
2686 int index
2687 ) {
2688 (void)param;
2689
2690 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2691 autoTabForward();
2692
2693 XML_CHECK_START(CALIB_SENSOR_AWB_WP_TH_TAG_ID, CALIB_SENSOR_AWB_ADJUSTPARA_GLOBALS_TAG_ID);
2694 CalibDb_Awb_Adjust_Para_t *adjust_para = (CalibDb_Awb_Adjust_Para_t*)param;
2695 const XMLNode* pchild = pelement->FirstChild();
2696 while (pchild) {
2697 XmlTag tag = XmlTag(pchild->ToElement());
2698 std::string tagname(pchild->ToElement()->Name());
2699 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
2700
2701 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WP_LV_TAG_ID)) {
2702 int no = ParseFloatArray(pchild, &adjust_para->WP_TH.lumaValue[index], tag.Size());
2703 DCT_ASSERT((no == tag.Size()));
2704 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WP_THL_TAG_ID)) {
2705 int no = ParseFloatArray(pchild, &adjust_para->WP_TH.WP_THL[index], tag.Size());
2706 DCT_ASSERT((no == tag.Size()));
2707 }
2708 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WP_THH_TAG_ID)) {
2709 int no = ParseFloatArray(pchild, &adjust_para->WP_TH.WP_THH[index], tag.Size());
2710 DCT_ASSERT((no == tag.Size()));
2711 }
2712 pchild = pchild->NextSibling();
2713 }
2714 XML_CHECK_END();
2715 adjust_para->WP_TH.num++;
2716 DCT_ASSERT((adjust_para->WP_TH.num <= CALD_AWB_LV_NUM_MAX));
2717 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
2718 autoTabBackward();
2719 return (true);
2720 }
2721
2722
2723
parseEntrySensorAwbXyRegionStableSelection(const XMLElement * pelement,void * param)2724 bool RkAiqCalibParser::parseEntrySensorAwbXyRegionStableSelection
2725 (
2726 const XMLElement* pelement,
2727 void* param
2728 ) {
2729 (void)param;
2730 if(param == NULL) {
2731 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2732 }
2733 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2734 autoTabForward();
2735
2736 XML_CHECK_START(CALIB_SENSOR_AWB_XYREGIONSTABLESELECTION_TAG_ID, CALIB_SENSOR_AWB_ADJUSTPARA_GLOBALS_TAG_ID);
2737 CalibDb_Awb_Adjust_Para_t *adjust_para = (CalibDb_Awb_Adjust_Para_t*)param;
2738
2739 const XMLNode* psubchild = pelement->FirstChild();
2740
2741 autoTabForward();
2742 while (psubchild) {
2743 XmlTag subTag = XmlTag(psubchild->ToElement());
2744 std::string subTagname(psubchild->ToElement()->Name());
2745 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
2746
2747 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_XYREGIONSIZE_TAG_ID)) {
2748 int no = ParseIntArray(psubchild, &adjust_para->xyTypeListSize, subTag.Size());
2749 DCT_ASSERT((no == subTag.Size()));
2750 }
2751 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LVVARTH_TAG_ID)) {
2752 int no = ParseFloatArray(psubchild, &adjust_para->varianceLumaTh, subTag.Size());
2753 DCT_ASSERT((no == subTag.Size()));
2754 }
2755 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_XYREGION_WPNUMTH_CELL_TAG_ID)) {
2756 if (!parseEntryCell2(psubchild->ToElement(), subTag.Size(),
2757 &RkAiqCalibParser::parseEntrySensorAwbXyRegionWpnumthCell,
2758 param,
2759 (uint32_t)CALIB_SENSOR_AWB_XYREGION_WPNUMTH_CELL_TAG_ID,
2760 (uint32_t)CALIB_SENSOR_AWB_XYREGIONSTABLESELECTION_TAG_ID)) {
2761 LOGE("parse error in AWB xyRegionStableSelection (%s)", subTagname.c_str());
2762 return (false);
2763 }
2764
2765 }
2766 psubchild = psubchild->NextSibling();
2767 }
2768
2769 //compatible with the version <= v1.4.7
2770 if(adjust_para->wpNumTh.num == 0) {
2771 adjust_para->wpNumTh.num = 1;
2772 adjust_para->wpNumTh.lumaValue[0] = 0;
2773 adjust_para->wpNumTh.wpNumThForBigType[0] = adjust_para->WP_TH.WP_THH[0];
2774 adjust_para->wpNumTh.wpNumThForExtraType[0] = adjust_para->WP_TH.WP_THH[0];
2775 }
2776
2777 XML_CHECK_END();
2778
2779 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
2780 autoTabBackward();
2781
2782 return (true);
2783
2784 }
2785
parseEntrySensorAwbStrategyGlobals(const XMLElement * pelement,void * param)2786 bool RkAiqCalibParser::parseEntrySensorAwbStrategyGlobals
2787 (
2788 const XMLElement* pelement,
2789 void* param
2790 ) {
2791 (void)param;
2792 if(param == NULL) {
2793 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2794 }
2795 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
2796 autoTabForward();
2797
2798 XML_CHECK_START(CALIB_SENSOR_AWB_ADJUSTPARA_GLOBALS_TAG_ID, CALIB_SENSOR_AWB_ADJUSTPARA_TAG_ID);
2799 CalibDb_Awb_Adjust_Para_t *adjust_para = (CalibDb_Awb_Adjust_Para_t*)param;
2800 int no1 = 0, no2 = 0, no3 = 0, no4 = 0;
2801 const XMLNode* pchild = pelement->FirstChild();
2802 while (pchild) {
2803
2804 XmlTag tag = XmlTag(pchild->ToElement());
2805 std::string tagname(pchild->ToElement()->Name());
2806 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
2807 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_AWB_ENABLE_TAG_ID)) {
2808 unsigned char tempVal = adjust_para->awbEnable;
2809 int no = ParseUcharArray(pchild, &tempVal, 1);
2810 adjust_para->awbEnable = (tempVal == 0 ? false : true);
2811 DCT_ASSERT((no == tag.Size()));
2812 }
2813 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WB_BYPASS_TAG_ID)) {
2814 unsigned char tempVal = adjust_para->wbBypass;
2815 int no = ParseUcharArray(pchild, &tempVal, 1);
2816 adjust_para->wbBypass = (tempVal == 0 ? false : true);
2817 DCT_ASSERT((no == tag.Size()));
2818 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WBGAINADJUSTENABLE_TAG_ID)) {
2819 unsigned char tempVal = adjust_para->wbGainAdjustEn;
2820 int no = ParseUcharArray(pchild, &tempVal, 1);
2821 DCT_ASSERT((no == tag.Size()));
2822 adjust_para->wbGainAdjustEn = (tempVal == 0 ? false : true);
2823
2824 }
2825 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LSFORFIRSTFRAME_TAG_ID)) {
2826 ParseString(pchild, adjust_para->lsForFirstFrame,
2827 sizeof(adjust_para->lsForFirstFrame));
2828 }
2829 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_UVRANGESMALLENABLE_TAG_ID)) {
2830 unsigned char tempVal = adjust_para->uvRange_small_enable;
2831 int no = ParseUcharArray(pchild, &tempVal, 1);
2832 DCT_ASSERT((no == tag.Size()));
2833 adjust_para->uvRange_small_enable = (tempVal == 0 ? false : true);
2834 }
2835 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CA_ENABLE_TAG_ID)) {
2836 unsigned char tempVal = adjust_para->ca_enable;
2837 int no = ParseUcharArray(pchild, &tempVal, 1);
2838 DCT_ASSERT((no == tag.Size()));
2839 adjust_para->ca_enable = (tempVal == 0 ? false : true);
2840 }
2841 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_TOLERANCE_TAG_ID)) {
2842 const XMLNode* psubchild = pchild->ToElement()->FirstChild();
2843 autoTabForward();
2844 adjust_para->tolerance.num = 0;
2845 XML_CHECK_START(CALIB_SENSOR_AWB_TOLERANCE_TAG_ID, CALIB_SENSOR_AWB_ADJUSTPARA_GLOBALS_TAG_ID);
2846 while (psubchild) {
2847 XmlTag subTag = XmlTag(psubchild->ToElement());
2848 std::string subTagname(psubchild->ToElement()->Name());
2849 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
2850 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LV_TAG_ID)) {
2851 no1 = ParseFloatArray(psubchild, adjust_para->tolerance.LV, subTag.Size());
2852 DCT_ASSERT((no1 == subTag.Size()));
2853 }
2854 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_VALUE_TAG_ID)) {
2855 no2 = ParseFloatArray(psubchild, adjust_para->tolerance.value, subTag.Size());
2856 DCT_ASSERT((no2 == subTag.Size()));
2857 }
2858 psubchild = psubchild->NextSibling();
2859 }
2860 XML_CHECK_END();
2861 autoTabBackward();
2862 }
2863 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_RUNINTERNAL_TAG_ID)) {
2864 const XMLNode* psubchild = pchild->ToElement()->FirstChild();
2865 autoTabForward();
2866 adjust_para->runInterval.num = 0;
2867 XML_CHECK_START(CALIB_SENSOR_AWB_RUNINTERNAL_TAG_ID, CALIB_SENSOR_AWB_ADJUSTPARA_GLOBALS_TAG_ID);
2868 while (psubchild) {
2869 XmlTag subTag = XmlTag(psubchild->ToElement());
2870 std::string subTagname(psubchild->ToElement()->Name());
2871 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
2872 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LV_TAG_ID)) {
2873 no3 = ParseFloatArray(psubchild, adjust_para->runInterval.LV, subTag.Size());
2874 DCT_ASSERT((no3 == subTag.Size()));
2875 }
2876 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_VALUE_TAG_ID)) {
2877 no4 = ParseFloatArray(psubchild, adjust_para->runInterval.value, subTag.Size());
2878 DCT_ASSERT((no4 == subTag.Size()));
2879 }
2880 psubchild = psubchild->NextSibling();
2881 }
2882 XML_CHECK_END();
2883 autoTabBackward();
2884 }
2885 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MULTIWINDOWMODE_TAG_ID)) {
2886 int no = ParseUcharArray(pchild, &adjust_para->multiwindowMode, tag.Size());
2887 DCT_ASSERT((no == tag.Size()));
2888 }
2889 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_DAMPFACTOR_TAG_ID)) {
2890 if (!parseEntrySensorAwbDampFactor(pchild->ToElement(), param)) {
2891 LOGE("parse error in AWB globals (%s)", tagname.c_str());
2892 return (false);
2893 }
2894 }
2895 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LVMATRIX_TAG_ID)) {
2896 int no = ParseUintArray(pchild, adjust_para->LVMatrix, tag.Size());
2897 DCT_ASSERT((no <= CALD_AWB_LV_NUM_MAX));
2898 DCT_ASSERT((no == tag.Size()));
2899 adjust_para->LV_NUM = no;
2900 }
2901 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LV_THL_TAG_ID)) {
2902 int no = ParseUintArray(pchild, &adjust_para->LV_THL, tag.Size());
2903 DCT_ASSERT((no == tag.Size()));
2904 }
2905 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LV_THL2_TAG_ID)) {
2906 int no = ParseUintArray(pchild, &adjust_para->LV_THL2, tag.Size());
2907 DCT_ASSERT((no == tag.Size()));
2908 }
2909 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LV_THH_TAG_ID)) {
2910 int no = ParseUintArray(pchild, &adjust_para->LV_THH, tag.Size());
2911 DCT_ASSERT((no == tag.Size()));
2912 }
2913 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LV_THH2_TAG_ID)) {
2914 int no = ParseUintArray(pchild, &adjust_para->LV_THH2, tag.Size());
2915 DCT_ASSERT((no == tag.Size()));
2916 }
2917 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WP_THL_TAG_ID)) {
2918 //compatible with the version <= v1.4.7
2919 int no = ParseFloatArray(pchild, &adjust_para->WP_TH.WP_THL[0], tag.Size());
2920 DCT_ASSERT((no == tag.Size()));
2921 adjust_para->WP_TH.num = 1;//compatible with the version <= v1.4.7
2922 }
2923 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WP_THH_TAG_ID)) {
2924 //compatible with the version <= v1.4.7
2925 int no = ParseFloatArray(pchild, &adjust_para->WP_TH.WP_THH[0], tag.Size());
2926 DCT_ASSERT((no == tag.Size()));
2927 }
2928 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WP_TH_TAG_ID)) {
2929 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
2930 &RkAiqCalibParser::parseEntrySensorAwbwbWpTh,
2931 param,
2932 (uint32_t)CALIB_SENSOR_AWB_WP_TH_TAG_ID,
2933 (uint32_t)CALIB_SENSOR_AWB_ADJUSTPARA_GLOBALS_TAG_ID)) {
2934 LOGE("parse error in AWB globals (%s)", tagname.c_str());
2935 return (false);
2936 }
2937 }
2938 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_PRODIS_THL_TAG_ID)) {
2939 int no = ParseFloatArray(pchild, &adjust_para->proDis_THL, tag.Size());
2940 DCT_ASSERT((no == tag.Size()));
2941 }
2942 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_PRODIS_THH_TAG_ID)) {
2943 int no = ParseFloatArray(pchild, &adjust_para->proDis_THH, tag.Size());
2944 DCT_ASSERT((no == tag.Size()));
2945 }
2946 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_PROLV_INDOOR_THL_TAG_ID)) {
2947 int no = ParseUintArray(pchild, &adjust_para->proLV_Indoor_THL, tag.Size());
2948 DCT_ASSERT((no == tag.Size()));
2949 }
2950 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_PROLV_INDOOR_THH_TAG_ID)) {
2951 int no = ParseUintArray(pchild, &adjust_para->proLV_Indoor_THH, tag.Size());
2952 DCT_ASSERT((no == tag.Size()));
2953 }
2954 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_PROLV_OUTDOOR_THL_TAG_ID)) {
2955 int no = ParseUintArray(pchild, &adjust_para->proLV_Outdoor_THL, tag.Size());
2956 DCT_ASSERT((no == tag.Size()));
2957 }
2958 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_PROLV_OUTDOOR_THH_TAG_ID)) {
2959 int no = ParseUintArray(pchild, &adjust_para->proLV_Outdoor_THH, tag.Size());
2960 DCT_ASSERT((no == tag.Size()));
2961 }
2962 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_TEMPORALCALGAINSETSIZE_TAG_ID)) {
2963 int no = ParseUcharArray(pchild, &adjust_para->temporalCalGainSetSize, tag.Size());
2964 DCT_ASSERT((no == tag.Size()));
2965 DCT_ASSERT((no <= CALD_AWB_TEMPORAL_GAIN_SIZE_MAX));
2966 }
2967 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_TEMPORALGAINSETWEIGHT_TAG_ID)) {
2968 int no = ParseUcharArray(pchild, adjust_para->temporalGainSetWeight, tag.Size());
2969 DCT_ASSERT((no <= CALD_AWB_TEMPORAL_GAIN_SIZE_MAX));
2970 DCT_ASSERT((no == tag.Size()));
2971 DCT_ASSERT((no == adjust_para->temporalCalGainSetSize));//check
2972 }
2973 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPNUMPERCTH_TAG_ID)) {
2974 int no = ParseFloatArray(pchild, &adjust_para->wpNumPercTh, tag.Size());
2975 DCT_ASSERT((no == tag.Size()));
2976 }
2977 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_TEMPWEIGTH_TAG_ID)) {
2978 int no = ParseUcharArray(pchild, adjust_para->tempWeight, tag.Size());
2979 DCT_ASSERT((no == tag.Size()));
2980 DCT_ASSERT((no <= CALD_AWB_LV_NUM_MAX));
2981 }
2982 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CA_LACALCFACTOR_TAG_ID)) {
2983 int no = ParseFloatArray(pchild, &adjust_para->ca_LACalcFactor, tag.Size());
2984 DCT_ASSERT((no == tag.Size()));
2985 }
2986 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CONVERGEDVARTH_TAG_ID)) {
2987 int no = ParseFloatArray(pchild, &adjust_para->convergedVarTh, tag.Size());
2988 DCT_ASSERT((no == tag.Size()));
2989 }
2990 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_XYREGIONSTABLESELECTION_TAG_ID)) {
2991 if (!parseEntrySensorAwbXyRegionStableSelection(pchild->ToElement(), param)) {
2992 LOGE("parse error in AWB globals (%s)", tagname.c_str());
2993 return (false);
2994 }
2995 }
2996 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WBGAINADJUST_TAG_ID)) {
2997 if (!parseEntrySensorAwbwbGainAdjust(pchild->ToElement(), param)) {
2998 LOGE("parse error in AWB (%s)", tagname.c_str());
2999 return (false);
3000 }
3001 }
3002 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WBGAINOFFSET_TAG_ID)) {
3003 if (!parseEntrySensorAwbwbGainOffset(pchild->ToElement(), param)) {
3004 LOGE("parse error in AWB (%s)", tagname.c_str());
3005 return (false);
3006 }
3007 }
3008 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_REMOSAICPARA_TAG_ID)) {
3009 if (!parseEntrySensorAwbRemosaicPara(pchild->ToElement(), &adjust_para->remosaic_cfg)) {
3010 LOGE("parse error in AWB (%s)", tagname.c_str());
3011 return (false);
3012 }
3013 }
3014 else {
3015 LOGW("parse error in AWB section (unknow tag:%s)", tagname.c_str());
3016 //return ( false );
3017 }
3018
3019 pchild = pchild->NextSibling();
3020 }
3021
3022 XML_CHECK_END();
3023 DCT_ASSERT((no2 == no1));
3024 adjust_para->tolerance.num = no1;
3025 DCT_ASSERT((no3 == no4));
3026 adjust_para->runInterval.num = no3;
3027
3028 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3029 autoTabBackward();
3030
3031 return (true);
3032 }
3033
parseEntrySensorAwbLsForYuvDet(const XMLElement * pelement,void * param,int index)3034 bool RkAiqCalibParser::parseEntrySensorAwbLsForYuvDet
3035 (
3036 const XMLElement* pelement,
3037 void* param,
3038 int index
3039 ) {
3040 if(param == NULL) {
3041 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3042 }
3043 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3044
3045 XML_CHECK_START(CALIB_SENSOR_AWB_LSUSEDFORYUVDET_TAG_ID, CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID);
3046 CalibDb_Awb_Calib_Para_V200_t *calib_para_v200 = (CalibDb_Awb_Calib_Para_V200_t*)param;
3047
3048 const XMLNode* pchild = pelement->FirstChild();
3049 while (pchild) {
3050 XmlTag tag = XmlTag(pchild->ToElement());
3051 const char* value = tag.Value();
3052 std::string tagname(pchild->ToElement()->Name());
3053 LOGD("%s(%d): tag.Size %d\n", __FUNCTION__, __LINE__, tag.Size());
3054 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3055 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LSUSEDFORYUVDET_NAME_TAG_ID)) {
3056 ParseString(pchild, calib_para_v200->lsUsedForYuvDet[index],
3057 sizeof(calib_para_v200->lsUsedForYuvDet[index]));//check
3058 } else {
3059 LOGW("UNKNOWN tag: %s", tagname.c_str());
3060 }
3061 pchild = pchild->NextSibling();
3062 }
3063 XML_CHECK_END();
3064 DCT_ASSERT((index <= CALD_AWB_LS_NUM_MAX));
3065 calib_para_v200->lsUsedForYuvDetNum++;
3066 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3067 return (true);
3068 }
3069
parseEntrySensorAwbFrameChoose(const XMLElement * pelement,void * param)3070 bool RkAiqCalibParser::parseEntrySensorAwbFrameChoose
3071 (
3072 const XMLElement* pelement,
3073 void* param
3074 ) {
3075 (void)param;
3076 if(param == NULL) {
3077 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3078 }
3079 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3080 autoTabForward();
3081
3082 XML_CHECK_START(CALIB_SENSOR_AWB_HDRFRAMECHOOSE_TAG_ID, CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID);
3083 CalibDb_Awb_Calib_Para_V200_t *calib_para_v200 = (CalibDb_Awb_Calib_Para_V200_t*)param;
3084
3085 const XMLNode* pchild = pelement->FirstChild();
3086 while (pchild) {
3087 XmlTag tag = XmlTag(pchild->ToElement());
3088 std::string tagname(pchild->ToElement()->Name());
3089 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3090 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MODE_TAG_ID)) {
3091 int no = ParseUcharArray(pchild, &calib_para_v200->hdrFrameChooseMode, 1);
3092 DCT_ASSERT((no == tag.Size()));
3093 }
3094 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_FRAMECHOOSE_TAG_ID)) {
3095 int no = ParseUcharArray(pchild, &calib_para_v200->hdrFrameChoose, 1);
3096 DCT_ASSERT((no == tag.Size()));
3097 }
3098
3099 pchild = pchild->NextSibling();
3100 }
3101 XML_CHECK_END();
3102 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3103 autoTabBackward();
3104 return (true);
3105 }
3106
parseEntrySensorAwbFrameChooseV201(const XMLElement * pelement,void * param)3107 bool RkAiqCalibParser::parseEntrySensorAwbFrameChooseV201
3108 (
3109 const XMLElement* pelement,
3110 void* param
3111 ) {
3112 (void)param;
3113 if(param == NULL) {
3114 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3115 }
3116 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3117 autoTabForward();
3118
3119 XML_CHECK_START(CALIB_SENSOR_AWB_HDRFRAMECHOOSE_TAG_ID, CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID);
3120 CalibDb_Awb_Calib_Para_V201_t *calib_para_v201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
3121
3122 const XMLNode* pchild = pelement->FirstChild();
3123 while (pchild) {
3124 XmlTag tag = XmlTag(pchild->ToElement());
3125 std::string tagname(pchild->ToElement()->Name());
3126 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3127 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MODE_TAG_ID)) {
3128 int no = ParseUcharArray(pchild, &calib_para_v201->hdrFrameChooseMode, 1);
3129 DCT_ASSERT((no == tag.Size()));
3130 }
3131 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_FRAMECHOOSE_TAG_ID)) {
3132 int no = ParseUcharArray(pchild, &calib_para_v201->hdrFrameChoose, 1);
3133 DCT_ASSERT((no == tag.Size()));
3134 }
3135
3136 pchild = pchild->NextSibling();
3137 }
3138 XML_CHECK_END();
3139 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3140 autoTabBackward();
3141 return (true);
3142 }
3143
parseEntrySensorAwbMeasureWindow(const XMLElement * pelement,void * param)3144 bool RkAiqCalibParser::parseEntrySensorAwbMeasureWindow
3145 (
3146 const XMLElement* pelement,
3147 void* param
3148 ) {
3149 (void)param;
3150 if(param == NULL) {
3151 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3152 }
3153 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3154 autoTabForward();
3155
3156 XML_CHECK_START(CALIB_SENSOR_AWB_MEASUREWINDOW_TAG_ID, CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID);
3157 CalibDb_Awb_Calib_Para_V200_t *calib_para_v200 = (CalibDb_Awb_Calib_Para_V200_t*)param;
3158
3159 const XMLNode* pchild = pelement->FirstChild();
3160 while (pchild) {
3161 XmlTag tag = XmlTag(pchild->ToElement());
3162 std::string tagname(pchild->ToElement()->Name());
3163 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3164 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MODE_TAG_ID)) {
3165 int no = ParseIntArray(pchild, &calib_para_v200->measeureWindow.mode, 1);
3166 DCT_ASSERT((no == tag.Size()));
3167 }
3168 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_RESALL_TAG_ID)) {
3169 calib_para_v200->measeureWindow.resNum = 0;
3170 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
3171 &RkAiqCalibParser::parseEntrySensorAwbWindow,
3172 param,
3173 (uint32_t)CALIB_SENSOR_AWB_RESALL_TAG_ID,
3174 (uint32_t)CALIB_SENSOR_AWB_MEASUREWINDOW_TAG_ID)) {
3175 LOGE("parse error in AWB light sources (%s)", tagname.c_str());
3176 return (false);
3177 }
3178 }
3179
3180 pchild = pchild->NextSibling();
3181 }
3182 XML_CHECK_END();
3183 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3184 autoTabBackward();
3185 return (true);
3186 }
3187
parseEntrySensorAwbLimitRange(const XMLElement * pelement,void * param)3188 bool RkAiqCalibParser::parseEntrySensorAwbLimitRange
3189 (
3190 const XMLElement* pelement,
3191 void* param
3192 ) {
3193 (void)param;
3194 if(param == NULL) {
3195 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3196 }
3197 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3198 autoTabForward();
3199
3200 XML_CHECK_START(CALIB_SENSOR_AWB_LIMITRANGE_TAG_ID, CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID);
3201 CalibDb_Awb_Calib_Para_V200_t *calib_para_v200 = (CalibDb_Awb_Calib_Para_V200_t*)param;
3202
3203 const XMLNode* pchild = pelement->FirstChild();
3204 while (pchild) {
3205 XmlTag tag = XmlTag(pchild->ToElement());
3206 std::string tagname(pchild->ToElement()->Name());
3207 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3208 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_Y_TAG_ID)) {
3209 unsigned short tmpValue[2] = { calib_para_v200->limitRange.minY[0], calib_para_v200->limitRange.maxY[0] };
3210 int no = ParseUshortArray(pchild, tmpValue, tag.Size());
3211 DCT_ASSERT((no == tag.Size()));
3212 calib_para_v200->limitRange.minY[0] = tmpValue[0];
3213 calib_para_v200->limitRange.maxY[0] = tmpValue[1];
3214 }
3215 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_R_TAG_ID)) {
3216 unsigned short tmpValue[2] = { calib_para_v200->limitRange.minR[0], calib_para_v200->limitRange.maxR[0] };
3217 int no = ParseUshortArray(pchild, tmpValue, tag.Size());
3218 DCT_ASSERT((no == tag.Size()));
3219 calib_para_v200->limitRange.minR[0] = tmpValue[0];
3220 calib_para_v200->limitRange.maxR[0] = tmpValue[1];
3221 }
3222 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_G_TAG_ID)) {
3223 unsigned short tmpValue[2] = { calib_para_v200->limitRange.minG[0], calib_para_v200->limitRange.maxG[0] };
3224 int no = ParseUshortArray(pchild, tmpValue, tag.Size());
3225 DCT_ASSERT((no == tag.Size()));
3226 calib_para_v200->limitRange.minG[0] = tmpValue[0];
3227 calib_para_v200->limitRange.maxG[0] = tmpValue[1];
3228 }
3229 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_B_TAG_ID)) {
3230 unsigned short tmpValue[2] = { calib_para_v200->limitRange.minB[0], calib_para_v200->limitRange.maxB[0] };
3231 int no = ParseUshortArray(pchild, tmpValue, tag.Size());
3232 DCT_ASSERT((no == tag.Size()));
3233 calib_para_v200->limitRange.minB[0] = tmpValue[0];
3234 calib_para_v200->limitRange.maxB[0] = tmpValue[1];
3235 }
3236 else {
3237 LOGW("unknown tag %s", tagname.c_str());
3238 }
3239 pchild = pchild->NextSibling();
3240 }
3241
3242 calib_para_v200->limitRange.lumaNum = 1;
3243 calib_para_v200->limitRange.lumaValue[0] = 0;
3244 XML_CHECK_END();
3245 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3246 autoTabBackward();
3247 return (true);
3248 }
3249
parseEntrySensorAwbLimitRangeCell(const XMLElement * pelement,void * param,int index)3250 bool RkAiqCalibParser::parseEntrySensorAwbLimitRangeCell
3251 (
3252 const XMLElement* pelement,
3253 void* param,
3254 int index
3255 ) {
3256 (void)param;
3257
3258 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3259 autoTabForward();
3260
3261 XML_CHECK_START(CALIB_SENSOR_AWB_LIMITRANGE_CELL_TAG_ID, CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID);
3262 CalibDb_Awb_Calib_Para_V200_t *calib_para_v200 = (CalibDb_Awb_Calib_Para_V200_t*)param;
3263 const XMLNode* pchild = pelement->FirstChild();
3264 while (pchild) {
3265 XmlTag tag = XmlTag(pchild->ToElement());
3266 std::string tagname(pchild->ToElement()->Name());
3267 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3268 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_LV_TAG_ID)) {
3269 float tmpValue = calib_para_v200->limitRange.lumaValue[index];
3270 int no = ParseFloatArray(pchild, &tmpValue, tag.Size());
3271 DCT_ASSERT((no == tag.Size()));
3272 calib_para_v200->limitRange.lumaValue[index] = tmpValue;
3273 }
3274 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_Y_TAG_ID)) {
3275 unsigned short tmpValue[2] = { calib_para_v200->limitRange.minY[index], calib_para_v200->limitRange.maxY[index] };
3276 int no = ParseUshortArray(pchild, tmpValue, tag.Size());
3277 DCT_ASSERT((no == tag.Size()));
3278 calib_para_v200->limitRange.minY[index] = tmpValue[0];
3279 calib_para_v200->limitRange.maxY[index] = tmpValue[1];
3280 }
3281 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_R_TAG_ID)) {
3282 unsigned short tmpValue[2] = { calib_para_v200->limitRange.minR[index], calib_para_v200->limitRange.maxR[index] };
3283 int no = ParseUshortArray(pchild, tmpValue, tag.Size());
3284 DCT_ASSERT((no == tag.Size()));
3285 calib_para_v200->limitRange.minR[index] = tmpValue[0];
3286 calib_para_v200->limitRange.maxR[index] = tmpValue[1];
3287 }
3288 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_G_TAG_ID)) {
3289 unsigned short tmpValue[2] = { calib_para_v200->limitRange.minG[index], calib_para_v200->limitRange.maxG[index] };
3290 int no = ParseUshortArray(pchild, tmpValue, tag.Size());
3291 DCT_ASSERT((no == tag.Size()));
3292 calib_para_v200->limitRange.minG[index] = tmpValue[0];
3293 calib_para_v200->limitRange.maxG[index] = tmpValue[1];
3294 }
3295 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_B_TAG_ID)) {
3296 unsigned short tmpValue[2] = { calib_para_v200->limitRange.minB[index], calib_para_v200->limitRange.maxB[index] };
3297 int no = ParseUshortArray(pchild, tmpValue, tag.Size());
3298 DCT_ASSERT((no == tag.Size()));
3299 calib_para_v200->limitRange.minB[index] = tmpValue[0];
3300 calib_para_v200->limitRange.maxB[index] = tmpValue[1];
3301 }
3302 else {
3303 LOGW("unknown tag %s", tagname.c_str());
3304 }
3305 pchild = pchild->NextSibling();
3306 }
3307
3308 calib_para_v200->limitRange.lumaNum++;
3309 DCT_ASSERT(( calib_para_v200->limitRange.lumaNum <= CALD_AWB_LV_NUM_MAX));
3310 XML_CHECK_END();
3311 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3312 autoTabBackward();
3313 return (true);
3314 }
3315
parseEntrySensorAwbWindow(const XMLElement * pelement,void * param,int index)3316 bool RkAiqCalibParser::parseEntrySensorAwbWindow
3317 (
3318 const XMLElement* pelement,
3319 void* param,
3320 int index
3321 ) {
3322 if(param == NULL) {
3323 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3324 }
3325 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3326
3327 XML_CHECK_START(CALIB_SENSOR_AWB_RESALL_TAG_ID, CALIB_SENSOR_AWB_MEASUREWINDOW_TAG_ID);
3328 CalibDb_Awb_Calib_Para_V200_t *calib_para_v200 = (CalibDb_Awb_Calib_Para_V200_t*)param;
3329
3330 const XMLNode* pchild = pelement->FirstChild();
3331 while (pchild) {
3332 XmlTag tag = XmlTag(pchild->ToElement());
3333 const char* value = tag.Value();
3334 std::string tagname(pchild->ToElement()->Name());
3335 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3336 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_RESOLUTION_TAG_ID)) {
3337 ParseString(pchild, calib_para_v200->measeureWindow.resName[index],
3338 sizeof(calib_para_v200->measeureWindow.resName[index]));
3339 }
3340 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MEASUREWINDOWSIZE_TAG_ID)) {
3341 int no = ParseUshortArray(pchild, calib_para_v200->measeureWindow.window[index], tag.Size());
3342 DCT_ASSERT((no == tag.Size()));
3343 DCT_ASSERT((no <= 4));
3344 }
3345 pchild = pchild->NextSibling();
3346 }
3347 XML_CHECK_END();
3348 DCT_ASSERT((index <= CALD_AWB_RRES_NUM_MAX));
3349 calib_para_v200->measeureWindow.resNum++;
3350 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3351 return (true);
3352 }
3353
parseEntrySensorAwbwbGainAdjust(const XMLElement * pelement,void * param)3354 bool RkAiqCalibParser::parseEntrySensorAwbwbGainAdjust
3355 (
3356 const XMLElement* pelement,
3357 void* param
3358 ) {
3359 (void)param;
3360 if(param == NULL) {
3361 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3362 }
3363 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3364 autoTabForward();
3365
3366 XML_CHECK_START(CALIB_SENSOR_AWB_WBGAINADJUST_TAG_ID, CALIB_SENSOR_AWB_ADJUSTPARA_GLOBALS_TAG_ID);
3367 CalibDb_Awb_Adjust_Para_t *adjust_para = (CalibDb_Awb_Adjust_Para_t*)param;
3368
3369 const XMLNode* pchild = pelement->FirstChild();
3370 while (pchild) {
3371 XmlTag tag = XmlTag(pchild->ToElement());
3372 std::string tagname(pchild->ToElement()->Name());
3373 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3374 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CTGRID_NUM_TAG_ID)) {
3375 int no = ParseIntArray(pchild, &adjust_para->cct_lut_cfg[0].ct_grid_num, tag.Size());
3376 DCT_ASSERT((no == tag.Size()));
3377 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CTINRANGE_TAG_ID)) {
3378 int no = ParseFloatArray(pchild, adjust_para->cct_lut_cfg[0].ct_range, tag.Size());
3379 DCT_ASSERT((no == tag.Size()));
3380 DCT_ASSERT((no == 2));
3381 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CRIGRID_NUM_TAG_ID)) {
3382 int no = ParseIntArray(pchild, &adjust_para->cct_lut_cfg[0].cri_grid_num, tag.Size());
3383 DCT_ASSERT((no == tag.Size()));
3384 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CRIINRANGE_TAG_ID)) {
3385 int no = ParseFloatArray(pchild, adjust_para->cct_lut_cfg[0].cri_range, tag.Size());
3386 DCT_ASSERT((no == tag.Size()));
3387 DCT_ASSERT((no == 2));
3388 }
3389 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LUTALL_TAG_ID)) {
3390
3391 adjust_para->cct_lut_cfg_num = tag.Size();
3392 DCT_ASSERT((adjust_para->cct_lut_cfg_num <= CALD_AWB_CT_LV_NUM_MAX));
3393 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
3394 &RkAiqCalibParser::parseEntrySensorAwbCctLutAll,
3395 param,
3396 (uint32_t)CALIB_SENSOR_AWB_LUTALL_TAG_ID,
3397 (uint32_t)CALIB_SENSOR_AWB_WBGAINADJUST_TAG_ID)) {
3398 LOGE("parse error in AWB wbGainAdjust (%s)", tagname.c_str());
3399 return (false);
3400 }
3401 }
3402 pchild = pchild->NextSibling();
3403 }
3404 XML_CHECK_END();
3405 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3406 autoTabBackward();
3407 return (true);
3408 }
parseEntrySensorAwbwbGainOffset(const XMLElement * pelement,void * param)3409 bool RkAiqCalibParser::parseEntrySensorAwbwbGainOffset
3410 (
3411 const XMLElement* pelement,
3412 void* param
3413 ) {
3414 (void)param;
3415
3416 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3417 autoTabForward();
3418
3419 XML_CHECK_START(CALIB_SENSOR_AWB_WBGAINOFFSET_TAG_ID, CALIB_SENSOR_AWB_ADJUSTPARA_GLOBALS_TAG_ID);
3420 CalibDb_Awb_Adjust_Para_t *adjust_para = (CalibDb_Awb_Adjust_Para_t*)param;
3421 const XMLNode* pchild = pelement->FirstChild();
3422 while (pchild) {
3423 XmlTag tag = XmlTag(pchild->ToElement());
3424 std::string tagname(pchild->ToElement()->Name());
3425 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3426
3427 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WBGAINOFFSET_ENABLE_TAG_ID)) {
3428 unsigned char tempVal = adjust_para->wbGainOffset.enable;
3429 int no = ParseUcharArray(pchild, &tempVal, 1);
3430 DCT_ASSERT((no == tag.Size()));
3431 adjust_para->wbGainOffset.enable = (tempVal == 0 ? false : true);
3432 }
3433 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WBGAINOFFSET_OFFSET_TAG_ID)) {
3434 int no = ParseFloatArray(pchild, adjust_para->wbGainOffset.offset, tag.Size());
3435 DCT_ASSERT((no == tag.Size()));
3436 DCT_ASSERT((no == 4));
3437 }
3438 pchild = pchild->NextSibling();
3439 }
3440 XML_CHECK_END();
3441 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3442 autoTabBackward();
3443 return (true);
3444 }
3445
3446
parseEntrySensorAwbwbGainDaylightClipV200(const XMLElement * pelement,void * param)3447 bool RkAiqCalibParser::parseEntrySensorAwbwbGainDaylightClipV200
3448 (
3449 const XMLElement* pelement,
3450 void* param
3451 ) {
3452 (void)param;
3453 if(param == NULL) {
3454 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3455 }
3456 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3457 autoTabForward();
3458
3459 XML_CHECK_START(CALIB_SENSOR_AWB_WBGAINDAYLIGHTCLIP_TAG_ID, CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID);
3460 CalibDb_Awb_Cct_Clip_Cfg_t *cct_clip_cfg = (CalibDb_Awb_Cct_Clip_Cfg_t *)param;
3461 const XMLNode* psubchild = pelement->FirstChild();
3462 autoTabForward();
3463 while (psubchild) {
3464 XmlTag subTag = XmlTag(psubchild->ToElement());
3465 std::string subTagname(psubchild->ToElement()->Name());
3466 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
3467
3468 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_OUTDOORCCTMIN_TAG_ID)) {
3469 int no = ParseFloatArray(psubchild, &cct_clip_cfg->outdoor_cct_min, subTag.Size());
3470 DCT_ASSERT((no == subTag.Size()));
3471 }
3472 psubchild = psubchild->NextSibling();
3473 }
3474 autoTabBackward();
3475
3476
3477 XML_CHECK_END();
3478 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3479 autoTabBackward();
3480 return (true);
3481 }
3482
parseEntrySensorAwbwbGainClipV200(const XMLElement * pelement,void * param)3483 bool RkAiqCalibParser::parseEntrySensorAwbwbGainClipV200
3484 (
3485 const XMLElement* pelement,
3486 void* param
3487 ) {
3488 (void)param;
3489 if(param == NULL) {
3490 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3491 }
3492 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3493 autoTabForward();
3494
3495 XML_CHECK_START(CALIB_SENSOR_AWB_WBGAINCLIP_TAG_ID, CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID);
3496 CalibDb_Awb_Cct_Clip_Cfg_t *cct_clip_cfg = (CalibDb_Awb_Cct_Clip_Cfg_t *)param;
3497
3498 const XMLNode* psubchild = pelement->FirstChild();
3499 autoTabForward();
3500 int cct_num = 0;
3501 int cri_bound_up_num = 0;
3502 int cri_bound_low_num = 0;
3503 while (psubchild) {
3504 XmlTag subTag = XmlTag(psubchild->ToElement());
3505 std::string subTagname(psubchild->ToElement()->Name());
3506 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
3507
3508 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CCT_TAG_ID)) {
3509 int no = ParseFloatArray(psubchild, cct_clip_cfg->cct, subTag.Size());
3510 DCT_ASSERT((no == subTag.Size()));
3511 cct_num = no;
3512 }
3513 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CRIBOUNDUP_TAG_ID)) {
3514 int no = ParseFloatArray(psubchild, cct_clip_cfg->cri_bound_up, subTag.Size());
3515 DCT_ASSERT((no == subTag.Size()));
3516 cri_bound_up_num = no;
3517 }
3518 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CRIBOUNDLOW_TAG_ID)) {
3519 int no = ParseFloatArray(psubchild, cct_clip_cfg->cri_bound_low, subTag.Size());
3520 DCT_ASSERT((no == subTag.Size()));
3521 cri_bound_low_num = no;
3522 }
3523 psubchild = psubchild->NextSibling();
3524 }
3525 if((cct_num != cri_bound_up_num) || (cct_num != cri_bound_low_num)) {
3526 LOGE("para error in AWB section tag:%s number of cct should be equal to cri_bound_up and cri_bound_low",
3527 pelement->Name());
3528 return ( false );
3529 }
3530 cct_clip_cfg->grid_num = cct_num;
3531 autoTabBackward();
3532
3533 XML_CHECK_END();
3534 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3535 autoTabBackward();
3536 return (true);
3537 }
3538
parseEntrySensorAwbwbGainDaylightClipV201(const XMLElement * pelement,void * param)3539 bool RkAiqCalibParser::parseEntrySensorAwbwbGainDaylightClipV201
3540 (
3541 const XMLElement* pelement,
3542 void* param
3543 ) {
3544 (void)param;
3545 if(param == NULL) {
3546 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3547 }
3548 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3549 autoTabForward();
3550
3551 XML_CHECK_START(CALIB_SENSOR_AWB_WBGAINDAYLIGHTCLIP_TAG_ID, CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID);
3552 CalibDb_Awb_Cct_Clip_Cfg_t *cct_clip_cfg = (CalibDb_Awb_Cct_Clip_Cfg_t *)param;
3553 const XMLNode* psubchild = pelement->FirstChild();
3554 autoTabForward();
3555 while (psubchild) {
3556 XmlTag subTag = XmlTag(psubchild->ToElement());
3557 std::string subTagname(psubchild->ToElement()->Name());
3558 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
3559
3560 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_OUTDOORCCTMIN_TAG_ID)) {
3561 int no = ParseFloatArray(psubchild, &cct_clip_cfg->outdoor_cct_min, subTag.Size());
3562 DCT_ASSERT((no == subTag.Size()));
3563 }
3564 psubchild = psubchild->NextSibling();
3565 }
3566 autoTabBackward();
3567
3568
3569 XML_CHECK_END();
3570 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3571 autoTabBackward();
3572 return (true);
3573 }
3574
parseEntrySensorAwbwbGainClipV201(const XMLElement * pelement,void * param)3575 bool RkAiqCalibParser::parseEntrySensorAwbwbGainClipV201
3576 (
3577 const XMLElement* pelement,
3578 void* param
3579 ) {
3580 (void)param;
3581 if(param == NULL) {
3582 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3583 }
3584 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3585 autoTabForward();
3586
3587 XML_CHECK_START(CALIB_SENSOR_AWB_WBGAINCLIP_TAG_ID, CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID);
3588 CalibDb_Awb_Cct_Clip_Cfg_t *cct_clip_cfg = (CalibDb_Awb_Cct_Clip_Cfg_t *)param;
3589
3590 const XMLNode* psubchild = pelement->FirstChild();
3591 autoTabForward();
3592 int cct_num = 0;
3593 int cri_bound_up_num = 0;
3594 int cri_bound_low_num = 0;
3595 while (psubchild) {
3596 XmlTag subTag = XmlTag(psubchild->ToElement());
3597 std::string subTagname(psubchild->ToElement()->Name());
3598 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
3599
3600 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CCT_TAG_ID)) {
3601 int no = ParseFloatArray(psubchild, cct_clip_cfg->cct, subTag.Size());
3602 DCT_ASSERT((no == subTag.Size()));
3603 cct_num = no;
3604 }
3605 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CRIBOUNDUP_TAG_ID)) {
3606 int no = ParseFloatArray(psubchild, cct_clip_cfg->cri_bound_up, subTag.Size());
3607 DCT_ASSERT((no == subTag.Size()));
3608 cri_bound_up_num = no;
3609 }
3610 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CRIBOUNDLOW_TAG_ID)) {
3611 int no = ParseFloatArray(psubchild, cct_clip_cfg->cri_bound_low, subTag.Size());
3612 DCT_ASSERT((no == subTag.Size()));
3613 cri_bound_low_num = no;
3614 }
3615 psubchild = psubchild->NextSibling();
3616 }
3617 if((cct_num != cri_bound_up_num) || (cct_num != cri_bound_low_num)) {
3618 LOGE("para error in AWB section tag:%s number of cct should be equal to cri_bound_up and cri_bound_low",
3619 pelement->Name());
3620 return ( false );
3621 }
3622 cct_clip_cfg->grid_num = cct_num;
3623 autoTabBackward();
3624
3625 XML_CHECK_END();
3626 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3627 autoTabBackward();
3628 return (true);
3629 }
3630
3631
parseEntrySensorAwbCctLutAll(const XMLElement * pelement,void * param,int index)3632 bool RkAiqCalibParser::parseEntrySensorAwbCctLutAll
3633 (
3634 const XMLElement* pelement,
3635 void* param,
3636 int index
3637 ) {
3638 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3639
3640 XML_CHECK_START(CALIB_SENSOR_AWB_LUTALL_TAG_ID, CALIB_SENSOR_AWB_WBGAINADJUST_TAG_ID);
3641 CalibDb_Awb_Adjust_Para_t *adjust_para = (CalibDb_Awb_Adjust_Para_t*)param;
3642 const XMLNode* pchild = pelement->FirstChild();
3643 while (pchild) {
3644 XmlTag tag = XmlTag(pchild->ToElement());
3645 const char* value = tag.Value();
3646 std::string tagname(pchild->ToElement()->Name());
3647 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3648 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LVVALUE_TAG_ID)) {
3649 int no = ParseFloatArray(pchild, &adjust_para->cct_lut_cfg[index].lv, tag.Size());
3650 DCT_ASSERT((no == tag.Size()));
3651 }
3652 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CTOUT_TAG_ID)) {
3653 int no = ParseFloatArray(pchild, adjust_para->cct_lut_cfg[index].ct_lut_out, tag.Size(), 6);
3654 DCT_ASSERT((no == tag.Size()));
3655 }
3656 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CRIOUT_TAG_ID)) {
3657 int no = ParseFloatArray(pchild, adjust_para->cct_lut_cfg[index].cri_lut_out, tag.Size(), 6);
3658 DCT_ASSERT((no == tag.Size()));
3659 }
3660 pchild = pchild->NextSibling();
3661 }
3662 XML_CHECK_END();
3663 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3664 return (true);
3665 }
3666
parseEntrySensorAwbSingleColorV200(const XMLElement * pelement,void * param)3667 bool RkAiqCalibParser::parseEntrySensorAwbSingleColorV200
3668 (
3669 const XMLElement* pelement,
3670 void* param
3671 ) {
3672 (void)param;
3673 if(param == NULL) {
3674 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3675 }
3676 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3677 autoTabForward();
3678 XML_CHECK_START(CALIB_SENSOR_AWB_SINGLECOLORPROCESS_TAG_ID, CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID);
3679 CalibDb_Awb_Calib_Para_V200_t *calib_para_v200 = (CalibDb_Awb_Calib_Para_V200_t*)param;
3680
3681 const XMLNode* pchild = pelement->FirstChild();
3682 while (pchild) {
3683 XmlTag tag = XmlTag(pchild->ToElement());
3684 std::string tagname(pchild->ToElement()->Name());
3685 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3686 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_COLORBLOCK_TAG_ID)) {
3687 calib_para_v200->sSelColorNUM = 0;
3688 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
3689 &RkAiqCalibParser::parseEntrySensorAwbColBlkV200,
3690 param,
3691 (uint32_t)CALIB_SENSOR_AWB_COLORBLOCK_TAG_ID,
3692 (uint32_t)CALIB_SENSOR_AWB_SINGLECOLORPROCESS_TAG_ID)) {
3693 LOGE("parse error in AWB light sources (%s)", tagname.c_str());
3694 return (false);
3695 }
3696 }
3697 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCEUSEDFORESTIMIATION_TAG_ID)) {
3698 calib_para_v200->sIllEstNum = 0;
3699 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
3700 &RkAiqCalibParser::parseEntrySensorAwbLsForEstimationV200,
3701 param,
3702 (uint32_t)CALIB_SENSOR_AWB_LIGHTSOURCEUSEDFORESTIMIATION_TAG_ID,
3703 (uint32_t)CALIB_SENSOR_AWB_SINGLECOLORPROCESS_TAG_ID)) {
3704 LOGE("parse error in AWB light sources (%s)", tagname.c_str());
3705 return (false);
3706 }
3707 }
3708 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_ALPHA_TAG_ID)) {
3709 int no = ParseFloatArray(pchild, &calib_para_v200->sAlpha, 1);
3710 DCT_ASSERT((no == tag.Size()));
3711 }
3712
3713 pchild = pchild->NextSibling();
3714 }
3715 XML_CHECK_END();
3716 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3717 autoTabBackward();
3718 return (true);
3719 }
parseEntrySensorAwbColBlkV200(const XMLElement * pelement,void * param,int index)3720 bool RkAiqCalibParser::parseEntrySensorAwbColBlkV200
3721 (
3722 const XMLElement* pelement,
3723 void* param,
3724 int index
3725 ) {
3726 if(param == NULL) {
3727 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3728 }
3729 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3730
3731 XML_CHECK_START(CALIB_SENSOR_AWB_COLORBLOCK_TAG_ID, CALIB_SENSOR_AWB_SINGLECOLORPROCESS_TAG_ID);
3732 CalibDb_Awb_Calib_Para_V200_t *calib_para_v200 = (CalibDb_Awb_Calib_Para_V200_t*)param;
3733
3734 const XMLNode* pchild = pelement->FirstChild();
3735 while (pchild) {
3736 XmlTag tag = XmlTag(pchild->ToElement());
3737 const char* value = tag.Value();
3738 std::string tagname(pchild->ToElement()->Name());
3739 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3740 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_INDEX_TAG_ID)) {
3741 int no = ParseUshortArray(pchild, &calib_para_v200->sIndSelColor[index], tag.Size());
3742 DCT_ASSERT((no == tag.Size()));
3743 }
3744 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MEANC_TAG_ID)) {
3745 int no = ParseFloatArray(pchild, &calib_para_v200->sMeanCh[0][index], tag.Size(), 6);
3746 DCT_ASSERT((no == tag.Size()));
3747 }
3748 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MEANH_TAG_ID)) {
3749 int no = ParseFloatArray(pchild, &calib_para_v200->sMeanCh[1][index], tag.Size(), 6);
3750 DCT_ASSERT((no == tag.Size()));
3751 }
3752 pchild = pchild->NextSibling();
3753 }
3754 XML_CHECK_END();
3755 DCT_ASSERT((index <= CALD_AWB_SGC_NUM_MAX));
3756 calib_para_v200->sSelColorNUM++;
3757 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3758 return (true);
3759 }
parseEntrySensorAwbLsForEstimationV200(const XMLElement * pelement,void * param,int index)3760 bool RkAiqCalibParser::parseEntrySensorAwbLsForEstimationV200
3761 (
3762 const XMLElement* pelement,
3763 void* param,
3764 int index
3765 ) {
3766 if(param == NULL) {
3767 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3768 }
3769 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3770 XML_CHECK_START(CALIB_SENSOR_AWB_LIGHTSOURCEUSEDFORESTIMIATION_TAG_ID, CALIB_SENSOR_AWB_SINGLECOLORPROCESS_TAG_ID);
3771 CalibDb_Awb_Calib_Para_V200_t *calib_para_v200 = (CalibDb_Awb_Calib_Para_V200_t*)param;
3772
3773 const XMLNode* pchild = pelement->FirstChild();
3774 while (pchild) {
3775 XmlTag tag = XmlTag(pchild->ToElement());
3776 const char* value = tag.Value();
3777 std::string tagname(pchild->ToElement()->Name());
3778 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3779 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LSUSEDFORESTIMIATION_NAME_TAG_ID)) {
3780 ParseString(pchild, calib_para_v200->sNameIllEst[index],
3781 sizeof(calib_para_v200->sNameIllEst[index]));
3782 }
3783 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_RGAIN_TAG_ID)) {
3784 int no = ParseFloatArray(pchild, &calib_para_v200->srGain[index], tag.Size(), 6);
3785 DCT_ASSERT((no == tag.Size()));
3786 }
3787 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_BGAIN_TAG_ID)) {
3788 int no = ParseFloatArray(pchild, &calib_para_v200->sbGain[index], tag.Size(), 6);
3789 DCT_ASSERT((no == tag.Size()));
3790 }
3791 pchild = pchild->NextSibling();
3792 }
3793 XML_CHECK_END();
3794 DCT_ASSERT((index <= CALD_AWB_LS_NUM_MAX));
3795 calib_para_v200->sIllEstNum++;
3796 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3797 return (true);
3798 }
3799
parseEntrySensorAwbSingleColorV201(const XMLElement * pelement,void * param)3800 bool RkAiqCalibParser::parseEntrySensorAwbSingleColorV201
3801 (
3802 const XMLElement* pelement,
3803 void* param
3804 ) {
3805 (void)param;
3806 if(param == NULL) {
3807 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3808 }
3809 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3810 autoTabForward();
3811 XML_CHECK_START(CALIB_SENSOR_AWB_SINGLECOLORPROCESS_TAG_ID, CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID);
3812 CalibDb_Awb_Calib_Para_V201_t *calib_para_V201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
3813
3814 const XMLNode* pchild = pelement->FirstChild();
3815 while (pchild) {
3816 XmlTag tag = XmlTag(pchild->ToElement());
3817 std::string tagname(pchild->ToElement()->Name());
3818 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3819 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_COLORBLOCK_TAG_ID)) {
3820 calib_para_V201->sSelColorNUM = 0;
3821 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
3822 &RkAiqCalibParser::parseEntrySensorAwbColBlkV201,
3823 param,
3824 (uint32_t)CALIB_SENSOR_AWB_COLORBLOCK_TAG_ID,
3825 (uint32_t)CALIB_SENSOR_AWB_SINGLECOLORPROCESS_TAG_ID)) {
3826 LOGE("parse error in AWB light sources (%s)", tagname.c_str());
3827 return (false);
3828 }
3829 }
3830 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCEUSEDFORESTIMIATION_TAG_ID)) {
3831 calib_para_V201->sIllEstNum = 0;
3832 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
3833 &RkAiqCalibParser::parseEntrySensorAwbLsForEstimationV201,
3834 param,
3835 (uint32_t)CALIB_SENSOR_AWB_LIGHTSOURCEUSEDFORESTIMIATION_TAG_ID,
3836 (uint32_t)CALIB_SENSOR_AWB_SINGLECOLORPROCESS_TAG_ID)) {
3837 LOGE("parse error in AWB light sources (%s)", tagname.c_str());
3838 return (false);
3839 }
3840 }
3841 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_ALPHA_TAG_ID)) {
3842 int no = ParseFloatArray(pchild, &calib_para_V201->sAlpha, 1);
3843 DCT_ASSERT((no == tag.Size()));
3844 }
3845
3846 pchild = pchild->NextSibling();
3847 }
3848 XML_CHECK_END();
3849 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3850 autoTabBackward();
3851 return (true);
3852 }
parseEntrySensorAwbColBlkV201(const XMLElement * pelement,void * param,int index)3853 bool RkAiqCalibParser::parseEntrySensorAwbColBlkV201
3854 (
3855 const XMLElement* pelement,
3856 void* param,
3857 int index
3858 ) {
3859 if(param == NULL) {
3860 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3861 }
3862 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3863
3864 XML_CHECK_START(CALIB_SENSOR_AWB_COLORBLOCK_TAG_ID, CALIB_SENSOR_AWB_SINGLECOLORPROCESS_TAG_ID);
3865 CalibDb_Awb_Calib_Para_V201_t *calib_para_V201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
3866
3867 const XMLNode* pchild = pelement->FirstChild();
3868 while (pchild) {
3869 XmlTag tag = XmlTag(pchild->ToElement());
3870 const char* value = tag.Value();
3871 std::string tagname(pchild->ToElement()->Name());
3872 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3873 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_INDEX_TAG_ID)) {
3874 int no = ParseUshortArray(pchild, &calib_para_V201->sIndSelColor[index], tag.Size());
3875 DCT_ASSERT((no == tag.Size()));
3876 }
3877 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MEANC_TAG_ID)) {
3878 int no = ParseFloatArray(pchild, &calib_para_V201->sMeanCh[0][index], tag.Size(), 6);
3879 DCT_ASSERT((no == tag.Size()));
3880 }
3881 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MEANH_TAG_ID)) {
3882 int no = ParseFloatArray(pchild, &calib_para_V201->sMeanCh[1][index], tag.Size(), 6);
3883 DCT_ASSERT((no == tag.Size()));
3884 }
3885 pchild = pchild->NextSibling();
3886 }
3887 XML_CHECK_END();
3888 DCT_ASSERT((index <= CALD_AWB_SGC_NUM_MAX));
3889 calib_para_V201->sSelColorNUM++;
3890 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3891 return (true);
3892 }
parseEntrySensorAwbLsForEstimationV201(const XMLElement * pelement,void * param,int index)3893 bool RkAiqCalibParser::parseEntrySensorAwbLsForEstimationV201
3894 (
3895 const XMLElement* pelement,
3896 void* param,
3897 int index
3898 ) {
3899 if(param == NULL) {
3900 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3901 }
3902 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3903 XML_CHECK_START(CALIB_SENSOR_AWB_LIGHTSOURCEUSEDFORESTIMIATION_TAG_ID, CALIB_SENSOR_AWB_SINGLECOLORPROCESS_TAG_ID);
3904 CalibDb_Awb_Calib_Para_V201_t *calib_para_V201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
3905
3906 const XMLNode* pchild = pelement->FirstChild();
3907 while (pchild) {
3908 XmlTag tag = XmlTag(pchild->ToElement());
3909 const char* value = tag.Value();
3910 std::string tagname(pchild->ToElement()->Name());
3911 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
3912 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LSUSEDFORESTIMIATION_NAME_TAG_ID)) {
3913 ParseString(pchild, calib_para_V201->sNameIllEst[index],
3914 sizeof(calib_para_V201->sNameIllEst[index]));
3915 }
3916 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_RGAIN_TAG_ID)) {
3917 int no = ParseFloatArray(pchild, &calib_para_V201->srGain[index], tag.Size(), 6);
3918 DCT_ASSERT((no == tag.Size()));
3919 }
3920 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_BGAIN_TAG_ID)) {
3921 int no = ParseFloatArray(pchild, &calib_para_V201->sbGain[index], tag.Size(), 6);
3922 DCT_ASSERT((no == tag.Size()));
3923 }
3924 pchild = pchild->NextSibling();
3925 }
3926 XML_CHECK_END();
3927 DCT_ASSERT((index <= CALD_AWB_LS_NUM_MAX));
3928 calib_para_V201->sIllEstNum++;
3929 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3930 return (true);
3931 }
3932
3933
parseEntrySensorAwbGlobalsExclude(const XMLElement * pelement,void * param,int index)3934 bool RkAiqCalibParser::parseEntrySensorAwbGlobalsExclude
3935 (
3936 const XMLElement* pelement,
3937 void* param,
3938 int index
3939 ) {
3940 if(param == NULL) {
3941 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3942 }
3943 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3944
3945 XML_CHECK_START(CALIB_SENSOR_AWB_EXCLUDERANGE_TAG_ID, CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID);
3946 CalibDb_Awb_Calib_Para_V200_t *calib_para_v200 = (CalibDb_Awb_Calib_Para_V200_t*)param;
3947
3948 const XMLNode* pchild = pelement->FirstChild();
3949 while (pchild) {
3950 XmlTag tag = XmlTag(pchild->ToElement());
3951 std::string Tagname(pchild->ToElement()->Name());
3952 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
3953
3954 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_EXCLUDERANGE_DOMAIN_TAG_ID)) {
3955 int no = ParseUcharArray(pchild, &calib_para_v200->excludeWpRange[index].domain, tag.Size());
3956 DCT_ASSERT((no == tag.Size()));
3957 }
3958 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_EXCLUDE_MODE_TAG_ID)) {
3959 int no = ParseUcharArray(pchild, &calib_para_v200->excludeWpRange[index].mode, tag.Size());
3960 DCT_ASSERT((no == tag.Size()));
3961 }
3962 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_EXCLUDE_WINDOW_TAG_ID)) {
3963 int xuyv[4] = { calib_para_v200->excludeWpRange[index].xu[0],
3964 calib_para_v200->excludeWpRange[index].xu[1],
3965 calib_para_v200->excludeWpRange[index].yv[0],
3966 calib_para_v200->excludeWpRange[index].yv[1]
3967 };
3968 int no = ParseIntArray(pchild, xuyv, tag.Size());
3969 DCT_ASSERT((no == tag.Size()));
3970 calib_para_v200->excludeWpRange[index].xu[0] = xuyv[0];
3971 calib_para_v200->excludeWpRange[index].xu[1] = xuyv[1];
3972 calib_para_v200->excludeWpRange[index].yv[0] = xuyv[2];
3973 calib_para_v200->excludeWpRange[index].yv[1] = xuyv[3];
3974
3975 }
3976 pchild = pchild->NextSibling();
3977 }
3978 XML_CHECK_END();
3979
3980 DCT_ASSERT((index <= CALD_AWB_EXCRANGE_NUM_MAX));
3981 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
3982 return (true);
3983 }
3984
parseEntrySensorAwbLightXYRegion(const XMLElement * pelement,void * param)3985 bool RkAiqCalibParser::parseEntrySensorAwbLightXYRegion
3986 (
3987 const XMLElement* pelement,
3988 void* param
3989 ) {
3990 if(param == NULL) {
3991 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3992 }
3993 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
3994
3995 XML_CHECK_START(CALIB_SENSOR_AWB_LIGHTSOURCES_LIGHTXYREGION_TAG_ID,
3996 CALIB_SENSOR_AWB_V200_LIGHTSOURCES_TAG_ID);
3997 CalibDb_tcs_range_ill_t *xyRangeLight = (CalibDb_tcs_range_ill_t *)param;
3998
3999 const XMLNode* pchild = pelement->FirstChild();
4000 autoTabForward();
4001 while (pchild) {
4002 XmlTag Tag = XmlTag(pchild->ToElement());
4003 std::string Tagname(pchild->ToElement()->Name());
4004 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), Tag.Type(), Tag.Size());
4005
4006 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_NORMAL_TAG_ID)) {
4007 float tempVal[4] = {xyRangeLight->NorrangeX[0],
4008 xyRangeLight->NorrangeX[1],
4009 xyRangeLight->NorrangeY[0],
4010 xyRangeLight->NorrangeY[1]
4011 };
4012 int no = ParseFloatArray(pchild, tempVal, Tag.Size());
4013 DCT_ASSERT((no == Tag.Size()));
4014 xyRangeLight->NorrangeX[0] = tempVal[0];
4015 xyRangeLight->NorrangeX[1] = tempVal[1];
4016 xyRangeLight->NorrangeY[0] = tempVal[2];
4017 xyRangeLight->NorrangeY[1] = tempVal[3];
4018 }
4019 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_BIG_TAG_ID)) {
4020 float tempVal[4] = { xyRangeLight->SperangeX[0],
4021 xyRangeLight->SperangeX[1],
4022 xyRangeLight->SperangeY[0],
4023 xyRangeLight->SperangeY[1]
4024 };
4025 int no = ParseFloatArray(pchild, tempVal, Tag.Size());
4026 DCT_ASSERT((no == Tag.Size()));
4027 xyRangeLight->SperangeX[0] = tempVal[0];
4028 xyRangeLight->SperangeX[1] = tempVal[1];
4029 xyRangeLight->SperangeY[0] = tempVal[2];
4030 xyRangeLight->SperangeY[1] = tempVal[3];
4031
4032 }
4033 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_SMALL_TAG_ID)) {
4034 float tempVal[4] = { xyRangeLight->SmalrangeX[0],
4035 xyRangeLight->SmalrangeX[1],
4036 xyRangeLight->SmalrangeY[0],
4037 xyRangeLight->SmalrangeY[1]
4038 };
4039 int no = ParseFloatArray(pchild, tempVal, Tag.Size());
4040 DCT_ASSERT((no == Tag.Size()));
4041 xyRangeLight->SmalrangeX[0] = tempVal[0];
4042 xyRangeLight->SmalrangeX[1] = tempVal[1];
4043 xyRangeLight->SmalrangeY[0] = tempVal[2];
4044 xyRangeLight->SmalrangeY[1] = tempVal[3];
4045 }
4046 pchild = pchild->NextSibling();
4047 }
4048 autoTabBackward();
4049
4050
4051 XML_CHECK_END();
4052
4053 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
4054 return (true);
4055
4056 }
4057
parseEntrySensorAwbLightYUVRegion(const XMLElement * pelement,void * param)4058 bool RkAiqCalibParser::parseEntrySensorAwbLightYUVRegion
4059 (
4060 const XMLElement* pelement,
4061 void* param
4062 ) {
4063 if(param == NULL) {
4064 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4065 }
4066 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4067
4068 XML_CHECK_START(CALIB_SENSOR_AWB_LIGHTSOURCES_YUVREGION_TAG_ID,
4069 CALIB_SENSOR_AWB_V200_LIGHTSOURCES_TAG_ID);
4070 CalibDb_Yuv3D_Range_Ill_t *yuv3DRange_param = ( CalibDb_Yuv3D_Range_Ill_t *)param;
4071
4072 const XMLNode* psubchild = pelement->FirstChild();
4073
4074 autoTabForward();
4075
4076 while (psubchild) {
4077 XmlTag subTag = XmlTag(psubchild->ToElement());
4078 std::string subTagname(psubchild->ToElement()->Name());
4079 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
4080
4081 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_K2SET_TAG_ID)) {
4082 int no = ParseIntArray(psubchild, &yuv3DRange_param->slope_inv_neg_uv, subTag.Size());
4083 DCT_ASSERT((no == subTag.Size()));
4084 }
4085 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_B0SET_TAG_ID)) {
4086 int no = ParseIntArray(psubchild, &yuv3DRange_param->b_uv, subTag.Size());
4087 DCT_ASSERT((no == subTag.Size()));
4088 }
4089 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_K3SET_TAG_ID)) {
4090 int no = ParseIntArray(psubchild, &yuv3DRange_param->slope_factor_uv, subTag.Size());
4091 DCT_ASSERT((no == subTag.Size()));
4092 }
4093 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_K_YDISSET_TAG_ID)) {
4094 int no = ParseIntArray(psubchild, &yuv3DRange_param->slope_ydis, subTag.Size());
4095 DCT_ASSERT((no == subTag.Size()));
4096 }
4097 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_B_YDISSET_TAG_ID)) {
4098 int no = ParseIntArray(psubchild, &yuv3DRange_param->b_ydis, subTag.Size());
4099 DCT_ASSERT((no == subTag.Size()));
4100 }
4101 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_UREFSET_TAG_ID)) {
4102 int no = ParseUcharArray(psubchild, &yuv3DRange_param->ref_u, subTag.Size());
4103 DCT_ASSERT((no == subTag.Size()));
4104 }
4105 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_VREFSET_TAG_ID)) {
4106 int no = ParseUcharArray(psubchild, &yuv3DRange_param->ref_v, subTag.Size());
4107 DCT_ASSERT((no == subTag.Size()));
4108 }
4109 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_DISSET_TAG_ID)) {
4110 int no = ParseUshortArray(psubchild, yuv3DRange_param->dis, subTag.Size());
4111 DCT_ASSERT((no == subTag.Size()));
4112 }
4113 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_THSET_TAG_ID)) {
4114 int no = ParseUcharArray(psubchild, yuv3DRange_param->th, subTag.Size());
4115 DCT_ASSERT((no == subTag.Size()));
4116
4117 }
4118 psubchild = psubchild->NextSibling();
4119 }
4120 autoTabBackward();
4121
4122 XML_CHECK_END();
4123
4124 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
4125 return (true);
4126
4127 }
4128
parseEntrySensorAwbMeasureLightSourcesV200(const XMLElement * pelement,void * param,int index)4129 bool RkAiqCalibParser::parseEntrySensorAwbMeasureLightSourcesV200
4130 (
4131 const XMLElement* pelement,
4132 void* param,
4133 int index
4134 ) {
4135 if(param == NULL) {
4136 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4137 }
4138 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4139
4140 XML_CHECK_START(CALIB_SENSOR_AWB_V200_LIGHTSOURCES_TAG_ID, CALIB_SENSOR_AWB_V200_TAG_ID);
4141
4142 CalibDb_Awb_Calib_Para_V200_t *calib_para_v200 = (CalibDb_Awb_Calib_Para_V200_t*)param;
4143 const XMLNode* pchild = pelement->FirstChild();
4144 while (pchild) {
4145 XmlTag tag = XmlTag(pchild->ToElement());
4146 const char* value = tag.Value();
4147 std::string tagname(pchild->ToElement()->Name());
4148 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
4149
4150 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_NAME_TAG_ID)) {
4151 ParseString(pchild, calib_para_v200->lightName[index],
4152 sizeof(calib_para_v200->lightName[index]));
4153 }
4154 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_DOORTYPE_TAG_ID)) {
4155 int no = ParseUcharArray(pchild, &calib_para_v200->doorType[index], tag.Size());
4156 DCT_ASSERT((no == tag.Size()));
4157 }
4158 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_STANDARDGAINVALUE_TAG_ID)) {
4159 int no = ParseFloatArray(pchild, calib_para_v200->standardGainValue[index], tag.Size());
4160 DCT_ASSERT((no == tag.Size()));
4161 }
4162 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_LIGHTUREGION_TAG_ID)) {
4163 int no = ParseFloatArray(pchild, calib_para_v200->uvRange_param[index].pu_region, tag.Size());
4164 DCT_ASSERT((no == tag.Size()));
4165
4166 }
4167 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_LIGHTVREGION_TAG_ID)) {
4168 int no = ParseFloatArray(pchild, calib_para_v200->uvRange_param[index].pv_region, tag.Size());
4169 DCT_ASSERT((no == tag.Size()));
4170 }
4171 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_SMALLUREGION_TAG_ID)) {
4172 int no = ParseFloatArray(pchild, calib_para_v200->uvRange_param_small[index].pu_region, tag.Size());
4173 DCT_ASSERT((no == tag.Size()));
4174 }
4175 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_SMALLVREGION_TAG_ID)) {
4176 int no = ParseFloatArray(pchild, calib_para_v200->uvRange_param_small[index].pv_region, tag.Size());
4177 DCT_ASSERT((no == tag.Size()));
4178 }
4179 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_LIGHTXYREGION_TAG_ID)) {
4180 if (!parseEntrySensorAwbLightXYRegion(pchild->ToElement(), &calib_para_v200->xyRangeLight[index])) {
4181 LOGE("parse error in AWB LightSources (%s)", tagname.c_str());
4182 return (false);
4183 }
4184 }
4185 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_YUVREGION_TAG_ID)) {
4186 if (!parseEntrySensorAwbLightYUVRegion(pchild->ToElement(), &calib_para_v200->yuv3DRange_param[index])) {
4187 LOGE("parse error in AWB LightSources (%s)", tagname.c_str());
4188 return (false);
4189 }
4190 }
4191 else {
4192 LOGW("UNKNOWN tag: %s", tagname.c_str());
4193 }
4194
4195 pchild = pchild->NextSibling();
4196 }
4197 XML_CHECK_END();
4198 DCT_ASSERT((index <= CALD_AWB_LS_NUM_MAX));
4199 calib_para_v200->lightNum++;
4200 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
4201 return (true);
4202 }
parseEntrySensorAwbStrategyLightSources(const XMLElement * pelement,void * param,int index)4203 bool RkAiqCalibParser::parseEntrySensorAwbStrategyLightSources
4204 (
4205 const XMLElement* pelement,
4206 void* param,
4207 int index
4208 ) {
4209 if(param == NULL) {
4210 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4211 }
4212 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4213 XML_CHECK_START(CALIB_SENSOR_AWB_ADJUSTPARA_LIGHTSOURCES_TAG_ID, CALIB_SENSOR_AWB_ADJUSTPARA_TAG_ID);
4214 CalibDb_Awb_Adjust_Para_t *adjust_para = (CalibDb_Awb_Adjust_Para_t*)param;
4215
4216 const XMLNode* pchild = pelement->FirstChild();
4217 while (pchild) {
4218 XmlTag tag = XmlTag(pchild->ToElement());
4219 const char* value = tag.Value();
4220 std::string tagname(pchild->ToElement()->Name());
4221 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
4222
4223 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_NAME_TAG_ID)) {
4224 ParseString(pchild, adjust_para->awb_light_info[index].light_name,
4225 sizeof(adjust_para->awb_light_info[index].light_name));
4226 }
4227 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_STAWEIGTHSET_TAG_ID)) {
4228 int no = ParseUcharArray(pchild, adjust_para->awb_light_info[index].staWeight, tag.Size());
4229 DCT_ASSERT((no == tag.Size()));
4230 }
4231 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_SPATIALGAIN_LV_THSET_TAG_ID)) {
4232 unsigned int tempVal[2] = { adjust_para->awb_light_info[index].spatialGain_LV_THL, adjust_para->awb_light_info[index].spatialGain_LV_THH};
4233 int no = ParseUintArray(pchild, tempVal, tag.Size());
4234 DCT_ASSERT((no == tag.Size()));
4235 adjust_para->awb_light_info[index].spatialGain_LV_THL = tempVal[0];
4236 adjust_para->awb_light_info[index].spatialGain_LV_THH = tempVal[1];
4237 }
4238 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_XYTYPE2ENABLE_TAG_ID)) {
4239 int no = ParseUcharArray(pchild, &adjust_para->awb_light_info[index].xyType2Enable, tag.Size());
4240 DCT_ASSERT((no == tag.Size()));
4241 }
4242 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_WEIGHTCURVE_RATIO_TAG_ID)) {
4243 int no = ParseFloatArray(pchild, adjust_para->awb_light_info[index].weightCurve_ratio, tag.Size());
4244 DCT_ASSERT((no == tag.Size()));
4245 }
4246 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_WEIGHTCURVE_WEIGHT_TAG_ID)) {
4247 int no = ParseFloatArray(pchild, adjust_para->awb_light_info[index].weightCurve_weight, tag.Size());
4248 DCT_ASSERT((no == tag.Size()));
4249 }
4250 else {
4251 LOGW("UNKNOWN tag: %s", tagname.c_str());
4252 }
4253
4254 pchild = pchild->NextSibling();
4255 }
4256 XML_CHECK_END();
4257 DCT_ASSERT((index <= CALD_AWB_LS_NUM_MAX));
4258 adjust_para->lightNum++;
4259 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
4260 return (true);
4261 }
4262
parseEntrySensorAwbCalibParaV201(const XMLElement * pelement,void * param,int index)4263 bool RkAiqCalibParser::parseEntrySensorAwbCalibParaV201
4264 (
4265 const XMLElement* pelement,
4266 void* param,
4267 int index
4268 ) {
4269 (void)param;
4270
4271 if(param == NULL) {
4272 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4273 }
4274 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4275 autoTabForward();
4276
4277 XML_CHECK_START(CALIB_SENSOR_AWB_V201_TAG_ID, CALIB_SENSOR_AWB_TAG_ID);
4278 list_head* calib_para_v201_list = (list_head* )param;
4279 CalibDb_Awb_Calib_Para_V201_t calib_para_v201;
4280 memset(&calib_para_v201, 0, sizeof(calib_para_v201));
4281 CALIBDB_MODULE_PTR_HELPER_RET(list_head, awb_calib_para_v201);
4282 bool ret;
4283 if (xmlParseReadWrite == XML_PARSER_WRITE) {
4284 const CalibDb_Awb_Calib_Para_V201_t *calib_para_v201_2 = NULL;
4285 ret = GetAwbProfileFromAwbCalibV201ListByIdx(awb_calib_para_v201, index, &calib_para_v201_2);
4286 DCT_ASSERT(ret == true);
4287 DCT_ASSERT(calib_para_v201_2 != NULL);
4288 memcpy(&calib_para_v201, calib_para_v201_2, sizeof(CalibDb_Awb_Calib_Para_V201_t));
4289 }
4290 const XMLNode* pchild = pelement->FirstChild();
4291 while (pchild) {
4292 XmlTag tag = XmlTag(pchild->ToElement());
4293 std::string tagname(pchild->ToElement()->Name());
4294 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
4295 if (XML_CHECK_TAGID_COMPARE(CALIIB_SCENE_TAG_ID)) {
4296 ParseString(pchild, calib_para_v201.scene, sizeof(calib_para_v201.scene));
4297 }
4298 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID)) {
4299 if (!parseEntrySensorAwbMeasureGlobalsV201(pchild->ToElement(), &calib_para_v201)) {
4300 LOGE("parse error in AWB globals (%s)", tagname.c_str());
4301 return (false);
4302 }
4303 }
4304 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_V201_LIGHTSOURCES_TAG_ID)) {
4305 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
4306 &RkAiqCalibParser::parseEntrySensorAwbMeasureLightSourcesV201,
4307 &calib_para_v201,
4308 (uint32_t)CALIB_SENSOR_AWB_V201_LIGHTSOURCES_TAG_ID,
4309 (uint32_t)CALIB_SENSOR_AWB_V201_TAG_ID)) {
4310 LOGE("parse error in AWB light sources (%s)", tagname.c_str());
4311 return (false);
4312 }
4313 }
4314 else {
4315 LOGW("parse error in AWB section (unknow tag:%s)", tagname.c_str());
4316 //return (false);
4317 }
4318
4319 pchild = pchild->NextSibling();
4320 }
4321
4322 XML_CHECK_END();
4323 if (xmlParseReadWrite == XML_PARSER_READ) {
4324 ret = AddAwbCalibV201Profile2AwbCalibV201List(calib_para_v201_list, &calib_para_v201);
4325 DCT_ASSERT(ret == true);
4326 }
4327
4328 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
4329 autoTabBackward();
4330
4331 return (true);
4332 }
4333
parseEntrySensorAwbMeasureGlobalsV201(const XMLElement * pelement,void * param)4334 bool RkAiqCalibParser::parseEntrySensorAwbMeasureGlobalsV201
4335 (
4336 const XMLElement* pelement,
4337 void* param
4338 ) {
4339 (void)param;
4340 if(param == NULL) {
4341 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4342 }
4343 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4344 autoTabForward();
4345
4346 XML_CHECK_START(CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID, CALIB_SENSOR_AWB_V201_TAG_ID);
4347 CalibDb_Awb_Calib_Para_V201_t *calib_para_v201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
4348
4349 const XMLNode* pchild = pelement->FirstChild();
4350 while (pchild) {
4351 XmlTag tag = XmlTag(pchild->ToElement());
4352 std::string tagname(pchild->ToElement()->Name());
4353 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
4354
4355 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_HDRFRAMECHOOSE_TAG_ID)) {
4356 if (!parseEntrySensorAwbFrameChooseV201(pchild->ToElement(), param)) {
4357 LOGE("parse error in AWB (%s)", tagname.c_str());
4358 return (false);
4359 }
4360 }
4361 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LSCBYPASSENABLE_TAG_ID)) {
4362 unsigned char tempVal = calib_para_v201->lscBypEnable;
4363 int no = ParseUcharArray(pchild, &tempVal, 1);
4364 DCT_ASSERT((no == tag.Size()));
4365 calib_para_v201->lscBypEnable = (tempVal == 0 ? false : true);
4366 }
4367 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_UVDETECTIONENABLE_TAG_ID)) {
4368 unsigned char tempVal = calib_para_v201->uvDetectionEnable;
4369 int no = ParseUcharArray(pchild, &tempVal, 1);
4370 DCT_ASSERT((no == tag.Size()));
4371 calib_para_v201->uvDetectionEnable = (tempVal == 0 ? false : true);
4372 }
4373 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_XYDETECTIONENABLE_TAG_ID)) {
4374 unsigned char tempVal = calib_para_v201->xyDetectionEnable;
4375 int no = ParseUcharArray(pchild, &tempVal, 1);
4376 DCT_ASSERT((no == tag.Size()));
4377 calib_para_v201->xyDetectionEnable = (tempVal == 0 ? false : true);
4378 }
4379 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_YUVDETECTIONENABLE_TAG_ID)) {
4380 unsigned char tempVal = calib_para_v201->yuvDetectionEnable;
4381 int no = ParseUcharArray(pchild, &tempVal, 1);
4382 DCT_ASSERT((no == tag.Size()));
4383 calib_para_v201->yuvDetectionEnable = (tempVal == 0 ? false : true);
4384 }
4385 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WBGAINDAYLIGHTCLIPENABLE_TAG_ID)) {
4386 unsigned char tempVal = calib_para_v201->wbGainDaylightClipEn;
4387 int no = ParseUcharArray(pchild, &tempVal, 1);
4388 DCT_ASSERT((no == tag.Size()));
4389 calib_para_v201->wbGainDaylightClipEn = (tempVal == 0 ? false : true);
4390 }
4391 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WBGAINCLIPEANBLE_TAG_ID)) {
4392 unsigned char tempVal = calib_para_v201->wbGainClipEn;
4393 int no = ParseUcharArray(pchild, &tempVal, 1);
4394 DCT_ASSERT((no == tag.Size()));
4395 calib_para_v201->wbGainClipEn = (tempVal == 0 ? false : true);
4396 }
4397 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LSUSEDFORYUVDET_TAG_ID)) {
4398 calib_para_v201->lsUsedForYuvDetNum = 0;
4399 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
4400 &RkAiqCalibParser::parseEntrySensorAwbLsForYuvDetV201,
4401 param,
4402 (uint32_t)CALIB_SENSOR_AWB_LSUSEDFORYUVDET_TAG_ID,
4403 (uint32_t)CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID)) {
4404 LOGE("parse error in AWB (%s)", tagname.c_str());
4405 return (false);
4406 }
4407 }
4408 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPDIFFWEIENABLE_TAG_ID)) {
4409 unsigned char tempVal = calib_para_v201->wpDiffWeiEnable;
4410 int no = ParseUcharArray(pchild, &tempVal, 1);
4411 DCT_ASSERT((no == tag.Size()));
4412 calib_para_v201->wpDiffWeiEnable = (tempVal == 0 ? false : true);
4413 }
4414 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPDIFFBLKWEIENABLE_TAG_ID)) {
4415 unsigned char tempVal = calib_para_v201->blkWeightEnable;
4416 int no = ParseUcharArray(pchild, &tempVal, 1);
4417 DCT_ASSERT((no == tag.Size()));
4418 calib_para_v201->blkWeightEnable = (tempVal == 0 ? false : true);
4419 }
4420 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_BLKSTATISTICSENABLE_TAG_ID)) {
4421 unsigned char tempVal = calib_para_v201->blkStatisticsEnable;
4422 int no = ParseUcharArray(pchild, &tempVal, 1);
4423 DCT_ASSERT((no == tag.Size()));
4424 calib_para_v201->blkStatisticsEnable = (tempVal == 0 ? false : true);
4425 }
4426 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_DOWNSCALEMODE_TAG_ID)) {
4427 int no = ParseUcharArray(pchild, &calib_para_v201->dsMode, 1);
4428 DCT_ASSERT((no == tag.Size()));
4429 }
4430 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_BLCKMEASUREMODE_TAG_ID)) {
4431 int no = ParseUcharArray(pchild, &calib_para_v201->blkMeasureMode, 1);
4432 DCT_ASSERT((no == tag.Size()));
4433 }
4434 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MULTIWINDOWENABLE_TAG_ID)) {
4435 unsigned char tempVal = calib_para_v201->multiwindow_en;
4436 int no = ParseUcharArray(pchild, &tempVal, 1);
4437 DCT_ASSERT((no == tag.Size()));
4438 calib_para_v201->multiwindow_en = (tempVal == 0 ? false : true);
4439 }
4440 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MEASUREWINDOW_TAG_ID)) {
4441 if (!parseEntrySensorAwbMeasureWindowV201(pchild->ToElement(), param)) {
4442 LOGE("parse error in AWB (%s)", tagname.c_str());
4443 return (false);
4444 }
4445 }
4446
4447 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_TAG_ID)) {
4448 if (!parseEntrySensorAwbLimitRangeV201(pchild->ToElement(), param)) {
4449 LOGE("parse error in AWB (%s)", tagname.c_str());
4450 return (false);
4451 }
4452 }
4453 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_CELL_TAG_ID)) {
4454 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
4455 &RkAiqCalibParser::parseEntrySensorAwbLimitRangeV201Cell,
4456 param,
4457 (uint32_t)CALIB_SENSOR_AWB_LIMITRANGE_CELL_TAG_ID,
4458 (uint32_t)CALIB_SENSOR_AWB_V200_GLOBALS_TAG_ID)) {
4459 LOGE("parse error in AWB (%s)", tagname.c_str());
4460 return (false);
4461 }
4462 }
4463 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_PSEUDOLUMWEIGHT_TAG_ID)) {
4464 int no = ParseFloatArray(pchild, calib_para_v201->rgb2tcs_param.pseudoLuminanceWeight, tag.Size(), 6);
4465 DCT_ASSERT((no == tag.Size()));
4466 }
4467 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_ROTATIONMAT_TAG_ID)) {
4468 int no = ParseFloatArray(pchild, calib_para_v201->rgb2tcs_param.rotationMat, tag.Size(), 6);
4469 DCT_ASSERT((no == tag.Size()));
4470 }
4471 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_RGB2ROTATIONYUVMAT_TAG_ID)) {
4472 int no = ParseFloatArray(pchild, calib_para_v201->rgb2RYuv_matrix, tag.Size(), 6);
4473 DCT_ASSERT((no == tag.Size()));
4474 DCT_ASSERT((no == 16));
4475 }
4476 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MULTIWINDOW_TAG_ID)) {
4477 //unsigned short tempVal[32];
4478 int no = ParseUshortArray(pchild, calib_para_v201->multiwindow[0], tag.Size());
4479 DCT_ASSERT((no == tag.Size()));
4480 DCT_ASSERT((no <= CALD_AWB_WINDOW_NUM_MAX * 4));
4481 //MEMCPY(calib_para_v201->multiwindow, tempVal, sizeof(short)*no);
4482 }
4483 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_EXCLUDERANGE_TAG_ID)) {
4484 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
4485 &RkAiqCalibParser::parseEntrySensorAwbGlobalsExcludeV201,
4486 param,
4487 (uint32_t)CALIB_SENSOR_AWB_EXCLUDERANGE_TAG_ID,
4488 (uint32_t)CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID)) {
4489 LOGE("parse error in AWB globals excluderange (%s)", tagname.c_str());
4490 return (false);
4491 }
4492
4493 }
4494 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_SPATIALGAIN_L_TAG_ID)) {
4495 int no = ParseFloatArray(pchild, calib_para_v201->spatialGain_L, tag.Size());
4496 DCT_ASSERT((no == tag.Size()));
4497 DCT_ASSERT((no == 4));
4498 }
4499 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_SPATIALGAIN_H_TAG_ID)) {
4500 int no = ParseFloatArray(pchild, calib_para_v201->spatialGain_H, tag.Size());
4501 DCT_ASSERT((no == tag.Size()));
4502 DCT_ASSERT((no == 4));
4503 }
4504 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_TEMPORALDEFAULTGAIN_TAG_ID)) {
4505 int no = ParseFloatArray(pchild, calib_para_v201->temporalDefaultGain, tag.Size());
4506 DCT_ASSERT((no == tag.Size()));
4507 DCT_ASSERT((no == 4));
4508 }
4509 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_CA_TARGETGAIN_TAG_ID)) {
4510 int no = ParseFloatArray(pchild, calib_para_v201->ca_targetGain, tag.Size());
4511 DCT_ASSERT((no == tag.Size()));
4512 }
4513 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_SINGLECOLORPROCESS_TAG_ID)) {
4514 if (!parseEntrySensorAwbSingleColorV201(pchild->ToElement(), param)) {
4515 LOGE("parse error in AWB (%s)", tagname.c_str());
4516 return (false);
4517 }
4518 }
4519 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LINERGBG_TAG_ID)) {
4520 int no = ParseFloatArray(pchild, calib_para_v201->lineRgBg, tag.Size());
4521 DCT_ASSERT((no == tag.Size()));
4522 }
4523 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LINERGBGPROJCCT_TAG_ID)) {
4524 int no = ParseFloatArray(pchild, calib_para_v201->lineRgProjCCT, tag.Size());
4525 DCT_ASSERT((no == tag.Size()));
4526 }
4527 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WBGAINDAYLIGHTCLIP_TAG_ID)) {
4528 if (!parseEntrySensorAwbwbGainDaylightClipV201(pchild->ToElement(), &calib_para_v201->cct_clip_cfg)) {
4529 LOGE("parse error in AWB (%s)", tagname.c_str());
4530 return (false);
4531 }
4532 }
4533 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WBGAINCLIP_TAG_ID)) {
4534 if (!parseEntrySensorAwbwbGainClipV201(pchild->ToElement(), &calib_para_v201->cct_clip_cfg)) {
4535 LOGE("parse error in AWB (%s)", tagname.c_str());
4536 return (false);
4537 }
4538 }
4539 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPDIFFWEIGHT_TAG_ID)) {
4540 if (!parseEntrySensorAwbWpDiffLumaWeight(pchild->ToElement(), param)) {
4541 LOGE("parse error in AWB (%s)", tagname.c_str());
4542 return (false);
4543 }
4544 }
4545 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPDIFFBLKWEIGHT_TAG_ID)) {
4546 int no = ParseUshortArray(pchild, calib_para_v201->blkWeight, tag.Size());
4547 DCT_ASSERT((no == tag.Size()));
4548 DCT_ASSERT((no == CALD_AWB_GRID_NUM_TOTAL));
4549 }
4550 else {
4551 LOGW("parse error in AWB section (unknow tag:%s)", tagname.c_str());
4552 //return ( false );
4553 }
4554
4555 pchild = pchild->NextSibling();
4556 }
4557
4558 XML_CHECK_END();
4559
4560 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
4561 autoTabBackward();
4562
4563
4564 return (true);
4565 }
4566
parseEntrySensorAwbLightXYRegionV201(const XMLElement * pelement,void * param)4567 bool RkAiqCalibParser::parseEntrySensorAwbLightXYRegionV201
4568 (
4569 const XMLElement* pelement,
4570 void* param
4571 ) {
4572 if(param == NULL) {
4573 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4574 }
4575 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4576
4577 XML_CHECK_START(CALIB_SENSOR_AWB_LIGHTSOURCES_LIGHTXYREGION_TAG_ID,
4578 CALIB_SENSOR_AWB_V201_LIGHTSOURCES_TAG_ID);
4579
4580 CalibDb_tcs_range_ill_t *xyRangeLight = (CalibDb_tcs_range_ill_t *)param;
4581
4582 const XMLNode* psubchild = pelement->FirstChild();
4583 autoTabForward();
4584 while (psubchild) {
4585 XmlTag subTag = XmlTag(psubchild->ToElement());
4586 std::string subTagname(psubchild->ToElement()->Name());
4587 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
4588
4589 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_NORMAL_TAG_ID)) {
4590 float tempVal[4] = {xyRangeLight->NorrangeX[0],
4591 xyRangeLight->NorrangeX[1],
4592 xyRangeLight->NorrangeY[0],
4593 xyRangeLight->NorrangeY[1]
4594 };
4595 int no = ParseFloatArray(psubchild, tempVal, subTag.Size());
4596 DCT_ASSERT((no == subTag.Size()));
4597 xyRangeLight->NorrangeX[0] = tempVal[0];
4598 xyRangeLight->NorrangeX[1] = tempVal[1];
4599 xyRangeLight->NorrangeY[0] = tempVal[2];
4600 xyRangeLight->NorrangeY[1] = tempVal[3];
4601 }
4602 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_BIG_TAG_ID)) {
4603 float tempVal[4] = { xyRangeLight->SperangeX[0],
4604 xyRangeLight->SperangeX[1],
4605 xyRangeLight->SperangeY[0],
4606 xyRangeLight->SperangeY[1]
4607 };
4608 int no = ParseFloatArray(psubchild, tempVal, subTag.Size());
4609 DCT_ASSERT((no == subTag.Size()));
4610 xyRangeLight->SperangeX[0] = tempVal[0];
4611 xyRangeLight->SperangeX[1] = tempVal[1];
4612 xyRangeLight->SperangeY[0] = tempVal[2];
4613 xyRangeLight->SperangeY[1] = tempVal[3];
4614
4615 }
4616 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_SMALL_TAG_ID)) {
4617 float tempVal[4] = { xyRangeLight->SmalrangeX[0],
4618 xyRangeLight->SmalrangeX[1],
4619 xyRangeLight->SmalrangeY[0],
4620 xyRangeLight->SmalrangeY[1]
4621 };
4622 int no = ParseFloatArray(psubchild, tempVal, subTag.Size());
4623 DCT_ASSERT((no == subTag.Size()));
4624 xyRangeLight->SmalrangeX[0] = tempVal[0];
4625 xyRangeLight->SmalrangeX[1] = tempVal[1];
4626 xyRangeLight->SmalrangeY[0] = tempVal[2];
4627 xyRangeLight->SmalrangeY[1] = tempVal[3];
4628 }
4629 psubchild = psubchild->NextSibling();
4630 }
4631 autoTabBackward();
4632
4633
4634
4635 XML_CHECK_END();
4636
4637 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
4638 return (true);
4639
4640 }
4641
parseEntrySensorAwbLightRTYUVRegionV201(const XMLElement * pelement,void * param)4642 bool RkAiqCalibParser::parseEntrySensorAwbLightRTYUVRegionV201
4643 (
4644 const XMLElement* pelement,
4645 void* param
4646 ) {
4647 if(param == NULL) {
4648 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4649 }
4650 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4651
4652 XML_CHECK_START(CALIB_SENSOR_AWB_LIGHTSOURCES_RTYUVREGION_TAG_ID,
4653 CALIB_SENSOR_AWB_V201_LIGHTSOURCES_TAG_ID);
4654
4655 //int index = *((int*)param);
4656 CalibDb_Yuv3D_2_Range_Ill_t *yuv3D2Range_param = (CalibDb_Yuv3D_2_Range_Ill_t *)param;
4657
4658 const XMLNode* psubchild = pelement->FirstChild();
4659 autoTabForward();
4660 while (psubchild) {
4661 XmlTag subTag = XmlTag(psubchild->ToElement());
4662 std::string subTagname(psubchild->ToElement()->Name());
4663 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
4664
4665 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_THCURVE_U_SET_TAG_ID)) {
4666 int no = ParseFloatArray(psubchild, yuv3D2Range_param->thcurve_u, subTag.Size());
4667 DCT_ASSERT((no == subTag.Size()));
4668 }
4669 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_THCURVE_TH_SET_TAG_ID)) {
4670 int no = ParseFloatArray(psubchild, yuv3D2Range_param->thcure_th, subTag.Size());
4671 DCT_ASSERT((no == subTag.Size()));
4672 }
4673 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_LINEVECTOR_TAG_ID)) {
4674 int no = ParseFloatArray(psubchild, yuv3D2Range_param->line, subTag.Size());
4675 DCT_ASSERT((no == subTag.Size()));
4676 }
4677 psubchild = psubchild->NextSibling();
4678 }
4679 autoTabBackward();
4680
4681 XML_CHECK_END();
4682
4683 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
4684 return (true);
4685
4686 }
4687
4688
parseEntrySensorAwbMeasureLightSourcesV201(const XMLElement * pelement,void * param,int index)4689 bool RkAiqCalibParser::parseEntrySensorAwbMeasureLightSourcesV201
4690 (
4691 const XMLElement* pelement,
4692 void* param,
4693 int index
4694 ) {
4695 if(param == NULL) {
4696 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4697 }
4698 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4699
4700 XML_CHECK_START(CALIB_SENSOR_AWB_V201_LIGHTSOURCES_TAG_ID, CALIB_SENSOR_AWB_V201_TAG_ID);
4701 CalibDb_Awb_Calib_Para_V201_t *calib_para_v201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
4702 DCT_ASSERT((index <= CALD_AWB_LS_NUM_MAX));
4703
4704 const XMLNode* pchild = pelement->FirstChild();
4705 while (pchild) {
4706 XmlTag tag = XmlTag(pchild->ToElement());
4707 const char* value = tag.Value();
4708 std::string tagname(pchild->ToElement()->Name());
4709 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
4710
4711 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_NAME_TAG_ID)) {
4712 ParseString(pchild, calib_para_v201->lightName[index],
4713 sizeof(calib_para_v201->lightName[index]));
4714 }
4715 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_DOORTYPE_TAG_ID)) {
4716 int no = ParseUcharArray(pchild, &calib_para_v201->doorType[index], tag.Size());
4717 DCT_ASSERT((no == tag.Size()));
4718 }
4719 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_STANDARDGAINVALUE_TAG_ID)) {
4720 int no = ParseFloatArray(pchild, calib_para_v201->standardGainValue[index], tag.Size());
4721 DCT_ASSERT((no == tag.Size()));
4722 }
4723 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_LIGHTUREGION_TAG_ID)) {
4724 int no = ParseFloatArray(pchild, calib_para_v201->uvRange_param[index].pu_region, tag.Size());
4725 DCT_ASSERT((no == tag.Size()));
4726
4727 }
4728 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_LIGHTVREGION_TAG_ID)) {
4729 int no = ParseFloatArray(pchild, calib_para_v201->uvRange_param[index].pv_region, tag.Size());
4730 DCT_ASSERT((no == tag.Size()));
4731 }
4732 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_SMALLUREGION_TAG_ID)) {
4733 int no = ParseFloatArray(pchild, calib_para_v201->uvRange_param_small[index].pu_region, tag.Size());
4734 DCT_ASSERT((no == tag.Size()));
4735 }
4736 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_SMALLVREGION_TAG_ID)) {
4737 int no = ParseFloatArray(pchild, calib_para_v201->uvRange_param_small[index].pv_region, tag.Size());
4738 DCT_ASSERT((no == tag.Size()));
4739 }
4740 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_LIGHTXYREGION_TAG_ID)) {
4741 if (!parseEntrySensorAwbLightXYRegionV201(pchild->ToElement(), &calib_para_v201->xyRangeLight[index])) {
4742 LOGE("parse error in AWB globals (%s)", tagname.c_str());
4743 return (false);
4744 }
4745 }
4746 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIGHTSOURCES_RTYUVREGION_TAG_ID)) {
4747 if (!parseEntrySensorAwbLightRTYUVRegionV201(pchild->ToElement(), &calib_para_v201->yuv3D2Range_param[index])) {
4748 LOGE("parse error in AWB globals (%s)", tagname.c_str());
4749 return (false);
4750 }
4751 }
4752 else {
4753 LOGW("UNKNOWN tag: %s", tagname.c_str());
4754 }
4755
4756 pchild = pchild->NextSibling();
4757 }
4758
4759 XML_CHECK_END();
4760
4761 DCT_ASSERT((index <= CALD_AWB_LS_NUM_MAX));
4762 calib_para_v201->lightNum++;
4763 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
4764 return (true);
4765 }
parseEntrySensorAwbLsForYuvDetV201(const XMLElement * pelement,void * param,int index)4766 bool RkAiqCalibParser::parseEntrySensorAwbLsForYuvDetV201
4767 (
4768 const XMLElement* pelement,
4769 void* param,
4770 int index
4771 ) {
4772 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4773
4774 XML_CHECK_START(CALIB_SENSOR_AWB_LSUSEDFORYUVDET_TAG_ID, CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID);
4775 CalibDb_Awb_Calib_Para_V201_t *calib_para_v201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
4776
4777 const XMLNode* pchild = pelement->FirstChild();
4778 while (pchild) {
4779 XmlTag tag = XmlTag(pchild->ToElement());
4780 const char* value = tag.Value();
4781 std::string tagname(pchild->ToElement()->Name());
4782 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
4783 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LSUSEDFORYUVDET_NAME_TAG_ID)) {
4784 ParseString(pchild, calib_para_v201->lsUsedForYuvDet[index],
4785 sizeof(calib_para_v201->lsUsedForYuvDet[index]));//check
4786 } else {
4787 LOGW("UNKNOWN tag: %s", tagname.c_str());
4788 }
4789 pchild = pchild->NextSibling();
4790 }
4791
4792 XML_CHECK_END();
4793
4794 DCT_ASSERT((index <= CALD_AWB_LS_NUM_MAX));
4795 calib_para_v201->lsUsedForYuvDetNum++;
4796 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
4797 return (true);
4798 }
4799
parseEntrySensorAwbMeasureWindowV201(const XMLElement * pelement,void * param)4800 bool RkAiqCalibParser::parseEntrySensorAwbMeasureWindowV201
4801 (
4802 const XMLElement* pelement,
4803 void* param
4804 ) {
4805 (void)param;
4806 if(param == NULL) {
4807 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4808 }
4809 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4810 autoTabForward();
4811
4812 XML_CHECK_START(CALIB_SENSOR_AWB_MEASUREWINDOW_TAG_ID, CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID);
4813 CalibDb_Awb_Calib_Para_V201_t *calib_para_v201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
4814
4815 const XMLNode* pchild = pelement->FirstChild();
4816 while (pchild) {
4817 XmlTag tag = XmlTag(pchild->ToElement());
4818 std::string tagname(pchild->ToElement()->Name());
4819 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
4820 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MODE_TAG_ID)) {
4821 int no = ParseIntArray(pchild, &calib_para_v201->measeureWindow.mode, 1);
4822 DCT_ASSERT((no == tag.Size()));
4823 }
4824 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_RESALL_TAG_ID)) {
4825 calib_para_v201->measeureWindow.resNum = 0;
4826 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
4827 &RkAiqCalibParser::parseEntrySensorAwbWindowV201,
4828 param,
4829 (uint32_t)CALIB_SENSOR_AWB_RESALL_TAG_ID,
4830 (uint32_t)CALIB_SENSOR_AWB_MEASUREWINDOW_TAG_ID)) {
4831 LOGE("parse error in AWB light sources (%s)", tagname.c_str());
4832 return (false);
4833 }
4834 }
4835
4836 pchild = pchild->NextSibling();
4837 }
4838 XML_CHECK_END();
4839 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
4840 autoTabBackward();
4841 return (true);
4842 }
4843
parseEntrySensorAwbLimitRangeV201(const XMLElement * pelement,void * param)4844 bool RkAiqCalibParser::parseEntrySensorAwbLimitRangeV201
4845 (
4846 const XMLElement* pelement,
4847 void* param
4848 ) {
4849 (void)param;
4850 if(param == NULL) {
4851 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4852 }
4853 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4854 autoTabForward();
4855
4856 XML_CHECK_START(CALIB_SENSOR_AWB_LIMITRANGE_TAG_ID, CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID);
4857 CalibDb_Awb_Calib_Para_V201_t *calib_para_v201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
4858
4859 const XMLNode* psubchild = pelement->FirstChild();
4860 while (psubchild) {
4861 XmlTag subTag = XmlTag(psubchild->ToElement());
4862 std::string subTagname(psubchild->ToElement()->Name());
4863 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
4864
4865 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_Y_TAG_ID)) {
4866 unsigned short tmpValue[2] = { calib_para_v201->limitRange.minY[0], calib_para_v201->limitRange.maxY[0] };
4867 int no = ParseUshortArray(psubchild, tmpValue, subTag.Size());
4868 DCT_ASSERT((no == subTag.Size()));
4869 calib_para_v201->limitRange.minY[0] = tmpValue[0];
4870 calib_para_v201->limitRange.maxY[0] = tmpValue[1];
4871 }
4872 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_R_TAG_ID)) {
4873 unsigned short tmpValue[2] = { calib_para_v201->limitRange.minR[0], calib_para_v201->limitRange.maxR[0] };
4874 int no = ParseUshortArray(psubchild, tmpValue, subTag.Size());
4875 DCT_ASSERT((no == subTag.Size()));
4876 calib_para_v201->limitRange.minR[0] = tmpValue[0];
4877 calib_para_v201->limitRange.maxR[0] = tmpValue[1];
4878 }
4879 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_G_TAG_ID)) {
4880 unsigned short tmpValue[2] = { calib_para_v201->limitRange.minG[0], calib_para_v201->limitRange.maxG[0] };
4881 int no = ParseUshortArray(psubchild, tmpValue, subTag.Size());
4882 DCT_ASSERT((no == subTag.Size()));
4883 calib_para_v201->limitRange.minG[0] = tmpValue[0];
4884 calib_para_v201->limitRange.maxG[0] = tmpValue[1];
4885 }
4886 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_B_TAG_ID)) {
4887 unsigned short tmpValue[2] = { calib_para_v201->limitRange.minB[0], calib_para_v201->limitRange.maxB[0] };
4888 int no = ParseUshortArray(psubchild, tmpValue, subTag.Size());
4889 DCT_ASSERT((no == subTag.Size()));
4890 calib_para_v201->limitRange.minB[0] = tmpValue[0];
4891 calib_para_v201->limitRange.maxB[0] = tmpValue[1];
4892 }
4893 else {
4894 LOGW("unknown subTag %s", subTagname.c_str());
4895 }
4896 psubchild = psubchild->NextSibling();
4897 }
4898 calib_para_v201->limitRange.lumaNum = 1;
4899 calib_para_v201->limitRange.lumaValue[0] = 0;
4900 XML_CHECK_END();
4901 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
4902 autoTabBackward();
4903 return (true);
4904 }
4905
parseEntrySensorAwbLimitRangeV201Cell(const XMLElement * pelement,void * param,int index)4906 bool RkAiqCalibParser::parseEntrySensorAwbLimitRangeV201Cell
4907 (
4908 const XMLElement* pelement,
4909 void* param,
4910 int index
4911 ) {
4912 (void)param;
4913
4914 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4915 autoTabForward();
4916
4917 XML_CHECK_START(CALIB_SENSOR_AWB_LIMITRANGE_CELL_TAG_ID, CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID);
4918 CalibDb_Awb_Calib_Para_V201_t *calib_para_v201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
4919 const XMLNode* pchild = pelement->FirstChild();
4920 while (pchild) {
4921 XmlTag tag = XmlTag(pchild->ToElement());
4922 std::string tagname(pchild->ToElement()->Name());
4923 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
4924 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_LV_TAG_ID)) {
4925 float tmpValue = calib_para_v201->limitRange.lumaValue[index];
4926 int no = ParseFloatArray(pchild, &tmpValue, tag.Size());
4927 DCT_ASSERT((no == tag.Size()));
4928 calib_para_v201->limitRange.lumaValue[index] = tmpValue;
4929 }
4930 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_Y_TAG_ID)) {
4931 unsigned short tmpValue[2] = { calib_para_v201->limitRange.minY[index], calib_para_v201->limitRange.maxY[index] };
4932 int no = ParseUshortArray(pchild, tmpValue, tag.Size());
4933 DCT_ASSERT((no == tag.Size()));
4934 calib_para_v201->limitRange.minY[index] = tmpValue[0];
4935 calib_para_v201->limitRange.maxY[index] = tmpValue[1];
4936 }
4937 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_R_TAG_ID)) {
4938 unsigned short tmpValue[2] = { calib_para_v201->limitRange.minR[index], calib_para_v201->limitRange.maxR[index] };
4939 int no = ParseUshortArray(pchild, tmpValue, tag.Size());
4940 DCT_ASSERT((no == tag.Size()));
4941 calib_para_v201->limitRange.minR[index] = tmpValue[0];
4942 calib_para_v201->limitRange.maxR[index] = tmpValue[1];
4943 }
4944 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_G_TAG_ID)) {
4945 unsigned short tmpValue[2] = { calib_para_v201->limitRange.minG[index], calib_para_v201->limitRange.maxG[index] };
4946 int no = ParseUshortArray(pchild, tmpValue, tag.Size());
4947 DCT_ASSERT((no == tag.Size()));
4948 calib_para_v201->limitRange.minG[index] = tmpValue[0];
4949 calib_para_v201->limitRange.maxG[index] = tmpValue[1];
4950 }
4951 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LIMITRANGE_B_TAG_ID)) {
4952 unsigned short tmpValue[2] = { calib_para_v201->limitRange.minB[index], calib_para_v201->limitRange.maxB[index] };
4953 int no = ParseUshortArray(pchild, tmpValue, tag.Size());
4954 DCT_ASSERT((no == tag.Size()));
4955 calib_para_v201->limitRange.minB[index] = tmpValue[0];
4956 calib_para_v201->limitRange.maxB[index] = tmpValue[1];
4957 }
4958 else {
4959 LOGW("unknown tag %s", tagname.c_str());
4960 }
4961 pchild = pchild->NextSibling();
4962 }
4963
4964 calib_para_v201->limitRange.lumaNum++;
4965 DCT_ASSERT(( calib_para_v201->limitRange.lumaNum <= CALD_AWB_LV_NUM_MAX));
4966 XML_CHECK_END();
4967 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
4968 autoTabBackward();
4969 return (true);
4970 }
4971
4972
parseEntrySensorAwbWpDiffWeiEnableTh(const XMLElement * pelement,void * param)4973 bool RkAiqCalibParser::parseEntrySensorAwbWpDiffWeiEnableTh
4974 (
4975 const XMLElement* pelement,
4976 void* param
4977 ) {
4978 (void)param;
4979 if(param == NULL) {
4980 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4981 }
4982 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
4983 autoTabForward();
4984
4985 XML_CHECK_START(CALIB_SENSOR_AWB_WPDIFFWEIENABLETH_TAG_ID, CALIB_SENSOR_AWB_WPDIFFWEIGHT_TAG_ID);
4986 CalibDb_Awb_Calib_Para_V201_t *calib_para_v201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
4987
4988 const XMLNode* psubsubchild = pelement->FirstChild();
4989 while (psubsubchild) {
4990 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
4991 std::string subsubTagname(psubsubchild->ToElement()->Name());
4992 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
4993 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPNOTH_TAG_ID)) {
4994 int no = ParseFloatArray(psubsubchild, &calib_para_v201->wpDiffNoTh, subsubTag.Size());
4995 DCT_ASSERT((no == subsubTag.Size()));
4996 }
4997 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_LVVALUETH_TAG_ID)) {
4998 int no = ParseUintArray(psubsubchild, &calib_para_v201->wpDiffLvValueTh, subsubTag.Size());
4999 DCT_ASSERT((no == subsubTag.Size()));
5000 }
5001 psubsubchild = psubsubchild->NextSibling();
5002 }
5003
5004 XML_CHECK_END();
5005 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5006 autoTabBackward();
5007 return (true);
5008 }
5009
parseEntrySensorAwbWpDiffwei_w_HighLV(const XMLElement * pelement,void * param)5010 bool RkAiqCalibParser::parseEntrySensorAwbWpDiffwei_w_HighLV
5011 (
5012 const XMLElement* pelement,
5013 void* param
5014 ) {
5015 (void)param;
5016 if(param == NULL) {
5017 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5018 }
5019 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5020 autoTabForward();
5021
5022 XML_CHECK_START(CALIB_SENSOR_AWB_WPDIFFWEI_W_HIGHLV_TAG_ID, CALIB_SENSOR_AWB_WPDIFFWEIGHT_TAG_ID);
5023 CalibDb_Awb_Calib_Para_V201_t *calib_para_v201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
5024
5025 const XMLNode* psubsubchild = pelement->FirstChild();
5026 while (psubsubchild) {
5027 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
5028 std::string subsubTagname(psubsubchild->ToElement()->Name());
5029 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
5030
5031 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPRATIO1_TAG_ID)) {
5032 int no = ParseFloatArray(psubsubchild, calib_para_v201->wpDiffweiSet_w_HigLV[0], subsubTag.Size());
5033 DCT_ASSERT((no == subsubTag.Size()));
5034 }
5035 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPRATIO2_TAG_ID)) {
5036 int no = ParseFloatArray(psubsubchild, calib_para_v201->wpDiffweiSet_w_HigLV[1], subsubTag.Size());
5037 DCT_ASSERT((no == subsubTag.Size()));
5038 }
5039 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPRATIO3_TAG_ID)) {
5040 int no = ParseFloatArray(psubsubchild, calib_para_v201->wpDiffweiSet_w_HigLV[2], subsubTag.Size());
5041 DCT_ASSERT((no == subsubTag.Size()));
5042 }
5043 psubsubchild = psubsubchild->NextSibling();
5044 }
5045
5046 XML_CHECK_END();
5047 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5048 autoTabBackward();
5049 return (true);
5050 }
5051
parseEntrySensorAwbWpDiffwei_w_LowLV(const XMLElement * pelement,void * param)5052 bool RkAiqCalibParser::parseEntrySensorAwbWpDiffwei_w_LowLV
5053 (
5054 const XMLElement* pelement,
5055 void* param
5056 ) {
5057 (void)param;
5058 if(param == NULL) {
5059 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5060 }
5061 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5062 autoTabForward();
5063
5064 XML_CHECK_START(CALIB_SENSOR_AWB_WPDIFFWEI_W_LOWLV_TAG_ID, CALIB_SENSOR_AWB_WPDIFFWEIGHT_TAG_ID);
5065 CalibDb_Awb_Calib_Para_V201_t *calib_para_v201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
5066
5067 const XMLNode* psubsubchild = pelement->FirstChild();
5068 while (psubsubchild) {
5069 XmlTag subsubsubTag = XmlTag(psubsubchild->ToElement());
5070 std::string subsubTagname(psubsubchild->ToElement()->Name());
5071 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubsubTag.Type(), subsubsubTag.Size());
5072
5073 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPRATIO1_TAG_ID)) {
5074 int no = ParseFloatArray(psubsubchild, calib_para_v201->wpDiffweiSet_w_LowLV[0], subsubsubTag.Size());
5075 DCT_ASSERT((no == subsubsubTag.Size()));
5076 }
5077 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPRATIO2_TAG_ID)) {
5078 int no = ParseFloatArray(psubsubchild, calib_para_v201->wpDiffweiSet_w_LowLV[1], subsubsubTag.Size());
5079 DCT_ASSERT((no == subsubsubTag.Size()));
5080 }
5081 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPRATIO3_TAG_ID)) {
5082 int no = ParseFloatArray(psubsubchild, calib_para_v201->wpDiffweiSet_w_LowLV[2], subsubsubTag.Size());
5083 DCT_ASSERT((no == subsubsubTag.Size()));
5084 }
5085 psubsubchild = psubsubchild->NextSibling();
5086 }
5087
5088
5089 XML_CHECK_END();
5090 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5091 autoTabBackward();
5092 return (true);
5093 }
5094
parseEntrySensorAwbWpDiffLumaWeight(const XMLElement * pelement,void * param)5095 bool RkAiqCalibParser::parseEntrySensorAwbWpDiffLumaWeight
5096 (
5097 const XMLElement* pelement,
5098 void* param
5099 ) {
5100 (void)param;
5101 if(param == NULL) {
5102 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5103 }
5104 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5105 autoTabForward();
5106
5107 XML_CHECK_START(CALIB_SENSOR_AWB_WPDIFFWEIGHT_TAG_ID, CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID);
5108 CalibDb_Awb_Calib_Para_V201_t *calib_para_v201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
5109
5110 const XMLNode* psubchild = pelement->FirstChild();
5111 while (psubchild) {
5112 XmlTag subTag = XmlTag(psubchild->ToElement());
5113 std::string subTagname(psubchild->ToElement()->Name());
5114 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
5115 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPDIFFWEIENABLETH_TAG_ID)) {
5116 if (!parseEntrySensorAwbWpDiffWeiEnableTh(psubchild->ToElement(), param)) {
5117 LOGE("parse error in AWB (%s)", subTagname.c_str());
5118 return (false);
5119 }
5120 }
5121 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPDIFFWEI_Y_TAG_ID)) {
5122 int no = ParseUcharArray(psubchild, calib_para_v201->wpDiffwei_y, subTag.Size());
5123 DCT_ASSERT((no == subTag.Size()));
5124 }
5125 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_PERFECTBINCONF_TAG_ID)) {
5126 int no = ParseUcharArray(psubchild, calib_para_v201->perfectBin, subTag.Size());
5127 DCT_ASSERT((no == subTag.Size()));
5128 }
5129 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPDIFFWEILVTH_TAG_ID)) {
5130 int no = ParseFloatArray(psubchild, calib_para_v201->wpDiffweiSet_w_LvValueTh, subTag.Size());
5131 DCT_ASSERT((no == subTag.Size()));
5132 }
5133 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPDIFFWEIRATIOTH_TAG_ID)) {
5134 int no = ParseFloatArray(psubchild, calib_para_v201->wpDiffWeiRatioTh, subTag.Size());
5135 DCT_ASSERT((no == subTag.Size()));
5136 }
5137 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPDIFFWEI_W_HIGHLV_TAG_ID)) {
5138 if (!parseEntrySensorAwbWpDiffwei_w_HighLV(psubchild->ToElement(), param)) {
5139 LOGE("parse error in AWB (%s)", subTagname.c_str());
5140 return (false);
5141 }
5142 }
5143 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_WPDIFFWEI_W_LOWLV_TAG_ID)) {
5144 if (!parseEntrySensorAwbWpDiffwei_w_LowLV(psubchild->ToElement(), param)) {
5145 LOGE("parse error in AWB (%s)", subTagname.c_str());
5146 return (false);
5147 }
5148 }
5149 else {
5150 LOGW("unknown tag %s", subTagname.c_str());
5151 }
5152 psubchild = psubchild->NextSibling();
5153 }
5154
5155 XML_CHECK_END();
5156 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5157 autoTabBackward();
5158 return (true);
5159 }
5160
parseEntrySensorAwbWindowV201(const XMLElement * pelement,void * param,int index)5161 bool RkAiqCalibParser::parseEntrySensorAwbWindowV201
5162 (
5163 const XMLElement* pelement,
5164 void* param,
5165 int index
5166 ) {
5167 if(param == NULL) {
5168 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5169 }
5170 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5171
5172 XML_CHECK_START(CALIB_SENSOR_AWB_RESALL_TAG_ID, CALIB_SENSOR_AWB_MEASUREWINDOW_TAG_ID);
5173 CalibDb_Awb_Calib_Para_V201_t *calib_para_v201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
5174
5175 const XMLNode* pchild = pelement->FirstChild();
5176 while (pchild) {
5177 XmlTag tag = XmlTag(pchild->ToElement());
5178 const char* value = tag.Value();
5179 std::string tagname(pchild->ToElement()->Name());
5180 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
5181 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_RESOLUTION_TAG_ID)) {
5182 ParseString(pchild, calib_para_v201->measeureWindow.resName[index],
5183 sizeof(calib_para_v201->measeureWindow.resName[index]));
5184 }
5185 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_MEASUREWINDOWSIZE_TAG_ID)) {
5186 int no = ParseUshortArray(pchild, calib_para_v201->measeureWindow.window[index], tag.Size());
5187 DCT_ASSERT((no == tag.Size()));
5188 DCT_ASSERT((no <= 4));
5189 }
5190 pchild = pchild->NextSibling();
5191 }
5192 XML_CHECK_END();
5193 DCT_ASSERT((index <= CALD_AWB_RRES_NUM_MAX));
5194 calib_para_v201->measeureWindow.resNum++;
5195 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5196 return (true);
5197 }
5198
parseEntrySensorAwbGlobalsExcludeV201(const XMLElement * pelement,void * param,int index)5199 bool RkAiqCalibParser::parseEntrySensorAwbGlobalsExcludeV201
5200 (
5201 const XMLElement* pelement,
5202 void* param,
5203 int index
5204 ) {
5205 if(param == NULL) {
5206 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5207 }
5208 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5209
5210 XML_CHECK_START(CALIB_SENSOR_AWB_EXCLUDERANGE_TAG_ID, CALIB_SENSOR_AWB_V201_GLOBALS_TAG_ID);
5211 CalibDb_Awb_Calib_Para_V201_t *calib_para_v201 = (CalibDb_Awb_Calib_Para_V201_t*)param;
5212
5213 const XMLNode* pchild = pelement->FirstChild();
5214 while (pchild) {
5215 XmlTag tag = XmlTag(pchild->ToElement());
5216 std::string Tagname(pchild->ToElement()->Name());
5217 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
5218
5219 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_EXCLUDERANGE_DOMAIN_TAG_ID)) {
5220 int no = ParseUcharArray(pchild, &calib_para_v201->excludeWpRange[index].domain, tag.Size());
5221 DCT_ASSERT((no == tag.Size()));
5222 }
5223 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_EXCLUDE_MODE_TAG_ID)) {
5224 int no = ParseUcharArray(pchild, &calib_para_v201->excludeWpRange[index].mode, tag.Size());
5225 DCT_ASSERT((no == tag.Size()));
5226 }
5227 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_EXCLUDE_WINDOW_TAG_ID)) {
5228 int xuyv[4] = { calib_para_v201->excludeWpRange[index].xu[0],
5229 calib_para_v201->excludeWpRange[index].xu[1],
5230 calib_para_v201->excludeWpRange[index].yv[0],
5231 calib_para_v201->excludeWpRange[index].yv[1]
5232 };
5233 int no = ParseIntArray(pchild, xuyv, tag.Size());
5234 DCT_ASSERT((no == tag.Size()));
5235 calib_para_v201->excludeWpRange[index].xu[0] = xuyv[0];
5236 calib_para_v201->excludeWpRange[index].xu[1] = xuyv[1];
5237 calib_para_v201->excludeWpRange[index].yv[0] = xuyv[2];
5238 calib_para_v201->excludeWpRange[index].yv[1] = xuyv[3];
5239
5240 }
5241 pchild = pchild->NextSibling();
5242 }
5243 XML_CHECK_END();
5244 DCT_ASSERT((index <= CALD_AWB_EXCRANGE_NUM_MAX));
5245 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5246 return (true);
5247 }
5248
parseEntrySensorAwbRemosaicPara(const XMLElement * pelement,void * param)5249 bool RkAiqCalibParser::parseEntrySensorAwbRemosaicPara
5250 (
5251 const XMLElement* pelement,
5252 void* param
5253 ) {
5254 (void)param;
5255 if(param == NULL) {
5256 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5257 }
5258 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5259 autoTabForward();
5260
5261 XML_CHECK_START(CALIB_SENSOR_AWB_REMOSAICPARA_TAG_ID, CALIB_SENSOR_AWB_ADJUSTPARA_GLOBALS_TAG_ID);
5262 CalibDb_Awb_Remosaic_Para_t *remosaic_cfg = (CalibDb_Awb_Remosaic_Para_t *)param;
5263
5264
5265 const XMLNode* pchild = pelement->FirstChild();
5266 while (pchild) {
5267 XmlTag tag = XmlTag(pchild->ToElement());
5268 std::string tagname(pchild->ToElement()->Name());
5269 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
5270
5271 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_REMOSAICPARA_ENABLE_TAG_ID)) {
5272 unsigned char tempVal = remosaic_cfg->enable;
5273 int no = ParseUcharArray(pchild, &tempVal, 1);
5274 DCT_ASSERT((no == tag.Size()));
5275 remosaic_cfg->enable = (tempVal == 0 ? false : true);
5276 }
5277 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AWB_REMOSAICPARA_WBGAIN_TAG_ID)) {
5278 int no = ParseFloatArray(pchild, remosaic_cfg->sensor_awb_gain, tag.Size(), 6);
5279 DCT_ASSERT((no == tag.Size()));
5280 }
5281 else {
5282 LOGW("parse error in AWB section (unknow tag:%s)", tagname.c_str());
5283 //return ( false );
5284 }
5285
5286 pchild = pchild->NextSibling();
5287 }
5288
5289 XML_CHECK_END();
5290
5291 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5292 autoTabBackward();
5293
5294
5295 return (true);
5296 }
5297
parseEntrySensorAecLinAlterExp(const XMLElement * pelement,void * param)5298 bool RkAiqCalibParser::parseEntrySensorAecLinAlterExp
5299 (
5300 const XMLElement* pelement,
5301 void* param
5302 ) {
5303 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5304
5305 XML_CHECK_START(CALIB_SENSOR_AEC_SYNCTEST_LINALTEREXP_TAG_ID, CALIB_SENSOR_AEC_SYNCTEST_ALTEREXP_TAG_ID);
5306
5307 int index = *((int*)param);
5308 const XMLNode* pchild = pelement->FirstChild();
5309
5310 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
5311
5312 while (pchild) {
5313 XmlTag tag = XmlTag(pchild->ToElement());
5314 std::string Tagname(pchild->ToElement()->Name());
5315 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
5316 #ifdef DEBUG_LOG
5317 redirectOut << "Tagname: " << Tagname << ",index:" << index << std::endl;
5318 #endif
5319 DCT_ASSERT((index < AEC_ALTER_EXP_MAX_NUM));
5320
5321 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_TIMEVALUE_TAG_ID)) {
5322 int no = ParseFloatArray(pchild, &aec->CommCtrl.stSyncTest.LinAlterExp.TimeValue[index], tag.Size());
5323 DCT_ASSERT((no == tag.Size()));
5324 }
5325 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_GAINVALUE_TAG_ID)) {
5326 int no = ParseFloatArray(pchild, &aec->CommCtrl.stSyncTest.LinAlterExp.GainValue[index], tag.Size());
5327 DCT_ASSERT((no == tag.Size()));
5328 }
5329 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_ISPGAINVALUE_TAG_ID)) {
5330 int no = ParseFloatArray(pchild, &aec->CommCtrl.stSyncTest.LinAlterExp.IspgainValue[index], tag.Size());
5331 DCT_ASSERT((no == tag.Size()));
5332 }
5333 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_DCGMODE_TAG_ID)) {
5334 int no = ParseIntArray(pchild, &aec->CommCtrl.stSyncTest.LinAlterExp.DcgMode[index], tag.Size());
5335 DCT_ASSERT((no == tag.Size()));
5336 }
5337 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_PIRISVALUE_TAG_ID)) {
5338 int no = ParseIntArray(pchild, &aec->CommCtrl.stSyncTest.LinAlterExp.PIrisGainValue[index], tag.Size());
5339 DCT_ASSERT((no == tag.Size()));
5340 }
5341 else {
5342 redirectOut
5343 << "parse error in LinAlterExp (unknow tag: "
5344 << Tagname
5345 << ")"
5346 << std::endl;
5347 }
5348 pchild = pchild->NextSibling();
5349 }
5350 XML_CHECK_END();
5351 aec->CommCtrl.stSyncTest.LinAlterExp.array_size = index + 1;
5352 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5353 return (true);
5354 }
5355
5356
parseEntrySensorAecHdrAlterExp(const XMLElement * pelement,void * param)5357 bool RkAiqCalibParser::parseEntrySensorAecHdrAlterExp
5358 (
5359 const XMLElement* pelement,
5360 void* param
5361 ) {
5362 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5363
5364 XML_CHECK_START(CALIB_SENSOR_AEC_SYNCTEST_HDRALTEREXP_TAG_ID, CALIB_SENSOR_AEC_SYNCTEST_ALTEREXP_TAG_ID);
5365
5366 int index = *((int*)param);
5367 const XMLNode* pchild = pelement->FirstChild();
5368
5369 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
5370
5371 while (pchild) {
5372 XmlTag tag = XmlTag(pchild->ToElement());
5373 std::string Tagname(pchild->ToElement()->Name());
5374 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
5375 #ifdef DEBUG_LOG
5376 redirectOut << "Tagname: " << Tagname << ",index:" << index << std::endl;
5377 #endif
5378 DCT_ASSERT((index < AEC_ALTER_EXP_MAX_NUM));
5379
5380 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_TIMEVALUE_TAG_ID)) {
5381 int no = ParseFloatArray(pchild, aec->CommCtrl.stSyncTest.HdrAlterExp.TimeValue[index], tag.Size());
5382 DCT_ASSERT((no == tag.Size()));
5383 }
5384 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_GAINVALUE_TAG_ID)) {
5385 int no = ParseFloatArray(pchild, aec->CommCtrl.stSyncTest.HdrAlterExp.GainValue[index], tag.Size());
5386 DCT_ASSERT((no == tag.Size()));
5387 }
5388 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_ISPGAINVALUE_TAG_ID)) {
5389 int no = ParseFloatArray(pchild, aec->CommCtrl.stSyncTest.HdrAlterExp.IspDGainValue[index], tag.Size());
5390 DCT_ASSERT((no == tag.Size()));
5391 }
5392 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_DCGMODE_TAG_ID)) {
5393 int no = ParseIntArray(pchild, aec->CommCtrl.stSyncTest.HdrAlterExp.DcgMode[index], tag.Size());
5394 DCT_ASSERT((no == tag.Size()));
5395 }
5396 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_PIRISVALUE_TAG_ID)) {
5397 int no = ParseIntArray(pchild, &aec->CommCtrl.stSyncTest.HdrAlterExp.PIrisGainValue[index], tag.Size());
5398 DCT_ASSERT((no == tag.Size()));
5399 }
5400 else {
5401 redirectOut
5402 << "parse error in HdrAlterExp (unknow tag: "
5403 << Tagname
5404 << ")"
5405 << std::endl;
5406 }
5407 pchild = pchild->NextSibling();
5408 }
5409 XML_CHECK_END();
5410 aec->CommCtrl.stSyncTest.HdrAlterExp.array_size = index + 1;
5411 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5412 return (true);
5413 }
5414
parseEntrySensorAecAlterExp(const XMLElement * pelement,void * param)5415 bool RkAiqCalibParser::parseEntrySensorAecAlterExp
5416 (
5417 const XMLElement* pelement,
5418 void* param
5419 ) {
5420 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5421 autoTabForward();
5422
5423 XML_CHECK_START(CALIB_SENSOR_AEC_SYNCTEST_ALTEREXP_TAG_ID, CALIB_SENSOR_AEC_SYNCTEST_TAG_ID);
5424
5425 #ifdef DEBUG_LOG
5426 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
5427 #endif
5428 const XMLNode* psubchild = pelement->FirstChild();
5429 while (psubchild) {
5430 XmlTag subTag = XmlTag(psubchild->ToElement());
5431 std::string subTagname(psubchild->ToElement()->Name());
5432 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
5433 #ifdef DEBUG_LOG
5434 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
5435 #endif
5436 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_LINALTEREXP_TAG_ID)) {
5437 if (!parseEntryCell(psubchild->ToElement(), subTag.Size(),
5438 &RkAiqCalibParser::parseEntrySensorAecLinAlterExp,
5439 param,
5440 (uint32_t)CALIB_SENSOR_AEC_SYNCTEST_LINALTEREXP_TAG_ID,
5441 (uint32_t)CALIB_SENSOR_AEC_SYNCTEST_ALTEREXP_TAG_ID)) {
5442 LOGE("parse error in AEC-SyncTest LinAlterExp(%s)", subTagname.c_str());
5443 return (false);
5444 }
5445 }
5446 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_HDRALTEREXP_TAG_ID)) {
5447 if (!parseEntryCell(psubchild->ToElement(), subTag.Size(),
5448 &RkAiqCalibParser::parseEntrySensorAecHdrAlterExp,
5449 param,
5450 (uint32_t)CALIB_SENSOR_AEC_SYNCTEST_HDRALTEREXP_TAG_ID,
5451 (uint32_t)CALIB_SENSOR_AEC_SYNCTEST_ALTEREXP_TAG_ID)) {
5452 LOGE("parse error in AEC-SyncTest HdrAlterExp(%s)", subTagname.c_str());
5453 return (false);
5454 }
5455 }
5456 else {
5457 LOGW("%s(%d): parse error in AEC-SyncTest AlterExp (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
5458 }
5459 psubchild = psubchild->NextSibling();
5460 }
5461
5462 XML_CHECK_END();
5463 autoTabBackward();
5464 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5465 return (true);
5466 }
5467
parseEntrySensorAecSyncTest(const XMLElement * pelement,void * param)5468 bool RkAiqCalibParser::parseEntrySensorAecSyncTest
5469 (
5470 const XMLElement* pelement,
5471 void* param
5472 ) {
5473 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5474 autoTabForward();
5475
5476 XML_CHECK_START(CALIB_SENSOR_AEC_SYNCTEST_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
5477
5478 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
5479
5480 const XMLNode* psubchild = pelement->FirstChild();
5481 #ifdef DEBUG_LOG
5482 LOGE("%s(%d): Tagname = [%s]\n", __FUNCTION__, __LINE__, pelement->Name());
5483 #endif
5484 while (psubchild) {
5485 XmlTag subTag = XmlTag(psubchild->ToElement());
5486 std::string subTagname(psubchild->ToElement()->Name());
5487 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
5488 #ifdef DEBUG_LOG
5489 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
5490 #endif
5491 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_ENABLE_TAG_ID)) {
5492 int no = ParseUcharArray(psubchild, &aec->CommCtrl.stSyncTest.enable, subTag.Size());
5493 DCT_ASSERT((no == subTag.Size()));
5494 }
5495 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_INTERVALFRM_TAG_ID)) {
5496 int no = ParseIntArray(psubchild, &aec->CommCtrl.stSyncTest.IntervalFrm, subTag.Size());
5497 DCT_ASSERT((no == subTag.Size()));
5498 }
5499 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_ALTEREXP_TAG_ID)) {
5500 if (!parseEntrySensorAecAlterExp(psubchild->ToElement(), param)) {
5501 LOGE("parse error in Aec-SyncTest AlterExp(%s)", subTagname.c_str());
5502 return (false);
5503 }
5504 }
5505 else {
5506 LOGW("%s(%d): parse error in Aec-SyncTest (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
5507 }
5508 psubchild = psubchild->NextSibling();
5509 }
5510 XML_CHECK_END();
5511 autoTabBackward();
5512 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5513 return (true);
5514 }
5515
5516
parseEntrySensorAecSpeed(const XMLElement * pelement,void * param)5517 bool RkAiqCalibParser::parseEntrySensorAecSpeed
5518 (
5519 const XMLElement* pelement,
5520 void* param
5521 ) {
5522 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5523 autoTabForward();
5524
5525 XML_CHECK_START(CALIB_SENSOR_AEC_AECSPEED_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
5526
5527 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
5528 bool newparams = false;
5529 const XMLNode* psubchild = pelement->FirstChild();
5530 #ifdef DEBUG_LOG
5531 LOGE("%s(%d): Tagname = [%s]\n", __FUNCTION__, __LINE__, pelement->Name());
5532 #endif
5533 while (psubchild) {
5534 XmlTag subTag = XmlTag(psubchild->ToElement());
5535 std::string subTagname(psubchild->ToElement()->Name());
5536 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
5537 #ifdef DEBUG_LOG
5538 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
5539 #endif
5540 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_DYDAMPEN_TAG_ID)) {
5541 uint8_t temp = aec->CommCtrl.stAuto.stAeSpeed.DyDampEn;
5542 int no = ParseUcharArray(psubchild, &temp, subTag.Size());
5543 aec->CommCtrl.stAuto.stAeSpeed.DyDampEn = (temp == 0) ? false : true;
5544 newparams = true;
5545 DCT_ASSERT((no == subTag.Size()));
5546 }
5547 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SMOOTHEN_TAG_ID)) {
5548 uint8_t temp = aec->CommCtrl.stAuto.stAeSpeed.SmoothEn;
5549 int no = ParseUcharArray(psubchild, &temp, subTag.Size());
5550 aec->CommCtrl.stAuto.stAeSpeed.SmoothEn = (temp == 0) ? false : true;
5551 newparams = true;
5552 DCT_ASSERT((no == subTag.Size()));
5553 }
5554 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_DAMPOVER_TAG_ID)) {
5555 int no = ParseFloatArray(psubchild, &aec->CommCtrl.stAuto.stAeSpeed.DampOver, subTag.Size());
5556 DCT_ASSERT((no == subTag.Size()));
5557 }
5558 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_DAMPUNDER_TAG_ID)) {
5559 int no = ParseFloatArray(psubchild, &aec->CommCtrl.stAuto.stAeSpeed.DampUnder, subTag.Size());
5560 DCT_ASSERT((no == subTag.Size()));
5561 }
5562 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_DAMPDARK2BRIGHT_TAG_ID)) {
5563 int no = ParseFloatArray(psubchild, &aec->CommCtrl.stAuto.stAeSpeed.DampDark2Bright, subTag.Size());
5564 DCT_ASSERT((no == subTag.Size()));
5565 }
5566 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_DAMPBRIGHT2DARK_TAG_ID)) {
5567 int no = ParseFloatArray(psubchild, &aec->CommCtrl.stAuto.stAeSpeed.DampBright2Dark, subTag.Size());
5568 DCT_ASSERT((no == subTag.Size()));
5569 }
5570 else {
5571 LOGW("%s(%d): parse error in AeSpeed (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
5572 }
5573 psubchild = psubchild->NextSibling();
5574 }
5575 if(newparams == false) {
5576 aec->CommCtrl.stAuto.stAeSpeed.DyDampEn = true;
5577 aec->CommCtrl.stAuto.stAeSpeed.SmoothEn = true;
5578 }
5579
5580 XML_CHECK_END();
5581 autoTabBackward();
5582 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5583 return (true);
5584 }
5585
parseEntrySensorAecDelayFrmNum(const XMLElement * pelement,void * param)5586 bool RkAiqCalibParser::parseEntrySensorAecDelayFrmNum
5587 (
5588 const XMLElement* pelement,
5589 void* param
5590 ) {
5591 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5592
5593 XML_CHECK_START(CALIB_SENSOR_AEC_AECDELAYFRMNUM_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
5594
5595 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
5596
5597 const XMLNode* psubchild = pelement->FirstChild();
5598 autoTabForward();
5599 #ifdef DEBUG_LOG
5600 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
5601 #endif
5602 while (psubchild) {
5603 XmlTag subTag = XmlTag(psubchild->ToElement());
5604 std::string subTagname(psubchild->ToElement()->Name());
5605 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
5606 #ifdef DEBUG_LOG
5607 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
5608 #endif
5609 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_BLACKDELAY_TAG_ID)) {
5610 int no = ParseUcharArray(psubchild, &aec->CommCtrl.stAuto.BlackDelayFrame, subTag.Size());
5611 DCT_ASSERT((no == subTag.Size()));
5612 }
5613 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_WHITEDELAY_TAG_ID)) {
5614 int no = ParseUcharArray(psubchild, &aec->CommCtrl.stAuto.WhiteDelayFrame, subTag.Size());
5615 DCT_ASSERT((no == subTag.Size()));
5616 }
5617 else {
5618 LOGW("%s(%d): parse error in AeDelayFrame (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
5619 }
5620 psubchild = psubchild->NextSibling();
5621 }
5622 XML_CHECK_END();
5623 autoTabBackward();
5624 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5625 return (true);
5626 }
5627
parseEntrySensorAecVBNightMode(const XMLElement * pelement,void * param)5628 bool RkAiqCalibParser::parseEntrySensorAecVBNightMode
5629 (
5630 const XMLElement* pelement,
5631 void* param
5632 ) {
5633 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5634
5635 XML_CHECK_START(CALIB_SENSOR_AEC_AECDNSWITCH_VBNIGHTMODE_TAG_ID, CALIB_SENSOR_AEC_AECDNSWITCH_TAG_ID);
5636
5637 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
5638
5639 XmlTag subTag = XmlTag(pelement);
5640
5641 const XMLNode* psubsubchild = pelement->FirstChild();
5642 autoTabForward();
5643 while (psubsubchild) {
5644 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
5645 std::string subsubTagname(psubsubchild->ToElement()->Name());
5646 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
5647 #ifdef DEBUG_LOG
5648 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
5649 #endif
5650 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_ENABLE_TAG_ID)) {
5651 int no = ParseUcharArray(psubsubchild, &aec->CommCtrl.stDNSwitch.stVBNightMode.enable, subTag.Size());
5652 DCT_ASSERT((no == subsubTag.Size()));
5653 }
5654 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_N2DFRMCNT_TAG_ID)) {
5655 int no = ParseUcharArray(psubsubchild, &aec->CommCtrl.stDNSwitch.stVBNightMode.Night2DayFrmCnt, subTag.Size());
5656 DCT_ASSERT((no == subsubTag.Size()));
5657 }
5658 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_N2DFACTH_TAG_ID)) {
5659 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stDNSwitch.stVBNightMode.Night2DayFacTh, subTag.Size());
5660 DCT_ASSERT((no == subsubTag.Size()));
5661 }
5662 else {
5663 LOGW("%s(%d): parse error in DNSwitch - VBNightMode(unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
5664 }
5665 psubsubchild = psubsubchild->NextSibling();
5666 }
5667 XML_CHECK_END();
5668 autoTabBackward();
5669 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5670 return (true);
5671 }
5672
parseEntrySensorAecIRNightMode(const XMLElement * pelement,void * param)5673 bool RkAiqCalibParser::parseEntrySensorAecIRNightMode
5674 (
5675 const XMLElement* pelement,
5676 void* param
5677 ) {
5678 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5679
5680 XML_CHECK_START(CALIB_SENSOR_AEC_AECDNSWITCH_IRNIGHTMODE_TAG_ID, CALIB_SENSOR_AEC_AECDNSWITCH_TAG_ID);
5681
5682 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
5683
5684 XmlTag subTag = XmlTag(pelement);
5685 const XMLNode* psubsubchild = pelement->FirstChild();
5686 autoTabForward();
5687 while (psubsubchild) {
5688 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
5689 std::string subsubTagname(psubsubchild->ToElement()->Name());
5690 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
5691 #ifdef DEBUG_LOG
5692 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
5693 #endif
5694 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_ENABLE_TAG_ID)) {
5695 int no = ParseUcharArray(psubsubchild, &aec->CommCtrl.stDNSwitch.stIRNightMode.enable, subTag.Size());
5696 DCT_ASSERT((no == subsubTag.Size()));
5697 }
5698 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_N2DFRMCNT_TAG_ID)) {
5699 int no = ParseUcharArray(psubsubchild, &aec->CommCtrl.stDNSwitch.stIRNightMode.Night2DayFrmCnt, subTag.Size());
5700 DCT_ASSERT((no == subsubTag.Size()));
5701 }
5702 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_N2DFACTH_TAG_ID)) {
5703 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stDNSwitch.stIRNightMode.Night2DayFacTh, subTag.Size());
5704 DCT_ASSERT((no == subsubTag.Size()));
5705 }
5706 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_IR_RG_TAG_ID)) {
5707 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stDNSwitch.stIRNightMode.IRRgain, subTag.Size());
5708 DCT_ASSERT((no == subsubTag.Size()));
5709 }
5710 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_IR_BG_TAG_ID)) {
5711 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stDNSwitch.stIRNightMode.IRBgain, subTag.Size());
5712 DCT_ASSERT((no == subsubTag.Size()));
5713 }
5714 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_MAX_DIS_TAG_ID)) {
5715 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stDNSwitch.stIRNightMode.MaxWbDis, subTag.Size());
5716 DCT_ASSERT((no == subsubTag.Size()));
5717 }
5718 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_VB_PERCENT_TAG_ID)) {
5719 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stDNSwitch.stIRNightMode.VbPercent, subTag.Size());
5720 DCT_ASSERT((no == subsubTag.Size()));
5721 } else {
5722 LOGW("%s(%d): parse error in DNSwitch - IRNightMode(unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
5723 }
5724 psubsubchild = psubsubchild->NextSibling();
5725 }
5726
5727 XML_CHECK_END();
5728 autoTabBackward();
5729 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5730 return (true);
5731 }
5732
5733
parseEntrySensorAecDNSwitch(const XMLElement * pelement,void * param)5734 bool RkAiqCalibParser::parseEntrySensorAecDNSwitch
5735 (
5736 const XMLElement* pelement,
5737 void* param
5738 ) {
5739 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5740
5741 XML_CHECK_START(CALIB_SENSOR_AEC_AECDNSWITCH_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
5742
5743 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
5744 const XMLNode* psubchild = pelement->FirstChild();
5745 autoTabForward();
5746 #ifdef DEBUG_LOG
5747 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
5748 #endif
5749 while (psubchild) {
5750 XmlTag subTag = XmlTag(psubchild->ToElement());
5751 std::string subTagname(psubchild->ToElement()->Name());
5752 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
5753
5754 #ifdef DEBUG_LOG
5755 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
5756 #endif
5757 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_DNTRIGGER_TAG_ID)) {
5758 int no = ParseUcharArray(psubchild, &aec->CommCtrl.stDNSwitch.DNTrigger, subTag.Size());
5759 DCT_ASSERT((no == subTag.Size()));
5760 }
5761 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_DNMODE_TAG_ID)) {
5762 char* value = Toupper(subTag.Value());
5763 std::string s_value(value);
5764 if (xmlParseReadWrite == XML_PARSER_READ)
5765 {
5766 if (s_value == CALIB_SENSOR_AEC_AECDNSWITCH_DNMODE_DAY) {
5767 aec->CommCtrl.stDNSwitch.DNMode = AEC_DNMODE_DAY;
5768 }
5769 else if (s_value == CALIB_SENSOR_AEC_AECDNSWITCH_DNMODE_NIGHT) {
5770 aec->CommCtrl.stDNSwitch.DNMode = AEC_DNMODE_NIGHT;
5771 }
5772 else {
5773 aec->CommCtrl.stDNSwitch.DNMode = AEC_DNMODE_MIN;
5774 LOGE("%s(%d): invalid AEC DNSwitch-DNMode = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
5775 }
5776 }
5777 else if (xmlParseReadWrite == XML_PARSER_WRITE)
5778 {
5779 XMLNode *pNode = (XMLNode*)psubchild;
5780 if (aec->CommCtrl.stDNSwitch.DNMode == AEC_DNMODE_DAY) {
5781 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_AECDNSWITCH_DNMODE_DAY);
5782 }
5783 else if (aec->CommCtrl.stDNSwitch.DNMode == AEC_DNMODE_NIGHT) {
5784 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_AECDNSWITCH_DNMODE_NIGHT);
5785 }
5786 else {
5787 pNode->FirstChild()->SetValue("Invalid");
5788 LOGE("%s(%d): (XML Write)invalid AEC DNSwitch-DNMode = %d\n", __FUNCTION__, __LINE__, aec->CommCtrl.stDNSwitch.DNMode);
5789 }
5790
5791 }
5792 }
5793 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_FILLLIGHTMODE_TAG_ID)) {
5794 int no = ParseUcharArray(psubchild, &aec->CommCtrl.stDNSwitch.FillLightMode, subTag.Size());
5795 DCT_ASSERT((no == subTag.Size()));
5796 }
5797 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_D2NFACTH_TAG_ID)) {
5798 int no = ParseFloatArray(psubchild, &aec->CommCtrl.stDNSwitch.Day2NightFacTh, subTag.Size());
5799 DCT_ASSERT((no == subTag.Size()));
5800 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_D2NFRMCNT_TAG_ID)) {
5801 int no = ParseUcharArray(psubchild, &aec->CommCtrl.stDNSwitch.Day2NightFrmCnt, subTag.Size());
5802 DCT_ASSERT((no == subTag.Size()));
5803 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_VBNIGHTMODE_TAG_ID)) {
5804 if (!parseEntrySensorAecVBNightMode(psubchild->ToElement())) {
5805 LOGE("parse error in Aec (%s)", subTagname.c_str());
5806 return (false);
5807 }
5808 }
5809 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_IRNIGHTMODE_TAG_ID)) {
5810 if (!parseEntrySensorAecIRNightMode(psubchild->ToElement())) {
5811 LOGE("parse error in Aec (%s)", subTagname.c_str());
5812 return (false);
5813 }
5814 }
5815 else {
5816 LOGW("%s(%d): parse error in DNSwitch (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
5817 }
5818 psubchild = psubchild->NextSibling();
5819 }
5820
5821 XML_CHECK_END();
5822 autoTabBackward();
5823 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5824 return (true);
5825 }
5826
parseEntrySensorAecAntiFlicker(const XMLElement * pelement,void * param)5827 bool RkAiqCalibParser::parseEntrySensorAecAntiFlicker
5828 (
5829 const XMLElement* pelement,
5830 void* param
5831 ) {
5832 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5833 autoTabForward();
5834
5835 XML_CHECK_START(CALIB_SENSOR_AEC_ANTIFLICKER_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
5836
5837 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
5838
5839 const XMLNode* psubchild = pelement->FirstChild();
5840 #ifdef DEBUG_LOG
5841 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
5842 #endif
5843 while (psubchild) {
5844 XmlTag subTag = XmlTag(psubchild->ToElement());
5845 std::string subTagname(psubchild->ToElement()->Name());
5846 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
5847 #ifdef DEBUG_LOG
5848 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
5849 #endif
5850 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_ANTIFLICKER_ENABLE_TAG_ID)) {
5851 uint8_t temp = aec->CommCtrl.stAntiFlicker.enable;
5852 int no = ParseUcharArray(psubchild, &temp, subTag.Size());
5853 aec->CommCtrl.stAntiFlicker.enable = (temp == 0) ? false : true;
5854 DCT_ASSERT((no == subTag.Size()));
5855 }
5856 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_ANTIFLICKER_FREQ_TAG_ID)) {
5857 char* value = Toupper(subTag.Value());
5858 std::string s_value(value);
5859 if (xmlParseReadWrite == XML_PARSER_READ)
5860 {
5861 if (s_value == CALIB_SENSOR_AEC_ANTIFLICKER_FREQ_50HZ) {
5862 aec->CommCtrl.stAntiFlicker.Frequency = AEC_FLICKER_FREQUENCY_50HZ;
5863 }
5864 else if (s_value == CALIB_SENSOR_AEC_ANTIFLICKER_FREQ_60HZ) {
5865 aec->CommCtrl.stAntiFlicker.Frequency = AEC_FLICKER_FREQUENCY_60HZ;
5866 }
5867 else if (s_value == CALIB_SENSOR_AEC_ANTIFLICKER_FREQ_AUTO) {
5868 mCalibDb->aec.CommCtrl.stAntiFlicker.Frequency = AEC_FLICKER_FREQUENCY_AUTO;
5869 }
5870 else {
5871 aec->CommCtrl.stAntiFlicker.Frequency = AEC_FLICKER_FREQUENCY_OFF;
5872 LOGE("%s(%d): invalid stAntiFlicker.Frequency = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
5873 }
5874 }
5875 else if (xmlParseReadWrite == XML_PARSER_WRITE)
5876 {
5877 XMLNode *pNode = (XMLNode*)psubchild;
5878 if (aec->CommCtrl.stAntiFlicker.Frequency == AEC_FLICKER_FREQUENCY_50HZ) {
5879 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_ANTIFLICKER_FREQ_50HZ);
5880 }
5881 else if (aec->CommCtrl.stAntiFlicker.Frequency == AEC_FLICKER_FREQUENCY_60HZ) {
5882 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_ANTIFLICKER_FREQ_60HZ);
5883 }
5884 else if (mCalibDb->aec.CommCtrl.stAntiFlicker.Frequency == AEC_FLICKER_FREQUENCY_AUTO) {
5885 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_ANTIFLICKER_FREQ_AUTO);
5886 }
5887 else {
5888 pNode->FirstChild()->SetValue("Invalid");
5889 LOGE("%s(%d): (XML Write)invalid AEC stAntiFlicker.Frequency = %d\n", __FUNCTION__, __LINE__, aec->CommCtrl.stAntiFlicker.Frequency);
5890 }
5891
5892 }
5893 }
5894 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_ANTIFLICKER_MODE_TAG_ID)) {
5895 char* value = Toupper(subTag.Value());
5896 std::string s_value(value);
5897 if (xmlParseReadWrite == XML_PARSER_READ)
5898 {
5899 if (s_value == CALIB_SENSOR_AEC_ANTIFLICKER_MODE_AUTO) {
5900 aec->CommCtrl.stAntiFlicker.Mode = AEC_ANTIFLICKER_AUTO_MODE;
5901 }
5902 else if (s_value == CALIB_SENSOR_AEC_ANTIFLICKER_MODE_NORMAL) {
5903 aec->CommCtrl.stAntiFlicker.Mode = AEC_ANTIFLICKER_NORMAL_MODE;
5904 }
5905 else {
5906 aec->CommCtrl.stAntiFlicker.Mode = AEC_ANTIFLICKER_AUTO_MODE;
5907 LOGE("%s(%d): invalid stAntiFlicker.Mode = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
5908 }
5909 }
5910 else if (xmlParseReadWrite == XML_PARSER_WRITE)
5911 {
5912 XMLNode *pNode = (XMLNode*)psubchild;
5913 if (aec->CommCtrl.stAntiFlicker.Mode == AEC_ANTIFLICKER_AUTO_MODE) {
5914 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_ANTIFLICKER_MODE_AUTO);
5915 }
5916 else if (aec->CommCtrl.stAntiFlicker.Mode == AEC_ANTIFLICKER_NORMAL_MODE) {
5917 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_ANTIFLICKER_MODE_NORMAL);
5918 }
5919 else {
5920 pNode->FirstChild()->SetValue("Invalid");
5921 LOGE("%s(%d): (XML Write)invalid AEC stAntiFlicker.Mode = %d\n", __FUNCTION__, __LINE__, aec->CommCtrl.stAntiFlicker.Mode);
5922 }
5923
5924 }
5925 }
5926 else {
5927 redirectOut << "parse error in stAntiFlicker (unknow tag: "
5928 << subTagname
5929 << ")"
5930 << std::endl;
5931 }
5932 psubchild = psubchild->NextSibling();
5933 }
5934
5935 XML_CHECK_END();
5936 autoTabBackward();
5937 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5938 return (true);
5939 }
5940
parseEntrySensorAecFrameRateMode(const XMLElement * pelement,void * param)5941 bool RkAiqCalibParser::parseEntrySensorAecFrameRateMode
5942 (
5943 const XMLElement* pelement,
5944 void* param
5945 ) {
5946 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5947 autoTabForward();
5948
5949 XML_CHECK_START(CALIB_SENSOR_AEC_AECFRAMERATEMODE_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
5950
5951 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
5952
5953 const XMLNode* psubchild = pelement->FirstChild();
5954 #ifdef DEBUG_LOG
5955 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
5956 #endif
5957 while (psubchild) {
5958 XmlTag subTag = XmlTag(psubchild->ToElement());
5959 std::string subTagname(psubchild->ToElement()->Name());
5960 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
5961 #ifdef DEBUG_LOG
5962 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
5963 #endif
5964 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_ISFPSFIX_TAG_ID)) {
5965 uint8_t temp = aec->CommCtrl.stAuto.stFrmRate.isFpsFix;
5966 int no = ParseUcharArray(psubchild, &temp, subTag.Size());
5967 aec->CommCtrl.stAuto.stFrmRate.isFpsFix = (temp == 0) ? false : true;
5968 DCT_ASSERT((no == subTag.Size()));
5969 }
5970 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_FPSVALUE_TAG_ID)) {
5971 int no = ParseFloatArray(psubchild, &aec->CommCtrl.stAuto.stFrmRate.FpsValue, subTag.Size());
5972 DCT_ASSERT((no == subTag.Size()));
5973 }
5974 else {
5975 redirectOut << "parse error in stFrmRate (unknow tag: "
5976 << subTagname
5977 << ")"
5978 << std::endl;
5979 }
5980 psubchild = psubchild->NextSibling();
5981 }
5982
5983 XML_CHECK_END();
5984 autoTabBackward();
5985 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
5986 return (true);
5987 }
5988
parseEntrySensorAecInitValueLinearAE(const XMLElement * pelement,void * param)5989 bool RkAiqCalibParser::parseEntrySensorAecInitValueLinearAE
5990 (
5991 const XMLElement* pelement,
5992 void* param
5993 ) {
5994 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
5995 autoTabForward();
5996 XML_CHECK_START(CALIB_SENSOR_AEC_AECINITVALUE_LINEARAE_TAG_ID, CALIB_SENSOR_AEC_AECINITVALUE_TAG_ID);
5997
5998 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
5999
6000 const XMLNode* psubsubchild = pelement->FirstChild();
6001 while (psubsubchild) {
6002 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
6003 std::string subsubTagname(psubsubchild->ToElement()->Name());
6004 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
6005 #ifdef DEBUG_LOG
6006 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6007 #endif
6008 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_INITTIMEVALUE_TAG_ID)) {
6009 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stInitExp.stLinExpInitExp.InitTimeValue, subsubTag.Size());
6010 DCT_ASSERT((no == subsubTag.Size()));
6011 aec->CommCtrl.stInitExp.stLinExpInitExp.array_size = no;
6012 }
6013 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_INITGAINVALUE_TAG_ID)) {
6014 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stInitExp.stLinExpInitExp.InitGainValue, subsubTag.Size());
6015 DCT_ASSERT((no == subsubTag.Size()));
6016 }
6017 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_INITISPDGAINVALUE_TAG_ID)) {
6018 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stInitExp.stLinExpInitExp.InitIspDGainValue, subsubTag.Size());
6019 DCT_ASSERT((no == subsubTag.Size()));
6020 }
6021 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_INITPIRISVALUE_TAG_ID)) {
6022 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stInitExp.stLinExpInitExp.InitPIrisGainValue, subsubTag.Size());
6023 DCT_ASSERT((no == subsubTag.Size()));
6024 }
6025 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_INITDCIRISVALUE_TAG_ID)) {
6026 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stInitExp.stLinExpInitExp.InitDCIrisDutyValue, subsubTag.Size());
6027 DCT_ASSERT((no == subsubTag.Size()));
6028 }
6029 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_INITHDCIRISVALUE_TAG_ID)) {
6030 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stInitExp.stLinExpInitExp.InitHDCIrisTargetValue, subsubTag.Size());
6031 DCT_ASSERT((no == subsubTag.Size()));
6032 }
6033 else {
6034 LOGW("%s(%d): parse error in stLinExpInitExp (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6035 }
6036 psubsubchild = psubsubchild->NextSibling();
6037 }
6038
6039 XML_CHECK_END();
6040 autoTabBackward();
6041 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6042 return (true);
6043 }
6044
parseEntrySensorAecInitValueHdrAE(const XMLElement * pelement,void * param)6045 bool RkAiqCalibParser::parseEntrySensorAecInitValueHdrAE
6046 (
6047 const XMLElement* pelement,
6048 void* param
6049 ) {
6050 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6051 autoTabForward();
6052 XML_CHECK_START(CALIB_SENSOR_AEC_AECINITVALUE_HDRAE_TAG_ID, CALIB_SENSOR_AEC_AECINITVALUE_TAG_ID);
6053
6054 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
6055
6056 const XMLNode* psubsubchild = pelement->FirstChild();
6057 while (psubsubchild) {
6058 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
6059 std::string subsubTagname(psubsubchild->ToElement()->Name());
6060 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
6061 #ifdef DEBUG_LOG
6062 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6063 #endif
6064 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_INITTIMEVALUE_TAG_ID)) {
6065 float tempVal[3];
6066 for (int i = 0; i < 3; i++)
6067 tempVal[i] = aec->CommCtrl.stInitExp.stHdrExpInitExp.InitTimeValue.fCoeff[i];
6068 int no = ParseFloatArray(psubsubchild, tempVal, subsubTag.Size());
6069 DCT_ASSERT((no == subsubTag.Size()));
6070 for (int i = 0; i < 3; i++)
6071 aec->CommCtrl.stInitExp.stHdrExpInitExp.InitTimeValue.fCoeff[i] = tempVal[i];
6072 aec->CommCtrl.stInitExp.stHdrExpInitExp.array_size = no;
6073 }
6074 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_INITGAINVALUE_TAG_ID)) {
6075 float tempVal[3];
6076 for (int i = 0; i < 3; i++)
6077 tempVal[i] = aec->CommCtrl.stInitExp.stHdrExpInitExp.InitGainValue.fCoeff[i];
6078 int no = ParseFloatArray(psubsubchild, tempVal, subsubTag.Size());
6079 DCT_ASSERT((no == subsubTag.Size()));
6080 for (int i = 0; i < 3; i++)
6081 aec->CommCtrl.stInitExp.stHdrExpInitExp.InitGainValue.fCoeff[i] = tempVal[i];
6082 }
6083 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_INITISPDGAINVALUE_TAG_ID)) {
6084 float tempVal[3];
6085 for (int i = 0; i < 3; i++)
6086 tempVal[i] = aec->CommCtrl.stInitExp.stHdrExpInitExp.InitIspDGainValue.fCoeff[i];
6087 int no = ParseFloatArray(psubsubchild, tempVal, subsubTag.Size());
6088 DCT_ASSERT((no == subsubTag.Size()));
6089 for (int i = 0; i < 3; i++)
6090 aec->CommCtrl.stInitExp.stHdrExpInitExp.InitIspDGainValue.fCoeff[i] = tempVal[i];
6091 }
6092 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_INITPIRISVALUE_TAG_ID)) {
6093 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stInitExp.stHdrExpInitExp.InitPIrisGainValue, subsubTag.Size());
6094 DCT_ASSERT((no == subsubTag.Size()));
6095 }
6096 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_INITDCIRISVALUE_TAG_ID)) {
6097 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stInitExp.stHdrExpInitExp.InitDCIrisDutyValue, subsubTag.Size());
6098 DCT_ASSERT((no == subsubTag.Size()));
6099 }
6100 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_INITHDCIRISVALUE_TAG_ID)) {
6101 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stInitExp.stHdrExpInitExp.InitHDCIrisTargetValue, subsubTag.Size());
6102 DCT_ASSERT((no == subsubTag.Size()));
6103 }
6104 else {
6105 LOGW("%s(%d): parse error in stHdrExpInitExp (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6106 }
6107 psubsubchild = psubsubchild->NextSibling();
6108 }
6109
6110 XML_CHECK_END();
6111 autoTabBackward();
6112 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6113 return (true);
6114 }
6115
6116
parseEntrySensorAecInitValue(const XMLElement * pelement,void * param)6117 bool RkAiqCalibParser::parseEntrySensorAecInitValue
6118 (
6119 const XMLElement* pelement,
6120 void* param
6121 ) {
6122 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6123 autoTabForward();
6124
6125 XML_CHECK_START(CALIB_SENSOR_AEC_AECINITVALUE_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
6126
6127 const XMLNode* psubchild = pelement->FirstChild();
6128
6129 #ifdef DEBUG_LOG
6130 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
6131 #endif
6132 while (psubchild) {
6133 XmlTag subTag = XmlTag(psubchild->ToElement());
6134 std::string subTagname(psubchild->ToElement()->Name());
6135 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
6136 #ifdef DEBUG_LOG
6137 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
6138 #endif
6139 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECINITVALUE_LINEARAE_TAG_ID)) {
6140 if (!parseEntrySensorAecInitValueLinearAE(psubchild->ToElement(), param)) {
6141 LOGE("parse error in Aec (%s)", subTagname.c_str());
6142 return (false);
6143 }
6144 }
6145 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECINITVALUE_HDRAE_TAG_ID)) {
6146 if (!parseEntrySensorAecInitValueHdrAE(psubchild->ToElement(), param)) {
6147 LOGE("parse error in Aec (%s)", subTagname.c_str());
6148 return (false);
6149 }
6150 }
6151 else {
6152 LOGW("%s(%d): parse error in stInitExp (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
6153 }
6154 psubchild = psubchild->NextSibling();
6155 }
6156
6157 XML_CHECK_END();
6158 autoTabBackward();
6159 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6160 return (true);
6161 }
6162
parseEntrySensorAecGridWeight(const XMLElement * pelement,void * param)6163 bool RkAiqCalibParser::parseEntrySensorAecGridWeight
6164 (
6165 const XMLElement* pelement,
6166 void* param
6167 ) {
6168 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6169 autoTabForward();
6170
6171 XML_CHECK_START(CALIB_SENSOR_AEC_AECGRIDWEIGHT_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
6172
6173 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
6174
6175 XMLNode* psubchild = (XMLNode*)pelement->FirstChild();
6176 #ifdef DEBUG_LOG
6177 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
6178 #endif
6179
6180 while (psubchild) {
6181 XmlTag subTag = XmlTag(psubchild->ToElement());
6182 std::string subTagname(psubchild->ToElement()->Name());
6183 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
6184 #ifdef DEBUG_LOG
6185 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
6186 #endif
6187 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_DAYGRIDWEIGHTS_TAG_ID)) {
6188 if (xmlParseReadWrite == XML_PARSER_WRITE)
6189 {
6190 char str[20];
6191 if (aec->CommCtrl.DayWeightNum == 25)
6192 snprintf(str, sizeof(str), "[5 5]");
6193 else
6194 snprintf(str, sizeof(str), "[15 15]");
6195 psubchild->ToElement()->SetAttribute(CALIB_ATTRIBUTE_SIZE, str);
6196 }
6197
6198 int no = ParseUcharArray(psubchild, aec->CommCtrl.DayGridWeights.uCoeff, subTag.Size());
6199 DCT_ASSERT((no == subTag.Size()));
6200 DCT_ASSERT((no == AEC_RAWAEBIG_WIN_NUM || no == AEC_RAWAELITE_WIN_NUM));
6201 aec->CommCtrl.DayWeightNum = no;
6202 }
6203 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_NIGHTGRIDWEIGHTS_TAG_ID)) {
6204 if (xmlParseReadWrite == XML_PARSER_WRITE)
6205 {
6206 char str[20];
6207 if (aec->CommCtrl.NightWeightNum == 25)
6208 snprintf(str, sizeof(str), "[5 5]");
6209 else
6210 snprintf(str, sizeof(str), "[15 15]");
6211 psubchild->ToElement()->SetAttribute(CALIB_ATTRIBUTE_SIZE, str);
6212 }
6213
6214 int no = ParseUcharArray(psubchild, aec->CommCtrl.NightGridWeights.uCoeff, subTag.Size());
6215 DCT_ASSERT((no == subTag.Size()));
6216 DCT_ASSERT((no == AEC_RAWAEBIG_WIN_NUM || no == AEC_RAWAELITE_WIN_NUM));
6217 aec->CommCtrl.NightWeightNum = no;
6218 }
6219 else {
6220 redirectOut
6221 << "parse error in Gridweights (unknow tag: "
6222 << subTagname
6223 << ")"
6224 << std::endl;
6225 }
6226 psubchild = psubchild->NextSibling();
6227 }
6228
6229 XML_CHECK_END();
6230 autoTabBackward();
6231 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6232 return (true);
6233 }
6234
parseEntrySensorAecIrisCtrlPAttr(const XMLElement * pelement,void * param)6235 bool RkAiqCalibParser::parseEntrySensorAecIrisCtrlPAttr
6236 (
6237 const XMLElement* pelement,
6238 void* param
6239 ) {
6240 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6241 autoTabForward();
6242
6243 XML_CHECK_START(CALIB_SENSOR_AEC_IRISCTRL_P_ATTR_TAG_ID, CALIB_SENSOR_AEC_IRISCTRL_TAG_ID);
6244
6245 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
6246
6247 const XMLNode* psubsubchild = pelement->FirstChild();
6248 while (psubsubchild) {
6249 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
6250 std::string subsubTagname(psubsubchild->ToElement()->Name());
6251 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
6252 #ifdef DEBUG_LOG
6253 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6254 #endif
6255 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_P_ATTR_TOTALSTEP_TAG_ID)) {
6256 int no = ParseUshortArray(psubsubchild, &aec->CommCtrl.stIris.PIrisAttr.TotalStep, subsubTag.Size());
6257 DCT_ASSERT((no == subsubTag.Size()));
6258 DCT_ASSERT((no <= AEC_PIRIS_STAP_TABLE_MAX));
6259 }
6260 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_P_ATTR_EFFCSTEP_TAG_ID)) {
6261 int no = ParseUshortArray(psubsubchild, &aec->CommCtrl.stIris.PIrisAttr.EffcStep, subsubTag.Size());
6262 DCT_ASSERT((no == subsubTag.Size()));
6263 DCT_ASSERT((no <= AEC_PIRIS_STAP_TABLE_MAX));
6264 }
6265 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_P_ATTR_ZEROISMAX_TAG_ID)) {
6266 uint8_t temp = aec->CommCtrl.stIris.PIrisAttr.ZeroIsMax;
6267 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
6268 aec->CommCtrl.stIris.PIrisAttr.ZeroIsMax = (temp == 0) ? false : true;
6269 DCT_ASSERT((no == subsubTag.Size()));
6270 }
6271 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_P_ATTR_STEPTABLE_TAG_ID)) {
6272 int no = ParseUshortArray(psubsubchild, aec->CommCtrl.stIris.PIrisAttr.StepTable, subsubTag.Size());
6273 DCT_ASSERT((no == subsubTag.Size()));
6274 DCT_ASSERT((no <= AEC_PIRIS_STAP_TABLE_MAX));
6275 }
6276 else {
6277 LOGW("%s(%d): parse error in AecIrisCtrl PAttr (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6278 }
6279 psubsubchild = psubsubchild->NextSibling();
6280 }
6281
6282 XML_CHECK_END();
6283 autoTabBackward();
6284 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6285 return (true);
6286 }
6287
parseEntrySensorAecIrisCtrlDCAttr(const XMLElement * pelement,void * param)6288 bool RkAiqCalibParser::parseEntrySensorAecIrisCtrlDCAttr
6289 (
6290 const XMLElement* pelement,
6291 void* param
6292 ) {
6293 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6294 autoTabForward();
6295
6296 XML_CHECK_START(CALIB_SENSOR_AEC_IRISCTRL_DC_ATTR_TAG_ID, CALIB_SENSOR_AEC_IRISCTRL_TAG_ID);
6297
6298 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
6299
6300 const XMLNode* psubsubchild = pelement->FirstChild();
6301 while (psubsubchild) {
6302 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
6303 std::string subsubTagname(psubsubchild->ToElement()->Name());
6304 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
6305 #ifdef DEBUG_LOG
6306 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6307 #endif
6308 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_DC_ATTR_KP_TAG_ID)) {
6309 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stIris.DCIrisAttr.Kp, subsubTag.Size());
6310 DCT_ASSERT((no == subsubTag.Size()));
6311 }
6312 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_DC_ATTR_KI_TAG_ID)) {
6313 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stIris.DCIrisAttr.Ki, subsubTag.Size());
6314 DCT_ASSERT((no == subsubTag.Size()));
6315 }
6316 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_DC_ATTR_KD_TAG_ID)) {
6317 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stIris.DCIrisAttr.Kd, subsubTag.Size());
6318 DCT_ASSERT((no == subsubTag.Size()));
6319 }
6320 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_DC_ATTR_MIN_PWMDUTY_TAG_ID)) {
6321 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stIris.DCIrisAttr.MinPwmDuty, subsubTag.Size());
6322 DCT_ASSERT((no == subsubTag.Size()));
6323 }
6324 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_DC_ATTR_MAX_PWMDUTY_TAG_ID)) {
6325 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stIris.DCIrisAttr.MaxPwmDuty, subsubTag.Size());
6326 DCT_ASSERT((no == subsubTag.Size()));
6327 }
6328 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_DC_ATTR_OPEN_PWMDUTY_TAG_ID)) {
6329 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stIris.DCIrisAttr.OpenPwmDuty, subsubTag.Size());
6330 DCT_ASSERT((no == subsubTag.Size()));
6331 }
6332 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_DC_ATTR_CLOSE_PWMDUTY_TAG_ID)) {
6333 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stIris.DCIrisAttr.ClosePwmDuty, subsubTag.Size());
6334 DCT_ASSERT((no == subsubTag.Size()));
6335 }
6336 else {
6337 LOGW("%s(%d): parse error in AecIrisCtrl DCAttr (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6338 }
6339 psubsubchild = psubsubchild->NextSibling();
6340 }
6341
6342 XML_CHECK_END();
6343 autoTabBackward();
6344 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6345 return (true);
6346 }
6347
parseEntrySensorAecIrisCtrlHDCAttr(const XMLElement * pelement,void * param)6348 bool RkAiqCalibParser::parseEntrySensorAecIrisCtrlHDCAttr
6349 (
6350 const XMLElement* pelement,
6351 void* param
6352 ) {
6353 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6354 autoTabForward();
6355
6356 XML_CHECK_START(CALIB_SENSOR_AEC_IRISCTRL_HDC_ATTR_TAG_ID, CALIB_SENSOR_AEC_IRISCTRL_TAG_ID);
6357
6358 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
6359
6360 const XMLNode* psubsubchild = pelement->FirstChild();
6361
6362 int nZoomTargetDot = 0;
6363 int nZoomDot = 0;
6364 int nIrisTargetDot = 0;
6365 int nGainDot = 0;
6366
6367 while (psubsubchild) {
6368 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
6369 std::string subsubTagname(psubsubchild->ToElement()->Name());
6370 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
6371 #ifdef DEBUG_LOG
6372 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6373 #endif
6374 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_HDC_ATTR_DAMPOVER_TAG_ID)) {
6375 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stIris.HDCIrisAttr.DampOver, subsubTag.Size());
6376 DCT_ASSERT((no == subsubTag.Size()));
6377 }
6378 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_HDC_ATTR_DAMPUNDER_TAG_ID)) {
6379 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stIris.HDCIrisAttr.DampUnder, subsubTag.Size());
6380 DCT_ASSERT((no == subsubTag.Size()));
6381 }
6382 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_HDC_ATTR_ZEROISMAX_TAG_ID)) {
6383 uint8_t temp = aec->CommCtrl.stIris.HDCIrisAttr.ZeroIsMax;
6384 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
6385 aec->CommCtrl.stIris.HDCIrisAttr.ZeroIsMax = (temp == 0) ? false : true;
6386 DCT_ASSERT((no == subsubTag.Size()));
6387 }
6388 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_HDC_ATTR_MINTARGET_TAG_ID)) {
6389 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stIris.HDCIrisAttr.MinTarget, subsubTag.Size());
6390 DCT_ASSERT((no == subsubTag.Size()));
6391 }
6392 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_HDC_ATTR_MAXTARGET_TAG_ID)) {
6393 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stIris.HDCIrisAttr.MaxTarget, subsubTag.Size());
6394 DCT_ASSERT((no == subsubTag.Size()));
6395 }
6396 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_HDC_ATTR_ZOOMTARGETDOT_TAG_ID)) {
6397 int no = ParseIntArray(psubsubchild, aec->CommCtrl.stIris.HDCIrisAttr.ZoomTargetDot, subsubTag.Size());
6398 DCT_ASSERT((no == subsubTag.Size()));
6399 nZoomTargetDot = no;
6400 }
6401 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_HDC_ATTR_ZOOMDOT_TAG_ID)) {
6402 int no = ParseIntArray(psubsubchild, aec->CommCtrl.stIris.HDCIrisAttr.ZoomDot, subsubTag.Size());
6403 DCT_ASSERT((no == subsubTag.Size()));
6404 nZoomDot = no;
6405 }
6406 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_HDC_ATTR_IRISTARGETDOT_TAG_ID)) {
6407 int no = ParseIntArray(psubsubchild, aec->CommCtrl.stIris.HDCIrisAttr.IrisTargetDot, subsubTag.Size());
6408 DCT_ASSERT((no == subsubTag.Size()));
6409 nIrisTargetDot = no;
6410 }
6411 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_HDC_ATTR_GAINDOT_TAG_ID)) {
6412 int no = ParseIntArray(psubsubchild, aec->CommCtrl.stIris.HDCIrisAttr.GainDot, subsubTag.Size());
6413 DCT_ASSERT((no == subsubTag.Size()));
6414 nGainDot = no;
6415 }
6416 else {
6417 LOGW("%s(%d): parse error in AecIrisCtrl DCAttr (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6418 }
6419 psubsubchild = psubsubchild->NextSibling();
6420 }
6421 XML_CHECK_END();
6422 autoTabBackward();
6423
6424 DCT_ASSERT((nZoomTargetDot == nZoomDot));
6425 DCT_ASSERT((nIrisTargetDot == nGainDot));
6426 aec->CommCtrl.stIris.HDCIrisAttr.zoom_array_size = nZoomTargetDot;
6427 aec->CommCtrl.stIris.HDCIrisAttr.iris_array_size = nIrisTargetDot;
6428
6429 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6430 return (true);
6431 }
6432
parseEntrySensorAecIrisCtrl(const XMLElement * pelement,void * param)6433 bool RkAiqCalibParser::parseEntrySensorAecIrisCtrl
6434 (
6435 const XMLElement* pelement,
6436 void* param
6437 ) {
6438 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6439 autoTabForward();
6440
6441 XML_CHECK_START(CALIB_SENSOR_AEC_IRISCTRL_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
6442
6443 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
6444 const XMLNode* psubchild = pelement->FirstChild();
6445
6446 #ifdef DEBUG_LOG
6447 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
6448 #endif
6449 while (psubchild) {
6450 XmlTag subTag = XmlTag(psubchild->ToElement());
6451 std::string subTagname(psubchild->ToElement()->Name());
6452 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
6453 #ifdef DEBUG_LOG
6454 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
6455 #endif
6456 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_ENABLE_TAG_ID)) {
6457 int no = ParseUcharArray(psubchild, &aec->CommCtrl.stIris.enable, subTag.Size());
6458 DCT_ASSERT((no == subTag.Size()));
6459 }
6460 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_TYPE_TAG_ID)) {
6461 char* value = Toupper(subTag.Value());
6462 std::string s_value(value);
6463 if (xmlParseReadWrite == XML_PARSER_READ)
6464 {
6465 if (s_value == CALIB_SENSOR_AEC_IRISCTRL_TYPE_P) {
6466 aec->CommCtrl.stIris.IrisType = IRIS_P_TYPE;
6467 }
6468 else if (s_value == CALIB_SENSOR_AEC_IRISCTRL_TYPE_DC) {
6469 aec->CommCtrl.stIris.IrisType = IRIS_DC_TYPE;
6470 }
6471 else if (s_value == CALIB_SENSOR_AEC_IRISCTRL_TYPE_HDC) {
6472 aec->CommCtrl.stIris.IrisType = IRIS_HDC_TYPE;
6473 }
6474 else {
6475 aec->CommCtrl.stIris.IrisType = IRIS_INVALID_TYPE;
6476 LOGE("%s(%d): invalid stIris.IrisType = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
6477 }
6478 }
6479 else if (xmlParseReadWrite == XML_PARSER_WRITE)
6480 {
6481 XMLNode *pNode = (XMLNode*)psubchild;
6482 if (aec->CommCtrl.stIris.IrisType == IRIS_P_TYPE) {
6483 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_IRISCTRL_TYPE_P);
6484 }
6485 else if (aec->CommCtrl.stIris.IrisType == IRIS_DC_TYPE) {
6486 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_IRISCTRL_TYPE_DC);
6487 }
6488 else if (aec->CommCtrl.stIris.IrisType == IRIS_HDC_TYPE) {
6489 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_IRISCTRL_TYPE_HDC);
6490 }
6491 else {
6492 pNode->FirstChild()->SetValue("Invalid");
6493 LOGE("%s(%d): (XML Write)invalid AEC stAntiFlicker.Frequency = %d\n", __FUNCTION__, __LINE__, aec->CommCtrl.stAntiFlicker.Frequency);
6494 }
6495
6496 }
6497 }
6498 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_P_ATTR_TAG_ID)) {
6499 if (!parseEntrySensorAecIrisCtrlPAttr(psubchild->ToElement(), param)) {
6500 LOGE("parse error in Aec IrisCtrl (%s)", subTagname.c_str());
6501 return (false);
6502 }
6503 }
6504 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_DC_ATTR_TAG_ID)) {
6505 if (!parseEntrySensorAecIrisCtrlDCAttr(psubchild->ToElement(), param)) {
6506 LOGE("parse error in Aec IrisCtrl (%s)", subTagname.c_str());
6507 return (false);
6508 }
6509 }
6510 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_HDC_ATTR_TAG_ID)) {
6511 if (!parseEntrySensorAecIrisCtrlHDCAttr(psubchild->ToElement(), param)) {
6512 LOGE("parse error in Aec IrisCtrl (%s)", subTagname.c_str());
6513 return (false);
6514 }
6515 }
6516 else {
6517 LOGW("%s(%d): parse error in Aec IrisCtrl (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
6518 }
6519 psubchild = psubchild->NextSibling();
6520 }
6521 XML_CHECK_END();
6522 autoTabBackward();
6523 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6524 return (true);
6525 }
6526
parseEntrySensorAecManualCtrlLinearAE(const XMLElement * pelement,void * param)6527 bool RkAiqCalibParser::parseEntrySensorAecManualCtrlLinearAE
6528 (
6529 const XMLElement* pelement,
6530 void* param
6531 ) {
6532 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6533 autoTabForward();
6534
6535 XML_CHECK_START(CALIB_SENSOR_AEC_MANUALCTRL_LINEARAE_TAG_ID, CALIB_SENSOR_AEC_MANUALCTRL_TAG_ID);
6536
6537 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
6538
6539 const XMLNode* psubsubchild = pelement->FirstChild();
6540 while (psubsubchild) {
6541 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
6542 std::string subsubTagname(psubsubchild->ToElement()->Name());
6543 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
6544 #ifdef DEBUG_LOG
6545 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6546 #endif
6547 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_TIMEEN_TAG_ID)) {
6548 uint8_t temp = aec->CommCtrl.stManual.stLinMe.ManualTimeEn;
6549 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
6550 aec->CommCtrl.stManual.stLinMe.ManualTimeEn = (temp == 0) ? false : true;
6551 DCT_ASSERT((no == subsubTag.Size()));
6552 }
6553 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_GAINEN_TAG_ID)) {
6554 uint8_t temp = aec->CommCtrl.stManual.stLinMe.ManualGainEn;
6555 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
6556 aec->CommCtrl.stManual.stLinMe.ManualGainEn = (temp == 0) ? false : true;
6557 DCT_ASSERT((no == subsubTag.Size()));
6558 }
6559 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_ISPDGAINEN_TAG_ID)) {
6560 uint8_t temp = aec->CommCtrl.stManual.stLinMe.ManualIspDgainEn;
6561 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
6562 aec->CommCtrl.stManual.stLinMe.ManualIspDgainEn = (temp == 0) ? false : true;
6563 DCT_ASSERT((no == subsubTag.Size()));
6564 }
6565 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_IRISEN_TAG_ID)) {
6566 uint8_t temp = aec->CommCtrl.stManual.stLinMe.ManualIrisEn;
6567 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
6568 aec->CommCtrl.stManual.stLinMe.ManualIrisEn = (temp == 0) ? false : true;
6569 DCT_ASSERT((no == subsubTag.Size()));
6570 }
6571 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_TIMEVALUE_TAG_ID)) {
6572 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stManual.stLinMe.TimeValue, subsubTag.Size());
6573 DCT_ASSERT((no == subsubTag.Size()));
6574 }
6575 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_GAINVALUE_TAG_ID)) {
6576 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stManual.stLinMe.GainValue, subsubTag.Size());
6577 DCT_ASSERT((no == subsubTag.Size()));
6578 }
6579 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_ISPDGAINVALUE_TAG_ID)) {
6580 int no = ParseFloatArray(psubsubchild, &aec->CommCtrl.stManual.stLinMe.IspDGainValue, subsubTag.Size());
6581 DCT_ASSERT((no == subsubTag.Size()));
6582 }
6583 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_PIRISVALUE_TAG_ID)) {
6584 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stManual.stLinMe.PIrisGainValue, subsubTag.Size());
6585 DCT_ASSERT((no == subsubTag.Size()));
6586 }
6587 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_DCIRISVALUE_TAG_ID)) {
6588 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stManual.stLinMe.DCIrisValue, subsubTag.Size());
6589 DCT_ASSERT((no == subsubTag.Size()));
6590 }
6591 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_HDCIRISVALUE_TAG_ID)) {
6592 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stManual.stLinMe.HDCIrisValue, subsubTag.Size());
6593 DCT_ASSERT((no == subsubTag.Size()));
6594 }
6595 else {
6596 LOGW("%s(%d): parse error in stManual.stLinMe (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6597 }
6598 psubsubchild = psubsubchild->NextSibling();
6599 }
6600
6601 XML_CHECK_END();
6602 autoTabBackward();
6603 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6604 return (true);
6605 }
6606
parseEntrySensorAecManualCtrlHdrAE(const XMLElement * pelement,void * param)6607 bool RkAiqCalibParser::parseEntrySensorAecManualCtrlHdrAE
6608 (
6609 const XMLElement* pelement,
6610 void* param
6611 ) {
6612 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6613 autoTabForward();
6614
6615 XML_CHECK_START(CALIB_SENSOR_AEC_MANUALCTRL_HDRAE_TAG_ID, CALIB_SENSOR_AEC_MANUALCTRL_TAG_ID);
6616
6617 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
6618
6619 const XMLNode* psubsubchild = pelement->FirstChild();
6620 while (psubsubchild) {
6621 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
6622 std::string subsubTagname(psubsubchild->ToElement()->Name());
6623 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
6624 #ifdef DEBUG_LOG
6625 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6626 #endif
6627 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_TIMEEN_TAG_ID)) {
6628 uint8_t temp = aec->CommCtrl.stManual.stHdrMe.ManualTimeEn;
6629 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
6630 aec->CommCtrl.stManual.stHdrMe.ManualTimeEn = (temp == 0) ? false : true;
6631 DCT_ASSERT((no == subsubTag.Size()));
6632 }
6633 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_GAINEN_TAG_ID)) {
6634 uint8_t temp = aec->CommCtrl.stManual.stHdrMe.ManualGainEn;
6635 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
6636 aec->CommCtrl.stManual.stHdrMe.ManualGainEn = (temp == 0) ? false : true;
6637 DCT_ASSERT((no == subsubTag.Size()));
6638 }
6639 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_ISPDGAINEN_TAG_ID)) {
6640 uint8_t temp = aec->CommCtrl.stManual.stHdrMe.ManualIspDgainEn;
6641 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
6642 aec->CommCtrl.stManual.stHdrMe.ManualIspDgainEn = (temp == 0) ? false : true;
6643 DCT_ASSERT((no == subsubTag.Size()));
6644 }
6645 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_IRISEN_TAG_ID)) {
6646 uint8_t temp = aec->CommCtrl.stManual.stHdrMe.ManualIrisEn;
6647 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
6648 aec->CommCtrl.stManual.stHdrMe.ManualIrisEn = (temp == 0) ? false : true;
6649 DCT_ASSERT((no == subsubTag.Size()));
6650 }
6651 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_TIMEVALUE_TAG_ID)) {
6652 float tempVal[3];
6653 for (int i = 0; i < 3; i++)
6654 tempVal[i] = aec->CommCtrl.stManual.stHdrMe.TimeValue.fCoeff[i];
6655 int no = ParseFloatArray(psubsubchild, tempVal, subsubTag.Size());
6656 DCT_ASSERT((no == subsubTag.Size()));
6657 for (int i = 0; i < 3; i++)
6658 aec->CommCtrl.stManual.stHdrMe.TimeValue.fCoeff[i] = tempVal[i];
6659 }
6660 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_GAINVALUE_TAG_ID)) {
6661 float tempVal[3];
6662 for (int i = 0; i < 3; i++)
6663 tempVal[i] = aec->CommCtrl.stManual.stHdrMe.GainValue.fCoeff[i];
6664 int no = ParseFloatArray(psubsubchild, tempVal, subsubTag.Size());
6665 DCT_ASSERT((no == subsubTag.Size()));
6666 for (int i = 0; i < 3; i++)
6667 aec->CommCtrl.stManual.stHdrMe.GainValue.fCoeff[i] = tempVal[i];
6668 }
6669 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_ISPDGAINVALUE_TAG_ID)) {
6670 float tempVal[3];
6671 for (int i = 0; i < 3; i++)
6672 tempVal[i] = aec->CommCtrl.stManual.stHdrMe.IspDGainValue.fCoeff[i];
6673 int no = ParseFloatArray(psubsubchild, tempVal, subsubTag.Size());
6674 DCT_ASSERT((no == subsubTag.Size()));
6675 for (int i = 0; i < 3; i++)
6676 aec->CommCtrl.stManual.stHdrMe.IspDGainValue.fCoeff[i] = tempVal[i];
6677 }
6678 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_PIRISVALUE_TAG_ID)) {
6679 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stManual.stHdrMe.PIrisGainValue, subsubTag.Size());
6680 }
6681 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_DCIRISVALUE_TAG_ID)) {
6682 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stManual.stHdrMe.DCIrisValue, subsubTag.Size());
6683 }
6684 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_HDCIRISVALUE_TAG_ID)) {
6685 int no = ParseIntArray(psubsubchild, &aec->CommCtrl.stManual.stHdrMe.HDCIrisValue, subsubTag.Size());
6686 }
6687 else {
6688 LOGW("%s(%d): parse error in stManual.stHdrMe (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
6689 }
6690 psubsubchild = psubsubchild->NextSibling();
6691 }
6692
6693 XML_CHECK_END();
6694 autoTabBackward();
6695 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6696 return (true);
6697 }
6698
parseEntrySensorAecManualCtrl(const XMLElement * pelement,void * param)6699 bool RkAiqCalibParser::parseEntrySensorAecManualCtrl
6700 (
6701 const XMLElement* pelement,
6702 void* param
6703 ) {
6704 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6705 autoTabForward();
6706
6707 XML_CHECK_START(CALIB_SENSOR_AEC_MANUALCTRL_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
6708
6709 const XMLNode* psubchild = pelement->FirstChild();
6710 #ifdef DEBUG_LOG
6711 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
6712 #endif
6713 while (psubchild) {
6714 XmlTag subTag = XmlTag(psubchild->ToElement());
6715 std::string subTagname(psubchild->ToElement()->Name());
6716 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
6717 #ifdef DEBUG_LOG
6718 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
6719 #endif
6720 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_LINEARAE_TAG_ID)) {
6721 if (!parseEntrySensorAecManualCtrlLinearAE(psubchild->ToElement(), param)) {
6722 LOGE("parse error in Aec ManualCtrl (%s)", subTagname.c_str());
6723 return (false);
6724 }
6725 }
6726 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_HDRAE_TAG_ID)) {
6727 if (!parseEntrySensorAecManualCtrlHdrAE(psubchild->ToElement(), param)) {
6728 LOGE("parse error in Aec ManualCtrl (%s)", subTagname.c_str());
6729 return (false);
6730 }
6731 }
6732 else {
6733 LOGW("%s(%d): parse error in stManual (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
6734 }
6735 psubchild = psubchild->NextSibling();
6736 }
6737 XML_CHECK_END();
6738 autoTabBackward();
6739 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6740 return (true);
6741 }
6742
parseEntrySensorAecRoute(const XMLElement * pelement,void * param)6743 bool RkAiqCalibParser::parseEntrySensorAecRoute
6744 (
6745 const XMLElement* pelement,
6746 void* param
6747 ) {
6748 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6749 autoTabForward();
6750
6751 XML_CHECK_START(CALIB_SENSOR_AEC_AECROUTE_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
6752
6753 #ifdef DEBUG_LOG
6754 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
6755 #endif
6756 const XMLNode* psubchild = pelement->FirstChild();
6757 while (psubchild) {
6758 XmlTag subTag = XmlTag(psubchild->ToElement());
6759 std::string subTagname(psubchild->ToElement()->Name());
6760 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
6761 #ifdef DEBUG_LOG
6762 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
6763 #endif
6764 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECROUTE_LINEARAE_TAG_ID)) {
6765 if (!parseEntryCell(psubchild->ToElement(), subTag.Size(),
6766 &RkAiqCalibParser::parseEntrySensorAecLinearAeRoute,
6767 param,
6768 (uint32_t)CALIB_SENSOR_AEC_AECROUTE_LINEARAE_TAG_ID,
6769 (uint32_t)CALIB_SENSOR_AEC_AECROUTE_TAG_ID)) {
6770 LOGE("parse error in AEC LinAeRoute(%s)", subTagname.c_str());
6771 return (false);
6772 }
6773 }
6774 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECROUTE_HDRAE_TAG_ID)) {
6775 if (!parseEntryCell(psubchild->ToElement(), subTag.Size(),
6776 &RkAiqCalibParser::parseEntrySensorAecHdrAeRoute,
6777 param,
6778 (uint32_t)CALIB_SENSOR_AEC_AECROUTE_HDRAE_TAG_ID,
6779 (uint32_t)CALIB_SENSOR_AEC_AECROUTE_TAG_ID)) {
6780 LOGE("parse error in AEC HdrAeRoute (%s)", subTagname.c_str());
6781 return (false);
6782 }
6783 }
6784 else {
6785 LOGW("%s(%d): parse error in AecRoute (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
6786 }
6787 psubchild = psubchild->NextSibling();
6788 }
6789
6790 XML_CHECK_END();
6791 autoTabBackward();
6792 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6793 return (true);
6794 }
6795
parseEntrySensorLinearAECtrlBackLight(const XMLElement * pelement,void * param)6796 bool RkAiqCalibParser::parseEntrySensorLinearAECtrlBackLight
6797 (
6798 const XMLElement* pelement,
6799 void* param
6800 ) {
6801 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6802 autoTabForward();
6803
6804 XML_CHECK_START(CALIB_SENSOR_LINAECTRL_BACKLIGHT_CONFIG_TAG_ID, CALIB_SENSOR_AEC_LINEARAE_CTRL_TAG_ID);
6805
6806 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
6807
6808 const XMLNode* psecsubchild = pelement->FirstChild();
6809 while (psecsubchild) {
6810 XmlTag secsubtag = XmlTag(psecsubchild->ToElement());
6811 std::string secsubTagname(psecsubchild->ToElement()->Name());
6812 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubtag.Type(), secsubtag.Size());
6813 #ifdef DEBUG_LOG
6814 redirectOut << "secsubTagname: " << secsubTagname << std::endl;
6815 #endif
6816 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_BACKLIGHT_ENABLE_TAG_ID)) {
6817 int no = ParseUcharArray(psecsubchild, &aec->LinearAeCtrl.BackLightConf.enable, secsubtag.Size());
6818 DCT_ASSERT((no == secsubtag.Size()));
6819 }
6820 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_BACKLIGHT_MEASAREA_TAG_ID)) {
6821 char* value = Toupper(secsubtag.Value());
6822 std::string s_value(value);
6823 #ifdef DEBUG_LOG
6824 redirectOut << "value:" << value << std::endl;
6825 redirectOut << s_value << std::endl;
6826 #endif
6827 if (xmlParseReadWrite == XML_PARSER_READ)
6828 {
6829 if (s_value == CALIB_SENSOR_AEC_MEASAREA_AUTO) {
6830 aec->LinearAeCtrl.BackLightConf.MeasArea = AEC_MEASURE_AREA_AUTO;
6831 }
6832 else if (s_value == CALIB_SENSOR_AEC_MEASAREA_CENTER) {
6833 aec->LinearAeCtrl.BackLightConf.MeasArea = AEC_MEASURE_AREA_CENTER;
6834 }
6835 else if (s_value == CALIB_SENSOR_AEC_MEASAREA_UP) {
6836 aec->LinearAeCtrl.BackLightConf.MeasArea = AEC_MEASURE_AREA_UP;
6837 }
6838 else if (s_value == CALIB_SENSOR_AEC_MEASAREA_BOTTOM) {
6839 aec->LinearAeCtrl.BackLightConf.MeasArea = AEC_MEASURE_AREA_BOTTOM;
6840 }
6841 else if (s_value == CALIB_SENSOR_AEC_MEASAREA_LEFT) {
6842 aec->LinearAeCtrl.BackLightConf.MeasArea = AEC_MEASURE_AREA_LEFT;
6843 }
6844 else if (s_value == CALIB_SENSOR_AEC_MEASAREA_RIGHT) {
6845 aec->LinearAeCtrl.BackLightConf.MeasArea = AEC_MEASURE_AREA_RIGHT;
6846 }
6847 else {
6848 aec->LinearAeCtrl.BackLightConf.MeasArea = AEC_MEASURE_AREA_AUTO;
6849 redirectOut << "invalid BackLit MeasArea (" << s_value << ")" << std::endl;
6850 }
6851 }
6852 else if (xmlParseReadWrite == XML_PARSER_WRITE)
6853 {
6854 XMLNode* pNode = (XMLNode *)psecsubchild;
6855 if (aec->LinearAeCtrl.BackLightConf.MeasArea == AEC_MEASURE_AREA_AUTO)
6856 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_MEASAREA_AUTO);
6857 else if (aec->LinearAeCtrl.BackLightConf.MeasArea == AEC_MEASURE_AREA_CENTER)
6858 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_MEASAREA_CENTER);
6859 else if (aec->LinearAeCtrl.BackLightConf.MeasArea == AEC_MEASURE_AREA_UP)
6860 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_MEASAREA_UP);
6861 else if (aec->LinearAeCtrl.BackLightConf.MeasArea == AEC_MEASURE_AREA_BOTTOM)
6862 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_MEASAREA_BOTTOM);
6863 else if (aec->LinearAeCtrl.BackLightConf.MeasArea == AEC_MEASURE_AREA_LEFT)
6864 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_MEASAREA_LEFT);
6865 else if (aec->LinearAeCtrl.BackLightConf.MeasArea == AEC_MEASURE_AREA_RIGHT)
6866 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_MEASAREA_RIGHT);
6867 else {
6868 pNode->FirstChild()->SetValue("INVALID");
6869 redirectOut << "(XML Write)invalid BackLit MeasArea (" << aec->LinearAeCtrl.BackLightConf.MeasArea << ")" << std::endl;
6870 }
6871 }
6872 }
6873 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_BACKLIGHT_OEROI_LOWTH_TAG_ID)) {
6874 int no = ParseFloatArray(psecsubchild, &aec->LinearAeCtrl.BackLightConf.OEROILowTh, secsubtag.Size());
6875 DCT_ASSERT((no == secsubtag.Size()));
6876 }
6877 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_BACKLIGHT_LV_HIGHTH_TAG_ID)) {
6878 int no = ParseFloatArray(psecsubchild, &aec->LinearAeCtrl.BackLightConf.LvHightTh, secsubtag.Size());
6879 DCT_ASSERT((no == secsubtag.Size()));
6880 }
6881 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_BACKLIGHT_LV_LOWTH_TAG_ID)) {
6882 int no = ParseFloatArray(psecsubchild, &aec->LinearAeCtrl.BackLightConf.LvLowTh, secsubtag.Size());
6883 DCT_ASSERT((no == secsubtag.Size()));
6884 }
6885 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_BACKLIGHT_LUMADISTTH_TAG_ID)) {
6886 int no = ParseFloatArray(psecsubchild, &aec->LinearAeCtrl.BackLightConf.LumaDistTh, secsubtag.Size());
6887 DCT_ASSERT((no == secsubtag.Size()));
6888 }
6889 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_BACKLIGHT_LOWLIGHTPDFTH_TAG_ID)) {
6890 int i = (sizeof(aec->LinearAeCtrl.BackLightConf.LowLightPdfTh) / sizeof(aec->LinearAeCtrl.BackLightConf.LowLightPdfTh.fCoeff[0]));
6891 int no = ParseFloatArray(psecsubchild, aec->LinearAeCtrl.BackLightConf.LowLightPdfTh.fCoeff, i);
6892 DCT_ASSERT((no == secsubtag.Size()));
6893 }
6894 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_BACKLIGHT_NONOEPDFTH_TAG_ID)) {
6895 int i = (sizeof(aec->LinearAeCtrl.BackLightConf.NonOEPdfTh) / sizeof(aec->LinearAeCtrl.BackLightConf.NonOEPdfTh.fCoeff[0]));
6896 int no = ParseFloatArray(psecsubchild, aec->LinearAeCtrl.BackLightConf.NonOEPdfTh.fCoeff, i);
6897 DCT_ASSERT((no == secsubtag.Size()));
6898 }
6899 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_BACKLIGHT_EXPLEVEL_TAG_ID)) {
6900 int i = (sizeof(aec->LinearAeCtrl.BackLightConf.ExpLevel) / sizeof(aec->LinearAeCtrl.BackLightConf.ExpLevel.fCoeff[0]));
6901 int no = ParseFloatArray(psecsubchild, aec->LinearAeCtrl.BackLightConf.ExpLevel.fCoeff, i);
6902 DCT_ASSERT((no == secsubtag.Size()));
6903 }
6904 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_BACKLIGHT_TARGETLLLUMA_TAG_ID)) {
6905 int i = (sizeof(aec->LinearAeCtrl.BackLightConf.TargetLLLuma) / sizeof(aec->LinearAeCtrl.BackLightConf.TargetLLLuma.fCoeff[0]));
6906 int no = ParseFloatArray(psecsubchild, aec->LinearAeCtrl.BackLightConf.TargetLLLuma.fCoeff, i);
6907 DCT_ASSERT((no == secsubtag.Size()));
6908 }
6909 else {
6910 redirectOut
6911 << "parse error in LINAECTRL backlight section (unknow tag: "
6912 << secsubTagname
6913 << ")"
6914 << std::endl;
6915 }
6916 psecsubchild = psecsubchild->NextSibling();
6917 }
6918
6919 XML_CHECK_END();
6920 autoTabBackward();
6921 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6922 return (true);
6923 }
6924
parseEntrySensorLinearAECtrlOverExp(const XMLElement * pelement,void * param)6925 bool RkAiqCalibParser::parseEntrySensorLinearAECtrlOverExp
6926 (
6927 const XMLElement* pelement,
6928 void* param
6929 ) {
6930 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6931 autoTabForward();
6932
6933 XML_CHECK_START(CALIB_SENSOR_LINAECTRL_OVEREXP_CONTROL_TAG_ID, CALIB_SENSOR_AEC_LINEARAE_CTRL_TAG_ID);
6934
6935 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
6936
6937 const XMLNode* psecsubchild = pelement->FirstChild();
6938 while (psecsubchild) {
6939 XmlTag secsubtag = XmlTag(psecsubchild->ToElement());
6940 std::string secsubTagname(psecsubchild->ToElement()->Name());
6941 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubtag.Type(), secsubtag.Size());
6942 #ifdef DEBUG_LOG
6943 redirectOut << "secsubTagname: " << secsubTagname << std::endl;
6944 #endif
6945 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_OVEREXP_ENABLE_TAG_ID)) {
6946 int no = ParseUcharArray(psecsubchild, &aec->LinearAeCtrl.OverExpCtrl.enable, secsubtag.Size());
6947 DCT_ASSERT((no == secsubtag.Size()));
6948 }
6949 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_OVEREXP_LOWLIGHT_TH_TAG_ID)) {
6950 int no = ParseFloatArray(psecsubchild, &aec->LinearAeCtrl.OverExpCtrl.LowLightTh, secsubtag.Size());
6951 DCT_ASSERT((no == secsubtag.Size()));
6952 }
6953 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_OVEREXP_HIGHLIGHT_TH_TAG_ID)) {
6954 int no = ParseFloatArray(psecsubchild, &aec->LinearAeCtrl.OverExpCtrl.HighLightTh, secsubtag.Size());
6955 DCT_ASSERT((no == secsubtag.Size()));
6956 }
6957 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_OVEREXP_MAXWEIGHT_TAG_ID)) {
6958 int no = ParseFloatArray(psecsubchild, &aec->LinearAeCtrl.OverExpCtrl.MaxWeight, secsubtag.Size());
6959 DCT_ASSERT((no == secsubtag.Size()));
6960 }
6961 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_OVEREXP_OEPDF_TAG_ID)) {
6962 int i = (sizeof(aec->LinearAeCtrl.OverExpCtrl.OEpdf) / sizeof(aec->LinearAeCtrl.OverExpCtrl.OEpdf.fCoeff[0]));
6963 int no = ParseFloatArray(psecsubchild, aec->LinearAeCtrl.OverExpCtrl.OEpdf.fCoeff, i);
6964 DCT_ASSERT((no == secsubtag.Size()));
6965 }
6966 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_OVEREXP_HIGHLIGHT_WEIGHT_TAG_ID)) {
6967 int i = (sizeof(aec->LinearAeCtrl.OverExpCtrl.HighLightWeight) / sizeof(aec->LinearAeCtrl.OverExpCtrl.HighLightWeight.fCoeff[0]));
6968 int no = ParseFloatArray(psecsubchild, aec->LinearAeCtrl.OverExpCtrl.HighLightWeight.fCoeff, i);
6969 DCT_ASSERT((no == secsubtag.Size()));
6970 }
6971 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_OVEREXP_LOWLIGHT_WEIGHT_TAG_ID)) {
6972 int i = (sizeof(aec->LinearAeCtrl.OverExpCtrl.LowLightWeight) / sizeof(aec->LinearAeCtrl.OverExpCtrl.LowLightWeight.fCoeff[0]));
6973 int no = ParseFloatArray(psecsubchild, aec->LinearAeCtrl.OverExpCtrl.LowLightWeight.fCoeff, i);
6974 DCT_ASSERT((no == secsubtag.Size()));
6975 }
6976 else {
6977 redirectOut
6978 << "parse error in LINAECTRL OverExpCtrl section (unknow tag: "
6979 << secsubTagname
6980 << ")"
6981 << std::endl;
6982 }
6983 psecsubchild = psecsubchild->NextSibling();
6984 }
6985
6986 XML_CHECK_END();
6987 autoTabBackward();
6988 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
6989 return (true);
6990 }
6991
parseEntrySensorLinearAECtrl(const XMLElement * pelement,void * param)6992 bool RkAiqCalibParser::parseEntrySensorLinearAECtrl
6993 (
6994 const XMLElement* pelement,
6995 void* param
6996 ) {
6997 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
6998 autoTabForward();
6999
7000 XML_CHECK_START(CALIB_SENSOR_AEC_LINEARAE_CTRL_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
7001
7002 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
7003
7004 const XMLNode* psubchild = pelement->FirstChild();
7005 #ifdef DEBUG_LOG
7006 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
7007 #endif
7008 while (psubchild) {
7009 XmlTag subTag = XmlTag(psubchild->ToElement());
7010 std::string subTagname(psubchild->ToElement()->Name());
7011 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
7012 #ifdef DEBUG_LOG
7013 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
7014 #endif
7015 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_RAWSTATS_EN_TAG_ID)) {
7016 int no = ParseUcharArray(psubchild, &aec->LinearAeCtrl.RawStatsEn, subTag.Size());
7017 DCT_ASSERT((no == subTag.Size()));
7018 }
7019 else if(XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SETPOINT_TAG_ID)) {
7020 int no = ParseFloatArray(psubchild, &aec->LinearAeCtrl.SetPoint, subTag.Size());
7021 DCT_ASSERT((no == subTag.Size()));
7022 }
7023 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_NIGHTSETPOINT_TAG_ID)) {
7024 int no = ParseFloatArray(psubchild, &aec->LinearAeCtrl.NightSetPoint, subTag.Size());
7025 DCT_ASSERT((no == subTag.Size()));
7026 }
7027 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_DYSETPOINTEN_TAG_ID)) {
7028 uint8_t temp = aec->LinearAeCtrl.DySetPointEn;
7029 ParseUcharArray(psubchild, &temp, subTag.Size());
7030 aec->LinearAeCtrl.DySetPointEn = (temp == 0) ? false : true;
7031 }
7032 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_EVBIAS_TAG_ID)) {
7033 int no = ParseFloatArray(psubchild, &aec->LinearAeCtrl.Evbias, subTag.Size());
7034 DCT_ASSERT((no == subTag.Size()));
7035 }
7036 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_DYNAMICSETPOINT_TAG_ID)) {
7037 if (!parseEntryCell(psubchild->ToElement(), subTag.Size(),
7038 &RkAiqCalibParser::parseEntrySensorAecLinearAeDynamicPoint,
7039 param,
7040 (uint32_t)CALIB_SENSOR_AEC_DYNAMICSETPOINT_TAG_ID,
7041 (uint32_t)CALIB_SENSOR_AEC_LINEARAE_CTRL_TAG_ID)) {
7042 LOGE("parse error in AEC linear dynamic setpoint (%s)", subTagname.c_str());
7043 return (false);
7044 }
7045 }
7046 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_TOLERANCE_IN_TAG_ID)) {
7047 int no = ParseFloatArray(psubchild, &aec->LinearAeCtrl.ToleranceIn, subTag.Size());
7048 DCT_ASSERT((no == subTag.Size()));
7049 }
7050 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_TOLERANCE_OUT_TAG_ID)) {
7051 int no = ParseFloatArray(psubchild, &aec->LinearAeCtrl.ToleranceOut, subTag.Size());
7052 DCT_ASSERT((no == subTag.Size()));
7053 }
7054 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_STRATEGYMODE_TAG_ID)) {
7055 char* value = Toupper(subTag.Value());
7056 std::string s_value(value);
7057 #ifdef DEBUG_LOG
7058 LOGE("%s(%d): s_value = %s\n", __FUNCTION__, __LINE__, s_value);
7059 #endif
7060 if (xmlParseReadWrite == XML_PARSER_READ)
7061 {
7062 if (s_value == CALIB_SENSOR_AEC_STRATEGYMODE_LOWLIGHT) {
7063 aec->LinearAeCtrl.StrategyMode = RKAIQ_AEC_STRATEGY_MODE_LOWLIGHT_PRIOR;
7064 }
7065 else if (s_value == CALIB_SENSOR_AEC_STRATEGYMODE_HIGHLIGHT) {
7066 aec->LinearAeCtrl.StrategyMode = RKAIQ_AEC_STRATEGY_MODE_HIGHLIGHT_PRIOR;
7067 }
7068 else {
7069 aec->LinearAeCtrl.StrategyMode = RKAIQ_AEC_STRATEGY_MODE_AUTO;
7070 redirectOut << "invalid AEC LinAe StrategyMode (" << s_value << ")" << std::endl;
7071 }
7072 }
7073 else if (xmlParseReadWrite == XML_PARSER_WRITE)
7074 {
7075 XMLNode *pNode = (XMLNode *)psubchild;
7076 if (aec->LinearAeCtrl.StrategyMode == RKAIQ_AEC_STRATEGY_MODE_LOWLIGHT_PRIOR)
7077 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_STRATEGYMODE_LOWLIGHT);
7078 else if (aec->LinearAeCtrl.StrategyMode == RKAIQ_AEC_STRATEGY_MODE_HIGHLIGHT_PRIOR)
7079 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_STRATEGYMODE_HIGHLIGHT);
7080 else {
7081 pNode->FirstChild()->SetValue("AUTO");
7082 redirectOut << "(XML Wrtie)invalid AEC LinAe StrategyMode (" << aec->LinearAeCtrl.StrategyMode << ")" << std::endl;
7083 }
7084 }
7085
7086 }
7087 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_BACKLIGHT_CONFIG_TAG_ID)) {
7088 if (!parseEntrySensorLinearAECtrlBackLight(psubchild->ToElement(), param)) {
7089 LOGE("parse error in Aec (%s)", subTagname.c_str());
7090 return (false);
7091 }
7092 }
7093 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LINAECTRL_OVEREXP_CONTROL_TAG_ID)) {
7094 if (!parseEntrySensorLinearAECtrlOverExp(psubchild->ToElement(), param)) {
7095 LOGE("parse error in Aec (%s)", subTagname.c_str());
7096 return (false);
7097 }
7098 }
7099
7100 psubchild = psubchild->NextSibling();
7101 }
7102
7103 XML_CHECK_END();
7104 autoTabBackward();
7105 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
7106 return (true);
7107 }
7108
parseEntrySensorHdrAECtrlExpRatioCtrl(const XMLElement * pelement,void * param)7109 bool RkAiqCalibParser::parseEntrySensorHdrAECtrlExpRatioCtrl
7110 (
7111 const XMLElement* pelement,
7112 void* param
7113 ) {
7114 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
7115 autoTabForward();
7116
7117 XML_CHECK_START(CALIB_SENSOR_AEC_HDRAECTRL_EXPRATIOCTRL_TAG_ID, CALIB_SENSOR_AEC_HDRAECTRL_TAG_ID);
7118
7119 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
7120
7121 const XMLNode* psubsubchild = pelement->FirstChild();
7122 while (psubsubchild) {
7123 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
7124 std::string subsubTagname(psubsubchild->ToElement()->Name());
7125 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
7126 #ifdef DEBUG_LOG
7127 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
7128 #endif
7129 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_EXPRATIOTYPE_TAG_ID)) {
7130 char* value = Toupper(subsubTag.Value());
7131 std::string s_value(value);
7132 #ifdef DEBUG_LOG
7133 redirectOut << "value:" << value << std::endl;
7134 redirectOut << s_value << std::endl;
7135 #endif
7136 if (xmlParseReadWrite == XML_PARSER_READ)
7137 {
7138 if (s_value == CALIB_SENSOR_AEC_HDRAECTRL_EXPRATIOTYPE_AUTO) {
7139 aec->HdrAeCtrl.ExpRatioType = RKAIQ_HDRAE_RATIOTYPE_MODE_AUTO;
7140 }
7141 else if (s_value == CALIB_SENSOR_AEC_HDRAECTRL_EXPRATIOTYPE_FIX) {
7142 aec->HdrAeCtrl.ExpRatioType = RKAIQ_HDRAE_RATIOTYPE_MODE_FIX;
7143 }
7144 else {
7145 aec->HdrAeCtrl.ExpRatioType = RKAIQ_HDRAE_RATIOTYPE_MODE_INVALID;
7146 redirectOut << "invalid AEC HdrAe ExpRatioType (" << s_value << ")" << std::endl;
7147 }
7148 }
7149 else if (xmlParseReadWrite == XML_PARSER_WRITE)
7150 {
7151 XMLNode *pNode = (XMLNode*)psubsubchild;
7152 if (aec->HdrAeCtrl.ExpRatioType == RKAIQ_HDRAE_RATIOTYPE_MODE_AUTO)
7153 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_EXPRATIOTYPE_AUTO);
7154 else if (aec->HdrAeCtrl.ExpRatioType == RKAIQ_HDRAE_RATIOTYPE_MODE_FIX)
7155 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_EXPRATIOTYPE_FIX);
7156 else
7157 {
7158 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_EXPRATIOTYPE_AUTO);
7159 redirectOut << "(XML Write)invalid AEC HdrAe ExpRatioType (" << aec->HdrAeCtrl.ExpRatioType << ")" << std::endl;
7160 }
7161 }
7162 }
7163 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_RATIOEXPDOT_TAG_ID)) {
7164 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.RatioExpDot.fCoeff, subsubTag.Size());
7165 DCT_ASSERT((no == subsubTag.Size()));
7166 }
7167 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_M2SRATIOFIX_TAG_ID)) {
7168 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.M2SRatioFix.fCoeff, subsubTag.Size());
7169 DCT_ASSERT((no == subsubTag.Size()));
7170 }
7171 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_L2MRATIOFIX_TAG_ID)) {
7172 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.L2MRatioFix.fCoeff, subsubTag.Size());
7173 DCT_ASSERT((no == subsubTag.Size()));
7174 }
7175 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_M2SRATIOMAX_TAG_ID)) {
7176 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.M2SRatioMax.fCoeff, subsubTag.Size());
7177 DCT_ASSERT((no == subsubTag.Size()));
7178 }
7179 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_L2MRATIOMAX_TAG_ID)) {
7180 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.L2MRatioMax.fCoeff, subsubTag.Size());
7181 DCT_ASSERT((no == subsubTag.Size()));
7182 }
7183 else {
7184 redirectOut
7185 << "parse error in AEC HdrAeCtrl (unknow tag: "
7186 << subsubTagname
7187 << ")"
7188 << std::endl;
7189 }
7190 psubsubchild = psubsubchild->NextSibling();
7191 }
7192
7193 XML_CHECK_END();
7194 autoTabBackward();
7195 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
7196 return (true);
7197 }
7198
parseEntrySensorHdrAECtrlLframeMode(const XMLElement * pelement,void * param)7199 bool RkAiqCalibParser::parseEntrySensorHdrAECtrlLframeMode
7200 (
7201 const XMLElement* pelement,
7202 void* param
7203 ) {
7204 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
7205 autoTabForward();
7206
7207 XML_CHECK_START(CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_TAG_ID, CALIB_SENSOR_AEC_HDRAECTRL_TAG_ID);
7208
7209 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
7210
7211 const XMLNode* psubsubchild = pelement->FirstChild();
7212 while (psubsubchild) {
7213 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
7214 std::string subsubTagname(psubsubchild->ToElement()->Name());
7215 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
7216 #ifdef DEBUG_LOG
7217 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
7218 #endif
7219 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_MODE_TAG_ID)) {
7220 char* value = Toupper(subsubTag.Value());
7221 std::string s_value(value);
7222 #ifdef DEBUG_LOG
7223 redirectOut << "value:" << value << std::endl;
7224 redirectOut << s_value << std::endl;
7225 #endif
7226 if (xmlParseReadWrite == XML_PARSER_READ)
7227 {
7228 if (s_value == CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_NORMAL) {
7229 aec->HdrAeCtrl.LongfrmMode = RKAIQ_AEC_HDR_LONGFRMMODE_NORMAL;
7230 }
7231 else if (s_value == CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_LONGFRAME) {
7232 aec->HdrAeCtrl.LongfrmMode = RKAIQ_AEC_HDR_LONGFRMMODE_LONG_FRAME;
7233 }
7234 else if (s_value == CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_AUTO_LONGFRAME) {
7235 aec->HdrAeCtrl.LongfrmMode = RKAIQ_AEC_HDR_LONGFRMMODE_AUTO_LONG_FRAME;
7236 }
7237 else {
7238 aec->HdrAeCtrl.LongfrmMode = RKAIQ_AEC_HDR_LONGFRMMODE_NORMAL;
7239 redirectOut << "invalid AEC HdrAe LongFrmMode (" << s_value << ")" << std::endl;
7240 }
7241 }
7242 else if (xmlParseReadWrite == XML_PARSER_WRITE)
7243 {
7244 XMLNode *pNode = (XMLNode*)psubsubchild;
7245 if (aec->HdrAeCtrl.LongfrmMode == RKAIQ_AEC_HDR_LONGFRMMODE_NORMAL) {
7246 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_NORMAL);
7247 }
7248 else if (aec->HdrAeCtrl.LongfrmMode == RKAIQ_AEC_HDR_LONGFRMMODE_LONG_FRAME) {
7249 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_LONGFRAME);
7250 }
7251 else if (aec->HdrAeCtrl.LongfrmMode == RKAIQ_AEC_HDR_LONGFRMMODE_AUTO_LONG_FRAME) {
7252 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_AUTO_LONGFRAME);
7253 }
7254 else {
7255 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_NORMAL);
7256 redirectOut << "(XML Write)invalid AEC HdrAe LongFrmMode (" << aec->HdrAeCtrl.LongfrmMode << ")" << std::endl;
7257 }
7258 }
7259 }
7260 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_LFRMMODEEXPTH_TAG_ID)) {
7261 int no = ParseFloatArray(psubsubchild, &aec->HdrAeCtrl.LfrmModeExpTh, subsubTag.Size());
7262 DCT_ASSERT((no == subsubTag.Size()));
7263 }
7264 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_SFRMMINLINE_TAG_ID)) {
7265 int no = ParseUshortArray(psubsubchild, &aec->HdrAeCtrl.SfrmMinLine, subsubTag.Size());
7266 DCT_ASSERT((no == subsubTag.Size()));
7267 } else {
7268 redirectOut
7269 << "parse error in AEC LongFrmMode (unknow tag: "
7270 << subsubTagname
7271 << ")"
7272 << std::endl;
7273 }
7274 psubsubchild = psubsubchild->NextSibling();
7275 }
7276 autoTabBackward();
7277 XML_CHECK_END();
7278 autoTabBackward();
7279 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
7280 return (true);
7281 }
7282
parseEntrySensorHdrAECtrlLframeCtrl(const XMLElement * pelement,void * param)7283 bool RkAiqCalibParser::parseEntrySensorHdrAECtrlLframeCtrl
7284 (
7285 const XMLElement* pelement,
7286 void* param
7287 ) {
7288 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
7289 autoTabForward();
7290
7291 XML_CHECK_START(CALIB_SENSOR_AEC_HDRAECTRL_LFRAMECTRL_TAG_ID, CALIB_SENSOR_AEC_HDRAECTRL_TAG_ID);
7292
7293 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
7294
7295 const XMLNode* psubsubchild = pelement->FirstChild();
7296 autoTabForward();
7297 while (psubsubchild) {
7298 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
7299 std::string subsubTagname(psubsubchild->ToElement()->Name());
7300 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
7301 #ifdef DEBUG_LOG
7302 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
7303 #endif
7304 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_OEROILOWTH_TAG_ID)) {
7305 int no = ParseFloatArray(psubsubchild, &aec->HdrAeCtrl.LframeCtrl.OEROILowTh, subsubTag.Size());
7306 DCT_ASSERT((no == subsubTag.Size()));
7307 }
7308 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_LVHIGHTH_TAG_ID)) {
7309 int no = ParseFloatArray(psubsubchild, &aec->HdrAeCtrl.LframeCtrl.LvHighTh, subsubTag.Size());
7310 DCT_ASSERT((no == subsubTag.Size()));
7311 }
7312 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_LVLOWTH_TAG_ID)) {
7313 int no = ParseFloatArray(psubsubchild, &aec->HdrAeCtrl.LframeCtrl.LvLowTh, subsubTag.Size());
7314 DCT_ASSERT((no == subsubTag.Size()));
7315 }
7316 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_LEXPLEVEL_TAG_ID)) {
7317 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.LframeCtrl.LExpLevel.fCoeff, subsubTag.Size());
7318 DCT_ASSERT((no == subsubTag.Size()));
7319 }
7320 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_LSETPOINT_TAG_ID)) {
7321 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.LframeCtrl.LSetPoint.fCoeff, subsubTag.Size());
7322 DCT_ASSERT((no == subsubTag.Size()));
7323 }
7324 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_TARGETLLLUMA_TAG_ID)) {
7325 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.LframeCtrl.TargetLLLuma.fCoeff, subsubTag.Size());
7326 DCT_ASSERT((no == subsubTag.Size()));
7327 }
7328 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_NONOEPDFTH_TAG_ID)) {
7329 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.LframeCtrl.NonOEPdfTh.fCoeff, subsubTag.Size());
7330 DCT_ASSERT((no == subsubTag.Size()));
7331 }
7332 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_LOWLIGHTPDFTH_TAG_ID)) {
7333 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.LframeCtrl.LowLightPdfTh.fCoeff, subsubTag.Size());
7334 DCT_ASSERT((no == subsubTag.Size()));
7335 }
7336 else {
7337 redirectOut
7338 << "parse error in AEC HdrAeCtrl LframeCtrl (unknow tag: "
7339 << subsubTagname
7340 << ")"
7341 << std::endl;
7342 }
7343 psubsubchild = psubsubchild->NextSibling();
7344 }
7345 XML_CHECK_END();
7346 autoTabBackward();
7347 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
7348 return (true);
7349 }
7350
parseEntrySensorHdrAECtrlMframeCtrl(const XMLElement * pelement,void * param)7351 bool RkAiqCalibParser::parseEntrySensorHdrAECtrlMframeCtrl
7352 (
7353 const XMLElement* pelement,
7354 void* param
7355 ) {
7356 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
7357 autoTabForward();
7358
7359 XML_CHECK_START(CALIB_SENSOR_AEC_HDRAECTRL_MFRAMECTRL_TAG_ID, CALIB_SENSOR_AEC_HDRAECTRL_TAG_ID);
7360
7361 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
7362
7363 const XMLNode* psubsubchild = pelement->FirstChild();
7364 while (psubsubchild) {
7365 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
7366 std::string subsubTagname(psubsubchild->ToElement()->Name());
7367 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
7368 #ifdef DEBUG_LOG
7369 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
7370 #endif
7371 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_MEXPLEVEL_TAG_ID)) {
7372 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.MframeCtrl.MExpLevel.fCoeff, subsubTag.Size());
7373 DCT_ASSERT((no == subsubTag.Size()));
7374 }
7375 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_MSETPOINT_TAG_ID)) {
7376 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.MframeCtrl.MSetPoint.fCoeff, subsubTag.Size());
7377 DCT_ASSERT((no == subsubTag.Size()));
7378 }
7379 else {
7380 redirectOut
7381 << "parse error in AEC HdrAeCtrl MframeCtrl (unknow tag: "
7382 << subsubTagname
7383 << ")"
7384 << std::endl;
7385 }
7386 psubsubchild = psubsubchild->NextSibling();
7387 }
7388 XML_CHECK_END();
7389 autoTabBackward();
7390 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
7391 return (true);
7392 }
7393
parseEntrySensorHdrAECtrlSframeCtrl(const XMLElement * pelement,void * param)7394 bool RkAiqCalibParser::parseEntrySensorHdrAECtrlSframeCtrl
7395 (
7396 const XMLElement* pelement,
7397 void* param
7398 ) {
7399 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
7400 autoTabForward();
7401
7402 XML_CHECK_START(CALIB_SENSOR_AEC_HDRAECTRL_SFRAMECTRL_TAG_ID, CALIB_SENSOR_AEC_HDRAECTRL_TAG_ID);
7403
7404 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
7405
7406 const XMLNode* psubsubchild = pelement->FirstChild();
7407 while (psubsubchild) {
7408 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
7409 std::string subsubTagname(psubsubchild->ToElement()->Name());
7410 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
7411 #ifdef DEBUG_LOG
7412 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
7413 #endif
7414 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_SEXPLEVEL_TAG_ID)) {
7415 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.SframeCtrl.SExpLevel.fCoeff, subsubTag.Size());
7416 DCT_ASSERT((no == subsubTag.Size()));
7417 }
7418 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_HLROIEXPANDEN_TAG_ID)) {
7419 uint8_t temp = aec->HdrAeCtrl.SframeCtrl.HLROIExpandEn;
7420 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
7421 aec->HdrAeCtrl.SframeCtrl.HLROIExpandEn = (temp == 0) ? false : true;
7422 DCT_ASSERT((no == subsubTag.Size()));
7423 }
7424 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_TARGETHLLUMA_TAG_ID)) {
7425 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.SframeCtrl.TargetHLLuma.fCoeff, subsubTag.Size());
7426 DCT_ASSERT((no == subsubTag.Size()));
7427 }
7428 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_SSETPOINT_TAG_ID)) {
7429 int no = ParseFloatArray(psubsubchild, aec->HdrAeCtrl.SframeCtrl.SSetPoint.fCoeff, subsubTag.Size());
7430 DCT_ASSERT((no == subsubTag.Size()));
7431 }
7432 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_HLLUMATOLERANCE_TAG_ID)) {
7433 int no = ParseFloatArray(psubsubchild, &aec->HdrAeCtrl.SframeCtrl.HLLumaTolerance, subsubTag.Size());
7434 DCT_ASSERT((no == subsubTag.Size()));
7435 }
7436 else {
7437 redirectOut
7438 << "parse error in AEC HdrAeCtrl SframeCtrl (unknow tag: "
7439 << subsubTagname
7440 << ")"
7441 << std::endl;
7442 }
7443 psubsubchild = psubsubchild->NextSibling();
7444 }
7445
7446 XML_CHECK_END();
7447 autoTabBackward();
7448 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
7449 return (true);
7450 }
7451
parseEntrySensorHdrAECtrl(const XMLElement * pelement,void * param)7452 bool RkAiqCalibParser::parseEntrySensorHdrAECtrl
7453 (
7454 const XMLElement* pelement,
7455 void* param
7456 ) {
7457 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
7458 autoTabForward();
7459
7460 XML_CHECK_START(CALIB_SENSOR_AEC_HDRAECTRL_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
7461
7462 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
7463
7464 const XMLNode* psubchild = pelement->FirstChild();
7465 while (psubchild) {
7466 XmlTag subTag = XmlTag(psubchild->ToElement());
7467 std::string subTagname(psubchild->ToElement()->Name());
7468 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
7469 #ifdef DEBUG_LOG
7470 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
7471 #endif
7472 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_TOLERANCE_IN_TAG_ID)) {
7473 int no = ParseFloatArray(psubchild, &aec->HdrAeCtrl.ToleranceIn, subTag.Size());
7474 DCT_ASSERT((no == subTag.Size()));
7475 }
7476 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_TOLERANCE_OUT_TAG_ID)) {
7477 int no = ParseFloatArray(psubchild, &aec->HdrAeCtrl.ToleranceOut, subTag.Size());
7478 DCT_ASSERT((no == subTag.Size()));
7479 }
7480 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_EVBIAS_TAG_ID)) {
7481 int no = ParseFloatArray(psubchild, &aec->HdrAeCtrl.Evbias, subTag.Size());
7482 DCT_ASSERT((no == subTag.Size()));
7483 }
7484 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_STRATEGYMODE_TAG_ID)) {
7485 char* value = Toupper(subTag.Value());
7486 std::string s_value(value);
7487 #ifdef DEBUG_LOG
7488 redirectOut << "value:" << value << std::endl;
7489 redirectOut << s_value << std::endl;
7490 #endif
7491 if (xmlParseReadWrite == XML_PARSER_READ)
7492 {
7493 if (s_value == CALIB_SENSOR_AEC_STRATEGYMODE_LOWLIGHT) {
7494 aec->HdrAeCtrl.StrategyMode = RKAIQ_AEC_STRATEGY_MODE_LOWLIGHT_PRIOR;
7495 }
7496 else if (s_value == CALIB_SENSOR_AEC_STRATEGYMODE_HIGHLIGHT) {
7497 aec->HdrAeCtrl.StrategyMode = RKAIQ_AEC_STRATEGY_MODE_HIGHLIGHT_PRIOR;
7498 }
7499 else {
7500 aec->HdrAeCtrl.StrategyMode = RKAIQ_AEC_STRATEGY_MODE_AUTO;
7501 redirectOut << "invalid AEC HdrAe StrategyMode (" << s_value << ")" << std::endl;
7502 }
7503 }
7504 else if (xmlParseReadWrite == XML_PARSER_WRITE)
7505 {
7506 XMLNode *pNode = (XMLNode*)psubchild;
7507 if (aec->HdrAeCtrl.StrategyMode == RKAIQ_AEC_STRATEGY_MODE_LOWLIGHT_PRIOR) {
7508 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_STRATEGYMODE_LOWLIGHT);
7509 }
7510 else if (aec->HdrAeCtrl.StrategyMode == RKAIQ_AEC_STRATEGY_MODE_HIGHLIGHT_PRIOR) {
7511 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_STRATEGYMODE_HIGHLIGHT);
7512 }
7513 else {
7514 pNode->FirstChild()->SetValue("AUTO");
7515 redirectOut << "(XML Write)invalid AEC HdrAe StrategyMode (" << aec->HdrAeCtrl.StrategyMode << ")" << std::endl;
7516 }
7517 }
7518 }
7519 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_EXPRATIOCTRL_TAG_ID)) {
7520 if (!parseEntrySensorHdrAECtrlExpRatioCtrl(psubchild->ToElement(), param)) {
7521 LOGE("parse error in Aec (%s)", subTagname.c_str());
7522 return (false);
7523 }
7524 }
7525 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_LUMADISTTH_TAG_ID)) {
7526 int no = ParseFloatArray(psubchild, &aec->HdrAeCtrl.LumaDistTh, subTag.Size());
7527 DCT_ASSERT((no == subTag.Size()));
7528 }
7529 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_LFRAMECTRL_TAG_ID)) {
7530 if (!parseEntrySensorHdrAECtrlLframeCtrl(psubchild->ToElement(), param)) {
7531 LOGE("parse error in Aec (%s)", subTagname.c_str());
7532 return (false);
7533 }
7534 }
7535 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_MFRAMECTRL_TAG_ID)) {
7536 if (!parseEntrySensorHdrAECtrlMframeCtrl(psubchild->ToElement(), param)) {
7537 LOGE("parse error in Aec (%s)", subTagname.c_str());
7538 return (false);
7539 }
7540 }
7541 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_SFRAMECTRL_TAG_ID)) {
7542 if (!parseEntrySensorHdrAECtrlSframeCtrl(psubchild->ToElement(), param)) {
7543 LOGE("parse error in Aec (%s)", subTagname.c_str());
7544 return (false);
7545 }
7546 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_TAG_ID)) {
7547 if (!parseEntrySensorHdrAECtrlLframeMode(psubchild->ToElement(), param)) {
7548 LOGE("parse error in Aec (%s)", subTagname.c_str());
7549 return (false);
7550 }
7551 }
7552 else {
7553 redirectOut
7554 << "parse error in AEC HdrAeCtrl (unknow tag: "
7555 << subTagname
7556 << ")"
7557 << std::endl;
7558 }
7559 psubchild = psubchild->NextSibling();
7560 }
7561 autoTabBackward();
7562
7563 XML_CHECK_END();
7564 autoTabBackward();
7565 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
7566 return (true);
7567 }
7568
parseEntrySensorAecEnvLvCalib(const XMLElement * pelement,void * param)7569 bool RkAiqCalibParser::parseEntrySensorAecEnvLvCalib
7570 (
7571 const XMLElement* pelement,
7572 void* param
7573 ) {
7574 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
7575 autoTabForward();
7576
7577 XML_CHECK_START(CALIB_SENSOR_AEC_ENVLVCALIB_TAG_ID, CALIB_SENSOR_AEC_TAG_ID);
7578
7579 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
7580
7581 const XMLNode* psubchild = pelement->FirstChild();
7582 #ifdef DEBUG_LOG
7583 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
7584 #endif
7585 while (psubchild) {
7586 XmlTag subTag = XmlTag(psubchild->ToElement());
7587 std::string subTagname(psubchild->ToElement()->Name());
7588 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
7589 #ifdef DEBUG_LOG
7590 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
7591 #endif
7592 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_ENVLVCALIB_CALIBFNUMBER_TAG_ID)) {
7593 int no = ParseFloatArray(psubchild, &aec->CommCtrl.stEnvLvCalib.CalibFN, subTag.Size());
7594 DCT_ASSERT((no == subTag.Size()));
7595 }
7596 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_ENVLVCALIB_CURVECOEFF_TAG_ID)) {
7597 int no = ParseFloatArray(psubchild, aec->CommCtrl.stEnvLvCalib.Curve.fCoeff, subTag.Size());
7598 DCT_ASSERT((no == subTag.Size()));
7599 }
7600 else {
7601 LOGW("%s(%d): parse error in AecEnvLv (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
7602 }
7603 psubchild = psubchild->NextSibling();
7604 }
7605
7606 XML_CHECK_END();
7607 autoTabBackward();
7608 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
7609 return (true);
7610 }
7611
7612
parseEntrySensorAec(const XMLElement * pelement,void * param)7613 bool RkAiqCalibParser::parseEntrySensorAec
7614 (
7615 const XMLElement* pelement,
7616 void* param
7617 ) {
7618 (void)param;
7619
7620 LOGI("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
7621 autoTabForward();
7622
7623 XML_CHECK_START(CALIB_SENSOR_AEC_TAG_ID, CALIB_SENSOR_TAG_ID);
7624
7625 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
7626
7627 const XMLNode* pchild = pelement->FirstChild();
7628 while (pchild) {
7629 XmlTag tag = XmlTag(pchild->ToElement());
7630 std::string tagname(pchild->ToElement()->Name());
7631 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
7632
7633 #ifdef DEBUG_LOG
7634 LOGE("%s(%d): tagname: [%s]\n", __FUNCTION__, __LINE__, tagname.c_str());
7635 #endif
7636
7637 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_ENABLE_TAG_ID)) {
7638 ParseUcharArray(pchild, &aec->CommCtrl.enable, tag.Size());
7639 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HISTSTATSMODE_TAG_ID)) {
7640 char* value = Toupper(tag.Value());
7641 char* value2 = Toupper(tag.Value());
7642 char* value3 = value2;
7643 int i = 0;
7644 while (*value != '\0') {
7645 if (*value == 'R') {
7646 *value2++ = 'R';
7647 i++;
7648 }
7649 else if (*value == 'G') {
7650 *value2++ = 'G';
7651 i++;
7652 }
7653 else if (*value == 'B') {
7654 *value2++ = 'B';
7655 i++;
7656 }
7657 else if (*value == 'Y') {
7658 *value2++ = 'Y';
7659 i++;
7660 }
7661 value++;
7662 }
7663 *value2 = '\0';
7664 std::string s_value(value3);
7665 #ifdef DEBUG_LOG
7666 LOGE("%s(%d): value: %s\n", __FUNCTION__, __LINE__, s_value.c_str());
7667 #endif
7668 if (xmlParseReadWrite == XML_PARSER_READ)
7669 {
7670 if (s_value == CALIB_SENSOR_AEC_HISTSTATSMODE_R) {
7671 aec->CommCtrl.HistStatsMode = CAM_HIST_MODE_R;
7672 }
7673 else if (s_value == CALIB_SENSOR_AEC_HISTSTATSMODE_G) {
7674 aec->CommCtrl.HistStatsMode = CAM_HIST_MODE_G;
7675 }
7676 else if (s_value == CALIB_SENSOR_AEC_HISTSTATSMODE_B) {
7677 aec->CommCtrl.HistStatsMode = CAM_HIST_MODE_B;
7678 }
7679 else if (s_value == CALIB_SENSOR_AEC_HISTSTATSMODE_RGB) {
7680 aec->CommCtrl.HistStatsMode = CAM_HIST_MODE_RGB_COMBINED;
7681 }
7682 else if (s_value == CALIB_SENSOR_AEC_HISTSTATSMODE_Y) {
7683 aec->CommCtrl.HistStatsMode = CAM_HIST_MODE_Y;
7684 }
7685 else {
7686 aec->CommCtrl.HistStatsMode = CAM_HIST_MODE_INVALID;
7687 LOGE("%s(%d): invalid AEC HistStatsMode = %s end\n", __FUNCTION__, __LINE__, s_value.c_str());
7688 }
7689 }
7690 else if (xmlParseReadWrite == XML_PARSER_WRITE)
7691 {
7692 XMLNode *pNode = (XMLNode*)pchild;
7693 switch (aec->CommCtrl.HistStatsMode)
7694 {
7695 case CAM_HIST_MODE_R:
7696 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HISTSTATSMODE_R);
7697 break;
7698 case CAM_HIST_MODE_G:
7699 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HISTSTATSMODE_G);
7700 break;
7701 case CAM_HIST_MODE_B:
7702 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HISTSTATSMODE_B);
7703 break;
7704 case CAM_HIST_MODE_RGB_COMBINED:
7705 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HISTSTATSMODE_RGB);
7706 break;
7707 case CAM_HIST_MODE_Y:
7708 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HISTSTATSMODE_Y);
7709 break;
7710 default:
7711 pNode->FirstChild()->SetValue("INVALID");
7712 LOGE("%s(%d): (XML Write)invalid AEC HistStatsMode = %d end\n", __FUNCTION__, __LINE__, aec->CommCtrl.HistStatsMode);
7713 break;
7714 }
7715 }
7716
7717 }
7718 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_RAWSTATSMODE_TAG_ID)) {
7719 char* value = Toupper(tag.Value());
7720 char* value2 = Toupper(tag.Value());
7721 char* value3 = value2;
7722 int i = 0;
7723 while (*value != '\0') {
7724 if (*value == 'R') {
7725 *value2++ = 'R';
7726 i++;
7727 }
7728 else if (*value == 'G') {
7729 *value2++ = 'G';
7730 i++;
7731 }
7732 else if (*value == 'B') {
7733 *value2++ = 'B';
7734 i++;
7735 }
7736 else if (*value == 'Y') {
7737 *value2++ = 'Y';
7738 i++;
7739 }
7740 value++;
7741 }
7742 *value2 = '\0';
7743 std::string s_value(value3);
7744 #ifdef DEBUG_LOG
7745 LOGE("%s(%d): value = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
7746 #endif
7747 if (xmlParseReadWrite == XML_PARSER_READ)
7748 {
7749 if (s_value == CALIB_SENSOR_AEC_RAWSTATSMODE_R) {
7750 aec->CommCtrl.RawStatsMode = CAM_RAWSTATS_MODE_R;
7751 }
7752 else if (s_value == CALIB_SENSOR_AEC_RAWSTATSMODE_G) {
7753 aec->CommCtrl.RawStatsMode = CAM_RAWSTATS_MODE_G;
7754 }
7755 else if (s_value == CALIB_SENSOR_AEC_RAWSTATSMODE_B) {
7756 aec->CommCtrl.RawStatsMode = CAM_RAWSTATS_MODE_B;
7757 }
7758 else if (s_value == CALIB_SENSOR_AEC_RAWSTATSMODE_Y) {
7759 aec->CommCtrl.RawStatsMode = CAM_RAWSTATS_MODE_Y;
7760 }
7761 else {
7762 aec->CommCtrl.RawStatsMode = CAM_RAWSTATS_MODE_INVALID;
7763 LOGE("%s(%d): invalid AEC RawStatsMode = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
7764 }
7765 }
7766 else if (xmlParseReadWrite == XML_PARSER_WRITE)
7767 {
7768 XMLNode *pNode = (XMLNode*)pchild;
7769 switch (aec->CommCtrl.RawStatsMode)
7770 {
7771 case CAM_RAWSTATS_MODE_R:
7772 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_RAWSTATSMODE_R);
7773 break;
7774 case CAM_RAWSTATS_MODE_G:
7775 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_RAWSTATSMODE_G);
7776 break;
7777 case CAM_RAWSTATS_MODE_B:
7778 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_RAWSTATSMODE_B);
7779 break;
7780 case CAM_RAWSTATS_MODE_Y:
7781 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_RAWSTATSMODE_Y);
7782 break;
7783 default:
7784 pNode->FirstChild()->SetValue("INVALID");
7785 LOGE("%s(%d): (XML Write)invalid AEC RawStatsMode = %d end\n", __FUNCTION__, __LINE__, aec->CommCtrl.RawStatsMode);
7786 break;
7787 }
7788 }
7789 }
7790 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_YRANGEMODE_TAG_ID)) {
7791 char* value = Toupper(tag.Value());
7792 std::string s_value(value);
7793 if (xmlParseReadWrite == XML_PARSER_READ)
7794 {
7795 if (s_value == CALIB_SENSOR_AEC_YRANGEMODE_FULL) {
7796 aec->CommCtrl.YRangeMode = CAM_YRANGE_MODE_FULL;
7797 }
7798 else if (s_value == CALIB_SENSOR_AEC_YRANGEMODE_LIMITED) {
7799 aec->CommCtrl.YRangeMode = CAM_YRANGE_MODE_LIMITED;
7800 }
7801 else {
7802 aec->CommCtrl.YRangeMode = CAM_YRANGE_MODE_INVALID;
7803 LOGE("%s(%d): invalid AEC YRangeMode = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
7804 }
7805 }
7806 else if (xmlParseReadWrite == XML_PARSER_WRITE)
7807 {
7808 XMLNode *pNode = (XMLNode*)pchild;
7809 if (aec->CommCtrl.YRangeMode == CAM_YRANGE_MODE_FULL) {
7810 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_YRANGEMODE_FULL);
7811 }
7812 else if (aec->CommCtrl.YRangeMode == CAM_YRANGE_MODE_LIMITED) {
7813 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_YRANGEMODE_LIMITED);
7814 }
7815 else {
7816 pNode->FirstChild()->SetValue("Invalid");
7817 LOGE("%s(%d): (XML Write)invalid AEC YRangeMode = %d\n", __FUNCTION__, __LINE__, aec->CommCtrl.YRangeMode);
7818 }
7819 }
7820 }
7821 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECRUNINTERVAL_TAG_ID)) {
7822 ParseUcharArray(pchild, &aec->CommCtrl.AecRunInterval, tag.Size());
7823 }
7824 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECOPTYPE_TAG_ID)) {
7825 char* value = Toupper(tag.Value());
7826 std::string s_value(value);
7827 if (xmlParseReadWrite == XML_PARSER_READ)
7828 {
7829 if (s_value == CALIB_SENSOR_AEC_AECOPTYPE_AUTO) {
7830 aec->CommCtrl.AecOpType = RK_AIQ_OP_MODE_AUTO;
7831 }
7832 else if (s_value == CALIB_SENSOR_AEC_AECOPTYPE_MANUAL) {
7833 aec->CommCtrl.AecOpType = RK_AIQ_OP_MODE_MANUAL;
7834 }
7835 else {
7836 aec->CommCtrl.AecOpType = RK_AIQ_OP_MODE_INVALID;
7837 LOGE("%s(%d): invalid AEC AecOpType = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
7838 }
7839 }
7840 else if (xmlParseReadWrite == XML_PARSER_WRITE)
7841 {
7842 XMLNode *pNode = (XMLNode*)pchild;
7843 if (aec->CommCtrl.AecOpType == RK_AIQ_OP_MODE_AUTO) {
7844 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_AECOPTYPE_AUTO);
7845 }
7846 else if (aec->CommCtrl.AecOpType == RK_AIQ_OP_MODE_MANUAL) {
7847 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_AECOPTYPE_MANUAL);
7848 }
7849 else {
7850 pNode->FirstChild()->SetValue("Invalid");
7851 LOGE("%s(%d): (XML Write)invalid AEC AecOpType = %d\n", __FUNCTION__, __LINE__, aec->CommCtrl.AecOpType);
7852 }
7853
7854 }
7855 }
7856 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SYNCTEST_TAG_ID)) {
7857 if (!parseEntrySensorAecSyncTest(pchild->ToElement()), param) {
7858 LOGE("parse error in Aec (%s)", tagname.c_str());
7859 return (false);
7860 }
7861 }
7862 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECSPEED_TAG_ID)) {
7863 if (!parseEntrySensorAecSpeed(pchild->ToElement()), param) {
7864 LOGE("parse error in Aec (%s)", tagname.c_str());
7865 return (false);
7866 }
7867 }
7868 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDELAYFRMNUM_TAG_ID)) {
7869 if (!parseEntrySensorAecDelayFrmNum(pchild->ToElement())) {
7870 LOGE("parse error in Aec (%s)", tagname.c_str(), param);
7871 return (false);
7872 }
7873 }
7874 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECDNSWITCH_TAG_ID)) {
7875 if (!parseEntrySensorAecDNSwitch(pchild->ToElement(), param)) {
7876 LOGE("parse error in Aec (%s)", tagname.c_str());
7877 return (false);
7878 }
7879 }
7880 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_ANTIFLICKER_TAG_ID)) {
7881 if (!parseEntrySensorAecAntiFlicker(pchild->ToElement(), param)) {
7882 LOGE("parse error in Aec (%s)", tagname.c_str());
7883 return (false);
7884 }
7885 }
7886 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECFRAMERATEMODE_TAG_ID)) {
7887 if (!parseEntrySensorAecFrameRateMode(pchild->ToElement(), param)) {
7888 LOGE("parse error in Aec (%s)", tagname.c_str());
7889 return (false);
7890 }
7891 }
7892 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECINITVALUE_TAG_ID)) {
7893 if (!parseEntrySensorAecInitValue(pchild->ToElement(), param)) {
7894 LOGE("parse error in Aec (%s)", tagname.c_str());
7895 return (false);
7896 }
7897 }
7898 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECGRIDWEIGHT_TAG_ID)) {
7899 if (!parseEntrySensorAecGridWeight(pchild->ToElement(), param)) {
7900 LOGE("parse error in Aec (%s)", tagname.c_str());
7901 return (false);
7902 }
7903 }
7904 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_IRISCTRL_TAG_ID)) {
7905 if (!parseEntrySensorAecIrisCtrl(pchild->ToElement(), param)) {
7906 LOGE("parse error in Aec (%s)", tagname.c_str());
7907 return (false);
7908 }
7909 }
7910 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MANUALCTRL_TAG_ID)) {
7911 if (!parseEntrySensorAecManualCtrl(pchild->ToElement(), param)) {
7912 LOGE("parse error in Aec (%s)", tagname.c_str());
7913 return (false);
7914 }
7915 }
7916 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_AECROUTE_TAG_ID)) {
7917 if (!parseEntrySensorAecRoute(pchild->ToElement(), param)) {
7918 LOGE("parse error in Aec (%s)", tagname.c_str());
7919 return (false);
7920 }
7921 }
7922 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_ENVLVCALIB_TAG_ID)) {
7923 if (!parseEntrySensorAecEnvLvCalib(pchild->ToElement(), param)) {
7924 LOGE("parse error in Aec (%s)", tagname.c_str());
7925 return (false);
7926 }
7927 }
7928 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_LINEARAE_CTRL_TAG_ID)) {
7929 if (!parseEntrySensorLinearAECtrl(pchild->ToElement(), param)) {
7930 LOGE("parse error in Aec (%s)", tagname.c_str());
7931 return (false);
7932 }
7933 }
7934 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_HDRAECTRL_TAG_ID)) {
7935 if (!parseEntrySensorHdrAECtrl(pchild->ToElement(), param)) {
7936 LOGE("parse error in Aec (%s)", tagname.c_str());
7937 return (false);
7938 }
7939 }
7940 else {
7941 LOGW("parse error in AEC section (unknow tag:%s)", tagname.c_str());
7942 //return (false);
7943 }
7944
7945 pchild = pchild->NextSibling();
7946 }
7947
7948 XML_CHECK_END();
7949
7950 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
7951 autoTabBackward();
7952
7953 return (true);
7954 }
7955
parseEntrySensorAecLinearAeRoute(const XMLElement * pelement,void * param)7956 bool RkAiqCalibParser::parseEntrySensorAecLinearAeRoute
7957 (
7958 const XMLElement* pelement,
7959 void* param
7960 ) {
7961 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
7962
7963 XML_CHECK_START(CALIB_SENSOR_AEC_AECROUTE_LINEARAE_TAG_ID, CALIB_SENSOR_AEC_AECROUTE_TAG_ID);
7964
7965 int index = *((int*)param);
7966 const XMLNode* pchild = pelement->FirstChild();
7967
7968 int nTimeDot = 0;
7969 int nGainDot = 0;
7970 int nIspDGainDot = 0;
7971 int nPIrisDot = 0;
7972
7973 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
7974
7975 while (pchild) {
7976 XmlTag tag = XmlTag(pchild->ToElement());
7977 std::string Tagname(pchild->ToElement()->Name());
7978 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
7979 #ifdef DEBUG_LOG
7980 redirectOut << "Tagname: " << Tagname << ",index:" << index << std::endl;
7981 #endif
7982
7983 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_NAME_TAG_ID)) {
7984 char* value = Toupper(tag.Value());
7985 ParseString(pchild,
7986 aec->CommCtrl.stAeRoute.LinAeSeperate[index].name,
7987 sizeof(aec->CommCtrl.stAeRoute.LinAeSeperate[index].name));
7988 #ifdef DEBUG_LOG
7989 redirectOut << "value:" << value << std::endl;
7990 redirectOut << aec->CommCtrl.stAeRoute.LinAeSeperate[index].name << std::endl;
7991 #endif
7992 }
7993 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_TIMEDOT_TAG_ID)) {
7994 int no = ParseFloatArray(pchild, aec->CommCtrl.stAeRoute.LinAeSeperate[index].TimeDot, tag.Size());
7995 DCT_ASSERT((no == tag.Size()));
7996 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
7997 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
7998 return false;
7999 }
8000 nTimeDot = no;
8001 }
8002 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_GAINDOT_TAG_ID)) {
8003 int no = ParseFloatArray(pchild, aec->CommCtrl.stAeRoute.LinAeSeperate[index].GainDot, tag.Size());
8004 DCT_ASSERT((no == tag.Size()));
8005 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
8006 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
8007 return false;
8008 }
8009 nGainDot = no;
8010 }
8011 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_ISPDGAINDOT_TAG_ID)) {
8012 int no = ParseFloatArray(pchild, aec->CommCtrl.stAeRoute.LinAeSeperate[index].IspgainDot, tag.Size());
8013 DCT_ASSERT((no == tag.Size()));
8014 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
8015 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
8016 return false;
8017 }
8018 nIspDGainDot = no;
8019 }
8020 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_PIRISDOT_TAG_ID)) {
8021 int no = ParseIntArray(pchild, aec->CommCtrl.stAeRoute.LinAeSeperate[index].PIrisGainDot, tag.Size());
8022 DCT_ASSERT((no == tag.Size()));
8023 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
8024 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
8025 return false;
8026 }
8027 nPIrisDot = no;
8028 }
8029 else {
8030 redirectOut
8031 << "parse error in LinAe Route (unknow tag: "
8032 << Tagname
8033 << ")"
8034 << std::endl;
8035 }
8036 pchild = pchild->NextSibling();
8037 }
8038 XML_CHECK_END();
8039 DCT_ASSERT((nGainDot == nTimeDot));
8040 DCT_ASSERT((nGainDot == nIspDGainDot));
8041 aec->CommCtrl.stAeRoute.LinAeSeperate[index].array_size = nTimeDot;
8042 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8043 return (true);
8044 }
8045
parseEntrySensorAecHdrAeRoute(const XMLElement * pelement,void * param)8046 bool RkAiqCalibParser::parseEntrySensorAecHdrAeRoute
8047 (
8048 const XMLElement* pelement,
8049 void* param
8050 ) {
8051 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8052
8053
8054 XML_CHECK_START(CALIB_SENSOR_AEC_AECROUTE_HDRAE_TAG_ID, CALIB_SENSOR_AEC_AECROUTE_TAG_ID);
8055
8056 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
8057
8058 int index = *((int*)param);
8059 const XMLNode* pchild = pelement->FirstChild();
8060 int nTimeDot = 0;
8061 int nGainDot = 0;
8062 int nIspDGainDot = 0;
8063 int nPIrisDot = 0;
8064
8065 while (pchild) {
8066 XmlTag tag = XmlTag(pchild->ToElement());
8067 std::string Tagname(pchild->ToElement()->Name());
8068 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
8069
8070 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_NAME_TAG_ID)) {
8071 char* value = Toupper(tag.Value());
8072 ParseString(pchild,
8073 aec->CommCtrl.stAeRoute.HdrAeSeperate[index].name,
8074 sizeof(aec->CommCtrl.stAeRoute.HdrAeSeperate[index].name));
8075 #ifdef DEBUG_LOG
8076 redirectOut << "value:" << value << std::endl;
8077 redirectOut << aec->CommCtrl.stAeRoute.HdrAeSeperate[index].name << std::endl;
8078 #endif
8079 }
8080 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_LTIMEDOT_TAG_ID)) {
8081 int no = ParseFloatArray(pchild, aec->CommCtrl.stAeRoute.HdrAeSeperate[index].HdrTimeDot[2], tag.Size());
8082 DCT_ASSERT((no == tag.Size()));
8083 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
8084 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
8085 return false;
8086 }
8087 nTimeDot = no;
8088 }
8089 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MTIMEDOT_TAG_ID)) {
8090 int no = ParseFloatArray(pchild, aec->CommCtrl.stAeRoute.HdrAeSeperate[index].HdrTimeDot[1], tag.Size());
8091 DCT_ASSERT((no == tag.Size()));
8092 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
8093 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
8094 return false;
8095 }
8096 DCT_ASSERT((nTimeDot == no));
8097 }
8098 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_STIMEDOT_TAG_ID)) {
8099 int no = ParseFloatArray(pchild, aec->CommCtrl.stAeRoute.HdrAeSeperate[index].HdrTimeDot[0], tag.Size());
8100 DCT_ASSERT((no == tag.Size()));
8101 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
8102 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
8103 return false;
8104 }
8105 DCT_ASSERT((nTimeDot == no));
8106 }
8107 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_LGAINDOT_TAG_ID)) {
8108 int no = ParseFloatArray(pchild, aec->CommCtrl.stAeRoute.HdrAeSeperate[index].HdrGainDot[2], tag.Size());
8109 DCT_ASSERT((no == tag.Size()));
8110 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
8111 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
8112 return false;
8113 }
8114 nGainDot = no;
8115 }
8116 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MGAINDOT_TAG_ID)) {
8117 int no = ParseFloatArray(pchild, aec->CommCtrl.stAeRoute.HdrAeSeperate[index].HdrGainDot[1], tag.Size());
8118 DCT_ASSERT((no == tag.Size()));
8119 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
8120 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
8121 return false;
8122 }
8123 DCT_ASSERT((no == nGainDot));
8124 }
8125 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SGAINDOT_TAG_ID)) {
8126 int no = ParseFloatArray(pchild, aec->CommCtrl.stAeRoute.HdrAeSeperate[index].HdrGainDot[0], tag.Size());
8127 DCT_ASSERT((no == tag.Size()));
8128 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
8129 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
8130 return false;
8131 }
8132 DCT_ASSERT((no == nGainDot));
8133 }
8134 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_LISPDGAINDOT_TAG_ID)) {
8135 int no = ParseFloatArray(pchild, aec->CommCtrl.stAeRoute.HdrAeSeperate[index].HdrIspDGainDot[2], tag.Size());
8136 DCT_ASSERT((no == tag.Size()));
8137 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
8138 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
8139 return false;
8140 }
8141 nIspDGainDot = no;
8142 }
8143 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_MISPDGAINDOT_TAG_ID)) {
8144 int no = ParseFloatArray(pchild, aec->CommCtrl.stAeRoute.HdrAeSeperate[index].HdrIspDGainDot[1], tag.Size());
8145 DCT_ASSERT((no == tag.Size()));
8146 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
8147 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
8148 return false;
8149 }
8150 DCT_ASSERT((nIspDGainDot == no));
8151 }
8152 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SISPDGAINDOT_TAG_ID)) {
8153 int no = ParseFloatArray(pchild, aec->CommCtrl.stAeRoute.HdrAeSeperate[index].HdrIspDGainDot[0], tag.Size());
8154 DCT_ASSERT((no == tag.Size()));
8155 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
8156 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
8157 return false;
8158 }
8159 DCT_ASSERT((nIspDGainDot == no));
8160 }
8161 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_PIRISDOT_TAG_ID)) {
8162 int no = ParseIntArray(pchild, aec->CommCtrl.stAeRoute.HdrAeSeperate[index].PIrisGainDot, tag.Size());
8163 DCT_ASSERT((no == tag.Size()));
8164 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
8165 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
8166 return false;
8167 }
8168 nPIrisDot = no;
8169 }
8170 else {
8171 redirectOut
8172 << "parse error in HdrAe Route (unknow tag: "
8173 << Tagname
8174 << ")"
8175 << std::endl;
8176 }
8177 pchild = pchild->NextSibling();
8178 }
8179 XML_CHECK_END();
8180 DCT_ASSERT((nGainDot == nTimeDot));
8181 DCT_ASSERT((nGainDot == nIspDGainDot));
8182 aec->CommCtrl.stAeRoute.HdrAeSeperate[index].array_size = nTimeDot;
8183 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8184 return (true);
8185 }
8186
parseEntrySensorAecLinearAeDynamicPoint(const XMLElement * pelement,void * param)8187 bool RkAiqCalibParser::parseEntrySensorAecLinearAeDynamicPoint
8188 (
8189 const XMLElement* pelement,
8190 void* param
8191 ) {
8192 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8193
8194 XML_CHECK_START(CALIB_SENSOR_AEC_DYNAMICSETPOINT_TAG_ID, CALIB_SENSOR_AEC_LINEARAE_CTRL_TAG_ID);
8195
8196 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Aec_Para_t, aec);
8197
8198 int index = *((int*)param);
8199 const XMLNode* pchild = pelement->FirstChild();
8200
8201 int nExpValue = 0;
8202 int nDysetpoint = 0;
8203 while (pchild) {
8204 XmlTag tag = XmlTag(pchild->ToElement());
8205 std::string Tagname(pchild->ToElement()->Name());
8206 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
8207 INFO_PRINT(Tagname);
8208 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_NAME_TAG_ID)) {
8209 char* value = Toupper(tag.Value());
8210 ParseString(pchild,
8211 aec->LinearAeCtrl.DySetpoint[index].name,
8212 sizeof(aec->LinearAeCtrl.DySetpoint[index].name));
8213 #ifdef DEBUG_LOG
8214 redirectOut << "value:" << value << std::endl;
8215 redirectOut << aec->LinearAeCtrl.DySetpoint[index].name << std::endl;
8216 #endif
8217 }
8218 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_EXPLEVEL_TAG_ID)) {
8219 int no = ParseFloatArray(pchild, aec->LinearAeCtrl.DySetpoint[index].ExpValue, tag.Size());
8220 DCT_ASSERT((no == tag.Size()));
8221 if(tag.Size() > AEC_SETPOINT_MAX_NODES) {
8222 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_SETPOINT_MAX_NODES);
8223 return false;
8224 }
8225 nExpValue = no;
8226 }
8227 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_DYSETPOINT_TAG_ID)) {
8228 int no = ParseFloatArray(pchild, aec->LinearAeCtrl.DySetpoint[index].DySetpoint, tag.Size());
8229 DCT_ASSERT((no == tag.Size()));
8230 if(tag.Size() > AEC_SETPOINT_MAX_NODES) {
8231 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_SETPOINT_MAX_NODES);
8232 return false;
8233 }
8234 nDysetpoint = no;
8235 }
8236 else {
8237 redirectOut
8238 << "parse error in DynamicPoint (unknow tag: "
8239 << Tagname
8240 << ")"
8241 << std::endl;
8242 }
8243 pchild = pchild->NextSibling();
8244 }
8245 XML_CHECK_END();
8246 DCT_ASSERT((nDysetpoint == nExpValue));
8247 aec->LinearAeCtrl.DySetpoint[index].array_size = nDysetpoint;
8248
8249 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8250 return (true);
8251 }
8252 //aec v21 parser
parseEntrySensorAecLinAlterExpV21(const XMLElement * pelement,void * param,int index)8253 bool RkAiqCalibParser::parseEntrySensorAecLinAlterExpV21
8254 (
8255 const XMLElement* pelement,
8256 void* param,
8257 int index
8258 ) {
8259 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8260
8261 XML_CHECK_START(CALIB_SENSOR_AEC_V21_SYNCTEST_LINALTEREXP_TAG_ID, CALIB_SENSOR_AEC_V21_SYNCTEST_ALTEREXP_TAG_ID);
8262
8263 const XMLNode* pchild = pelement->FirstChild();
8264 CalibDb_AeSyncTest_t* paec_synctest = (CalibDb_AeSyncTest_t*)param;
8265
8266 while (pchild) {
8267 XmlTag tag = XmlTag(pchild->ToElement());
8268 std::string Tagname(pchild->ToElement()->Name());
8269 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
8270 #ifdef DEBUG_LOG
8271 redirectOut << "Tagname: " << Tagname << ",index:" << index << std::endl;
8272 #endif
8273 DCT_ASSERT((index < AEC_ALTER_EXP_MAX_NUM));
8274
8275 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_TIMEVALUE_TAG_ID)) {
8276 int no = ParseFloatArray(pchild, &paec_synctest->LinAlterExp.TimeValue[index], tag.Size());
8277 DCT_ASSERT((no == tag.Size()));
8278 }
8279 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_GAINVALUE_TAG_ID)) {
8280 int no = ParseFloatArray(pchild, &paec_synctest->LinAlterExp.GainValue[index], tag.Size());
8281 DCT_ASSERT((no == tag.Size()));
8282 }
8283 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_ISPGAINVALUE_TAG_ID)) {
8284 int no = ParseFloatArray(pchild, &paec_synctest->LinAlterExp.IspgainValue[index], tag.Size());
8285 DCT_ASSERT((no == tag.Size()));
8286 }
8287 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_DCGMODE_TAG_ID)) {
8288 int no = ParseIntArray(pchild, &paec_synctest->LinAlterExp.DcgMode[index], tag.Size());
8289 DCT_ASSERT((no == tag.Size()));
8290 }
8291 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_PIRISVALUE_TAG_ID)) {
8292 int no = ParseIntArray(pchild, &paec_synctest->LinAlterExp.PIrisGainValue[index], tag.Size());
8293 DCT_ASSERT((no == tag.Size()));
8294 }
8295 else {
8296 redirectOut
8297 << "parse error in LinAlterExp (unknow tag: "
8298 << Tagname
8299 << ")"
8300 << std::endl;
8301 }
8302 pchild = pchild->NextSibling();
8303 }
8304 XML_CHECK_END();
8305 paec_synctest->LinAlterExp.array_size = index + 1;
8306
8307 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8308 return (true);
8309 }
8310
8311
parseEntrySensorAecHdrAlterExpV21(const XMLElement * pelement,void * param,int index)8312 bool RkAiqCalibParser::parseEntrySensorAecHdrAlterExpV21
8313 (
8314 const XMLElement* pelement,
8315 void* param,
8316 int index
8317 ) {
8318 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8319
8320 XML_CHECK_START(CALIB_SENSOR_AEC_V21_SYNCTEST_HDRALTEREXP_TAG_ID, CALIB_SENSOR_AEC_V21_SYNCTEST_ALTEREXP_TAG_ID);
8321
8322 const XMLNode* pchild = pelement->FirstChild();
8323 CalibDb_AeSyncTest_t* paec_synctest = (CalibDb_AeSyncTest_t*)param;
8324
8325 while (pchild) {
8326 XmlTag tag = XmlTag(pchild->ToElement());
8327 std::string Tagname(pchild->ToElement()->Name());
8328 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
8329 #ifdef DEBUG_LOG
8330 redirectOut << "Tagname: " << Tagname << ",index:" << index << std::endl;
8331 #endif
8332 DCT_ASSERT((index < AEC_ALTER_EXP_MAX_NUM));
8333
8334 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_TIMEVALUE_TAG_ID)) {
8335 int no = ParseFloatArray(pchild, paec_synctest->HdrAlterExp.TimeValue[index], tag.Size());
8336 DCT_ASSERT((no == tag.Size()));
8337 }
8338 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_GAINVALUE_TAG_ID)) {
8339 int no = ParseFloatArray(pchild, paec_synctest->HdrAlterExp.GainValue[index], tag.Size());
8340 DCT_ASSERT((no == tag.Size()));
8341 }
8342 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_ISPGAINVALUE_TAG_ID)) {
8343 int no = ParseFloatArray(pchild, paec_synctest->HdrAlterExp.IspDGainValue[index], tag.Size());
8344 DCT_ASSERT((no == tag.Size()));
8345 }
8346 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_DCGMODE_TAG_ID)) {
8347 int no = ParseIntArray(pchild, paec_synctest->HdrAlterExp.DcgMode[index], tag.Size());
8348 DCT_ASSERT((no == tag.Size()));
8349 }
8350 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_PIRISVALUE_TAG_ID)) {
8351 int no = ParseIntArray(pchild, &paec_synctest->HdrAlterExp.PIrisGainValue[index], tag.Size());
8352 DCT_ASSERT((no == tag.Size()));
8353 }
8354 else {
8355 redirectOut
8356 << "parse error in HdrAlterExp (unknow tag: "
8357 << Tagname
8358 << ")"
8359 << std::endl;
8360 }
8361 pchild = pchild->NextSibling();
8362 }
8363 XML_CHECK_END();
8364 paec_synctest->HdrAlterExp.array_size = index + 1;
8365 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8366 return (true);
8367 }
8368
parseEntrySensorAecAlterExpV21(const XMLElement * pelement,void * param)8369 bool RkAiqCalibParser::parseEntrySensorAecAlterExpV21
8370 (
8371 const XMLElement* pelement,
8372 void* param
8373 ) {
8374 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8375 autoTabForward();
8376
8377 XML_CHECK_START(CALIB_SENSOR_AEC_V21_SYNCTEST_ALTEREXP_TAG_ID, CALIB_SENSOR_AEC_V21_SYNCTEST_TAG_ID);
8378 CalibDb_AeSyncTest_t* paec_synctest = (CalibDb_AeSyncTest_t*)param;
8379
8380 #ifdef DEBUG_LOG
8381 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
8382 #endif
8383 const XMLNode* psubchild = pelement->FirstChild();
8384 while (psubchild) {
8385 XmlTag subTag = XmlTag(psubchild->ToElement());
8386 std::string subTagname(psubchild->ToElement()->Name());
8387 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
8388 #ifdef DEBUG_LOG
8389 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
8390 #endif
8391 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_LINALTEREXP_TAG_ID)) {
8392 if (!parseEntryCell2(psubchild->ToElement(), subTag.Size(),
8393 &RkAiqCalibParser::parseEntrySensorAecLinAlterExpV21,
8394 paec_synctest,
8395 (uint32_t)CALIB_SENSOR_AEC_V21_SYNCTEST_LINALTEREXP_TAG_ID,
8396 (uint32_t)CALIB_SENSOR_AEC_V21_SYNCTEST_ALTEREXP_TAG_ID)) {
8397 LOGE("parse error in AEC-SyncTest LinAlterExp(%s)", subTagname.c_str());
8398 return (false);
8399 }
8400 }
8401 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_HDRALTEREXP_TAG_ID)) {
8402 if (!parseEntryCell2(psubchild->ToElement(), subTag.Size(),
8403 &RkAiqCalibParser::parseEntrySensorAecHdrAlterExpV21,
8404 paec_synctest,
8405 (uint32_t)CALIB_SENSOR_AEC_V21_SYNCTEST_HDRALTEREXP_TAG_ID,
8406 (uint32_t)CALIB_SENSOR_AEC_V21_SYNCTEST_ALTEREXP_TAG_ID)) {
8407 LOGE("parse error in AEC-SyncTest HdrAlterExp(%s)", subTagname.c_str());
8408 return (false);
8409 }
8410 }
8411 else {
8412 LOGE("%s(%d): parse error in AEC-SyncTest AlterExp (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
8413 }
8414 psubchild = psubchild->NextSibling();
8415 }
8416
8417 XML_CHECK_END();
8418 autoTabBackward();
8419 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8420 return (true);
8421 }
8422
parseEntrySensorAecSyncTestV21(const XMLElement * pelement,void * param)8423 bool RkAiqCalibParser::parseEntrySensorAecSyncTestV21
8424 (
8425 const XMLElement* pelement,
8426 void* param
8427 ) {
8428 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8429 autoTabForward();
8430
8431 XML_CHECK_START(CALIB_SENSOR_AEC_V21_SYNCTEST_TAG_ID, CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID);
8432
8433 CalibDb_AeSyncTest_t* paec_synctest = (CalibDb_AeSyncTest_t*)param;
8434
8435 const XMLNode* psubchild = pelement->FirstChild();
8436 #ifdef DEBUG_LOG
8437 LOGE("%s(%d): Tagname = [%s]\n", __FUNCTION__, __LINE__, pelement->Name());
8438 #endif
8439
8440 while (psubchild) {
8441 XmlTag subTag = XmlTag(psubchild->ToElement());
8442 std::string subTagname(psubchild->ToElement()->Name());
8443 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
8444 #ifdef DEBUG_LOG
8445 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
8446 #endif
8447 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_ENABLE_TAG_ID)) {
8448 int no = ParseUcharArray(psubchild, &paec_synctest->enable, subTag.Size());
8449 DCT_ASSERT((no == subTag.Size()));
8450 }
8451 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_INTERVALFRM_TAG_ID)) {
8452 int no = ParseIntArray(psubchild, &paec_synctest->IntervalFrm, subTag.Size());
8453 DCT_ASSERT((no == subTag.Size()));
8454 }
8455 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_ALTEREXP_TAG_ID)) {
8456 if (!parseEntrySensorAecAlterExpV21(psubchild->ToElement(), paec_synctest)) {
8457 LOGE("parse error in Aec-SyncTest AlterExp(%s)", subTagname.c_str());
8458 return (false);
8459 }
8460 }
8461 else {
8462 LOGE("%s(%d): parse error in Aec-SyncTest (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
8463 }
8464 psubchild = psubchild->NextSibling();
8465 }
8466 XML_CHECK_END();
8467 autoTabBackward();
8468 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8469 return (true);
8470 }
8471
8472
parseEntrySensorAecSpeedV21(const XMLElement * pelement,void * param)8473 bool RkAiqCalibParser::parseEntrySensorAecSpeedV21
8474 (
8475 const XMLElement* pelement,
8476 void* param
8477 ) {
8478 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8479 autoTabForward();
8480
8481 XML_CHECK_START(CALIB_SENSOR_AEC_V21_AECSPEED_TAG_ID, CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID);
8482 CalibDb_AeSpeed_t* paec_speed = (CalibDb_AeSpeed_t*)param;
8483 bool newparams = false;
8484 const XMLNode* psubchild = pelement->FirstChild();
8485 #ifdef DEBUG_LOG
8486 LOGE("%s(%d): Tagname = [%s]\n", __FUNCTION__, __LINE__, pelement->Name());
8487 #endif
8488 while (psubchild) {
8489 XmlTag subTag = XmlTag(psubchild->ToElement());
8490 std::string subTagname(psubchild->ToElement()->Name());
8491 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
8492 #ifdef DEBUG_LOG
8493 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
8494 #endif
8495 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_DYDAMPEN_TAG_ID)) {
8496 uint8_t temp = paec_speed->DyDampEn;
8497 int no = ParseUcharArray(psubchild, &temp, subTag.Size());
8498 paec_speed->DyDampEn = (temp == 0) ? false : true;
8499 newparams = true;
8500 DCT_ASSERT((no == subTag.Size()));
8501 }
8502 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_SMOOTHEN_TAG_ID)) {
8503 uint8_t temp = paec_speed->SmoothEn;
8504 int no = ParseUcharArray(psubchild, &temp, subTag.Size());
8505 paec_speed->SmoothEn = (temp == 0) ? false : true;
8506 newparams = true;
8507 DCT_ASSERT((no == subTag.Size()));
8508 }
8509 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_DAMPOVER_TAG_ID)) {
8510 int no = ParseFloatArray(psubchild, &paec_speed->DampOver, subTag.Size());
8511 DCT_ASSERT((no == subTag.Size()));
8512 }
8513 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_DAMPUNDER_TAG_ID)) {
8514 int no = ParseFloatArray(psubchild, &paec_speed->DampUnder, subTag.Size());
8515 DCT_ASSERT((no == subTag.Size()));
8516 }
8517 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_DAMPDARK2BRIGHT_TAG_ID)) {
8518 int no = ParseFloatArray(psubchild, &paec_speed->DampDark2Bright, subTag.Size());
8519 DCT_ASSERT((no == subTag.Size()));
8520 }
8521 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_DAMPBRIGHT2DARK_TAG_ID)) {
8522 int no = ParseFloatArray(psubchild, &paec_speed->DampBright2Dark, subTag.Size());
8523 DCT_ASSERT((no == subTag.Size()));
8524 }
8525 else {
8526 LOGE("%s(%d): parse error in AeSpeed (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
8527 }
8528 psubchild = psubchild->NextSibling();
8529 }
8530
8531 if(newparams == false) {
8532 paec_speed->DyDampEn = true;
8533 paec_speed->SmoothEn = true;
8534 }
8535 XML_CHECK_END();
8536 autoTabBackward();
8537 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8538 return (true);
8539 }
8540
parseEntrySensorAecDelayFrmNumV21(const XMLElement * pelement,void * param)8541 bool RkAiqCalibParser::parseEntrySensorAecDelayFrmNumV21
8542 (
8543 const XMLElement* pelement,
8544 void* param
8545 ) {
8546 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8547
8548 XML_CHECK_START(CALIB_SENSOR_AEC_V21_AECDELAYFRMNUM_TAG_ID, CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID);
8549 CalibDb_AeAttr_t* paec_auto = (CalibDb_AeAttr_t*)param;
8550
8551 const XMLNode* psubchild = pelement->FirstChild();
8552 autoTabForward();
8553 #ifdef DEBUG_LOG
8554 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
8555 #endif
8556 while (psubchild) {
8557 XmlTag subTag = XmlTag(psubchild->ToElement());
8558 std::string subTagname(psubchild->ToElement()->Name());
8559 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
8560 #ifdef DEBUG_LOG
8561 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
8562 #endif
8563 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_BLACKDELAY_TAG_ID)) {
8564 int no = ParseUcharArray(psubchild, &paec_auto->BlackDelayFrame, subTag.Size());
8565 DCT_ASSERT((no == subTag.Size()));
8566 }
8567 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_WHITEDELAY_TAG_ID)) {
8568 int no = ParseUcharArray(psubchild, &paec_auto->WhiteDelayFrame, subTag.Size());
8569 DCT_ASSERT((no == subTag.Size()));
8570 }
8571 else {
8572 LOGE("%s(%d): parse error in AeDelayFrame (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
8573 }
8574 psubchild = psubchild->NextSibling();
8575 }
8576 XML_CHECK_END();
8577 autoTabBackward();
8578 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8579 return (true);
8580 }
8581
parseEntrySensorAecVBNightModeV21(const XMLElement * pelement,void * param)8582 bool RkAiqCalibParser::parseEntrySensorAecVBNightModeV21
8583 (
8584 const XMLElement* pelement,
8585 void* param
8586 ) {
8587 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8588
8589 XML_CHECK_START(CALIB_SENSOR_AEC_V21_AECDNSWITCH_VBNIGHTMODE_TAG_ID, CALIB_SENSOR_AEC_V21_AECDNSWITCH_TAG_ID);
8590
8591 XmlTag subTag = XmlTag(pelement);
8592 CalibDb_DNSwitch_Attr_t* paec_dnswitch = (CalibDb_DNSwitch_Attr_t*)param;
8593
8594 const XMLNode* psubsubchild = pelement->FirstChild();
8595 autoTabForward();
8596 while (psubsubchild) {
8597 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
8598 std::string subsubTagname(psubsubchild->ToElement()->Name());
8599 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
8600 #ifdef DEBUG_LOG
8601 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
8602 #endif
8603 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_ENABLE_TAG_ID)) {
8604 int no = ParseUcharArray(psubsubchild, &paec_dnswitch->stVBNightMode.enable, subTag.Size());
8605 DCT_ASSERT((no == subsubTag.Size()));
8606 }
8607 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_N2DFRMCNT_TAG_ID)) {
8608 int no = ParseUcharArray(psubsubchild, &paec_dnswitch->stVBNightMode.Night2DayFrmCnt, subTag.Size());
8609 DCT_ASSERT((no == subsubTag.Size()));
8610 }
8611 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_N2DFACTH_TAG_ID)) {
8612 int no = ParseFloatArray(psubsubchild, &paec_dnswitch->stVBNightMode.Night2DayFacTh, subTag.Size());
8613 DCT_ASSERT((no == subsubTag.Size()));
8614 }
8615 else {
8616 LOGE("%s(%d): parse error in DNSwitch - VBNightMode(unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
8617 }
8618 psubsubchild = psubsubchild->NextSibling();
8619 }
8620 XML_CHECK_END();
8621 autoTabBackward();
8622 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8623 return (true);
8624 }
8625
parseEntrySensorAecIRNightModeV21(const XMLElement * pelement,void * param)8626 bool RkAiqCalibParser::parseEntrySensorAecIRNightModeV21
8627 (
8628 const XMLElement* pelement,
8629 void* param
8630 ) {
8631 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8632
8633 XML_CHECK_START(CALIB_SENSOR_AEC_V21_AECDNSWITCH_IRNIGHTMODE_TAG_ID, CALIB_SENSOR_AEC_V21_AECDNSWITCH_TAG_ID);
8634 CalibDb_DNSwitch_Attr_t* paec_dnswitch = (CalibDb_DNSwitch_Attr_t*)param;
8635
8636 XmlTag subTag = XmlTag(pelement);
8637 const XMLNode* psubsubchild = pelement->FirstChild();
8638 autoTabForward();
8639 while (psubsubchild) {
8640 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
8641 std::string subsubTagname(psubsubchild->ToElement()->Name());
8642 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
8643 #ifdef DEBUG_LOG
8644 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
8645 #endif
8646 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_ENABLE_TAG_ID)) {
8647 int no = ParseUcharArray(psubsubchild, &paec_dnswitch->stIRNightMode.enable, subTag.Size());
8648 DCT_ASSERT((no == subsubTag.Size()));
8649 }
8650 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_N2DFRMCNT_TAG_ID)) {
8651 int no = ParseUcharArray(psubsubchild, &paec_dnswitch->stIRNightMode.Night2DayFrmCnt, subTag.Size());
8652 DCT_ASSERT((no == subsubTag.Size()));
8653 }
8654 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_N2DFACTH_TAG_ID)) {
8655 int no = ParseFloatArray(psubsubchild, &paec_dnswitch->stIRNightMode.Night2DayFacTh, subTag.Size());
8656 DCT_ASSERT((no == subsubTag.Size()));
8657 }
8658 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_IR_RG_TAG_ID)) {
8659 int no = ParseFloatArray(psubsubchild, &paec_dnswitch->stIRNightMode.IRRgain, subTag.Size());
8660 DCT_ASSERT((no == subsubTag.Size()));
8661 }
8662 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_IR_BG_TAG_ID)) {
8663 int no = ParseFloatArray(psubsubchild, &paec_dnswitch->stIRNightMode.IRBgain, subTag.Size());
8664 DCT_ASSERT((no == subsubTag.Size()));
8665 }
8666 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_MAX_DIS_TAG_ID)) {
8667 int no = ParseFloatArray(psubsubchild, &paec_dnswitch->stIRNightMode.MaxWbDis, subTag.Size());
8668 DCT_ASSERT((no == subsubTag.Size()));
8669 }
8670 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_VB_PERCENT_TAG_ID)) {
8671 int no = ParseFloatArray(psubsubchild, &paec_dnswitch->stIRNightMode.VbPercent, subTag.Size());
8672 DCT_ASSERT((no == subsubTag.Size()));
8673 } else {
8674 LOGE("%s(%d): parse error in DNSwitch - IRNightMode(unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
8675 }
8676 psubsubchild = psubsubchild->NextSibling();
8677 }
8678
8679 XML_CHECK_END();
8680 autoTabBackward();
8681 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8682 return (true);
8683 }
8684
8685
parseEntrySensorAecDNSwitchV21(const XMLElement * pelement,void * param)8686 bool RkAiqCalibParser::parseEntrySensorAecDNSwitchV21
8687 (
8688 const XMLElement* pelement,
8689 void* param
8690 ) {
8691 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8692
8693 XML_CHECK_START(CALIB_SENSOR_AEC_V21_AECDNSWITCH_TAG_ID, CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID);
8694 CalibDb_DNSwitch_Attr_t* paec_dnswitch = (CalibDb_DNSwitch_Attr_t*)param;
8695
8696 const XMLNode* psubchild = pelement->FirstChild();
8697 autoTabForward();
8698 #ifdef DEBUG_LOG
8699 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
8700 #endif
8701 while (psubchild) {
8702 XmlTag subTag = XmlTag(psubchild->ToElement());
8703 std::string subTagname(psubchild->ToElement()->Name());
8704 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
8705
8706 #ifdef DEBUG_LOG
8707 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
8708 #endif
8709 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_DNTRIGGER_TAG_ID)) {
8710 int no = ParseUcharArray(psubchild, &paec_dnswitch->DNTrigger, subTag.Size());
8711 DCT_ASSERT((no == subTag.Size()));
8712 }
8713 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_DNMODE_TAG_ID)) {
8714 char* value = Toupper(subTag.Value());
8715 std::string s_value(value);
8716 if (xmlParseReadWrite == XML_PARSER_READ)
8717 {
8718 if (s_value == CALIB_SENSOR_AEC_AECDNSWITCH_DNMODE_DAY) {
8719 paec_dnswitch->DNMode = AEC_DNMODE_DAY;
8720 }
8721 else if (s_value == CALIB_SENSOR_AEC_AECDNSWITCH_DNMODE_NIGHT) {
8722 paec_dnswitch->DNMode = AEC_DNMODE_NIGHT;
8723 }
8724 else {
8725 paec_dnswitch->DNMode = AEC_DNMODE_MIN;
8726 LOGE("%s(%d): invalid AEC DNSwitch-DNMode = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
8727 }
8728 }
8729 else if (xmlParseReadWrite == XML_PARSER_WRITE)
8730 {
8731 XMLNode *pNode = (XMLNode*)psubchild;
8732 if (paec_dnswitch->DNMode == AEC_DNMODE_DAY) {
8733 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_AECDNSWITCH_DNMODE_DAY);
8734 }
8735 else if (paec_dnswitch->DNMode == AEC_DNMODE_NIGHT) {
8736 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_AECDNSWITCH_DNMODE_NIGHT);
8737 }
8738 else {
8739 pNode->FirstChild()->SetValue("Invalid");
8740 LOGE("%s(%d): (XML Write)invalid AEC DNSwitch-DNMode = %d\n", __FUNCTION__, __LINE__, paec_dnswitch->DNMode);
8741 }
8742
8743 }
8744 }
8745 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_FILLLIGHTMODE_TAG_ID)) {
8746 int no = ParseUcharArray(psubchild, &paec_dnswitch->FillLightMode, subTag.Size());
8747 DCT_ASSERT((no == subTag.Size()));
8748 }
8749 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_D2NFACTH_TAG_ID)) {
8750 int no = ParseFloatArray(psubchild, &paec_dnswitch->Day2NightFacTh, subTag.Size());
8751 DCT_ASSERT((no == subTag.Size()));
8752 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_D2NFRMCNT_TAG_ID)) {
8753 int no = ParseUcharArray(psubchild, &paec_dnswitch->Day2NightFrmCnt, subTag.Size());
8754 DCT_ASSERT((no == subTag.Size()));
8755 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_VBNIGHTMODE_TAG_ID)) {
8756 if (!parseEntrySensorAecVBNightModeV21(psubchild->ToElement(), paec_dnswitch)) {
8757 LOGE("parse error in Aec (%s)", subTagname.c_str());
8758 return (false);
8759 }
8760 }
8761 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_IRNIGHTMODE_TAG_ID)) {
8762 if (!parseEntrySensorAecIRNightModeV21(psubchild->ToElement(), paec_dnswitch)) {
8763 LOGE("parse error in Aec (%s)", subTagname.c_str());
8764 return (false);
8765 }
8766 }
8767 else {
8768 LOGE("%s(%d): parse error in DNSwitch (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
8769 }
8770 psubchild = psubchild->NextSibling();
8771 }
8772
8773 XML_CHECK_END();
8774 autoTabBackward();
8775 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8776 return (true);
8777 }
8778
parseEntrySensorAecAntiFlickerV21(const XMLElement * pelement,void * param)8779 bool RkAiqCalibParser::parseEntrySensorAecAntiFlickerV21
8780 (
8781 const XMLElement* pelement,
8782 void* param
8783 ) {
8784 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8785 autoTabForward();
8786
8787 XML_CHECK_START(CALIB_SENSOR_AEC_V21_ANTIFLICKER_TAG_ID, CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID);
8788 CalibDb_AntiFlickerAttr_t* paec_antiflicker = (CalibDb_AntiFlickerAttr_t*)param;
8789
8790 const XMLNode* psubchild = pelement->FirstChild();
8791 #ifdef DEBUG_LOG
8792 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
8793 #endif
8794 while (psubchild) {
8795 XmlTag subTag = XmlTag(psubchild->ToElement());
8796 std::string subTagname(psubchild->ToElement()->Name());
8797 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
8798 #ifdef DEBUG_LOG
8799 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
8800 #endif
8801 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_ANTIFLICKER_ENABLE_TAG_ID)) {
8802 uint8_t temp = paec_antiflicker->enable;
8803 int no = ParseUcharArray(psubchild, &temp, subTag.Size());
8804 paec_antiflicker->enable = (temp == 0) ? false : true;
8805 DCT_ASSERT((no == subTag.Size()));
8806 }
8807 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_ANTIFLICKER_FREQ_TAG_ID)) {
8808 char* value = Toupper(subTag.Value());
8809 std::string s_value(value);
8810 if (xmlParseReadWrite == XML_PARSER_READ)
8811 {
8812 if (s_value == CALIB_SENSOR_AEC_ANTIFLICKER_FREQ_50HZ) {
8813 paec_antiflicker->Frequency = AEC_FLICKER_FREQUENCY_50HZ;
8814 }
8815 else if (s_value == CALIB_SENSOR_AEC_ANTIFLICKER_FREQ_60HZ) {
8816 paec_antiflicker->Frequency = AEC_FLICKER_FREQUENCY_60HZ;
8817 }
8818 else {
8819 paec_antiflicker->Frequency = AEC_FLICKER_FREQUENCY_OFF;
8820 LOGE("%s(%d): invalid stAntiFlicker.Frequency = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
8821 }
8822 }
8823 else if (xmlParseReadWrite == XML_PARSER_WRITE)
8824 {
8825 XMLNode *pNode = (XMLNode*)psubchild;
8826 if (paec_antiflicker->Frequency == AEC_FLICKER_FREQUENCY_50HZ) {
8827 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_ANTIFLICKER_FREQ_50HZ);
8828 }
8829 else if (paec_antiflicker->Frequency == AEC_FLICKER_FREQUENCY_60HZ) {
8830 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_ANTIFLICKER_FREQ_60HZ);
8831 }
8832 else {
8833 pNode->FirstChild()->SetValue("Invalid");
8834 LOGE("%s(%d): (XML Write)invalid AEC stAntiFlicker.Frequency = %d\n", __FUNCTION__, __LINE__, paec_antiflicker->Frequency);
8835 }
8836
8837 }
8838 }
8839 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_ANTIFLICKER_MODE_TAG_ID)) {
8840 char* value = Toupper(subTag.Value());
8841 std::string s_value(value);
8842 if (xmlParseReadWrite == XML_PARSER_READ)
8843 {
8844 if (s_value == CALIB_SENSOR_AEC_ANTIFLICKER_MODE_AUTO) {
8845 paec_antiflicker->Mode = AEC_ANTIFLICKER_AUTO_MODE;
8846 }
8847 else if (s_value == CALIB_SENSOR_AEC_ANTIFLICKER_MODE_NORMAL) {
8848 paec_antiflicker->Mode = AEC_ANTIFLICKER_NORMAL_MODE;
8849 }
8850 else {
8851 paec_antiflicker->Mode = AEC_ANTIFLICKER_AUTO_MODE;
8852 LOGE("%s(%d): invalid stAntiFlicker.Mode = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
8853 }
8854 }
8855 else if (xmlParseReadWrite == XML_PARSER_WRITE)
8856 {
8857 XMLNode *pNode = (XMLNode*)psubchild;
8858 if (paec_antiflicker->Mode == AEC_ANTIFLICKER_AUTO_MODE) {
8859 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_ANTIFLICKER_MODE_AUTO);
8860 }
8861 else if (paec_antiflicker->Mode == AEC_ANTIFLICKER_NORMAL_MODE) {
8862 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_ANTIFLICKER_MODE_NORMAL);
8863 }
8864 else {
8865 pNode->FirstChild()->SetValue("Invalid");
8866 LOGE("%s(%d): (XML Write)invalid AEC stAntiFlicker.Mode = %d\n", __FUNCTION__, __LINE__, paec_antiflicker->Mode);
8867 }
8868
8869 }
8870 }
8871 else {
8872 redirectOut << "parse error in stAntiFlicker (unknow tag: "
8873 << subTagname
8874 << ")"
8875 << std::endl;
8876 }
8877 psubchild = psubchild->NextSibling();
8878 }
8879
8880 XML_CHECK_END();
8881 autoTabBackward();
8882 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8883 return (true);
8884 }
8885
parseEntrySensorAecFrameRateModeV21(const XMLElement * pelement,void * param)8886 bool RkAiqCalibParser::parseEntrySensorAecFrameRateModeV21
8887 (
8888 const XMLElement* pelement,
8889 void* param
8890 ) {
8891 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8892 autoTabForward();
8893
8894 XML_CHECK_START(CALIB_SENSOR_AEC_V21_AECFRAMERATEMODE_TAG_ID, CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID);
8895 CalibDb_AeFrmRateAttr_t* paec_frm = (CalibDb_AeFrmRateAttr_t*)param;
8896
8897 const XMLNode* psubchild = pelement->FirstChild();
8898 #ifdef DEBUG_LOG
8899 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
8900 #endif
8901 while (psubchild) {
8902 XmlTag subTag = XmlTag(psubchild->ToElement());
8903 std::string subTagname(psubchild->ToElement()->Name());
8904 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
8905 #ifdef DEBUG_LOG
8906 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
8907 #endif
8908 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_ISFPSFIX_TAG_ID)) {
8909 uint8_t temp = paec_frm->isFpsFix;
8910 int no = ParseUcharArray(psubchild, &temp, subTag.Size());
8911 paec_frm->isFpsFix = (temp == 0) ? false : true;
8912 DCT_ASSERT((no == subTag.Size()));
8913 }
8914 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_FPSVALUE_TAG_ID)) {
8915 int no = ParseFloatArray(psubchild, &paec_frm->FpsValue, subTag.Size());
8916 DCT_ASSERT((no == subTag.Size()));
8917 }
8918 else {
8919 redirectOut << "parse error in stFrmRate (unknow tag: "
8920 << subTagname
8921 << ")"
8922 << std::endl;
8923 }
8924 psubchild = psubchild->NextSibling();
8925 }
8926
8927 XML_CHECK_END();
8928 autoTabBackward();
8929 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8930 return (true);
8931 }
8932
parseEntrySensorAecInitValueLinearAEV21(const XMLElement * pelement,void * param)8933 bool RkAiqCalibParser::parseEntrySensorAecInitValueLinearAEV21
8934 (
8935 const XMLElement* pelement,
8936 void* param
8937 ) {
8938 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8939 autoTabForward();
8940 XML_CHECK_START(CALIB_SENSOR_AEC_V21_AECINITVALUE_LINEARAE_TAG_ID, CALIB_SENSOR_AEC_V21_AECINITVALUE_TAG_ID);
8941 CalibDb_ExpInitExp_t* paec_init = (CalibDb_ExpInitExp_t*)param;
8942
8943 const XMLNode* psubsubchild = pelement->FirstChild();
8944 while (psubsubchild) {
8945 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
8946 std::string subsubTagname(psubsubchild->ToElement()->Name());
8947 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
8948 #ifdef DEBUG_LOG
8949 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
8950 #endif
8951 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_INITTIMEVALUE_TAG_ID)) {
8952 int no = ParseFloatArray(psubsubchild, &paec_init->stLinExpInitExp.InitTimeValue, subsubTag.Size());
8953 DCT_ASSERT((no == subsubTag.Size()));
8954 paec_init->stLinExpInitExp.array_size = no;
8955 }
8956 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_INITGAINVALUE_TAG_ID)) {
8957 int no = ParseFloatArray(psubsubchild, &paec_init->stLinExpInitExp.InitGainValue, subsubTag.Size());
8958 DCT_ASSERT((no == subsubTag.Size()));
8959 }
8960 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_INITISPDGAINVALUE_TAG_ID)) {
8961 int no = ParseFloatArray(psubsubchild, &paec_init->stLinExpInitExp.InitIspDGainValue, subsubTag.Size());
8962 DCT_ASSERT((no == subsubTag.Size()));
8963 }
8964 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_INITPIRISVALUE_TAG_ID)) {
8965 int no = ParseIntArray(psubsubchild, &paec_init->stLinExpInitExp.InitPIrisGainValue, subsubTag.Size());
8966 DCT_ASSERT((no == subsubTag.Size()));
8967 }
8968 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_INITDCIRISVALUE_TAG_ID)) {
8969 int no = ParseIntArray(psubsubchild, &paec_init->stLinExpInitExp.InitDCIrisDutyValue, subsubTag.Size());
8970 DCT_ASSERT((no == subsubTag.Size()));
8971 }
8972 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_INITHDCIRISVALUE_TAG_ID)) {
8973 int no = ParseIntArray(psubsubchild, &paec_init->stLinExpInitExp.InitHDCIrisTargetValue, subsubTag.Size());
8974 DCT_ASSERT((no == subsubTag.Size()));
8975 }
8976 else {
8977 LOGE("%s(%d): parse error in stLinExpInitExp (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
8978 }
8979 psubsubchild = psubsubchild->NextSibling();
8980 }
8981
8982 XML_CHECK_END();
8983 autoTabBackward();
8984 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
8985 return (true);
8986 }
8987
parseEntrySensorAecInitValueHdrAEV21(const XMLElement * pelement,void * param)8988 bool RkAiqCalibParser::parseEntrySensorAecInitValueHdrAEV21
8989 (
8990 const XMLElement* pelement,
8991 void* param
8992 ) {
8993 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
8994 autoTabForward();
8995 XML_CHECK_START(CALIB_SENSOR_AEC_V21_AECINITVALUE_HDRAE_TAG_ID, CALIB_SENSOR_AEC_V21_AECINITVALUE_TAG_ID);
8996 CalibDb_ExpInitExp_t* paec_init = (CalibDb_ExpInitExp_t*)param;
8997
8998 const XMLNode* psubsubchild = pelement->FirstChild();
8999 while (psubsubchild) {
9000 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
9001 std::string subsubTagname(psubsubchild->ToElement()->Name());
9002 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
9003 #ifdef DEBUG_LOG
9004 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
9005 #endif
9006 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_INITTIMEVALUE_TAG_ID)) {
9007 float tempVal[3];
9008 for (int i = 0; i < 3; i++)
9009 tempVal[i] = paec_init->stHdrExpInitExp.InitTimeValue.fCoeff[i];
9010 int no = ParseFloatArray(psubsubchild, tempVal, subsubTag.Size());
9011 DCT_ASSERT((no == subsubTag.Size()));
9012 for (int i = 0; i < 3; i++)
9013 paec_init->stHdrExpInitExp.InitTimeValue.fCoeff[i] = tempVal[i];
9014 paec_init->stHdrExpInitExp.array_size = no;
9015 }
9016 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_INITGAINVALUE_TAG_ID)) {
9017 float tempVal[3];
9018 for (int i = 0; i < 3; i++)
9019 tempVal[i] = paec_init->stHdrExpInitExp.InitGainValue.fCoeff[i];
9020 int no = ParseFloatArray(psubsubchild, tempVal, subsubTag.Size());
9021 DCT_ASSERT((no == subsubTag.Size()));
9022 for (int i = 0; i < 3; i++)
9023 paec_init->stHdrExpInitExp.InitGainValue.fCoeff[i] = tempVal[i];
9024 }
9025 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_INITISPDGAINVALUE_TAG_ID)) {
9026 float tempVal[3];
9027 for (int i = 0; i < 3; i++)
9028 tempVal[i] = paec_init->stHdrExpInitExp.InitIspDGainValue.fCoeff[i];
9029 int no = ParseFloatArray(psubsubchild, tempVal, subsubTag.Size());
9030 DCT_ASSERT((no == subsubTag.Size()));
9031 for (int i = 0; i < 3; i++)
9032 paec_init->stHdrExpInitExp.InitIspDGainValue.fCoeff[i] = tempVal[i];
9033 }
9034 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_INITPIRISVALUE_TAG_ID)) {
9035 int no = ParseIntArray(psubsubchild, &paec_init->stHdrExpInitExp.InitPIrisGainValue, subsubTag.Size());
9036 DCT_ASSERT((no == subsubTag.Size()));
9037 }
9038 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_INITDCIRISVALUE_TAG_ID)) {
9039 int no = ParseIntArray(psubsubchild, &paec_init->stHdrExpInitExp.InitDCIrisDutyValue, subsubTag.Size());
9040 DCT_ASSERT((no == subsubTag.Size()));
9041 }
9042 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_INITHDCIRISVALUE_TAG_ID)) {
9043 int no = ParseIntArray(psubsubchild, &paec_init->stHdrExpInitExp.InitHDCIrisTargetValue, subsubTag.Size());
9044 DCT_ASSERT((no == subsubTag.Size()));
9045 }
9046 else {
9047 LOGE("%s(%d): parse error in stHdrExpInitExp (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
9048 }
9049 psubsubchild = psubsubchild->NextSibling();
9050 }
9051
9052 XML_CHECK_END();
9053 autoTabBackward();
9054 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
9055 return (true);
9056 }
9057
parseEntrySensorAecInitValueV21(const XMLElement * pelement,void * param)9058 bool RkAiqCalibParser::parseEntrySensorAecInitValueV21
9059 (
9060 const XMLElement* pelement,
9061 void* param
9062 ) {
9063 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
9064 autoTabForward();
9065
9066 XML_CHECK_START(CALIB_SENSOR_AEC_V21_AECINITVALUE_TAG_ID, CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID);
9067 CalibDb_ExpInitExp_t* paec_init = (CalibDb_ExpInitExp_t*)param;
9068
9069 const XMLNode* psubchild = pelement->FirstChild();
9070
9071 #ifdef DEBUG_LOG
9072 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
9073 #endif
9074 while (psubchild) {
9075 XmlTag subTag = XmlTag(psubchild->ToElement());
9076 std::string subTagname(psubchild->ToElement()->Name());
9077 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
9078 #ifdef DEBUG_LOG
9079 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
9080 #endif
9081 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECINITVALUE_LINEARAE_TAG_ID)) {
9082 if (!parseEntrySensorAecInitValueLinearAEV21(psubchild->ToElement(), paec_init)) {
9083 LOGE("parse error in Aec (%s)", subTagname.c_str());
9084 return (false);
9085 }
9086 }
9087 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECINITVALUE_HDRAE_TAG_ID)) {
9088 if (!parseEntrySensorAecInitValueHdrAEV21(psubchild->ToElement(), paec_init)) {
9089 LOGE("parse error in Aec (%s)", subTagname.c_str());
9090 return (false);
9091 }
9092 }
9093 else {
9094 LOGE("%s(%d): parse error in stInitExp (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
9095 }
9096 psubchild = psubchild->NextSibling();
9097 }
9098
9099 XML_CHECK_END();
9100 autoTabBackward();
9101 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
9102 return (true);
9103 }
9104
parseEntrySensorAecIrisCtrlPAttrV21(const XMLElement * pelement,void * param)9105 bool RkAiqCalibParser::parseEntrySensorAecIrisCtrlPAttrV21
9106 (
9107 const XMLElement* pelement,
9108 void* param
9109 ) {
9110 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
9111 autoTabForward();
9112
9113 XML_CHECK_START(CALIB_SENSOR_AEC_V21_IRISCTRL_P_ATTR_TAG_ID, CALIB_SENSOR_AEC_V21_IRISCTRL_TAG_ID);
9114 CalibDb_AecIrisCtrl_t* paec_iris = (CalibDb_AecIrisCtrl_t*)param;
9115
9116 const XMLNode* psubsubchild = pelement->FirstChild();
9117 while (psubsubchild) {
9118 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
9119 std::string subsubTagname(psubsubchild->ToElement()->Name());
9120 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
9121 #ifdef DEBUG_LOG
9122 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
9123 #endif
9124 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_P_ATTR_TOTALSTEP_TAG_ID)) {
9125 int no = ParseUshortArray(psubsubchild, &paec_iris->PIrisAttr.TotalStep, subsubTag.Size());
9126 DCT_ASSERT((no == subsubTag.Size()));
9127 DCT_ASSERT((no <= AEC_PIRIS_STAP_TABLE_MAX));
9128 }
9129 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_P_ATTR_EFFCSTEP_TAG_ID)) {
9130 int no = ParseUshortArray(psubsubchild, &paec_iris->PIrisAttr.EffcStep, subsubTag.Size());
9131 DCT_ASSERT((no == subsubTag.Size()));
9132 DCT_ASSERT((no <= AEC_PIRIS_STAP_TABLE_MAX));
9133 }
9134 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_P_ATTR_ZEROISMAX_TAG_ID)) {
9135 uint8_t temp = paec_iris->PIrisAttr.ZeroIsMax;
9136 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
9137 paec_iris->PIrisAttr.ZeroIsMax = (temp == 0) ? false : true;
9138 DCT_ASSERT((no == subsubTag.Size()));
9139 }
9140 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_P_ATTR_STEPTABLE_TAG_ID)) {
9141 int no = ParseUshortArray(psubsubchild, paec_iris->PIrisAttr.StepTable, subsubTag.Size());
9142 DCT_ASSERT((no == subsubTag.Size()));
9143 DCT_ASSERT((no <= AEC_PIRIS_STAP_TABLE_MAX));
9144 }
9145 else {
9146 LOGE("%s(%d): parse error in AecIrisCtrl PAttr (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
9147 }
9148 psubsubchild = psubsubchild->NextSibling();
9149 }
9150
9151 XML_CHECK_END();
9152 autoTabBackward();
9153 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
9154 return (true);
9155 }
9156
parseEntrySensorAecIrisCtrlDCAttrV21(const XMLElement * pelement,void * param)9157 bool RkAiqCalibParser::parseEntrySensorAecIrisCtrlDCAttrV21
9158 (
9159 const XMLElement* pelement,
9160 void* param
9161 ) {
9162 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
9163 autoTabForward();
9164
9165 XML_CHECK_START(CALIB_SENSOR_AEC_V21_IRISCTRL_DC_ATTR_TAG_ID, CALIB_SENSOR_AEC_V21_IRISCTRL_TAG_ID);
9166 CalibDb_AecIrisCtrl_t* paec_iris = (CalibDb_AecIrisCtrl_t*)param;
9167
9168 const XMLNode* psubsubchild = pelement->FirstChild();
9169 while (psubsubchild) {
9170 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
9171 std::string subsubTagname(psubsubchild->ToElement()->Name());
9172 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
9173 #ifdef DEBUG_LOG
9174 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
9175 #endif
9176 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_DC_ATTR_KP_TAG_ID)) {
9177 int no = ParseFloatArray(psubsubchild, &paec_iris->DCIrisAttr.Kp, subsubTag.Size());
9178 DCT_ASSERT((no == subsubTag.Size()));
9179 }
9180 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_DC_ATTR_KI_TAG_ID)) {
9181 int no = ParseFloatArray(psubsubchild, &paec_iris->DCIrisAttr.Ki, subsubTag.Size());
9182 DCT_ASSERT((no == subsubTag.Size()));
9183 }
9184 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_DC_ATTR_KD_TAG_ID)) {
9185 int no = ParseFloatArray(psubsubchild, &paec_iris->DCIrisAttr.Kd, subsubTag.Size());
9186 DCT_ASSERT((no == subsubTag.Size()));
9187 }
9188 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_DC_ATTR_MIN_PWMDUTY_TAG_ID)) {
9189 int no = ParseIntArray(psubsubchild, &paec_iris->DCIrisAttr.MinPwmDuty, subsubTag.Size());
9190 DCT_ASSERT((no == subsubTag.Size()));
9191 }
9192 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_DC_ATTR_MAX_PWMDUTY_TAG_ID)) {
9193 int no = ParseIntArray(psubsubchild, &paec_iris->DCIrisAttr.MaxPwmDuty, subsubTag.Size());
9194 DCT_ASSERT((no == subsubTag.Size()));
9195 }
9196 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_DC_ATTR_OPEN_PWMDUTY_TAG_ID)) {
9197 int no = ParseIntArray(psubsubchild, &paec_iris->DCIrisAttr.OpenPwmDuty, subsubTag.Size());
9198 DCT_ASSERT((no == subsubTag.Size()));
9199 }
9200 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_DC_ATTR_CLOSE_PWMDUTY_TAG_ID)) {
9201 int no = ParseIntArray(psubsubchild, &paec_iris->DCIrisAttr.ClosePwmDuty, subsubTag.Size());
9202 DCT_ASSERT((no == subsubTag.Size()));
9203 }
9204 else {
9205 LOGE("%s(%d): parse error in AecIrisCtrl DCAttr (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
9206 }
9207 psubsubchild = psubsubchild->NextSibling();
9208 }
9209
9210 XML_CHECK_END();
9211 autoTabBackward();
9212 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
9213 return (true);
9214 }
9215
parseEntrySensorAecIrisCtrlHDCAttrV21(const XMLElement * pelement,void * param)9216 bool RkAiqCalibParser::parseEntrySensorAecIrisCtrlHDCAttrV21
9217 (
9218 const XMLElement* pelement,
9219 void* param
9220 ) {
9221 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
9222 autoTabForward();
9223
9224 XML_CHECK_START(CALIB_SENSOR_AEC_V21_IRISCTRL_HDC_ATTR_TAG_ID, CALIB_SENSOR_AEC_V21_IRISCTRL_TAG_ID);
9225 CalibDb_AecIrisCtrl_t* paec_iris = (CalibDb_AecIrisCtrl_t*)param;
9226
9227 const XMLNode* psubsubchild = pelement->FirstChild();
9228
9229 int nZoomTargetDot = 0;
9230 int nZoomDot = 0;
9231 int nIrisTargetDot = 0;
9232 int nGainDot = 0;
9233
9234 while (psubsubchild) {
9235 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
9236 std::string subsubTagname(psubsubchild->ToElement()->Name());
9237 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
9238 #ifdef DEBUG_LOG
9239 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
9240 #endif
9241 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_HDC_ATTR_DAMPOVER_TAG_ID)) {
9242 int no = ParseFloatArray(psubsubchild, &paec_iris->HDCIrisAttr.DampOver, subsubTag.Size());
9243 DCT_ASSERT((no == subsubTag.Size()));
9244 }
9245 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_HDC_ATTR_DAMPUNDER_TAG_ID)) {
9246 int no = ParseFloatArray(psubsubchild, &paec_iris->HDCIrisAttr.DampUnder, subsubTag.Size());
9247 DCT_ASSERT((no == subsubTag.Size()));
9248 }
9249 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_HDC_ATTR_ZEROISMAX_TAG_ID)) {
9250 uint8_t temp = paec_iris->HDCIrisAttr.ZeroIsMax;
9251 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
9252 paec_iris->HDCIrisAttr.ZeroIsMax = (temp == 0) ? false : true;
9253 DCT_ASSERT((no == subsubTag.Size()));
9254 }
9255 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_HDC_ATTR_MINTARGET_TAG_ID)) {
9256 int no = ParseIntArray(psubsubchild, &paec_iris->HDCIrisAttr.MinTarget, subsubTag.Size());
9257 DCT_ASSERT((no == subsubTag.Size()));
9258 }
9259 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_HDC_ATTR_MAXTARGET_TAG_ID)) {
9260 int no = ParseIntArray(psubsubchild, &paec_iris->HDCIrisAttr.MaxTarget, subsubTag.Size());
9261 DCT_ASSERT((no == subsubTag.Size()));
9262 }
9263 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_HDC_ATTR_ZOOMTARGETDOT_TAG_ID)) {
9264 int no = ParseIntArray(psubsubchild, paec_iris->HDCIrisAttr.ZoomTargetDot, subsubTag.Size());
9265 DCT_ASSERT((no == subsubTag.Size()));
9266 nZoomTargetDot = no;
9267 }
9268 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_HDC_ATTR_ZOOMDOT_TAG_ID)) {
9269 int no = ParseIntArray(psubsubchild, paec_iris->HDCIrisAttr.ZoomDot, subsubTag.Size());
9270 DCT_ASSERT((no == subsubTag.Size()));
9271 nZoomDot = no;
9272 }
9273 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_HDC_ATTR_IRISTARGETDOT_TAG_ID)) {
9274 int no = ParseIntArray(psubsubchild, paec_iris->HDCIrisAttr.IrisTargetDot, subsubTag.Size());
9275 DCT_ASSERT((no == subsubTag.Size()));
9276 nIrisTargetDot = no;
9277 }
9278 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_HDC_ATTR_GAINDOT_TAG_ID)) {
9279 int no = ParseIntArray(psubsubchild, paec_iris->HDCIrisAttr.GainDot, subsubTag.Size());
9280 DCT_ASSERT((no == subsubTag.Size()));
9281 nGainDot = no;
9282 }
9283 else {
9284 LOGW("%s(%d): parse error in AecIrisCtrl DCAttr (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
9285 }
9286 psubsubchild = psubsubchild->NextSibling();
9287 }
9288 XML_CHECK_END();
9289 autoTabBackward();
9290
9291 DCT_ASSERT((nZoomTargetDot == nZoomDot));
9292 DCT_ASSERT((nIrisTargetDot == nGainDot));
9293 paec_iris->HDCIrisAttr.zoom_array_size = nZoomTargetDot;
9294 paec_iris->HDCIrisAttr.iris_array_size = nIrisTargetDot;
9295
9296 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
9297 return (true);
9298 }
9299
parseEntrySensorAecIrisCtrlV21(const XMLElement * pelement,void * param)9300 bool RkAiqCalibParser::parseEntrySensorAecIrisCtrlV21
9301 (
9302 const XMLElement* pelement,
9303 void* param
9304 ) {
9305 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
9306 autoTabForward();
9307
9308 XML_CHECK_START(CALIB_SENSOR_AEC_V21_IRISCTRL_TAG_ID, CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID);
9309 CalibDb_AecIrisCtrl_t* paec_iris = (CalibDb_AecIrisCtrl_t*)param;
9310
9311 const XMLNode* psubchild = pelement->FirstChild();
9312 #ifdef DEBUG_LOG
9313 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
9314 #endif
9315 while (psubchild) {
9316 XmlTag subTag = XmlTag(psubchild->ToElement());
9317 std::string subTagname(psubchild->ToElement()->Name());
9318 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
9319 #ifdef DEBUG_LOG
9320 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
9321 #endif
9322 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_ENABLE_TAG_ID)) {
9323 int no = ParseUcharArray(psubchild, &paec_iris->enable, subTag.Size());
9324 DCT_ASSERT((no == subTag.Size()));
9325 }
9326 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_TYPE_TAG_ID)) {
9327 char* value = Toupper(subTag.Value());
9328 std::string s_value(value);
9329 if (xmlParseReadWrite == XML_PARSER_READ)
9330 {
9331 if (s_value == CALIB_SENSOR_AEC_IRISCTRL_TYPE_P) {
9332 paec_iris->IrisType = IRIS_P_TYPE;
9333 }
9334 else if (s_value == CALIB_SENSOR_AEC_IRISCTRL_TYPE_DC) {
9335 paec_iris->IrisType = IRIS_DC_TYPE;
9336 }
9337 else if (s_value == CALIB_SENSOR_AEC_IRISCTRL_TYPE_HDC) {
9338 paec_iris->IrisType = IRIS_HDC_TYPE;
9339 }
9340 else {
9341 paec_iris->IrisType = IRIS_INVALID_TYPE;
9342 LOGE("%s(%d): invalid stIris.IrisType = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
9343 }
9344 }
9345 else if (xmlParseReadWrite == XML_PARSER_WRITE)
9346 {
9347 XMLNode *pNode = (XMLNode*)psubchild;
9348 if (paec_iris->IrisType == IRIS_P_TYPE) {
9349 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_IRISCTRL_TYPE_P);
9350 }
9351 else if (paec_iris->IrisType == IRIS_DC_TYPE) {
9352 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_IRISCTRL_TYPE_DC);
9353 }
9354 else if (paec_iris->IrisType == IRIS_HDC_TYPE) {
9355 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_IRISCTRL_TYPE_HDC);
9356 }
9357 else {
9358 pNode->FirstChild()->SetValue("Invalid");
9359 LOGE("%s(%d): (XML Write)invalid stIris.IrisType = %d\n", __FUNCTION__, __LINE__, paec_iris->IrisType);
9360 }
9361
9362 }
9363 }
9364 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_P_ATTR_TAG_ID)) {
9365 if (!parseEntrySensorAecIrisCtrlPAttrV21(psubchild->ToElement(), paec_iris)) {
9366 LOGE("parse error in Aec IrisCtrl (%s)", subTagname.c_str());
9367 return (false);
9368 }
9369 }
9370 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_DC_ATTR_TAG_ID)) {
9371 if (!parseEntrySensorAecIrisCtrlDCAttrV21(psubchild->ToElement(), paec_iris)) {
9372 LOGE("parse error in Aec IrisCtrl (%s)", subTagname.c_str());
9373 return (false);
9374 }
9375 }
9376 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_HDC_ATTR_TAG_ID)) {
9377 if (!parseEntrySensorAecIrisCtrlHDCAttrV21(psubchild->ToElement(), paec_iris)) {
9378 LOGE("parse error in Aec IrisCtrl (%s)", subTagname.c_str());
9379 return (false);
9380 }
9381 }
9382 else {
9383 LOGE("%s(%d): parse error in Aec IrisCtrl (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
9384 }
9385 psubchild = psubchild->NextSibling();
9386 }
9387 XML_CHECK_END();
9388 autoTabBackward();
9389 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
9390 return (true);
9391 }
9392
parseEntrySensorAecManualCtrlLinearAEV21(const XMLElement * pelement,void * param)9393 bool RkAiqCalibParser::parseEntrySensorAecManualCtrlLinearAEV21
9394 (
9395 const XMLElement* pelement,
9396 void* param
9397 ) {
9398 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
9399 autoTabForward();
9400
9401 XML_CHECK_START(CALIB_SENSOR_AEC_V21_MANUALCTRL_LINEARAE_TAG_ID, CALIB_SENSOR_AEC_V21_MANUALCTRL_TAG_ID);
9402 CalibDb_MeAttr_t* paec_manual = (CalibDb_MeAttr_t*)param;
9403
9404 const XMLNode* psubsubchild = pelement->FirstChild();
9405 while (psubsubchild) {
9406 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
9407 std::string subsubTagname(psubsubchild->ToElement()->Name());
9408 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
9409 #ifdef DEBUG_LOG
9410 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
9411 #endif
9412 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_TIMEEN_TAG_ID)) {
9413 uint8_t temp = paec_manual->stLinMe.ManualTimeEn;
9414 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
9415 paec_manual->stLinMe.ManualTimeEn = (temp == 0) ? false : true;
9416 DCT_ASSERT((no == subsubTag.Size()));
9417 }
9418 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_GAINEN_TAG_ID)) {
9419 uint8_t temp = paec_manual->stLinMe.ManualGainEn;
9420 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
9421 paec_manual->stLinMe.ManualGainEn = (temp == 0) ? false : true;
9422 DCT_ASSERT((no == subsubTag.Size()));
9423 }
9424 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_ISPDGAINEN_TAG_ID)) {
9425 uint8_t temp = paec_manual->stLinMe.ManualIspDgainEn;
9426 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
9427 paec_manual->stLinMe.ManualIspDgainEn = (temp == 0) ? false : true;
9428 DCT_ASSERT((no == subsubTag.Size()));
9429 }
9430 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_IRISEN_TAG_ID)) {
9431 uint8_t temp = paec_manual->stLinMe.ManualIrisEn;
9432 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
9433 paec_manual->stLinMe.ManualIrisEn = (temp == 0) ? false : true;
9434 DCT_ASSERT((no == subsubTag.Size()));
9435 }
9436 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_TIMEVALUE_TAG_ID)) {
9437 int no = ParseFloatArray(psubsubchild, &paec_manual->stLinMe.TimeValue, subsubTag.Size());
9438 DCT_ASSERT((no == subsubTag.Size()));
9439 }
9440 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_GAINVALUE_TAG_ID)) {
9441 int no = ParseFloatArray(psubsubchild, &paec_manual->stLinMe.GainValue, subsubTag.Size());
9442 DCT_ASSERT((no == subsubTag.Size()));
9443 }
9444 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_ISPDGAINVALUE_TAG_ID)) {
9445 int no = ParseFloatArray(psubsubchild, &paec_manual->stLinMe.IspDGainValue, subsubTag.Size());
9446 DCT_ASSERT((no == subsubTag.Size()));
9447 }
9448 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_PIRISVALUE_TAG_ID)) {
9449 int no = ParseIntArray(psubsubchild, &paec_manual->stLinMe.PIrisGainValue, subsubTag.Size());
9450 DCT_ASSERT((no == subsubTag.Size()));
9451 }
9452 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_DCIRISVALUE_TAG_ID)) {
9453 int no = ParseIntArray(psubsubchild, &paec_manual->stLinMe.DCIrisValue, subsubTag.Size());
9454 DCT_ASSERT((no == subsubTag.Size()));
9455 }
9456 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_HDCIRISVALUE_TAG_ID)) {
9457 int no = ParseIntArray(psubsubchild, &paec_manual->stLinMe.HDCIrisValue, subsubTag.Size());
9458 DCT_ASSERT((no == subsubTag.Size()));
9459 }
9460 else {
9461 LOGE("%s(%d): parse error in stManual.stLinMe (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
9462 }
9463 psubsubchild = psubsubchild->NextSibling();
9464 }
9465
9466 XML_CHECK_END();
9467 autoTabBackward();
9468 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
9469 return (true);
9470 }
9471
parseEntrySensorAecManualCtrlHdrAEV21(const XMLElement * pelement,void * param)9472 bool RkAiqCalibParser::parseEntrySensorAecManualCtrlHdrAEV21
9473 (
9474 const XMLElement* pelement,
9475 void* param
9476 ) {
9477 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
9478 autoTabForward();
9479
9480 XML_CHECK_START(CALIB_SENSOR_AEC_V21_MANUALCTRL_HDRAE_TAG_ID, CALIB_SENSOR_AEC_V21_MANUALCTRL_TAG_ID);
9481 CalibDb_MeAttr_t* paec_manual = (CalibDb_MeAttr_t*)param;
9482
9483 const XMLNode* psubsubchild = pelement->FirstChild();
9484 while (psubsubchild) {
9485 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
9486 std::string subsubTagname(psubsubchild->ToElement()->Name());
9487 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
9488 #ifdef DEBUG_LOG
9489 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
9490 #endif
9491 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_TIMEEN_TAG_ID)) {
9492 uint8_t temp = paec_manual->stHdrMe.ManualTimeEn;
9493 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
9494 paec_manual->stHdrMe.ManualTimeEn = (temp == 0) ? false : true;
9495 DCT_ASSERT((no == subsubTag.Size()));
9496 }
9497 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_GAINEN_TAG_ID)) {
9498 uint8_t temp = paec_manual->stHdrMe.ManualGainEn;
9499 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
9500 paec_manual->stHdrMe.ManualGainEn = (temp == 0) ? false : true;
9501 DCT_ASSERT((no == subsubTag.Size()));
9502 }
9503 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_ISPDGAINEN_TAG_ID)) {
9504 uint8_t temp = paec_manual->stHdrMe.ManualIspDgainEn;
9505 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
9506 paec_manual->stHdrMe.ManualIspDgainEn = (temp == 0) ? false : true;
9507 DCT_ASSERT((no == subsubTag.Size()));
9508 }
9509 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_IRISEN_TAG_ID)) {
9510 uint8_t temp = paec_manual->stHdrMe.ManualIrisEn;
9511 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
9512 paec_manual->stHdrMe.ManualIrisEn = (temp == 0) ? false : true;
9513 DCT_ASSERT((no == subsubTag.Size()));
9514 }
9515 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_TIMEVALUE_TAG_ID)) {
9516 float tempVal[3];
9517 for (int i = 0; i < 3; i++)
9518 tempVal[i] = paec_manual->stHdrMe.TimeValue.fCoeff[i];
9519 int no = ParseFloatArray(psubsubchild, tempVal, subsubTag.Size());
9520 DCT_ASSERT((no == subsubTag.Size()));
9521 for (int i = 0; i < 3; i++)
9522 paec_manual->stHdrMe.TimeValue.fCoeff[i] = tempVal[i];
9523 }
9524 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_GAINVALUE_TAG_ID)) {
9525 float tempVal[3];
9526 for (int i = 0; i < 3; i++)
9527 tempVal[i] = paec_manual->stHdrMe.GainValue.fCoeff[i];
9528 int no = ParseFloatArray(psubsubchild, tempVal, subsubTag.Size());
9529 DCT_ASSERT((no == subsubTag.Size()));
9530 for (int i = 0; i < 3; i++)
9531 paec_manual->stHdrMe.GainValue.fCoeff[i] = tempVal[i];
9532 }
9533 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_ISPDGAINVALUE_TAG_ID)) {
9534 float tempVal[3];
9535 for (int i = 0; i < 3; i++)
9536 tempVal[i] = paec_manual->stHdrMe.IspDGainValue.fCoeff[i];
9537 int no = ParseFloatArray(psubsubchild, tempVal, subsubTag.Size());
9538 DCT_ASSERT((no == subsubTag.Size()));
9539 for (int i = 0; i < 3; i++)
9540 paec_manual->stHdrMe.IspDGainValue.fCoeff[i] = tempVal[i];
9541 }
9542 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_PIRISVALUE_TAG_ID)) {
9543 int no = ParseIntArray(psubsubchild, &paec_manual->stHdrMe.PIrisGainValue, subsubTag.Size());
9544 }
9545 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_DCIRISVALUE_TAG_ID)) {
9546 int no = ParseIntArray(psubsubchild, &paec_manual->stHdrMe.DCIrisValue, subsubTag.Size());
9547 }
9548 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_HDCIRISVALUE_TAG_ID)) {
9549 int no = ParseIntArray(psubsubchild, &paec_manual->stHdrMe.HDCIrisValue, subsubTag.Size());
9550 }
9551 else {
9552 LOGE("%s(%d): parse error in stManual.stHdrMe (unknow tag: %s )\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
9553 }
9554 psubsubchild = psubsubchild->NextSibling();
9555 }
9556
9557 XML_CHECK_END();
9558 autoTabBackward();
9559 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
9560 return (true);
9561 }
9562
parseEntrySensorAecManualCtrlV21(const XMLElement * pelement,void * param)9563 bool RkAiqCalibParser::parseEntrySensorAecManualCtrlV21
9564 (
9565 const XMLElement* pelement,
9566 void* param
9567 ) {
9568 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
9569 autoTabForward();
9570
9571 XML_CHECK_START(CALIB_SENSOR_AEC_V21_MANUALCTRL_TAG_ID, CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID);
9572 CalibDb_MeAttr_t* paec_manual = (CalibDb_MeAttr_t*)param;
9573
9574 const XMLNode* psubchild = pelement->FirstChild();
9575 #ifdef DEBUG_LOG
9576 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
9577 #endif
9578 while (psubchild) {
9579 XmlTag subTag = XmlTag(psubchild->ToElement());
9580 std::string subTagname(psubchild->ToElement()->Name());
9581 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
9582 #ifdef DEBUG_LOG
9583 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
9584 #endif
9585 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_LINEARAE_TAG_ID)) {
9586 if (!parseEntrySensorAecManualCtrlLinearAEV21(psubchild->ToElement(), paec_manual)) {
9587 LOGE("parse error in Aec ManualCtrl (%s)", subTagname.c_str());
9588 return (false);
9589 }
9590 }
9591 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_HDRAE_TAG_ID)) {
9592 if (!parseEntrySensorAecManualCtrlHdrAEV21(psubchild->ToElement(), paec_manual)) {
9593 LOGE("parse error in Aec ManualCtrl (%s)", subTagname.c_str());
9594 return (false);
9595 }
9596 }
9597 else {
9598 LOGE("%s(%d): parse error in stManual (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
9599 }
9600 psubchild = psubchild->NextSibling();
9601 }
9602 XML_CHECK_END();
9603 autoTabBackward();
9604 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
9605 return (true);
9606 }
9607
parseEntrySensorAecLinearRouteV21(const XMLElement * pelement,void * param)9608 bool RkAiqCalibParser::parseEntrySensorAecLinearRouteV21
9609 (
9610 const XMLElement* pelement,
9611 void* param
9612 ) {
9613 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
9614
9615 XML_CHECK_START(CALIB_SENSOR_AEC_V21_AECROUTE_LINEARAE_TAG_ID, CALIB_SENSOR_AEC_V21_AECROUTE_TAG_ID);
9616 CalibDb_AeRoute_Attr_V21_t* paec_route = (CalibDb_AeRoute_Attr_V21_t*)param;
9617
9618 const XMLNode* pchild = pelement->FirstChild();
9619
9620 int nTimeDot = 0;
9621 int nGainDot = 0;
9622 int nIspDGainDot = 0;
9623 int nPIrisDot = 0;
9624
9625 while (pchild) {
9626 XmlTag tag = XmlTag(pchild->ToElement());
9627 std::string Tagname(pchild->ToElement()->Name());
9628 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
9629 #ifdef DEBUG_LOG
9630 redirectOut << "Tagname: " << Tagname << std::endl;
9631 #endif
9632
9633 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_TIMEDOT_TAG_ID)) {
9634 int no = ParseFloatArray(pchild, paec_route->LinAeSeperate.TimeDot, tag.Size());
9635 DCT_ASSERT((no == tag.Size()));
9636 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9637 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9638 return false;
9639 }
9640 nTimeDot = no;
9641 }
9642 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_GAINDOT_TAG_ID)) {
9643 int no = ParseFloatArray(pchild, paec_route->LinAeSeperate.GainDot, tag.Size());
9644 DCT_ASSERT((no == tag.Size()));
9645 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9646 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9647 return false;
9648 }
9649 nGainDot = no;
9650 }
9651 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_ISPDGAINDOT_TAG_ID)) {
9652 int no = ParseFloatArray(pchild, paec_route->LinAeSeperate.IspgainDot, tag.Size());
9653 DCT_ASSERT((no == tag.Size()));
9654 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9655 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9656 return false;
9657 }
9658 nIspDGainDot = no;
9659 }
9660 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_PIRISDOT_TAG_ID)) {
9661 int no = ParseIntArray(pchild, paec_route->LinAeSeperate.PIrisGainDot, tag.Size());
9662 DCT_ASSERT((no == tag.Size()));
9663 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9664 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9665 return false;
9666 }
9667 nPIrisDot = no;
9668 }
9669 else {
9670 redirectOut
9671 << "parse error in LinAe Route (unknow tag: "
9672 << Tagname
9673 << ")"
9674 << std::endl;
9675 }
9676 pchild = pchild->NextSibling();
9677 }
9678 XML_CHECK_END();
9679 DCT_ASSERT((nGainDot == nTimeDot));
9680 DCT_ASSERT((nGainDot == nIspDGainDot));
9681 paec_route->LinAeSeperate.array_size = nTimeDot;
9682 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
9683 return (true);
9684 }
9685
parseEntrySensorAecHdrRouteV21(const XMLElement * pelement,void * param)9686 bool RkAiqCalibParser::parseEntrySensorAecHdrRouteV21
9687 (
9688 const XMLElement* pelement,
9689 void* param
9690 ) {
9691 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
9692
9693
9694 XML_CHECK_START(CALIB_SENSOR_AEC_V21_AECROUTE_HDRAE_TAG_ID, CALIB_SENSOR_AEC_V21_AECROUTE_TAG_ID);
9695 CalibDb_AeRoute_Attr_V21_t* paec_route = (CalibDb_AeRoute_Attr_V21_t*)param;
9696
9697 const XMLNode* pchild = pelement->FirstChild();
9698 int nTimeDot = 0;
9699 int nGainDot = 0;
9700 int nIspDGainDot = 0;
9701 int nPIrisDot = 0;
9702
9703 while (pchild) {
9704 XmlTag tag = XmlTag(pchild->ToElement());
9705 std::string Tagname(pchild->ToElement()->Name());
9706 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
9707
9708 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LTIMEDOT_TAG_ID)) {
9709 int no = ParseFloatArray(pchild, paec_route->HdrAeSeperate.HdrTimeDot[2], tag.Size());
9710 DCT_ASSERT((no == tag.Size()));
9711 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9712 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9713 return false;
9714 }
9715 nTimeDot = no;
9716 }
9717 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MTIMEDOT_TAG_ID)) {
9718 int no = ParseFloatArray(pchild, paec_route->HdrAeSeperate.HdrTimeDot[1], tag.Size());
9719 DCT_ASSERT((no == tag.Size()));
9720 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9721 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9722 return false;
9723 }
9724 DCT_ASSERT((nTimeDot == no));
9725 }
9726 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_STIMEDOT_TAG_ID)) {
9727 int no = ParseFloatArray(pchild, paec_route->HdrAeSeperate.HdrTimeDot[0], tag.Size());
9728 DCT_ASSERT((no == tag.Size()));
9729 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9730 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9731 return false;
9732 }
9733 DCT_ASSERT((nTimeDot == no));
9734 }
9735 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LGAINDOT_TAG_ID)) {
9736 int no = ParseFloatArray(pchild, paec_route->HdrAeSeperate.HdrGainDot[2], tag.Size());
9737 DCT_ASSERT((no == tag.Size()));
9738 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9739 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9740 return false;
9741 }
9742 nGainDot = no;
9743 }
9744 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MGAINDOT_TAG_ID)) {
9745 int no = ParseFloatArray(pchild, paec_route->HdrAeSeperate.HdrGainDot[1], tag.Size());
9746 DCT_ASSERT((no == tag.Size()));
9747 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9748 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9749 return false;
9750 }
9751 DCT_ASSERT((no == nGainDot));
9752 }
9753 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SGAINDOT_TAG_ID)) {
9754 int no = ParseFloatArray(pchild, paec_route->HdrAeSeperate.HdrGainDot[0], tag.Size());
9755 DCT_ASSERT((no == tag.Size()));
9756 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9757 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9758 return false;
9759 }
9760 DCT_ASSERT((no == nGainDot));
9761 }
9762 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LISPDGAINDOT_TAG_ID)) {
9763 int no = ParseFloatArray(pchild, paec_route->HdrAeSeperate.HdrIspDGainDot[2], tag.Size());
9764 DCT_ASSERT((no == tag.Size()));
9765 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9766 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9767 return false;
9768 }
9769 nIspDGainDot = no;
9770 }
9771 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MISPDGAINDOT_TAG_ID)) {
9772 int no = ParseFloatArray(pchild, paec_route->HdrAeSeperate.HdrIspDGainDot[1], tag.Size());
9773 DCT_ASSERT((no == tag.Size()));
9774 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9775 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9776 return false;
9777 }
9778 DCT_ASSERT((nIspDGainDot == no));
9779 }
9780 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SISPDGAINDOT_TAG_ID)) {
9781 int no = ParseFloatArray(pchild, paec_route->HdrAeSeperate.HdrIspDGainDot[0], tag.Size());
9782 DCT_ASSERT((no == tag.Size()));
9783 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9784 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9785 return false;
9786 }
9787 DCT_ASSERT((nIspDGainDot == no));
9788 }
9789 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_PIRISDOT_TAG_ID)) {
9790 int no = ParseIntArray(pchild, paec_route->HdrAeSeperate.PIrisGainDot, tag.Size());
9791 DCT_ASSERT((no == tag.Size()));
9792 if(tag.Size() > AEC_ROUTE_MAX_NODES) {
9793 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_ROUTE_MAX_NODES);
9794 return false;
9795 }
9796 nPIrisDot = no;
9797 }
9798 else {
9799 redirectOut
9800 << "parse error in HdrAe Route (unknow tag: "
9801 << Tagname
9802 << ")"
9803 << std::endl;
9804 }
9805 pchild = pchild->NextSibling();
9806 }
9807 XML_CHECK_END();
9808 DCT_ASSERT((nGainDot == nTimeDot));
9809 DCT_ASSERT((nGainDot == nIspDGainDot));
9810 paec_route->HdrAeSeperate.array_size = nTimeDot;
9811 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
9812 return (true);
9813 }
9814
parseEntrySensorAecRouteV21(const XMLElement * pelement,void * param)9815 bool RkAiqCalibParser::parseEntrySensorAecRouteV21
9816 (
9817 const XMLElement* pelement,
9818 void* param
9819 ) {
9820 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
9821 autoTabForward();
9822
9823 XML_CHECK_START(CALIB_SENSOR_AEC_V21_AECROUTE_TAG_ID, CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID);
9824 CalibDb_AeRoute_Attr_V21_t* paec_route = (CalibDb_AeRoute_Attr_V21_t*)param;
9825
9826 #ifdef DEBUG_LOG
9827 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
9828 #endif
9829 const XMLNode* psubchild = pelement->FirstChild();
9830 while (psubchild) {
9831 XmlTag subTag = XmlTag(psubchild->ToElement());
9832 std::string subTagname(psubchild->ToElement()->Name());
9833 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
9834 #ifdef DEBUG_LOG
9835 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
9836 #endif
9837 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECROUTE_LINEARAE_TAG_ID)) {
9838 if (!parseEntrySensorAecLinearRouteV21(psubchild->ToElement(), paec_route)) {
9839 LOGE("parse error in Aec LinAeRoute(%s)", subTagname.c_str());
9840 return (false);
9841 }
9842 }
9843 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECROUTE_HDRAE_TAG_ID)) {
9844 if (!parseEntrySensorAecHdrRouteV21(psubchild->ToElement(), paec_route)) {
9845 LOGE("parse error in Aec HdrAeRoute(%s)", subTagname.c_str());
9846 return (false);
9847 }
9848 }
9849 else {
9850 LOGE("%s(%d): parse error in AecRoute (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
9851 }
9852 psubchild = psubchild->NextSibling();
9853 }
9854
9855 XML_CHECK_END();
9856 autoTabBackward();
9857 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
9858 return (true);
9859 }
9860
parseEntrySensorAecLinearAeDynamicPointV21(const XMLElement * pelement,void * param)9861 bool RkAiqCalibParser::parseEntrySensorAecLinearAeDynamicPointV21
9862 (
9863 const XMLElement* pelement,
9864 void* param
9865 ) {
9866 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
9867
9868 XML_CHECK_START(CALIB_SENSOR_AEC_V21_DYNAMICSETPOINT_TAG_ID, CALIB_SENSOR_AEC_V21_LINEARAE_CTRL_TAG_ID);
9869 CalibDb_LinearAE_Attr_V21_t* paec_linctrl = (CalibDb_LinearAE_Attr_V21_t*)param;
9870
9871 const XMLNode* pchild = pelement->FirstChild();
9872
9873 int nExpValue = 0;
9874 int nDysetpoint = 0;
9875 while (pchild) {
9876 XmlTag tag = XmlTag(pchild->ToElement());
9877 std::string Tagname(pchild->ToElement()->Name());
9878 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
9879 INFO_PRINT(Tagname);
9880 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_EXPLEVEL_TAG_ID)) {
9881 int no = ParseFloatArray(pchild, paec_linctrl->DySetpoint.ExpValue, tag.Size());
9882 DCT_ASSERT((no == tag.Size()));
9883 if(tag.Size() > AEC_SETPOINT_MAX_NODES) {
9884 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_SETPOINT_MAX_NODES);
9885 return false;
9886 }
9887 nExpValue = no;
9888 }
9889 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_DYSETPOINT_TAG_ID)) {
9890 int no = ParseFloatArray(pchild, paec_linctrl->DySetpoint.DySetpoint, tag.Size());
9891 DCT_ASSERT((no == tag.Size()));
9892 if(tag.Size() > AEC_SETPOINT_MAX_NODES) {
9893 LOGE("array size: %d out of Maximum range(%d)", tag.Size(), AEC_SETPOINT_MAX_NODES);
9894 return false;
9895 }
9896 nDysetpoint = no;
9897 }
9898 else {
9899 redirectOut
9900 << "parse error in DynamicPoint (unknow tag: "
9901 << Tagname
9902 << ")"
9903 << std::endl;
9904 }
9905 pchild = pchild->NextSibling();
9906 }
9907 XML_CHECK_END();
9908 DCT_ASSERT((nDysetpoint == nExpValue));
9909 paec_linctrl->DySetpoint.array_size = nDysetpoint;
9910
9911 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
9912 return (true);
9913 }
9914
parseEntrySensorLinearAECtrlBackLightV21(const XMLElement * pelement,void * param)9915 bool RkAiqCalibParser::parseEntrySensorLinearAECtrlBackLightV21
9916 (
9917 const XMLElement* pelement,
9918 void* param
9919 ) {
9920 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
9921 autoTabForward();
9922
9923 XML_CHECK_START(CALIB_SENSOR_AEC_V21_LINAECTRL_BACKLIGHT_CONFIG_TAG_ID, CALIB_SENSOR_AEC_V21_LINEARAE_CTRL_TAG_ID);
9924 CalibDb_LinearAE_Attr_V21_t* paec_linctrl = (CalibDb_LinearAE_Attr_V21_t*)param;
9925
9926 const XMLNode* psecsubchild = pelement->FirstChild();
9927 while (psecsubchild) {
9928 XmlTag secsubtag = XmlTag(psecsubchild->ToElement());
9929 std::string secsubTagname(psecsubchild->ToElement()->Name());
9930 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubtag.Type(), secsubtag.Size());
9931 #ifdef DEBUG_LOG
9932 redirectOut << "secsubTagname: " << secsubTagname << std::endl;
9933 #endif
9934 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_BACKLIGHT_ENABLE_TAG_ID)) {
9935 int no = ParseUcharArray(psecsubchild, &paec_linctrl->BackLightConf.enable, secsubtag.Size());
9936 DCT_ASSERT((no == secsubtag.Size()));
9937 }
9938 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_BACKLIGHT_MEASAREA_TAG_ID)) {
9939 char* value = Toupper(secsubtag.Value());
9940 std::string s_value(value);
9941 #ifdef DEBUG_LOG
9942 redirectOut << "value:" << value << std::endl;
9943 redirectOut << s_value << std::endl;
9944 #endif
9945 if (xmlParseReadWrite == XML_PARSER_READ)
9946 {
9947 if (s_value == CALIB_SENSOR_AEC_MEASAREA_AUTO) {
9948 paec_linctrl->BackLightConf.MeasArea = AEC_MEASURE_AREA_AUTO;
9949 }
9950 else if (s_value == CALIB_SENSOR_AEC_MEASAREA_CENTER) {
9951 paec_linctrl->BackLightConf.MeasArea = AEC_MEASURE_AREA_CENTER;
9952 }
9953 else if (s_value == CALIB_SENSOR_AEC_MEASAREA_UP) {
9954 paec_linctrl->BackLightConf.MeasArea = AEC_MEASURE_AREA_UP;
9955 }
9956 else if (s_value == CALIB_SENSOR_AEC_MEASAREA_BOTTOM) {
9957 paec_linctrl->BackLightConf.MeasArea = AEC_MEASURE_AREA_BOTTOM;
9958 }
9959 else if (s_value == CALIB_SENSOR_AEC_MEASAREA_LEFT) {
9960 paec_linctrl->BackLightConf.MeasArea = AEC_MEASURE_AREA_LEFT;
9961 }
9962 else if (s_value == CALIB_SENSOR_AEC_MEASAREA_RIGHT) {
9963 paec_linctrl->BackLightConf.MeasArea = AEC_MEASURE_AREA_RIGHT;
9964 }
9965 else {
9966 paec_linctrl->BackLightConf.MeasArea = AEC_MEASURE_AREA_AUTO;
9967 redirectOut << "invalid BackLit MeasArea (" << s_value << ")" << std::endl;
9968 }
9969 }
9970 else if (xmlParseReadWrite == XML_PARSER_WRITE)
9971 {
9972 XMLNode* pNode = (XMLNode *)psecsubchild;
9973 if (paec_linctrl->BackLightConf.MeasArea == AEC_MEASURE_AREA_AUTO)
9974 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_MEASAREA_AUTO);
9975 else if (paec_linctrl->BackLightConf.MeasArea == AEC_MEASURE_AREA_CENTER)
9976 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_MEASAREA_CENTER);
9977 else if (paec_linctrl->BackLightConf.MeasArea == AEC_MEASURE_AREA_UP)
9978 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_MEASAREA_UP);
9979 else if (paec_linctrl->BackLightConf.MeasArea == AEC_MEASURE_AREA_BOTTOM)
9980 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_MEASAREA_BOTTOM);
9981 else if (paec_linctrl->BackLightConf.MeasArea == AEC_MEASURE_AREA_LEFT)
9982 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_MEASAREA_LEFT);
9983 else if (paec_linctrl->BackLightConf.MeasArea == AEC_MEASURE_AREA_RIGHT)
9984 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_MEASAREA_RIGHT);
9985 else {
9986 pNode->FirstChild()->SetValue("INVALID");
9987 redirectOut << "(XML Write)invalid BackLit MeasArea (" << paec_linctrl->BackLightConf.MeasArea << ")" << std::endl;
9988 }
9989 }
9990 }
9991 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_BACKLIGHT_OEROI_LOWTH_TAG_ID)) {
9992 int no = ParseFloatArray(psecsubchild, &paec_linctrl->BackLightConf.OEROILowTh, secsubtag.Size());
9993 DCT_ASSERT((no == secsubtag.Size()));
9994 }
9995 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_BACKLIGHT_LV_HIGHTH_TAG_ID)) {
9996 int no = ParseFloatArray(psecsubchild, &paec_linctrl->BackLightConf.LvHightTh, secsubtag.Size());
9997 DCT_ASSERT((no == secsubtag.Size()));
9998 }
9999 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_BACKLIGHT_LV_LOWTH_TAG_ID)) {
10000 int no = ParseFloatArray(psecsubchild, &paec_linctrl->BackLightConf.LvLowTh, secsubtag.Size());
10001 DCT_ASSERT((no == secsubtag.Size()));
10002 }
10003 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_BACKLIGHT_LUMADISTTH_TAG_ID)) {
10004 int no = ParseFloatArray(psecsubchild, &paec_linctrl->BackLightConf.LumaDistTh, secsubtag.Size());
10005 DCT_ASSERT((no == secsubtag.Size()));
10006 }
10007 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_BACKLIGHT_LOWLIGHTPDFTH_TAG_ID)) {
10008 int i = (sizeof(paec_linctrl->BackLightConf.LowLightPdfTh) / sizeof(paec_linctrl->BackLightConf.LowLightPdfTh.fCoeff[0]));
10009 int no = ParseFloatArray(psecsubchild, paec_linctrl->BackLightConf.LowLightPdfTh.fCoeff, i);
10010 DCT_ASSERT((no == secsubtag.Size()));
10011 }
10012 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_BACKLIGHT_NONOEPDFTH_TAG_ID)) {
10013 int i = (sizeof(paec_linctrl->BackLightConf.NonOEPdfTh) / sizeof(paec_linctrl->BackLightConf.NonOEPdfTh.fCoeff[0]));
10014 int no = ParseFloatArray(psecsubchild, paec_linctrl->BackLightConf.NonOEPdfTh.fCoeff, i);
10015 DCT_ASSERT((no == secsubtag.Size()));
10016 }
10017 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_BACKLIGHT_EXPLEVEL_TAG_ID)) {
10018 int i = (sizeof(paec_linctrl->BackLightConf.ExpLevel) / sizeof(paec_linctrl->BackLightConf.ExpLevel.fCoeff[0]));
10019 int no = ParseFloatArray(psecsubchild, paec_linctrl->BackLightConf.ExpLevel.fCoeff, i);
10020 DCT_ASSERT((no == secsubtag.Size()));
10021 }
10022 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_BACKLIGHT_TARGETLLLUMA_TAG_ID)) {
10023 int i = (sizeof(paec_linctrl->BackLightConf.TargetLLLuma) / sizeof(paec_linctrl->BackLightConf.TargetLLLuma.fCoeff[0]));
10024 int no = ParseFloatArray(psecsubchild, paec_linctrl->BackLightConf.TargetLLLuma.fCoeff, i);
10025 DCT_ASSERT((no == secsubtag.Size()));
10026 }
10027 else {
10028 redirectOut
10029 << "parse error in LINAECTRL backlight section (unknow tag: "
10030 << secsubTagname
10031 << ")"
10032 << std::endl;
10033 }
10034 psecsubchild = psecsubchild->NextSibling();
10035 }
10036
10037 XML_CHECK_END();
10038 autoTabBackward();
10039 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
10040 return (true);
10041 }
10042
parseEntrySensorLinearAECtrlOverExpV21(const XMLElement * pelement,void * param)10043 bool RkAiqCalibParser::parseEntrySensorLinearAECtrlOverExpV21
10044 (
10045 const XMLElement* pelement,
10046 void* param
10047 ) {
10048 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10049 autoTabForward();
10050
10051 XML_CHECK_START(CALIB_SENSOR_AEC_V21_LINAECTRL_OVEREXP_CONTROL_TAG_ID, CALIB_SENSOR_AEC_V21_LINEARAE_CTRL_TAG_ID);
10052 CalibDb_LinearAE_Attr_V21_t* paec_linctrl = (CalibDb_LinearAE_Attr_V21_t*)param;
10053
10054 const XMLNode* psecsubchild = pelement->FirstChild();
10055 while (psecsubchild) {
10056 XmlTag secsubtag = XmlTag(psecsubchild->ToElement());
10057 std::string secsubTagname(psecsubchild->ToElement()->Name());
10058 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubtag.Type(), secsubtag.Size());
10059 #ifdef DEBUG_LOG
10060 redirectOut << "secsubTagname: " << secsubTagname << std::endl;
10061 #endif
10062 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_OVEREXP_ENABLE_TAG_ID)) {
10063 int no = ParseUcharArray(psecsubchild, &paec_linctrl->OverExpCtrl.enable, secsubtag.Size());
10064 DCT_ASSERT((no == secsubtag.Size()));
10065 }
10066 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_OVEREXP_LOWLIGHT_TH_TAG_ID)) {
10067 int no = ParseFloatArray(psecsubchild, &paec_linctrl->OverExpCtrl.LowLightTh, secsubtag.Size());
10068 DCT_ASSERT((no == secsubtag.Size()));
10069 }
10070 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_OVEREXP_HIGHLIGHT_TH_TAG_ID)) {
10071 int no = ParseFloatArray(psecsubchild, &paec_linctrl->OverExpCtrl.HighLightTh, secsubtag.Size());
10072 DCT_ASSERT((no == secsubtag.Size()));
10073 }
10074 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_OVEREXP_MAXWEIGHT_TAG_ID)) {
10075 int no = ParseFloatArray(psecsubchild, &paec_linctrl->OverExpCtrl.MaxWeight, secsubtag.Size());
10076 DCT_ASSERT((no == secsubtag.Size()));
10077 }
10078 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_OVEREXP_OEPDF_TAG_ID)) {
10079 int i = (sizeof(paec_linctrl->OverExpCtrl.OEpdf) / sizeof(paec_linctrl->OverExpCtrl.OEpdf.fCoeff[0]));
10080 int no = ParseFloatArray(psecsubchild, paec_linctrl->OverExpCtrl.OEpdf.fCoeff, i);
10081 DCT_ASSERT((no == secsubtag.Size()));
10082 }
10083 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_OVEREXP_HIGHLIGHT_WEIGHT_TAG_ID)) {
10084 int i = (sizeof(paec_linctrl->OverExpCtrl.HighLightWeight) / sizeof(paec_linctrl->OverExpCtrl.HighLightWeight.fCoeff[0]));
10085 int no = ParseFloatArray(psecsubchild, paec_linctrl->OverExpCtrl.HighLightWeight.fCoeff, i);
10086 DCT_ASSERT((no == secsubtag.Size()));
10087 }
10088 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_OVEREXP_LOWLIGHT_WEIGHT_TAG_ID)) {
10089 int i = (sizeof(paec_linctrl->OverExpCtrl.LowLightWeight) / sizeof(paec_linctrl->OverExpCtrl.LowLightWeight.fCoeff[0]));
10090 int no = ParseFloatArray(psecsubchild, paec_linctrl->OverExpCtrl.LowLightWeight.fCoeff, i);
10091 DCT_ASSERT((no == secsubtag.Size()));
10092 }
10093 else {
10094 redirectOut
10095 << "parse error in LINAECTRL OverExpCtrl section (unknow tag: "
10096 << secsubTagname
10097 << ")"
10098 << std::endl;
10099 }
10100 psecsubchild = psecsubchild->NextSibling();
10101 }
10102
10103 XML_CHECK_END();
10104 autoTabBackward();
10105 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
10106 return (true);
10107 }
10108
parseEntrySensorLinearAECtrlV21(const XMLElement * pelement,void * param)10109 bool RkAiqCalibParser::parseEntrySensorLinearAECtrlV21
10110 (
10111 const XMLElement* pelement,
10112 void* param
10113 ) {
10114 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10115 autoTabForward();
10116
10117 XML_CHECK_START(CALIB_SENSOR_AEC_V21_LINEARAE_CTRL_TAG_ID, CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID);
10118 CalibDb_LinearAE_Attr_V21_t* paec_linctrl = (CalibDb_LinearAE_Attr_V21_t*)param;
10119
10120 const XMLNode* psubchild = pelement->FirstChild();
10121 #ifdef DEBUG_LOG
10122 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
10123 #endif
10124 while (psubchild) {
10125 XmlTag subTag = XmlTag(psubchild->ToElement());
10126 std::string subTagname(psubchild->ToElement()->Name());
10127 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
10128 #ifdef DEBUG_LOG
10129 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
10130 #endif
10131 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_RAWSTATS_EN_TAG_ID)) {
10132 int no = ParseUcharArray(psubchild, &paec_linctrl->RawStatsEn, subTag.Size());
10133 DCT_ASSERT((no == subTag.Size()));
10134 }
10135 else if(XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SETPOINT_TAG_ID)) {
10136 int no = ParseFloatArray(psubchild, &paec_linctrl->SetPoint, subTag.Size());
10137 DCT_ASSERT((no == subTag.Size()));
10138 }
10139 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_NIGHTSETPOINT_TAG_ID)) {
10140 int no = ParseFloatArray(psubchild, &paec_linctrl->NightSetPoint, subTag.Size());
10141 DCT_ASSERT((no == subTag.Size()));
10142 }
10143 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_DYSETPOINTEN_TAG_ID)) {
10144 uint8_t temp = paec_linctrl->DySetPointEn;
10145 ParseUcharArray(psubchild, &temp, subTag.Size());
10146 paec_linctrl->DySetPointEn = (temp == 0) ? false : true;
10147 }
10148 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_EVBIAS_TAG_ID)) {
10149 int no = ParseFloatArray(psubchild, &paec_linctrl->Evbias, subTag.Size());
10150 DCT_ASSERT((no == subTag.Size()));
10151 }
10152 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_DYNAMICSETPOINT_TAG_ID)) {
10153 if (!parseEntrySensorAecLinearAeDynamicPointV21(psubchild->ToElement(), paec_linctrl)) {
10154 LOGE("parse error in Aec dynamic setpoint(%s)", subTagname.c_str());
10155 return (false);
10156 }
10157 }
10158 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_TOLERANCE_IN_TAG_ID)) {
10159 int no = ParseFloatArray(psubchild, &paec_linctrl->ToleranceIn, subTag.Size());
10160 DCT_ASSERT((no == subTag.Size()));
10161 }
10162 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_TOLERANCE_OUT_TAG_ID)) {
10163 int no = ParseFloatArray(psubchild, &paec_linctrl->ToleranceOut, subTag.Size());
10164 DCT_ASSERT((no == subTag.Size()));
10165 }
10166 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_STRATEGYMODE_TAG_ID)) {
10167 char* value = Toupper(subTag.Value());
10168 std::string s_value(value);
10169 #ifdef DEBUG_LOG
10170 LOGE("%s(%d): s_value = %s\n", __FUNCTION__, __LINE__, s_value);
10171 #endif
10172 if (xmlParseReadWrite == XML_PARSER_READ)
10173 {
10174 if (s_value == CALIB_SENSOR_AEC_STRATEGYMODE_LOWLIGHT) {
10175 paec_linctrl->StrategyMode = RKAIQ_AEC_STRATEGY_MODE_LOWLIGHT_PRIOR;
10176 }
10177 else if (s_value == CALIB_SENSOR_AEC_STRATEGYMODE_HIGHLIGHT) {
10178 paec_linctrl->StrategyMode = RKAIQ_AEC_STRATEGY_MODE_HIGHLIGHT_PRIOR;
10179 }
10180 else {
10181 paec_linctrl->StrategyMode = RKAIQ_AEC_STRATEGY_MODE_AUTO;
10182 redirectOut << "invalid AEC LinAe StrategyMode (" << s_value << ")" << std::endl;
10183 }
10184 }
10185 else if (xmlParseReadWrite == XML_PARSER_WRITE)
10186 {
10187 XMLNode *pNode = (XMLNode *)psubchild;
10188 if (paec_linctrl->StrategyMode == RKAIQ_AEC_STRATEGY_MODE_LOWLIGHT_PRIOR)
10189 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_STRATEGYMODE_LOWLIGHT);
10190 else if (paec_linctrl->StrategyMode == RKAIQ_AEC_STRATEGY_MODE_HIGHLIGHT_PRIOR)
10191 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_STRATEGYMODE_HIGHLIGHT);
10192 else {
10193 pNode->FirstChild()->SetValue("AUTO");
10194 redirectOut << "(XML Wrtie)invalid AEC LinAe StrategyMode (" << paec_linctrl->StrategyMode << ")" << std::endl;
10195 }
10196 }
10197
10198 }
10199 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_BACKLIGHT_CONFIG_TAG_ID)) {
10200 if (!parseEntrySensorLinearAECtrlBackLightV21(psubchild->ToElement(), paec_linctrl)) {
10201 LOGE("parse error in Aec (%s)", subTagname.c_str());
10202 return (false);
10203 }
10204 }
10205 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINAECTRL_OVEREXP_CONTROL_TAG_ID)) {
10206 if (!parseEntrySensorLinearAECtrlOverExpV21(psubchild->ToElement(), paec_linctrl)) {
10207 LOGE("parse error in Aec (%s)", subTagname.c_str());
10208 return (false);
10209 }
10210 }
10211
10212 psubchild = psubchild->NextSibling();
10213 }
10214
10215 XML_CHECK_END();
10216 autoTabBackward();
10217 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
10218 return (true);
10219 }
10220
parseEntrySensorHdrAECtrlExpRatioCtrlV21(const XMLElement * pelement,void * param)10221 bool RkAiqCalibParser::parseEntrySensorHdrAECtrlExpRatioCtrlV21
10222 (
10223 const XMLElement* pelement,
10224 void* param
10225 ) {
10226 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10227 autoTabForward();
10228
10229 XML_CHECK_START(CALIB_SENSOR_AEC_V21_HDRAECTRL_EXPRATIOCTRL_TAG_ID, CALIB_SENSOR_AEC_V21_HDRAECTRL_TAG_ID);
10230 CalibDb_HdrAE_Attr_t* paec_hdrctrl = (CalibDb_HdrAE_Attr_t*)param;
10231
10232 const XMLNode* psubsubchild = pelement->FirstChild();
10233 while (psubsubchild) {
10234 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
10235 std::string subsubTagname(psubsubchild->ToElement()->Name());
10236 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
10237 #ifdef DEBUG_LOG
10238 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
10239 #endif
10240 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_EXPRATIOTYPE_TAG_ID)) {
10241 char* value = Toupper(subsubTag.Value());
10242 std::string s_value(value);
10243 #ifdef DEBUG_LOG
10244 redirectOut << "value:" << value << std::endl;
10245 redirectOut << s_value << std::endl;
10246 #endif
10247 if (xmlParseReadWrite == XML_PARSER_READ)
10248 {
10249 if (s_value == CALIB_SENSOR_AEC_HDRAECTRL_EXPRATIOTYPE_AUTO) {
10250 paec_hdrctrl->ExpRatioType = RKAIQ_HDRAE_RATIOTYPE_MODE_AUTO;
10251 }
10252 else if (s_value == CALIB_SENSOR_AEC_HDRAECTRL_EXPRATIOTYPE_FIX) {
10253 paec_hdrctrl->ExpRatioType = RKAIQ_HDRAE_RATIOTYPE_MODE_FIX;
10254 }
10255 else {
10256 paec_hdrctrl->ExpRatioType = RKAIQ_HDRAE_RATIOTYPE_MODE_INVALID;
10257 redirectOut << "invalid AEC HdrAe ExpRatioType (" << s_value << ")" << std::endl;
10258 }
10259 }
10260 else if (xmlParseReadWrite == XML_PARSER_WRITE)
10261 {
10262 XMLNode *pNode = (XMLNode*)psubsubchild;
10263 if (paec_hdrctrl->ExpRatioType == RKAIQ_HDRAE_RATIOTYPE_MODE_AUTO)
10264 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_EXPRATIOTYPE_AUTO);
10265 else if (paec_hdrctrl->ExpRatioType == RKAIQ_HDRAE_RATIOTYPE_MODE_FIX)
10266 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_EXPRATIOTYPE_FIX);
10267 else
10268 {
10269 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_EXPRATIOTYPE_AUTO);
10270 redirectOut << "(XML Write)invalid AEC HdrAe ExpRatioType (" << paec_hdrctrl->ExpRatioType << ")" << std::endl;
10271 }
10272 }
10273 }
10274 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_RATIOEXPDOT_TAG_ID)) {
10275 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->RatioExpDot.fCoeff, subsubTag.Size());
10276 DCT_ASSERT((no == subsubTag.Size()));
10277 }
10278 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_M2SRATIOFIX_TAG_ID)) {
10279 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->M2SRatioFix.fCoeff, subsubTag.Size());
10280 DCT_ASSERT((no == subsubTag.Size()));
10281 }
10282 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_L2MRATIOFIX_TAG_ID)) {
10283 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->L2MRatioFix.fCoeff, subsubTag.Size());
10284 DCT_ASSERT((no == subsubTag.Size()));
10285 }
10286 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_M2SRATIOMAX_TAG_ID)) {
10287 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->M2SRatioMax.fCoeff, subsubTag.Size());
10288 DCT_ASSERT((no == subsubTag.Size()));
10289 }
10290 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_L2MRATIOMAX_TAG_ID)) {
10291 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->L2MRatioMax.fCoeff, subsubTag.Size());
10292 DCT_ASSERT((no == subsubTag.Size()));
10293 }
10294 else {
10295 redirectOut
10296 << "parse error in AEC HdrAeCtrl (unknow tag: "
10297 << subsubTagname
10298 << ")"
10299 << std::endl;
10300 }
10301 psubsubchild = psubsubchild->NextSibling();
10302 }
10303
10304 XML_CHECK_END();
10305 autoTabBackward();
10306 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
10307 return (true);
10308 }
10309
parseEntrySensorHdrAECtrlLframeModeV21(const XMLElement * pelement,void * param)10310 bool RkAiqCalibParser::parseEntrySensorHdrAECtrlLframeModeV21
10311 (
10312 const XMLElement* pelement,
10313 void* param
10314 ) {
10315 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10316 autoTabForward();
10317
10318 XML_CHECK_START(CALIB_SENSOR_AEC_V21_HDRAECTRL_LONGFRMMODE_TAG_ID, CALIB_SENSOR_AEC_V21_HDRAECTRL_TAG_ID);
10319 CalibDb_HdrAE_Attr_t* paec_hdrctrl = (CalibDb_HdrAE_Attr_t*)param;
10320
10321 const XMLNode* psubsubchild = pelement->FirstChild();
10322 while (psubsubchild) {
10323 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
10324 std::string subsubTagname(psubsubchild->ToElement()->Name());
10325 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
10326 #ifdef DEBUG_LOG
10327 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
10328 #endif
10329 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_LONGFRMMODE_MODE_TAG_ID)) {
10330 char* value = Toupper(subsubTag.Value());
10331 std::string s_value(value);
10332 #ifdef DEBUG_LOG
10333 redirectOut << "value:" << value << std::endl;
10334 redirectOut << s_value << std::endl;
10335 #endif
10336 if (xmlParseReadWrite == XML_PARSER_READ)
10337 {
10338 if (s_value == CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_NORMAL) {
10339 paec_hdrctrl->LongfrmMode = RKAIQ_AEC_HDR_LONGFRMMODE_NORMAL;
10340 }
10341 else if (s_value == CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_LONGFRAME) {
10342 paec_hdrctrl->LongfrmMode = RKAIQ_AEC_HDR_LONGFRMMODE_LONG_FRAME;
10343 }
10344 else if (s_value == CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_AUTO_LONGFRAME) {
10345 paec_hdrctrl->LongfrmMode = RKAIQ_AEC_HDR_LONGFRMMODE_AUTO_LONG_FRAME;
10346 }
10347 else {
10348 paec_hdrctrl->LongfrmMode = RKAIQ_AEC_HDR_LONGFRMMODE_NORMAL;
10349 redirectOut << "invalid AEC HdrAe LongFrmMode (" << s_value << ")" << std::endl;
10350 }
10351 }
10352 else if (xmlParseReadWrite == XML_PARSER_WRITE)
10353 {
10354 XMLNode *pNode = (XMLNode*)psubsubchild;
10355 if (paec_hdrctrl->LongfrmMode == RKAIQ_AEC_HDR_LONGFRMMODE_NORMAL) {
10356 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_NORMAL);
10357 }
10358 else if (paec_hdrctrl->LongfrmMode == RKAIQ_AEC_HDR_LONGFRMMODE_LONG_FRAME) {
10359 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_LONGFRAME);
10360 }
10361 else if (paec_hdrctrl->LongfrmMode == RKAIQ_AEC_HDR_LONGFRMMODE_AUTO_LONG_FRAME) {
10362 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_AUTO_LONGFRAME);
10363 }
10364 else {
10365 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HDRAECTRL_LONGFRMMODE_NORMAL);
10366 redirectOut << "(XML Write)invalid AEC HdrAe LongFrmMode (" << paec_hdrctrl->LongfrmMode << ")" << std::endl;
10367 }
10368 }
10369 }
10370 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_LONGFRMMODE_LFRMMODEEXPTH_TAG_ID)) {
10371 int no = ParseFloatArray(psubsubchild, &paec_hdrctrl->LfrmModeExpTh, subsubTag.Size());
10372 DCT_ASSERT((no == subsubTag.Size()));
10373 }
10374 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_LONGFRMMODE_SFRMMINLINE_TAG_ID)) {
10375 int no = ParseUshortArray(psubsubchild, &paec_hdrctrl->SfrmMinLine, subsubTag.Size());
10376 DCT_ASSERT((no == subsubTag.Size()));
10377 } else {
10378 redirectOut
10379 << "parse error in AEC LongFrmMode (unknow tag: "
10380 << subsubTagname
10381 << ")"
10382 << std::endl;
10383 }
10384 psubsubchild = psubsubchild->NextSibling();
10385 }
10386 autoTabBackward();
10387 XML_CHECK_END();
10388 autoTabBackward();
10389 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
10390 return (true);
10391 }
10392
parseEntrySensorHdrAECtrlLframeCtrlV21(const XMLElement * pelement,void * param)10393 bool RkAiqCalibParser::parseEntrySensorHdrAECtrlLframeCtrlV21
10394 (
10395 const XMLElement* pelement,
10396 void* param
10397 ) {
10398 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10399 autoTabForward();
10400
10401 XML_CHECK_START(CALIB_SENSOR_AEC_V21_HDRAECTRL_LFRAMECTRL_TAG_ID, CALIB_SENSOR_AEC_V21_HDRAECTRL_TAG_ID);
10402 CalibDb_HdrAE_Attr_t* paec_hdrctrl = (CalibDb_HdrAE_Attr_t*)param;
10403
10404 const XMLNode* psubsubchild = pelement->FirstChild();
10405 autoTabForward();
10406 while (psubsubchild) {
10407 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
10408 std::string subsubTagname(psubsubchild->ToElement()->Name());
10409 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
10410 #ifdef DEBUG_LOG
10411 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
10412 #endif
10413 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_OEROILOWTH_TAG_ID)) {
10414 int no = ParseFloatArray(psubsubchild, &paec_hdrctrl->LframeCtrl.OEROILowTh, subsubTag.Size());
10415 DCT_ASSERT((no == subsubTag.Size()));
10416 }
10417 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_LVHIGHTH_TAG_ID)) {
10418 int no = ParseFloatArray(psubsubchild, &paec_hdrctrl->LframeCtrl.LvHighTh, subsubTag.Size());
10419 DCT_ASSERT((no == subsubTag.Size()));
10420 }
10421 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_LVLOWTH_TAG_ID)) {
10422 int no = ParseFloatArray(psubsubchild, &paec_hdrctrl->LframeCtrl.LvLowTh, subsubTag.Size());
10423 DCT_ASSERT((no == subsubTag.Size()));
10424 }
10425 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_LEXPLEVEL_TAG_ID)) {
10426 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->LframeCtrl.LExpLevel.fCoeff, subsubTag.Size());
10427 DCT_ASSERT((no == subsubTag.Size()));
10428 }
10429 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_LSETPOINT_TAG_ID)) {
10430 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->LframeCtrl.LSetPoint.fCoeff, subsubTag.Size());
10431 DCT_ASSERT((no == subsubTag.Size()));
10432 }
10433 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_TARGETLLLUMA_TAG_ID)) {
10434 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->LframeCtrl.TargetLLLuma.fCoeff, subsubTag.Size());
10435 DCT_ASSERT((no == subsubTag.Size()));
10436 }
10437 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_NONOEPDFTH_TAG_ID)) {
10438 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->LframeCtrl.NonOEPdfTh.fCoeff, subsubTag.Size());
10439 DCT_ASSERT((no == subsubTag.Size()));
10440 }
10441 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_LOWLIGHTPDFTH_TAG_ID)) {
10442 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->LframeCtrl.LowLightPdfTh.fCoeff, subsubTag.Size());
10443 DCT_ASSERT((no == subsubTag.Size()));
10444 }
10445 else {
10446 redirectOut
10447 << "parse error in AEC HdrAeCtrl LframeCtrl (unknow tag: "
10448 << subsubTagname
10449 << ")"
10450 << std::endl;
10451 }
10452 psubsubchild = psubsubchild->NextSibling();
10453 }
10454 XML_CHECK_END();
10455 autoTabBackward();
10456 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
10457 return (true);
10458 }
10459
parseEntrySensorHdrAECtrlMframeCtrlV21(const XMLElement * pelement,void * param)10460 bool RkAiqCalibParser::parseEntrySensorHdrAECtrlMframeCtrlV21
10461 (
10462 const XMLElement* pelement,
10463 void* param
10464 ) {
10465 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10466 autoTabForward();
10467
10468 XML_CHECK_START(CALIB_SENSOR_AEC_V21_HDRAECTRL_MFRAMECTRL_TAG_ID, CALIB_SENSOR_AEC_V21_HDRAECTRL_TAG_ID);
10469 CalibDb_HdrAE_Attr_t* paec_hdrctrl = (CalibDb_HdrAE_Attr_t*)param;
10470
10471 const XMLNode* psubsubchild = pelement->FirstChild();
10472 while (psubsubchild) {
10473 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
10474 std::string subsubTagname(psubsubchild->ToElement()->Name());
10475 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
10476 #ifdef DEBUG_LOG
10477 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
10478 #endif
10479 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_MEXPLEVEL_TAG_ID)) {
10480 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->MframeCtrl.MExpLevel.fCoeff, subsubTag.Size());
10481 DCT_ASSERT((no == subsubTag.Size()));
10482 }
10483 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_MSETPOINT_TAG_ID)) {
10484 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->MframeCtrl.MSetPoint.fCoeff, subsubTag.Size());
10485 DCT_ASSERT((no == subsubTag.Size()));
10486 }
10487 else {
10488 redirectOut
10489 << "parse error in AEC HdrAeCtrl MframeCtrl (unknow tag: "
10490 << subsubTagname
10491 << ")"
10492 << std::endl;
10493 }
10494 psubsubchild = psubsubchild->NextSibling();
10495 }
10496 XML_CHECK_END();
10497 autoTabBackward();
10498 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
10499 return (true);
10500 }
10501
parseEntrySensorHdrAECtrlSframeCtrlV21(const XMLElement * pelement,void * param)10502 bool RkAiqCalibParser::parseEntrySensorHdrAECtrlSframeCtrlV21
10503 (
10504 const XMLElement* pelement,
10505 void* param
10506 ) {
10507 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10508 autoTabForward();
10509
10510 XML_CHECK_START(CALIB_SENSOR_AEC_V21_HDRAECTRL_SFRAMECTRL_TAG_ID, CALIB_SENSOR_AEC_V21_HDRAECTRL_TAG_ID);
10511 CalibDb_HdrAE_Attr_t* paec_hdrctrl = (CalibDb_HdrAE_Attr_t*)param;
10512
10513 const XMLNode* psubsubchild = pelement->FirstChild();
10514 while (psubsubchild) {
10515 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
10516 std::string subsubTagname(psubsubchild->ToElement()->Name());
10517 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
10518 #ifdef DEBUG_LOG
10519 LOGE("%s(%d): subsubTagname = %s\n", __FUNCTION__, __LINE__, subsubTagname.c_str());
10520 #endif
10521 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_SEXPLEVEL_TAG_ID)) {
10522 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->SframeCtrl.SExpLevel.fCoeff, subsubTag.Size());
10523 DCT_ASSERT((no == subsubTag.Size()));
10524 }
10525 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_HLROIEXPANDEN_TAG_ID)) {
10526 uint8_t temp = paec_hdrctrl->SframeCtrl.HLROIExpandEn;
10527 int no = ParseUcharArray(psubsubchild, &temp, subsubTag.Size());
10528 paec_hdrctrl->SframeCtrl.HLROIExpandEn = (temp == 0) ? false : true;
10529 DCT_ASSERT((no == subsubTag.Size()));
10530 }
10531 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_TARGETHLLUMA_TAG_ID)) {
10532 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->SframeCtrl.TargetHLLuma.fCoeff, subsubTag.Size());
10533 DCT_ASSERT((no == subsubTag.Size()));
10534 }
10535 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_SSETPOINT_TAG_ID)) {
10536 int no = ParseFloatArray(psubsubchild, paec_hdrctrl->SframeCtrl.SSetPoint.fCoeff, subsubTag.Size());
10537 DCT_ASSERT((no == subsubTag.Size()));
10538 }
10539 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_HLLUMATOLERANCE_TAG_ID)) {
10540 int no = ParseFloatArray(psubsubchild, &paec_hdrctrl->SframeCtrl.HLLumaTolerance, subsubTag.Size());
10541 DCT_ASSERT((no == subsubTag.Size()));
10542 }
10543 else {
10544 redirectOut
10545 << "parse error in AEC HdrAeCtrl SframeCtrl (unknow tag: "
10546 << subsubTagname
10547 << ")"
10548 << std::endl;
10549 }
10550 psubsubchild = psubsubchild->NextSibling();
10551 }
10552
10553 XML_CHECK_END();
10554 autoTabBackward();
10555 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
10556 return (true);
10557 }
10558
10559
parseEntrySensorHdrAECtrlV21(const XMLElement * pelement,void * param)10560 bool RkAiqCalibParser::parseEntrySensorHdrAECtrlV21
10561 (
10562 const XMLElement* pelement,
10563 void* param
10564 ) {
10565 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10566 autoTabForward();
10567
10568 XML_CHECK_START(CALIB_SENSOR_AEC_V21_HDRAECTRL_TAG_ID, CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID);
10569 CalibDb_HdrAE_Attr_t* paec_hdrctrl = (CalibDb_HdrAE_Attr_t*)param;
10570
10571 const XMLNode* psubchild = pelement->FirstChild();
10572 while (psubchild) {
10573 XmlTag subTag = XmlTag(psubchild->ToElement());
10574 std::string subTagname(psubchild->ToElement()->Name());
10575 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
10576 #ifdef DEBUG_LOG
10577 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
10578 #endif
10579 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_TOLERANCE_IN_TAG_ID)) {
10580 int no = ParseFloatArray(psubchild, &paec_hdrctrl->ToleranceIn, subTag.Size());
10581 DCT_ASSERT((no == subTag.Size()));
10582 }
10583 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_TOLERANCE_OUT_TAG_ID)) {
10584 int no = ParseFloatArray(psubchild, &paec_hdrctrl->ToleranceOut, subTag.Size());
10585 DCT_ASSERT((no == subTag.Size()));
10586 }
10587 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_EVBIAS_TAG_ID)) {
10588 int no = ParseFloatArray(psubchild, &paec_hdrctrl->Evbias, subTag.Size());
10589 DCT_ASSERT((no == subTag.Size()));
10590 }
10591 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_STRATEGYMODE_TAG_ID)) {
10592 char* value = Toupper(subTag.Value());
10593 std::string s_value(value);
10594 #ifdef DEBUG_LOG
10595 redirectOut << "value:" << value << std::endl;
10596 redirectOut << s_value << std::endl;
10597 #endif
10598 if (xmlParseReadWrite == XML_PARSER_READ)
10599 {
10600 if (s_value == CALIB_SENSOR_AEC_STRATEGYMODE_LOWLIGHT) {
10601 paec_hdrctrl->StrategyMode = RKAIQ_AEC_STRATEGY_MODE_LOWLIGHT_PRIOR;
10602 }
10603 else if (s_value == CALIB_SENSOR_AEC_STRATEGYMODE_HIGHLIGHT) {
10604 paec_hdrctrl->StrategyMode = RKAIQ_AEC_STRATEGY_MODE_HIGHLIGHT_PRIOR;
10605 }
10606 else {
10607 paec_hdrctrl->StrategyMode = RKAIQ_AEC_STRATEGY_MODE_AUTO;
10608 redirectOut << "invalid AEC HdrAe StrategyMode (" << s_value << ")" << std::endl;
10609 }
10610 }
10611 else if (xmlParseReadWrite == XML_PARSER_WRITE)
10612 {
10613 XMLNode *pNode = (XMLNode*)psubchild;
10614 if (paec_hdrctrl->StrategyMode == RKAIQ_AEC_STRATEGY_MODE_LOWLIGHT_PRIOR) {
10615 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_STRATEGYMODE_LOWLIGHT);
10616 }
10617 else if (paec_hdrctrl->StrategyMode == RKAIQ_AEC_STRATEGY_MODE_HIGHLIGHT_PRIOR) {
10618 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_STRATEGYMODE_HIGHLIGHT);
10619 }
10620 else {
10621 pNode->FirstChild()->SetValue("AUTO");
10622 redirectOut << "(XML Write)invalid AEC HdrAe StrategyMode (" << paec_hdrctrl->StrategyMode << ")" << std::endl;
10623 }
10624 }
10625 }
10626 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_EXPRATIOCTRL_TAG_ID)) {
10627 if (!parseEntrySensorHdrAECtrlExpRatioCtrlV21(psubchild->ToElement(), paec_hdrctrl)) {
10628 LOGE("parse error in Aec (%s)", subTagname.c_str());
10629 return (false);
10630 }
10631 }
10632 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_LUMADISTTH_TAG_ID)) {
10633 int no = ParseFloatArray(psubchild, &paec_hdrctrl->LumaDistTh, subTag.Size());
10634 DCT_ASSERT((no == subTag.Size()));
10635 }
10636 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_LFRAMECTRL_TAG_ID)) {
10637 if (!parseEntrySensorHdrAECtrlLframeCtrlV21(psubchild->ToElement(), paec_hdrctrl)) {
10638 LOGE("parse error in Aec (%s)", subTagname.c_str());
10639 return (false);
10640 }
10641 }
10642 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_MFRAMECTRL_TAG_ID)) {
10643 if (!parseEntrySensorHdrAECtrlMframeCtrlV21(psubchild->ToElement(), paec_hdrctrl)) {
10644 LOGE("parse error in Aec (%s)", subTagname.c_str());
10645 return (false);
10646 }
10647 }
10648 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_SFRAMECTRL_TAG_ID)) {
10649 if (!parseEntrySensorHdrAECtrlSframeCtrlV21(psubchild->ToElement(), paec_hdrctrl)) {
10650 LOGE("parse error in Aec (%s)", subTagname.c_str());
10651 return (false);
10652 }
10653 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_LONGFRMMODE_TAG_ID)) {
10654 if (!parseEntrySensorHdrAECtrlLframeModeV21(psubchild->ToElement(), paec_hdrctrl)) {
10655 LOGE("parse error in Aec (%s)", subTagname.c_str());
10656 return (false);
10657 }
10658 }
10659 else {
10660 redirectOut
10661 << "parse error in AEC HdrAeCtrl (unknow tag: "
10662 << subTagname
10663 << ")"
10664 << std::endl;
10665 }
10666 psubchild = psubchild->NextSibling();
10667 }
10668 autoTabBackward();
10669
10670 XML_CHECK_END();
10671 autoTabBackward();
10672 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
10673 return (true);
10674 }
10675
parseEntrySensorAecWinScaleV21(const XMLElement * pelement,void * param)10676 bool RkAiqCalibParser::parseEntrySensorAecWinScaleV21
10677 (
10678 const XMLElement* pelement,
10679 void* param
10680 ) {
10681 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10682 autoTabForward();
10683
10684 XML_CHECK_START(CALIB_SENSOR_AEC_V21_WINSCALE_TAG_ID, CALIB_SENSOR_AEC_V21_CALIBPARA_TAG_ID);
10685 CalibDb_Aec_CalibPara_t *paec_calib = (CalibDb_Aec_CalibPara_t*)param;
10686
10687 const XMLNode* psubchild = pelement->FirstChild();
10688 #ifdef DEBUG_LOG
10689 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
10690 #endif
10691 while (psubchild) {
10692 XmlTag subTag = XmlTag(psubchild->ToElement());
10693 std::string subTagname(psubchild->ToElement()->Name());
10694 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
10695 #ifdef DEBUG_LOG
10696 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
10697 #endif
10698 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_WINSCALE_INRAW_TAG_ID)) {
10699 Cam1x4FloatMatrix_t tmpVal;
10700 int no = ParseFloatArray(psubchild, tmpVal.fCoeff, subTag.Size());
10701 DCT_ASSERT((no == subTag.Size()));
10702 DCT_ASSERT((tmpVal.fCoeff[0] >= 0));
10703 DCT_ASSERT((tmpVal.fCoeff[1] >= 0));
10704 DCT_ASSERT((tmpVal.fCoeff[2] <= 1));
10705 DCT_ASSERT((tmpVal.fCoeff[3] <= 1));
10706 paec_calib->InRawWinScale.h_offs = tmpVal.fCoeff[0];
10707 paec_calib->InRawWinScale.v_offs = tmpVal.fCoeff[1];
10708 paec_calib->InRawWinScale.h_size = tmpVal.fCoeff[2];
10709 paec_calib->InRawWinScale.v_size = tmpVal.fCoeff[3];
10710 }
10711 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_WINSCALE_TMORAW_TAG_ID)) {
10712 Cam1x4FloatMatrix_t tmpVal;
10713 int no = ParseFloatArray(psubchild, tmpVal.fCoeff, subTag.Size());
10714 DCT_ASSERT((no == subTag.Size()));
10715 DCT_ASSERT((tmpVal.fCoeff[0] >= 0));
10716 DCT_ASSERT((tmpVal.fCoeff[1] >= 0));
10717 DCT_ASSERT((tmpVal.fCoeff[2] <= 1));
10718 DCT_ASSERT((tmpVal.fCoeff[3] <= 1));
10719 paec_calib->TmoRawWinScale.h_offs = tmpVal.fCoeff[0];
10720 paec_calib->TmoRawWinScale.v_offs = tmpVal.fCoeff[1];
10721 paec_calib->TmoRawWinScale.h_size = tmpVal.fCoeff[2];
10722 paec_calib->TmoRawWinScale.v_size = tmpVal.fCoeff[3];
10723 }
10724 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_WINSCALE_YUVRAW_TAG_ID)) {
10725 Cam1x4FloatMatrix_t tmpVal;
10726 int no = ParseFloatArray(psubchild, tmpVal.fCoeff, subTag.Size());
10727 DCT_ASSERT((no == subTag.Size()));
10728 DCT_ASSERT((tmpVal.fCoeff[0] >= 0));
10729 DCT_ASSERT((tmpVal.fCoeff[1] >= 0));
10730 DCT_ASSERT((tmpVal.fCoeff[2] <= 1));
10731 DCT_ASSERT((tmpVal.fCoeff[3] <= 1));
10732 paec_calib->YuvWinScale.h_offs = tmpVal.fCoeff[0];
10733 paec_calib->YuvWinScale.v_offs = tmpVal.fCoeff[1];
10734 paec_calib->YuvWinScale.h_size = tmpVal.fCoeff[2];
10735 paec_calib->YuvWinScale.v_size = tmpVal.fCoeff[3];
10736 }
10737 else {
10738 LOGE("%s(%d): parse error in AecWinScale (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
10739 }
10740 psubchild = psubchild->NextSibling();
10741 }
10742
10743 XML_CHECK_END();
10744 autoTabBackward();
10745 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
10746 return (true);
10747 }
10748
parseEntrySensorAecEnvLvCalibV21(const XMLElement * pelement,void * param)10749 bool RkAiqCalibParser::parseEntrySensorAecEnvLvCalibV21
10750 (
10751 const XMLElement* pelement,
10752 void* param
10753 ) {
10754 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10755 autoTabForward();
10756
10757 XML_CHECK_START(CALIB_SENSOR_AEC_V21_ENVLVCALIB_TAG_ID, CALIB_SENSOR_AEC_V21_CALIBPARA_TAG_ID);
10758 CalibDb_Aec_CalibPara_t *paec_calib = (CalibDb_Aec_CalibPara_t*)param;
10759
10760 const XMLNode* psubchild = pelement->FirstChild();
10761 #ifdef DEBUG_LOG
10762 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
10763 #endif
10764 while (psubchild) {
10765 XmlTag subTag = XmlTag(psubchild->ToElement());
10766 std::string subTagname(psubchild->ToElement()->Name());
10767 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
10768 #ifdef DEBUG_LOG
10769 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
10770 #endif
10771 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_ENVLVCALIB_CALIBFNUMBER_TAG_ID)) {
10772 int no = ParseFloatArray(psubchild, &paec_calib->stEnvLvCalib.CalibFN, subTag.Size());
10773 DCT_ASSERT((no == subTag.Size()));
10774 }
10775 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_ENVLVCALIB_CURVECOEFF_TAG_ID)) {
10776 int no = ParseFloatArray(psubchild, paec_calib->stEnvLvCalib.Curve.fCoeff, subTag.Size());
10777 DCT_ASSERT((no == subTag.Size()));
10778 }
10779 else {
10780 LOGE("%s(%d): parse error in AecEnvLvCalib (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
10781 }
10782 psubchild = psubchild->NextSibling();
10783 }
10784
10785 XML_CHECK_END();
10786 autoTabBackward();
10787 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
10788 return (true);
10789 }
10790
parseEntrySensorAecCalibPara(const XMLElement * pelement,void * param,int index)10791 bool RkAiqCalibParser::parseEntrySensorAecCalibPara
10792 (
10793 const XMLElement* pelement,
10794 void* param,
10795 int index
10796 ) {
10797 (void)param;
10798 if(param == NULL) {
10799 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10800 }
10801
10802 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10803 autoTabForward();
10804
10805 XML_CHECK_START(CALIB_SENSOR_AEC_V21_CALIBPARA_TAG_ID, CALIB_SENSOR_AEC_V21_TAG_ID);
10806
10807 bool ret;
10808 const XMLNode* pchild = pelement->FirstChild();
10809
10810 list_head* paec_calib_list = (list_head* )param;
10811 CalibDb_Aec_CalibPara_t aec_calib;
10812 memset(&aec_calib, 0x00, sizeof(aec_calib));
10813
10814 if (xmlParseReadWrite == XML_PARSER_WRITE) {
10815 const CalibDb_Aec_CalibPara_t *paec_calib = NULL;
10816 ret = GetAecProfileFromAecCalibListByIdx(paec_calib_list, index, &paec_calib);
10817 DCT_ASSERT(ret == true);
10818 DCT_ASSERT(paec_calib != NULL);
10819 memcpy(&aec_calib, paec_calib, sizeof(CalibDb_Aec_CalibPara_t));
10820 }
10821
10822 #ifdef DEBUG_LOG
10823 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
10824 #endif
10825 while (pchild) {
10826 XmlTag tag = XmlTag(pchild->ToElement());
10827 std::string tagname(pchild->ToElement()->Name());
10828 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
10829 #ifdef DEBUG_LOG
10830 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, tagname.c_str());
10831 #endif
10832 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_CALIBSCENE_TAG_ID)) {
10833 ParseString(pchild, aec_calib.scene, sizeof(aec_calib.scene));
10834 }
10835 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_ENVLVCALIB_TAG_ID)) {
10836 if (!parseEntrySensorAecEnvLvCalibV21(pchild->ToElement(), &aec_calib)) {
10837 LOGE("parse error in AecCalibPara EnvLvCalib (%s)", tagname.c_str());
10838 return (false);
10839 }
10840 }
10841 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_WINSCALE_TAG_ID)) {
10842 if (!parseEntrySensorAecWinScaleV21(pchild->ToElement(), &aec_calib)) {
10843 LOGE("parse error in AecCalibPara EnvLvCalib (%s)", tagname.c_str());
10844 return (false);
10845 }
10846 }
10847 else {
10848 LOGE("%s(%d): parse error in AecCalibPara (unknow tag: %s )\n", __FUNCTION__, __LINE__, tagname.c_str());
10849 }
10850 pchild = pchild->NextSibling();
10851 }
10852
10853 XML_CHECK_END();
10854 if (xmlParseReadWrite == XML_PARSER_READ) {
10855 ret = AddAecCalibProfile2AecCalibList(paec_calib_list, &aec_calib);
10856 DCT_ASSERT(ret == true);
10857 }
10858
10859 autoTabBackward();
10860 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
10861 return (true);
10862 }
10863
parseEntrySensorAecTunePara(const XMLElement * pelement,void * param,int index)10864 bool RkAiqCalibParser::parseEntrySensorAecTunePara
10865 (
10866 const XMLElement* pelement,
10867 void* param,
10868 int index
10869 ) {
10870 (void)param;
10871 if(param == NULL) {
10872 LOGE("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10873 }
10874
10875 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
10876 autoTabForward();
10877
10878 XML_CHECK_START(CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID, CALIB_SENSOR_AEC_V21_TAG_ID);
10879
10880 bool ret;
10881 const XMLNode* pchild = pelement->FirstChild();
10882
10883 list_head* paec_tune_list = (list_head*)param;
10884 CalibDb_Aec_TunePara_t aec_tune;
10885 memset(&aec_tune, 0x00, sizeof(aec_tune));
10886
10887 if (xmlParseReadWrite == XML_PARSER_WRITE) {
10888 const CalibDb_Aec_TunePara_t *paec_tune = NULL;
10889 ret = GetAecProfileFromAecTuneListByIdx(paec_tune_list, index, &paec_tune);
10890 DCT_ASSERT(ret == true);
10891 DCT_ASSERT(paec_tune != NULL);
10892 memcpy(&aec_tune, paec_tune, sizeof(CalibDb_Aec_TunePara_t));
10893 }
10894
10895 #ifdef DEBUG_LOG
10896 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, pelement->Name());
10897 #endif
10898 while (pchild) {
10899 XmlTag tag = XmlTag(pchild->ToElement());
10900 std::string tagname(pchild->ToElement()->Name());
10901 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
10902
10903 #ifdef DEBUG_LOG
10904 LOGE("%s(%d): tagname: [%s]\n", __FUNCTION__, __LINE__, tagname.c_str());
10905 #endif
10906 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_TUNESCENE_TAG_ID)) {
10907 ParseString(pchild, aec_tune.scene, sizeof(aec_tune.scene));
10908 }
10909 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_ENABLE_TAG_ID)) {
10910 ParseUcharArray(pchild, &aec_tune.CommCtrl.enable, tag.Size());
10911 }
10912 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HISTSTATSMODE_TAG_ID)) {
10913 char* value = Toupper(tag.Value());
10914 char* value2 = Toupper(tag.Value());
10915 char* value3 = value2;
10916 int i = 0;
10917 while (*value != '\0') {
10918 if (*value == 'R') {
10919 *value2++ = 'R';
10920 i++;
10921 }
10922 else if (*value == 'G') {
10923 *value2++ = 'G';
10924 i++;
10925 }
10926 else if (*value == 'B') {
10927 *value2++ = 'B';
10928 i++;
10929 }
10930 else if (*value == 'Y') {
10931 *value2++ = 'Y';
10932 i++;
10933 }
10934 value++;
10935 }
10936 *value2 = '\0';
10937 std::string s_value(value3);
10938 #ifdef DEBUG_LOG
10939 LOGE("%s(%d): value: %s\n", __FUNCTION__, __LINE__, s_value.c_str());
10940 #endif
10941 if (xmlParseReadWrite == XML_PARSER_READ)
10942 {
10943 if (s_value == CALIB_SENSOR_AEC_HISTSTATSMODE_R) {
10944 aec_tune.CommCtrl.HistStatsMode = CAM_HIST_MODE_R;
10945 }
10946 else if (s_value == CALIB_SENSOR_AEC_HISTSTATSMODE_G) {
10947 aec_tune.CommCtrl.HistStatsMode = CAM_HIST_MODE_G;
10948 }
10949 else if (s_value == CALIB_SENSOR_AEC_HISTSTATSMODE_B) {
10950 aec_tune.CommCtrl.HistStatsMode = CAM_HIST_MODE_B;
10951 }
10952 else if (s_value == CALIB_SENSOR_AEC_HISTSTATSMODE_RGB) {
10953 aec_tune.CommCtrl.HistStatsMode = CAM_HIST_MODE_RGB_COMBINED;
10954 }
10955 else if (s_value == CALIB_SENSOR_AEC_HISTSTATSMODE_Y) {
10956 aec_tune.CommCtrl.HistStatsMode = CAM_HIST_MODE_Y;
10957 }
10958 else {
10959 aec_tune.CommCtrl.HistStatsMode = CAM_HIST_MODE_INVALID;
10960 LOGE("%s(%d): invalid AEC HistStatsMode = %s end\n", __FUNCTION__, __LINE__, s_value.c_str());
10961 }
10962 }
10963 else if (xmlParseReadWrite == XML_PARSER_WRITE)
10964 {
10965 XMLNode *pNode = (XMLNode*)pchild;
10966 switch (aec_tune.CommCtrl.HistStatsMode)
10967 {
10968 case CAM_HIST_MODE_R:
10969 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HISTSTATSMODE_R);
10970 break;
10971 case CAM_HIST_MODE_G:
10972 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HISTSTATSMODE_G);
10973 break;
10974 case CAM_HIST_MODE_B:
10975 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HISTSTATSMODE_B);
10976 break;
10977 case CAM_HIST_MODE_RGB_COMBINED:
10978 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HISTSTATSMODE_RGB);
10979 break;
10980 case CAM_HIST_MODE_Y:
10981 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_HISTSTATSMODE_Y);
10982 break;
10983 default:
10984 pNode->FirstChild()->SetValue("INVALID");
10985 LOGE("%s(%d): (XML Write)invalid AEC HistStatsMode = %d end\n", __FUNCTION__, __LINE__, aec_tune.CommCtrl.HistStatsMode);
10986 break;
10987 }
10988 }
10989
10990 }
10991 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_RAWSTATSMODE_TAG_ID)) {
10992 char* value = Toupper(tag.Value());
10993 char* value2 = Toupper(tag.Value());
10994 char* value3 = value2;
10995 int i = 0;
10996 while (*value != '\0') {
10997 if (*value == 'R') {
10998 *value2++ = 'R';
10999 i++;
11000 }
11001 else if (*value == 'G') {
11002 *value2++ = 'G';
11003 i++;
11004 }
11005 else if (*value == 'B') {
11006 *value2++ = 'B';
11007 i++;
11008 }
11009 else if (*value == 'Y') {
11010 *value2++ = 'Y';
11011 i++;
11012 }
11013 value++;
11014 }
11015 *value2 = '\0';
11016 std::string s_value(value3);
11017 #ifdef DEBUG_LOG
11018 LOGE("%s(%d): value = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
11019 #endif
11020 if (xmlParseReadWrite == XML_PARSER_READ)
11021 {
11022 if (s_value == CALIB_SENSOR_AEC_RAWSTATSMODE_R) {
11023 aec_tune.CommCtrl.RawStatsMode = CAM_RAWSTATS_MODE_R;
11024 }
11025 else if (s_value == CALIB_SENSOR_AEC_RAWSTATSMODE_G) {
11026 aec_tune.CommCtrl.RawStatsMode = CAM_RAWSTATS_MODE_G;
11027 }
11028 else if (s_value == CALIB_SENSOR_AEC_RAWSTATSMODE_B) {
11029 aec_tune.CommCtrl.RawStatsMode = CAM_RAWSTATS_MODE_B;
11030 }
11031 else if (s_value == CALIB_SENSOR_AEC_RAWSTATSMODE_Y) {
11032 aec_tune.CommCtrl.RawStatsMode = CAM_RAWSTATS_MODE_Y;
11033 }
11034 else {
11035 aec_tune.CommCtrl.RawStatsMode = CAM_RAWSTATS_MODE_INVALID;
11036 LOGE("%s(%d): invalid AEC RawStatsMode = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
11037 }
11038 }
11039 else if (xmlParseReadWrite == XML_PARSER_WRITE)
11040 {
11041 XMLNode *pNode = (XMLNode*)pchild;
11042 switch (aec_tune.CommCtrl.RawStatsMode)
11043 {
11044 case CAM_RAWSTATS_MODE_R:
11045 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_RAWSTATSMODE_R);
11046 break;
11047 case CAM_RAWSTATS_MODE_G:
11048 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_RAWSTATSMODE_G);
11049 break;
11050 case CAM_RAWSTATS_MODE_B:
11051 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_RAWSTATSMODE_B);
11052 break;
11053 case CAM_RAWSTATS_MODE_Y:
11054 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_RAWSTATSMODE_Y);
11055 break;
11056 default:
11057 pNode->FirstChild()->SetValue("INVALID");
11058 LOGE("%s(%d): (XML Write)invalid AEC RawStatsMode = %d end\n", __FUNCTION__, __LINE__, aec_tune.CommCtrl.RawStatsMode);
11059 break;
11060 }
11061 }
11062 }
11063 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_YRANGEMODE_TAG_ID)) {
11064 char* value = Toupper(tag.Value());
11065 std::string s_value(value);
11066 if (xmlParseReadWrite == XML_PARSER_READ)
11067 {
11068 if (s_value == CALIB_SENSOR_AEC_YRANGEMODE_FULL) {
11069 aec_tune.CommCtrl.YRangeMode = CAM_YRANGE_MODE_FULL;
11070 }
11071 else if (s_value == CALIB_SENSOR_AEC_YRANGEMODE_LIMITED) {
11072 aec_tune.CommCtrl.YRangeMode = CAM_YRANGE_MODE_LIMITED;
11073 }
11074 else {
11075 aec_tune.CommCtrl.YRangeMode = CAM_YRANGE_MODE_INVALID;
11076 LOGE("%s(%d): invalid AEC YRangeMode = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
11077 }
11078 }
11079 else if (xmlParseReadWrite == XML_PARSER_WRITE)
11080 {
11081 XMLNode *pNode = (XMLNode*)pchild;
11082 if (aec_tune.CommCtrl.YRangeMode == CAM_YRANGE_MODE_FULL) {
11083 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_YRANGEMODE_FULL);
11084 }
11085 else if (aec_tune.CommCtrl.YRangeMode == CAM_YRANGE_MODE_LIMITED) {
11086 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_YRANGEMODE_LIMITED);
11087 }
11088 else {
11089 pNode->FirstChild()->SetValue("Invalid");
11090 LOGE("%s(%d): (XML Write)invalid AEC YRangeMode = %d\n", __FUNCTION__, __LINE__, aec_tune.CommCtrl.YRangeMode);
11091 }
11092 }
11093 }
11094 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECRUNINTERVAL_TAG_ID)) {
11095 ParseUcharArray(pchild, &aec_tune.CommCtrl.AecRunInterval, tag.Size());
11096 }
11097 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECOPTYPE_TAG_ID)) {
11098 char* value = Toupper(tag.Value());
11099 std::string s_value(value);
11100 if (xmlParseReadWrite == XML_PARSER_READ)
11101 {
11102 if (s_value == CALIB_SENSOR_AEC_AECOPTYPE_AUTO) {
11103 aec_tune.CommCtrl.AecOpType = RK_AIQ_OP_MODE_AUTO;
11104 }
11105 else if (s_value == CALIB_SENSOR_AEC_AECOPTYPE_MANUAL) {
11106 aec_tune.CommCtrl.AecOpType = RK_AIQ_OP_MODE_MANUAL;
11107 }
11108 else {
11109 aec_tune.CommCtrl.AecOpType = RK_AIQ_OP_MODE_INVALID;
11110 LOGE("%s(%d): invalid AEC AecOpType = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
11111 }
11112 }
11113 else if (xmlParseReadWrite == XML_PARSER_WRITE)
11114 {
11115 XMLNode *pNode = (XMLNode*)pchild;
11116 if (aec_tune.CommCtrl.AecOpType == RK_AIQ_OP_MODE_AUTO) {
11117 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_AECOPTYPE_AUTO);
11118 }
11119 else if (aec_tune.CommCtrl.AecOpType == RK_AIQ_OP_MODE_MANUAL) {
11120 pNode->FirstChild()->SetValue(CALIB_SENSOR_AEC_AECOPTYPE_MANUAL);
11121 }
11122 else {
11123 pNode->FirstChild()->SetValue("Invalid");
11124 LOGE("%s(%d): (XML Write)invalid AEC AecOpType = %d\n", __FUNCTION__, __LINE__, aec_tune.CommCtrl.AecOpType);
11125 }
11126
11127 }
11128 }
11129 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_SYNCTEST_TAG_ID)) {
11130 if (!parseEntrySensorAecSyncTestV21(pchild->ToElement(), &aec_tune.CommCtrl.stSyncTest)) {
11131 LOGE("parse error in Aec (%s)", tagname.c_str());
11132 return (false);
11133 }
11134 }
11135 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECSPEED_TAG_ID)) {
11136 if (!parseEntrySensorAecSpeedV21(pchild->ToElement(), &aec_tune.CommCtrl.stAuto.stAeSpeed)) {
11137 LOGE("parse error in Aec (%s)", tagname.c_str());
11138 return (false);
11139 }
11140 }
11141 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDELAYFRMNUM_TAG_ID)) {
11142 if (!parseEntrySensorAecDelayFrmNumV21(pchild->ToElement(), &aec_tune.CommCtrl.stAuto)) {
11143 LOGE("parse error in Aec (%s)", tagname.c_str(), &aec_tune.CommCtrl.stAuto);
11144 return (false);
11145 }
11146 }
11147 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECDNSWITCH_TAG_ID)) {
11148 if (!parseEntrySensorAecDNSwitchV21(pchild->ToElement(), &aec_tune.CommCtrl.stDNSwitch)) {
11149 LOGE("parse error in Aec (%s)", tagname.c_str());
11150 return (false);
11151 }
11152 }
11153 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_ANTIFLICKER_TAG_ID)) {
11154 if (!parseEntrySensorAecAntiFlickerV21(pchild->ToElement(), &aec_tune.CommCtrl.stAntiFlicker)) {
11155 LOGE("parse error in Aec (%s)", tagname.c_str());
11156 return (false);
11157 }
11158 }
11159 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECFRAMERATEMODE_TAG_ID)) {
11160 if (!parseEntrySensorAecFrameRateModeV21(pchild->ToElement(), &aec_tune.CommCtrl.stAuto.stFrmRate)) {
11161 LOGE("parse error in Aec (%s)", tagname.c_str());
11162 return (false);
11163 }
11164 }
11165 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECINITVALUE_TAG_ID)) {
11166 if (!parseEntrySensorAecInitValueV21(pchild->ToElement(), &aec_tune.CommCtrl.stInitExp)) {
11167 LOGE("parse error in Aec (%s)", tagname.c_str());
11168 return (false);
11169 }
11170 }
11171 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECGRIDWEIGHT_TAG_ID)) {
11172 int no = ParseUcharArray(pchild, aec_tune.CommCtrl.GridWeights, tag.Size());
11173 DCT_ASSERT((no == tag.Size()));
11174 }
11175 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_IRISCTRL_TAG_ID)) {
11176 if (!parseEntrySensorAecIrisCtrlV21(pchild->ToElement(), &aec_tune.CommCtrl.stIris)) {
11177 LOGE("parse error in Aec (%s)", tagname.c_str());
11178 return (false);
11179 }
11180 }
11181 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_MANUALCTRL_TAG_ID)) {
11182 if (!parseEntrySensorAecManualCtrlV21(pchild->ToElement(), &aec_tune.CommCtrl.stManual)) {
11183 LOGE("parse error in Aec (%s)", tagname.c_str());
11184 return (false);
11185 }
11186 }
11187 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_AECROUTE_TAG_ID)) {
11188 if (!parseEntrySensorAecRouteV21(pchild->ToElement(), &aec_tune.CommCtrl.stAeRoute)) {
11189 LOGE("parse error in Aec (%s)", tagname.c_str());
11190 return (false);
11191 }
11192 }
11193 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_LINEARAE_CTRL_TAG_ID)) {
11194 if (!parseEntrySensorLinearAECtrlV21(pchild->ToElement(), &aec_tune.LinearAeCtrl)) {
11195 LOGE("parse error in Aec (%s)", tagname.c_str());
11196 return (false);
11197 }
11198 }
11199 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_HDRAECTRL_TAG_ID)) {
11200 if (!parseEntrySensorHdrAECtrlV21(pchild->ToElement(), &aec_tune.HdrAeCtrl)) {
11201 LOGE("parse error in Aec (%s)", tagname.c_str());
11202 return (false);
11203 }
11204 }
11205 else {
11206 LOGE("parse error in AEC section (unknow tag:%s)", tagname.c_str());
11207 return (false);
11208 }
11209
11210 pchild = pchild->NextSibling();
11211 }
11212
11213 if (xmlParseReadWrite == XML_PARSER_READ) {
11214 ret = AddAecTuneProfile2AecTuneList(paec_tune_list, &aec_tune);
11215 DCT_ASSERT(ret == true);
11216 }
11217
11218 XML_CHECK_END();
11219 autoTabBackward();
11220 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
11221 return (true);
11222 }
parseEntrySensorAecV21(const XMLElement * pelement,void * param)11223 bool RkAiqCalibParser::parseEntrySensorAecV21
11224 (
11225 const XMLElement* pelement,
11226 void* param
11227 ) {
11228 (void)param;
11229
11230 LOGI("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
11231 autoTabForward();
11232
11233 XML_CHECK_START(CALIB_SENSOR_AEC_V21_TAG_ID, CALIB_SENSOR_TAG_ID);
11234
11235 const XMLNode* pchild = pelement->FirstChild();
11236 while (pchild) {
11237 XmlTag tag = XmlTag(pchild->ToElement());
11238 std::string tagname(pchild->ToElement()->Name());
11239 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
11240
11241 #ifdef DEBUG_LOG
11242 LOGE("%s(%d): tagname: [%s]\n", __FUNCTION__, __LINE__, tagname.c_str());
11243 #endif
11244
11245 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_CALIBPARA_TAG_ID)) {
11246 CALIBDB_MODULE_PTR_HELPER_CON(list_head, ae_calib_para);
11247 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
11248 &RkAiqCalibParser::parseEntrySensorAecCalibPara,
11249 ae_calib_para,
11250 (uint32_t)CALIB_SENSOR_AEC_V21_CALIBPARA_TAG_ID,
11251 (uint32_t)CALIB_SENSOR_AEC_V21_TAG_ID)) {
11252 LOGE("parse error in AEC CalibPara(%s)", tagname.c_str());
11253 return (false);
11254 }
11255 }
11256 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID)) {
11257 CALIBDB_MODULE_PTR_HELPER_CON(list_head, ae_tuning_para);
11258 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
11259 &RkAiqCalibParser::parseEntrySensorAecTunePara,
11260 ae_tuning_para,
11261 (uint32_t)CALIB_SENSOR_AEC_V21_TUNEPARA_TAG_ID,
11262 (uint32_t)CALIB_SENSOR_AEC_V21_TAG_ID)) {
11263 LOGE("parse error in AEC TunePara(%s)", tagname.c_str());
11264 return (false);
11265 }
11266
11267 }
11268 else {
11269 LOGE("parse error in AEC section (unknow tag:%s)", tagname.c_str());
11270 return (false);
11271 }
11272
11273 pchild = pchild->NextSibling();
11274 }
11275
11276 XML_CHECK_END();
11277
11278 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
11279 autoTabBackward();
11280
11281 return (true);
11282 }
11283
11284 //sensorinfo
parseEntrySensorInfoGainRange(const XMLElement * pelement,void * param)11285 bool RkAiqCalibParser::parseEntrySensorInfoGainRange
11286 (
11287 const XMLElement* pelement,
11288 void* param
11289 ) {
11290 (void)param;
11291
11292 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
11293 autoTabForward();
11294
11295 XML_CHECK_START(CALIB_SENSOR_SENSORINFO_GAINRANGE_TAG_ID, CALIB_SENSOR_SENSORINFO_TAG_ID);
11296
11297 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Sensor_Para_t, sensor);
11298
11299 const XMLNode* pthrdsubchild = pelement->FirstChild();
11300 while (pthrdsubchild) {
11301 XmlTag secsubTag = XmlTag(pthrdsubchild->ToElement());
11302 const char* value = secsubTag.Value();
11303 std::string secsubTagname(pthrdsubchild->ToElement()->Name());
11304 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
11305 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_GAINRANGE_ISLINEAR_TAG_ID)) {
11306 uint8_t tempVal = sensor->GainRange.IsLinear;
11307 int no = ParseUcharArray(pthrdsubchild, &tempVal, 1);
11308 sensor->GainRange.IsLinear = (tempVal == 0 ? false : true);
11309 DCT_ASSERT((no == secsubTag.Size()));
11310 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_GAINRANGE_LINEAR_TAG_ID)) {
11311 if (xmlParseReadWrite == XML_PARSER_READ) {
11312 int i = secsubTag.Size();
11313 int no = ParseFloatArray(pthrdsubchild, sensor->GainRange.pGainRange, i);
11314 DCT_ASSERT((no == secsubTag.Size()));
11315 DCT_ASSERT((no <= CALD_AEC_GAIN_RANGE_MAX_LEN));
11316 DCT_ASSERT(((i % 7) == 0));
11317 sensor->GainRange.array_size = i;
11318 }
11319 else if (xmlParseReadWrite == XML_PARSER_WRITE) {
11320 char str[10];
11321 int i = sensor->GainRange.array_size;
11322 DCT_ASSERT(((i % 7) == 0));
11323 snprintf(str, sizeof(str), "[%u 7]", (i / 7));
11324 XMLElement* pElement = (((XMLNode*)pthrdsubchild)->ToElement());
11325 pElement->SetAttribute(CALIB_ATTRIBUTE_SIZE, str);
11326 int no = ParseFloatArray(pthrdsubchild, sensor->GainRange.pGainRange, i);
11327 DCT_ASSERT((no <= CALD_AEC_GAIN_RANGE_MAX_LEN));
11328 }
11329 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_GAINRANGE_NONLINEAR_TAG_ID)) {
11330 char* value = Toupper(secsubTag.Value());
11331 std::string s_value(value);
11332 if (xmlParseReadWrite == XML_PARSER_READ)
11333 {
11334 if (s_value == CALIB_SENSOR_SENSORINFO_GAINRANGE_NONLINEAR_DB) {
11335 sensor->GainRange.GainMode = RKAIQ_EXPGAIN_MODE_NONLINEAR_DB;
11336 }
11337 else {
11338 sensor->GainRange.GainMode = RKAIQ_EXPGAIN_MODE_NONLINEAR_DB;
11339 LOGE("%s(%d): invalid GainRange Mode = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
11340 }
11341 }
11342 else if (xmlParseReadWrite == XML_PARSER_WRITE)
11343 {
11344 XMLNode *pNode = (XMLNode*)pthrdsubchild;
11345 if (sensor->GainRange.GainMode == RKAIQ_EXPGAIN_MODE_NONLINEAR_DB) {
11346 pNode->FirstChild()->SetValue(CALIB_SENSOR_SENSORINFO_GAINRANGE_NONLINEAR_DB);
11347 }
11348 else {
11349 pNode->FirstChild()->SetValue("Invalid");
11350 LOGE("%s(%d): (XML Write)invalid GainRange Mode = %d\n", __FUNCTION__, __LINE__, sensor->GainRange.GainMode);
11351 }
11352 }
11353 }
11354 pthrdsubchild = pthrdsubchild->NextSibling();
11355 }
11356
11357 const XMLNode* pchild = pelement->FirstChild();
11358
11359
11360 XML_CHECK_END();
11361
11362 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
11363 autoTabBackward();
11364 return (true);
11365 }
11366
parseEntrySensorInfo(const XMLElement * pelement,void * param)11367 bool RkAiqCalibParser::parseEntrySensorInfo
11368 (
11369 const XMLElement* pelement,
11370 void* param
11371 ) {
11372 (void)param;
11373
11374 LOGI("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
11375 autoTabForward();
11376
11377 XML_CHECK_START(CALIB_SENSOR_SENSORINFO_TAG_ID, CALIB_SENSOR_TAG_ID);
11378
11379 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Sensor_Para_t, sensor);
11380
11381 const XMLNode* pchild = pelement->FirstChild();
11382 while (pchild) {
11383 XmlTag tag = XmlTag(pchild->ToElement());
11384 std::string tagname(pchild->ToElement()->Name());
11385 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
11386 #ifdef DEBUG_LOG
11387 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, tagname.c_str());
11388 #endif
11389 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_GAINRANGE_TAG_ID)) {
11390 if (!parseEntrySensorInfoGainRange(pchild->ToElement())) {
11391 LOGE("parse error in SensorInfo GainRange (%s)", tagname.c_str());
11392 return (false);
11393 }
11394 }
11395 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_TIMEFACTOR_TAG_ID)) {
11396 int i = (sizeof(sensor->TimeFactor) / sizeof(sensor->TimeFactor[0]));
11397 int no = ParseFloatArray(pchild, sensor->TimeFactor, i);
11398 DCT_ASSERT((no == tag.Size()));
11399 }
11400 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISHDRTIMEREG_SUMFAC_TAG_ID)) {
11401 int i = (sizeof(sensor->CISHdrTimeRegSumFac) / sizeof(sensor->CISHdrTimeRegSumFac.fCoeff[0]));
11402 int no = ParseFloatArray(pchild, sensor->CISHdrTimeRegSumFac.fCoeff, i);
11403 DCT_ASSERT((no == tag.Size()));
11404 }
11405 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISLINTIMEREG_MAXFAC_TAG_ID)) {
11406 int i = (sizeof(sensor->CISLinTimeRegMaxFac) / sizeof(sensor->CISLinTimeRegMaxFac.fCoeff[0]));
11407 int no = ParseFloatArray(pchild, sensor->CISLinTimeRegMaxFac.fCoeff, i);
11408 DCT_ASSERT((no == tag.Size()));
11409 }
11410 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISTIMEREG_ODEVITY_TAG_ID)) {
11411 int i = (sizeof(sensor->CISTimeRegOdevity) / sizeof(sensor->CISTimeRegOdevity.fCoeff[0]));
11412 int no = ParseFloatArray(pchild, sensor->CISTimeRegOdevity.fCoeff, i);
11413 DCT_ASSERT((no == tag.Size()));
11414 }
11415 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISHDRTIMEREG_ODEVITY_TAG_ID)) {
11416 int i = (sizeof(sensor->CISHdrTimeRegOdevity) / sizeof(sensor->CISHdrTimeRegOdevity.fCoeff[0]));
11417 int no = ParseFloatArray(pchild, sensor->CISHdrTimeRegOdevity.fCoeff, i);
11418 DCT_ASSERT((no == tag.Size()));
11419 }
11420 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISTIMEREG_MIN_TAG_ID)) {
11421 int no = ParseUshortArray(pchild, &sensor->CISTimeRegMin, 1);
11422 DCT_ASSERT((no == tag.Size()));
11423 }
11424 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISHDRTIMEREG_MIN_TAG_ID)) {
11425 int no = ParseUshortArray(pchild, &sensor->CISHdrTimeRegMin, 1);
11426 DCT_ASSERT((no == tag.Size()));
11427 }
11428 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISHDRTIMEREG_MAX_TAG_ID)) {
11429 int i = (sizeof(sensor->CISHdrTimeRegMax) / sizeof(sensor->CISHdrTimeRegMax.Coeff[0]));
11430 int no = ParseShortArray(pchild, sensor->CISHdrTimeRegMax.Coeff, i);
11431 DCT_ASSERT((no == tag.Size()));
11432 }
11433 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISTIMEREG_UNEQUALEN_TAG_ID)) {
11434 int no = ParseUcharArray(pchild, &sensor->CISTimeRegUnEqualEn, 1);
11435 DCT_ASSERT((no == tag.Size()));
11436 }
11437 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISMINFPS_TAG_ID)) {
11438 int no = ParseFloatArray(pchild, &sensor->CISMinFps, 1);
11439 DCT_ASSERT((no == tag.Size()));
11440 }
11441 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISAGAIN_RANGE_TAG_ID)) {
11442 float tempVal[2] = { sensor->CISAgainRange.Min, sensor->CISAgainRange.Max };
11443 int no = ParseFloatArray(pchild, tempVal, tag.Size());
11444 DCT_ASSERT((no == tag.Size()));
11445 sensor->CISAgainRange.Min = tempVal[0];
11446 sensor->CISAgainRange.Max = tempVal[1];
11447 }
11448 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISEXTRAAGAIN_RANGE_TAG_ID)) {
11449 float tempVal[2] = { sensor->CISExtraAgainRange.Min, sensor->CISExtraAgainRange.Max };
11450 int no = ParseFloatArray(pchild, tempVal, tag.Size());
11451 DCT_ASSERT((no == tag.Size()));
11452 sensor->CISExtraAgainRange.Min = tempVal[0];
11453 sensor->CISExtraAgainRange.Max = tempVal[1];
11454 }
11455 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISDGAIN_RANGE_TAG_ID)) {
11456 float tempVal[2] = { sensor->CISDgainRange.Min, sensor->CISDgainRange.Max };
11457 int no = ParseFloatArray(pchild, tempVal, tag.Size());
11458 DCT_ASSERT((no == tag.Size()));
11459 sensor->CISDgainRange.Min = tempVal[0];
11460 sensor->CISDgainRange.Max = tempVal[1];
11461 }
11462 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISISPDGAIN_RANGE_TAG_ID)) {
11463 float tempVal[2] = { sensor->CISIspDgainRange.Min, sensor->CISIspDgainRange.Max };
11464 int no = ParseFloatArray(pchild, tempVal, tag.Size());
11465 DCT_ASSERT((no == tag.Size()));
11466 sensor->CISIspDgainRange.Min = tempVal[0];
11467 sensor->CISIspDgainRange.Max = tempVal[1];
11468 }
11469 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORINFO_CISHDRGAININDSETEN_TAG_ID)) {
11470 int no = ParseUcharArray(pchild, &sensor->CISHdrGainIndSetEn, tag.Size());
11471 DCT_ASSERT((no == tag.Size()));
11472 }
11473 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SENSORSETTING_FLIP_ID)) {
11474 unsigned char flip = sensor->flip;
11475 int no = ParseUcharArray(pchild, &flip, tag.Size());
11476 DCT_ASSERT((no == tag.Size()));
11477 sensor->flip = flip;
11478 }
11479 else {
11480 redirectOut
11481 << "parse error in SensorInfo section (unknow tag: "
11482 << tagname
11483 << ")"
11484 << std::endl;
11485 }
11486 pchild = pchild->NextSibling();
11487 }
11488 XML_CHECK_END();
11489 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
11490 autoTabBackward();
11491 return (true);
11492 }
11493
11494
parseEntrySensorModuleInfo(const XMLElement * pelement,void * param)11495 bool RkAiqCalibParser::parseEntrySensorModuleInfo
11496 (
11497 const XMLElement* pelement,
11498 void* param
11499 ) {
11500 (void)param;
11501
11502 LOGI("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
11503 autoTabForward();
11504
11505 XML_CHECK_START(CALIB_SENSOR_MODULEINFO_TAG_ID, CALIB_SENSOR_TAG_ID);
11506
11507 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Module_Info_t, module);
11508
11509 const XMLNode* pchild = pelement->FirstChild();
11510 while (pchild) {
11511 XmlTag tag = XmlTag(pchild->ToElement());
11512 std::string tagname(pchild->ToElement()->Name());
11513 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
11514 #ifdef DEBUG_LOG
11515 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, tagname.c_str());
11516 #endif
11517 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MODULEINFO_FNUMBER_TAG_ID)) {
11518 int no = ParseFloatArray(pchild, &module->FNumber, 1);
11519 DCT_ASSERT((no == tag.Size()));
11520 }
11521 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MODULEINFO_EFL_TAG_ID)) {
11522 int no = ParseFloatArray(pchild, &module->EFL, 1);
11523 DCT_ASSERT((no == tag.Size()));
11524 }
11525 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MODULEINFO_LENS_TRANSMITTANCE_TAG_ID)) {
11526 int no = ParseFloatArray(pchild, &module->LensT, 1);
11527 DCT_ASSERT((no == tag.Size()));
11528 }
11529 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MODULEINFO_IRCUT_TRANSMITTANCE_TAG_ID)) {
11530 int no = ParseFloatArray(pchild, &module->IRCutT, 1);
11531 DCT_ASSERT((no == tag.Size()));
11532 }
11533 else {
11534 redirectOut
11535 << "parse error in ModuleInfo section (unknow tag: "
11536 << tagname
11537 << ")"
11538 << std::endl;
11539 }
11540 pchild = pchild->NextSibling();
11541 }
11542 XML_CHECK_END();
11543 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
11544 autoTabBackward();
11545 return (true);
11546 }
11547
parseEntrySensorAhdrMerge(const XMLElement * pelement,void * param)11548 bool RkAiqCalibParser::parseEntrySensorAhdrMerge
11549 (
11550 const XMLElement* pelement,
11551 void* param
11552 ) {
11553 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
11554 autoTabForward();
11555
11556 XML_CHECK_START(CALIB_SENSOR_AHDR_MERGE_TAG_ID, CALIB_SENSOR_TAG_ID);
11557
11558 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Amerge_Para_t, amerge);
11559
11560 const XMLNode* pchild = pelement->FirstChild();
11561 while (pchild) {
11562 XmlTag tag = XmlTag(pchild->ToElement());
11563 std::string Tagname(pchild->ToElement()->Name());
11564 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
11565
11566 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_ENVLV_TAG_ID)) {
11567 int no = ParseFloatArray(pchild, amerge->envLevel, tag.Size());
11568 DCT_ASSERT((no == tag.Size()));
11569 }
11570 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_MERGE_OECURVE_SMOOTH_TAG_ID)) {
11571 int no = ParseFloatArray(pchild, amerge->oeCurve_smooth, tag.Size());
11572 DCT_ASSERT((no == tag.Size()));
11573 }
11574 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_MERGE_OECURVE_OFFSET_TAG_ID)) {
11575 int no = ParseFloatArray(pchild, amerge->oeCurve_offset, tag.Size());
11576 DCT_ASSERT((no == tag.Size()));
11577 }
11578 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_MERGE_MOVECOEF_TAG_ID)) {
11579 int no = ParseFloatArray(pchild, amerge->moveCoef, tag.Size());
11580 DCT_ASSERT((no == tag.Size()));
11581 }
11582 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_MERGE_MDCURVELM_SMOOTH_TAG_ID)) {
11583 int no = ParseFloatArray(pchild, amerge->mdCurveLm_smooth, tag.Size());
11584 DCT_ASSERT((no == tag.Size()));
11585 }
11586 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_MERGE_MDCURVELM_OFFSET_TAG_ID)) {
11587 int no = ParseFloatArray(pchild, amerge->mdCurveLm_offset, tag.Size());
11588 DCT_ASSERT((no == tag.Size()));
11589 }
11590 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_MERGE_MDCURVEMS_SMOOTH_TAG_ID)) {
11591 int no = ParseFloatArray(pchild, amerge->mdCurveMs_smooth, tag.Size());
11592 DCT_ASSERT((no == tag.Size()));
11593 }
11594 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_MERGE_MDCURVEMS_OFFSET_TAG_ID)) {
11595 int no = ParseFloatArray(pchild, amerge->mdCurveMs_offset, tag.Size());
11596 DCT_ASSERT((no == tag.Size()));
11597 }
11598 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_MERGE_OECURVE_DAMP_TAG_ID)) {
11599 int no = ParseFloatArray(pchild, &amerge->oeCurve_damp, tag.Size());
11600 DCT_ASSERT((no == tag.Size()));
11601 }
11602 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_MERGE_MDCURVELM_DAMP_TAG_ID)) {
11603 int no = ParseFloatArray(pchild, &amerge->mdCurveLm_damp, tag.Size());
11604 DCT_ASSERT((no == tag.Size()));
11605 }
11606 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_MERGE_MDCURVEMS_DAMP_TAG_ID)) {
11607 int no = ParseFloatArray(pchild, &amerge->mdCurveMs_damp, tag.Size());
11608 DCT_ASSERT((no == tag.Size()));
11609 }
11610 pchild = pchild->NextSibling();
11611 }
11612 XML_CHECK_END();
11613
11614 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
11615 autoTabBackward();
11616 return (true);
11617 }
11618
parseEntrySensorAhdrTmo(const XMLElement * pelement,void * param)11619 bool RkAiqCalibParser::parseEntrySensorAhdrTmo
11620 (
11621 const XMLElement* pelement,
11622 void* param
11623 ) {
11624 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
11625 autoTabForward();
11626
11627 XML_CHECK_START(CALIB_SENSOR_AHDR_TMO_TAG_ID, CALIB_SENSOR_TAG_ID);
11628
11629 const XMLNode* pchild = pelement->FirstChild();
11630 while (pchild) {
11631 XmlTag tag = XmlTag(pchild->ToElement());
11632 std::string tagname(pchild->ToElement()->Name());
11633 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
11634
11635 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_TMO_EN_TAG_ID)) {
11636 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
11637 &RkAiqCalibParser::parseEntrySensorAhdrTmoEn,
11638 param,
11639 (uint32_t)CALIB_SENSOR_AHDR_TMO_TMO_EN_TAG_ID,
11640 (uint32_t)CALIB_SENSOR_AHDR_TMO_TAG_ID)) {
11641 LOGE("parse error in TMO GlobalLuma Setting (%s)", tagname.c_str());
11642 return (false);
11643 }
11644 }
11645 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_GLOBALLUMA_TAG_ID)) {
11646 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
11647 &RkAiqCalibParser::parseEntrySensorAhdrTmoGlobalLuma,
11648 param,
11649 (uint32_t)CALIB_SENSOR_AHDR_TMO_GLOBALLUMA_TAG_ID,
11650 (uint32_t)CALIB_SENSOR_AHDR_TMO_TAG_ID)) {
11651 LOGE("parse error in TMO GlobalLuma Setting (%s)", tagname.c_str());
11652 return (false);
11653 }
11654 }
11655 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_DETAILSHIGHLIGHT_TAG_ID)) {
11656 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
11657 &RkAiqCalibParser::parseEntrySensorAhdrTmoDetailsHighLight,
11658 param,
11659 (uint32_t)CALIB_SENSOR_AHDR_TMO_DETAILSHIGHLIGHT_TAG_ID,
11660 (uint32_t)CALIB_SENSOR_AHDR_TMO_TAG_ID)) {
11661 LOGE("parse error in TMO DetailsHighLight Setting (%s)", tagname.c_str());
11662 return (false);
11663 }
11664 }
11665 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_DETAILSLOWLIGHT_TAG_ID)) {
11666 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
11667 &RkAiqCalibParser::parseEntrySensorAhdrTmoDetailsLowLight,
11668 param,
11669 (uint32_t)CALIB_SENSOR_AHDR_TMO_DETAILSLOWLIGHT_TAG_ID,
11670 (uint32_t)CALIB_SENSOR_AHDR_TMO_TAG_ID)) {
11671 LOGE("parse error in TMO DetailsLowLight Setting (%s)", tagname.c_str());
11672 return (false);
11673 }
11674 }
11675 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_GLOBALTMO_TAG_ID)) {
11676 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
11677 &RkAiqCalibParser::parseEntrySensorAhdrGlobalTMO,
11678 param,
11679 (uint32_t)CALIB_SENSOR_AHDR_TMO_GLOBALTMO_TAG_ID,
11680 (uint32_t)CALIB_SENSOR_AHDR_TMO_TAG_ID)) {
11681 LOGE("parse error in TMO GlobalTMO Setting (%s)", tagname.c_str());
11682 return (false);
11683 }
11684 }
11685 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_LOCALTMO_TAG_ID)) {
11686 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
11687 &RkAiqCalibParser::parseEntrySensorAhdrLocalTMO,
11688 param,
11689 (uint32_t)CALIB_SENSOR_AHDR_TMO_LOCALTMO_TAG_ID,
11690 (uint32_t)CALIB_SENSOR_AHDR_TMO_TAG_ID)) {
11691 LOGE("parse error in TMO LocalTMO Setting (%s)", tagname.c_str());
11692 return (false);
11693 }
11694 }
11695 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_DAMP_TAG_ID)) {
11696 CALIBDB_MODULE_PTR_HELPER_CON(CalibDb_Atmo_Para_t, atmo);
11697 int no = ParseFloatArray(pchild, &atmo->damp, tag.Size());
11698 DCT_ASSERT((no == tag.Size()));
11699 }
11700
11701 pchild = pchild->NextSibling();
11702 }
11703
11704 XML_CHECK_END();
11705
11706 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
11707 autoTabBackward();
11708 return (true);
11709 }
11710
parseEntrySensorAhdrTmoEn(const XMLElement * pelement,void * param)11711 bool RkAiqCalibParser::parseEntrySensorAhdrTmoEn
11712 (
11713 const XMLElement* pelement,
11714 void* param
11715 ) {
11716 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
11717
11718 XML_CHECK_START(CALIB_SENSOR_AHDR_TMO_TMO_EN_TAG_ID, CALIB_SENSOR_AHDR_TMO_TAG_ID);
11719 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Atmo_Para_t, atmo);
11720 int index = *((int*)param);
11721 const XMLNode* pchild = pelement->FirstChild();
11722 while (pchild) {
11723 XmlTag tag = XmlTag(pchild->ToElement());
11724 const char* value = tag.Value();
11725 std::string tagname(pchild->ToElement()->Name());
11726 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
11727
11728 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_NAME_TAG_ID)) {
11729 ParseString(pchild, atmo->en[index].name, sizeof(atmo->en[index].name));
11730 }
11731 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_TMO_EN_CELL_EN_TAG_ID)) {
11732 int no = ParseFloatArray(pchild, &atmo->en[index].en, tag.Size());
11733 DCT_ASSERT((no == tag.Size()));
11734 }
11735
11736 pchild = pchild->NextSibling();
11737 }
11738 XML_CHECK_END();
11739 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
11740 return (true);
11741 }
11742
parseEntrySensorAhdrTmoGlobalLuma(const XMLElement * pelement,void * param)11743 bool RkAiqCalibParser::parseEntrySensorAhdrTmoGlobalLuma
11744 (
11745 const XMLElement* pelement,
11746 void* param
11747 ) {
11748 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
11749
11750 XML_CHECK_START(CALIB_SENSOR_AHDR_TMO_GLOBALLUMA_TAG_ID, CALIB_SENSOR_AHDR_TMO_TAG_ID);
11751 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Atmo_Para_t, atmo);
11752 int index = *((int*)param);
11753 const XMLNode* pchild = pelement->FirstChild();
11754 while (pchild) {
11755 XmlTag tag = XmlTag(pchild->ToElement());
11756 const char* value = tag.Value();
11757 std::string tagname(pchild->ToElement()->Name());
11758 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
11759
11760 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_NAME_TAG_ID)) {
11761 ParseString(pchild, atmo->luma[index].name, sizeof(atmo->luma[index].name));
11762 }
11763 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_GLOBALLUMAMODE_TAG_ID)) {
11764 int no = ParseFloatArray(pchild, &atmo->luma[index].GlobalLumaMode, tag.Size());
11765 DCT_ASSERT((no == tag.Size()));
11766 }
11767 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_ENVLV_TAG_ID)) {
11768 int no = ParseFloatArray(pchild, atmo->luma[index].envLevel, tag.Size());
11769 DCT_ASSERT((no == tag.Size()));
11770 }
11771 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_ISO_TAG_ID)) {
11772 int no = ParseFloatArray(pchild, atmo->luma[index].ISO, tag.Size());
11773 DCT_ASSERT((no == tag.Size()));
11774 }
11775 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TOLERANCE_TAG_ID)) {
11776 int no = ParseFloatArray(pchild, &atmo->luma[index].Tolerance, tag.Size());
11777 DCT_ASSERT((no == tag.Size()));
11778 }
11779 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_GLOBALLUMA_GLOBALLUMA_TAG_ID)) {
11780 int no = ParseFloatArray(pchild, atmo->luma[index].globalLuma, tag.Size());
11781 DCT_ASSERT((no == tag.Size()));
11782 }
11783
11784 pchild = pchild->NextSibling();
11785 }
11786 XML_CHECK_END();
11787 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
11788 return (true);
11789 }
11790
parseEntrySensorAhdrTmoDetailsHighLight(const XMLElement * pelement,void * param)11791 bool RkAiqCalibParser::parseEntrySensorAhdrTmoDetailsHighLight
11792 (
11793 const XMLElement* pelement,
11794 void* param
11795 ) {
11796 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
11797
11798 XML_CHECK_START(CALIB_SENSOR_AHDR_TMO_DETAILSHIGHLIGHT_TAG_ID, CALIB_SENSOR_AHDR_TMO_TAG_ID);
11799 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Atmo_Para_t, atmo);
11800 int index = *((int*)param);
11801 const XMLNode* pchild = pelement->FirstChild();
11802 while (pchild) {
11803 XmlTag tag = XmlTag(pchild->ToElement());
11804 const char* value = tag.Value();
11805 std::string tagname(pchild->ToElement()->Name());
11806 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
11807
11808 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_NAME_TAG_ID)) {
11809 ParseString(pchild, atmo->HighLight[index].name, sizeof(atmo->HighLight[index].name));
11810 }
11811 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_DETAILSHIGHLIGHTMODE_TAG_ID)) {
11812 int no = ParseFloatArray(pchild, &atmo->HighLight[index].DetailsHighLightMode, tag.Size());
11813 DCT_ASSERT((no == tag.Size()));
11814 }
11815 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_OEPDF_TAG_ID)) {
11816 int no = ParseFloatArray(pchild, atmo->HighLight[index].OEPdf, tag.Size());
11817 DCT_ASSERT((no == tag.Size()));
11818 }
11819 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_ENVLV_TAG_ID)) {
11820 int no = ParseFloatArray(pchild, atmo->HighLight[index].EnvLv, tag.Size());
11821 DCT_ASSERT((no == tag.Size()));
11822 }
11823 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TOLERANCE_TAG_ID)) {
11824 int no = ParseFloatArray(pchild, &atmo->HighLight[index].Tolerance, tag.Size());
11825 DCT_ASSERT((no == tag.Size()));
11826 }
11827 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_DETAILSHIGHLIGHT_DETAILSHIGHLIGHT_TAG_ID)) {
11828 int no = ParseFloatArray(pchild, atmo->HighLight[index].detailsHighLight, tag.Size());
11829 DCT_ASSERT((no == tag.Size()));
11830 }
11831
11832 pchild = pchild->NextSibling();
11833 }
11834 XML_CHECK_END();
11835 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
11836 return (true);
11837 }
11838
parseEntrySensorAhdrTmoDetailsLowLight(const XMLElement * pelement,void * param)11839 bool RkAiqCalibParser::parseEntrySensorAhdrTmoDetailsLowLight
11840 (
11841 const XMLElement* pelement,
11842 void* param
11843 ) {
11844 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
11845
11846 XML_CHECK_START(CALIB_SENSOR_AHDR_TMO_DETAILSLOWLIGHT_TAG_ID, CALIB_SENSOR_AHDR_TMO_TAG_ID);
11847 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Atmo_Para_t, atmo);
11848 int index = *((int*)param);
11849 const XMLNode* pchild = pelement->FirstChild();
11850 while (pchild) {
11851 XmlTag tag = XmlTag(pchild->ToElement());
11852 const char* value = tag.Value();
11853 std::string tagname(pchild->ToElement()->Name());
11854 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
11855
11856 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_NAME_TAG_ID)) {
11857 ParseString(pchild, atmo->LowLight[index].name, sizeof(atmo->LowLight[index].name));
11858 }
11859 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_DETAILSLOWLIGHTMODE_TAG_ID)) {
11860 int no = ParseFloatArray(pchild, &atmo->LowLight[index].DetailsLowLightMode, tag.Size());
11861 DCT_ASSERT((no == tag.Size()));
11862 }
11863 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_FOCUSLUMA_TAG_ID)) {
11864 int no = ParseFloatArray(pchild, atmo->LowLight[index].FocusLuma, tag.Size());
11865 DCT_ASSERT((no == tag.Size()));
11866 }
11867 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_DARKPDF_TAG_ID)) {
11868 int no = ParseFloatArray(pchild, atmo->LowLight[index].DarkPdf, tag.Size());
11869 DCT_ASSERT((no == tag.Size()));
11870 }
11871 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_ISO_TAG_ID)) {
11872 int no = ParseFloatArray(pchild, atmo->LowLight[index].ISO, tag.Size());
11873 DCT_ASSERT((no == tag.Size()));
11874 }
11875 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TOLERANCE_TAG_ID)) {
11876 int no = ParseFloatArray(pchild, &atmo->LowLight[index].Tolerance, tag.Size());
11877 DCT_ASSERT((no == tag.Size()));
11878 }
11879 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_DETAILSLOWLIGHT_DETAILSLOWLIGHT_TAG_ID)) {
11880 int no = ParseFloatArray(pchild, atmo->LowLight[index].detailsLowLight, tag.Size());
11881 DCT_ASSERT((no == tag.Size()));
11882 }
11883
11884 pchild = pchild->NextSibling();
11885 }
11886 XML_CHECK_END();
11887 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
11888 return (true);
11889 }
11890
parseEntrySensorAhdrLocalTMO(const XMLElement * pelement,void * param)11891 bool RkAiqCalibParser::parseEntrySensorAhdrLocalTMO
11892 (
11893 const XMLElement* pelement,
11894 void* param
11895 ) {
11896 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
11897
11898 XML_CHECK_START(CALIB_SENSOR_AHDR_TMO_LOCALTMO_TAG_ID, CALIB_SENSOR_AHDR_TMO_TAG_ID);
11899 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Atmo_Para_t, atmo);
11900 int index = *((int*)param);
11901 const XMLNode* pchild = pelement->FirstChild();
11902 while (pchild) {
11903 XmlTag tag = XmlTag(pchild->ToElement());
11904 const char* value = tag.Value();
11905 std::string tagname(pchild->ToElement()->Name());
11906 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
11907
11908 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_NAME_TAG_ID)) {
11909 ParseString(pchild, atmo->LocalTMO[index].name, sizeof(atmo->LocalTMO[index].name));
11910 }
11911 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_LOCALTMOMODE_TAG_ID)) {
11912 int no = ParseFloatArray(pchild, &atmo->LocalTMO[index].LocalTMOMode, tag.Size());
11913 DCT_ASSERT((no == tag.Size()));
11914 }
11915 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_DYNAMICRANGE_TAG_ID)) {
11916 int no = ParseFloatArray(pchild, atmo->LocalTMO[index].DynamicRange, tag.Size());
11917 DCT_ASSERT((no == tag.Size()));
11918 }
11919 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_ENVLV_TAG_ID)) {
11920 int no = ParseFloatArray(pchild, atmo->LocalTMO[index].EnvLv, tag.Size());
11921 DCT_ASSERT((no == tag.Size()));
11922 }
11923 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TOLERANCE_TAG_ID)) {
11924 int no = ParseFloatArray(pchild, &atmo->LocalTMO[index].Tolerance, tag.Size());
11925 DCT_ASSERT((no == tag.Size()));
11926 }
11927 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_LOCALTMO_STRENGTH_TAG_ID)) {
11928 int no = ParseFloatArray(pchild, atmo->LocalTMO[index].Strength, tag.Size());
11929 DCT_ASSERT((no == tag.Size()));
11930 }
11931
11932 pchild = pchild->NextSibling();
11933 }
11934 XML_CHECK_END();
11935 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
11936 return (true);
11937 }
11938
parseEntrySensorAhdrGlobalTMO(const XMLElement * pelement,void * param)11939 bool RkAiqCalibParser::parseEntrySensorAhdrGlobalTMO
11940 (
11941 const XMLElement* pelement,
11942 void* param
11943 ) {
11944 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
11945
11946 XML_CHECK_START(CALIB_SENSOR_AHDR_TMO_GLOBALTMO_TAG_ID, CALIB_SENSOR_AHDR_TMO_TAG_ID);
11947 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Atmo_Para_t, atmo);
11948 int index = *((int*)param);
11949 const XMLNode* pchild = pelement->FirstChild();
11950 while (pchild) {
11951 XmlTag tag = XmlTag(pchild->ToElement());
11952 const char* value = tag.Value();
11953 std::string tagname(pchild->ToElement()->Name());
11954 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
11955
11956 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_NAME_TAG_ID)) {
11957 ParseString(pchild, atmo->GlobaTMO[index].name, sizeof(atmo->GlobaTMO[index].name));
11958 }
11959 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_GLOBALTMO_EN_TAG_ID)) {
11960 int no = ParseFloatArray(pchild, &atmo->GlobaTMO[index].en, tag.Size());
11961 DCT_ASSERT((no == tag.Size()));
11962 }
11963 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_GLOBALTMO_IIR_TAG_ID)) {
11964 int no = ParseFloatArray(pchild, &atmo->GlobaTMO[index].iir, tag.Size());
11965 DCT_ASSERT((no == tag.Size()));
11966 }
11967 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_GLOBALTMO_MODE_TAG_ID)) {
11968 int no = ParseFloatArray(pchild, &atmo->GlobaTMO[index].mode, tag.Size());
11969 DCT_ASSERT((no == tag.Size()));
11970 }
11971 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_GLOBALTMO_DYNAMICRANGE_TAG_ID)) {
11972 int no = ParseFloatArray(pchild, atmo->GlobaTMO[index].DynamicRange, tag.Size());
11973 DCT_ASSERT((no == tag.Size()));
11974 }
11975 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_GLOBALTMO_ENVLV_TAG_ID)) {
11976 int no = ParseFloatArray(pchild, atmo->GlobaTMO[index].EnvLv, tag.Size());
11977 DCT_ASSERT((no == tag.Size()));
11978 }
11979 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_GLOBALTMO_TOLERANCE_TAG_ID)) {
11980 int no = ParseFloatArray(pchild, &atmo->GlobaTMO[index].Tolerance, tag.Size());
11981 DCT_ASSERT((no == tag.Size()));
11982 }
11983 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AHDR_TMO_GLOBALTMO_STRENGTH_TAG_ID)) {
11984 int no = ParseFloatArray(pchild, atmo->GlobaTMO[index].Strength, tag.Size());
11985 DCT_ASSERT((no == tag.Size()));
11986 }
11987
11988 pchild = pchild->NextSibling();
11989 }
11990 XML_CHECK_END();
11991 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
11992 return (true);
11993 }
11994
parseEntrySensorDrc(const XMLElement * pelement,void * param)11995 bool RkAiqCalibParser::parseEntrySensorDrc
11996 (
11997 const XMLElement* pelement,
11998 void* param
11999 ) {
12000 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12001 autoTabForward();
12002
12003 XML_CHECK_START(CALIB_SENSOR_DRC_TAG_ID, CALIB_SENSOR_TAG_ID);
12004
12005 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Adrc_Para_t, adrc);
12006
12007 const XMLNode* pchild = pelement->FirstChild();
12008 while (pchild) {
12009 XmlTag tag = XmlTag(pchild->ToElement());
12010 std::string tagname(pchild->ToElement()->Name());
12011 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12012
12013 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_CALIBPARA_TAG_ID)) {
12014 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
12015 &RkAiqCalibParser::parseEntrySensorDrcCalibPara,
12016 param,
12017 (uint32_t)CALIB_SENSOR_DRC_CALIBPARA_TAG_ID,
12018 (uint32_t)CALIB_SENSOR_DRC_TAG_ID)) {
12019 LOGE("parse error in Drc CalibPara Setting (%s)", tagname.c_str());
12020 return (false);
12021 }
12022 }
12023 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_TUNINGPARA_TAG_ID)) {
12024 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
12025 &RkAiqCalibParser::parseEntrySensorDrcTuningPara,
12026 param,
12027 (uint32_t)CALIB_SENSOR_DRC_TUNINGPARA_TAG_ID,
12028 (uint32_t)CALIB_SENSOR_DRC_TAG_ID)) {
12029 LOGE("parse error in Drc TuningPara Setting (%s)", tagname.c_str());
12030 return (false);
12031 }
12032 }
12033
12034 pchild = pchild->NextSibling();
12035 }
12036
12037 XML_CHECK_END();
12038
12039 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12040 autoTabBackward();
12041 return (true);
12042 }
12043
parseEntrySensorDrcCalibPara(const XMLElement * pelement,void * param)12044 bool RkAiqCalibParser::parseEntrySensorDrcCalibPara
12045 (
12046 const XMLElement* pelement,
12047 void* param
12048 ) {
12049 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12050
12051 XML_CHECK_START(CALIB_SENSOR_DRC_CALIBPARA_TAG_ID, CALIB_SENSOR_DRC_TAG_ID);
12052 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Adrc_Para_t, adrc);
12053 int index = *((int*)param);
12054 const XMLNode* pchild = pelement->FirstChild();
12055 while (pchild) {
12056 XmlTag tag = XmlTag(pchild->ToElement());
12057 const char* value = tag.Value();
12058 std::string tagname(pchild->ToElement()->Name());
12059 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12060
12061 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_SCENE_TAG_ID)) {
12062 ParseString(pchild, adrc->calib[index].scene, sizeof(adrc->calib[index].scene));
12063 }
12064 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_POSITION_TAG_ID)) {
12065 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_position, tag.Size());
12066 DCT_ASSERT((no == tag.Size()));
12067 }
12068 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_OFFSET_POW2_TAG_ID)) {
12069 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_offset_pow2, tag.Size());
12070 DCT_ASSERT((no == tag.Size()));
12071 }
12072 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_LPDETAIL_RATIO_TAG_ID)) {
12073 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_lpdetail_ratio, tag.Size());
12074 DCT_ASSERT((no == tag.Size()));
12075 }
12076 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_HPDETAIL_RATIO_TAG_ID)) {
12077 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_hpdetail_ratio, tag.Size());
12078 DCT_ASSERT((no == tag.Size()));
12079 }
12080 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_WEIPRE_FRAME_TAG_ID)) {
12081 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_weipre_frame, tag.Size());
12082 DCT_ASSERT((no == tag.Size()));
12083 }
12084 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_WEICUR_PIX_TAG_ID)) {
12085 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_weicur_pix, tag.Size());
12086 DCT_ASSERT((no == tag.Size()));
12087 }
12088 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_EDGE_SCL_TAG_ID)) {
12089 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_edge_scl, tag.Size());
12090 DCT_ASSERT((no == tag.Size()));
12091 }
12092 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_MOTION_SCL_TAG_ID)) {
12093 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_motion_scl, tag.Size());
12094 DCT_ASSERT((no == tag.Size()));
12095 }
12096 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_FORCE_SGM_INV0_TAG_ID)) {
12097 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_force_sgm_inv0, tag.Size());
12098 DCT_ASSERT((no == tag.Size()));
12099 }
12100 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_SPACE_SGM_INV0_TAG_ID)) {
12101 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_space_sgm_inv0, tag.Size());
12102 DCT_ASSERT((no == tag.Size()));
12103 }
12104 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_SPACE_SGM_INV1_TAG_ID)) {
12105 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_space_sgm_inv1, tag.Size());
12106 DCT_ASSERT((no == tag.Size()));
12107 }
12108 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_RANGE_SGM_INV0_TAG_ID)) {
12109 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_range_sgm_inv0, tag.Size());
12110 DCT_ASSERT((no == tag.Size()));
12111 }
12112 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_RANGE_SGM_INV1_TAG_ID)) {
12113 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_range_sgm_inv1, tag.Size());
12114 DCT_ASSERT((no == tag.Size()));
12115 }
12116 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_WEIG_BILAT_TAG_ID)) {
12117 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_weig_bilat, tag.Size());
12118 DCT_ASSERT((no == tag.Size()));
12119 }
12120 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_WEIG_MAXL_TAG_ID)) {
12121 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_weig_maxl, tag.Size());
12122 DCT_ASSERT((no == tag.Size()));
12123 }
12124 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_MIN_OGAIN_TAG_ID)) {
12125 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_min_ogain, tag.Size());
12126 DCT_ASSERT((no == tag.Size()));
12127 }
12128 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_IIR_FRAME_TAG_ID)) {
12129 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_iir_frame, tag.Size());
12130 DCT_ASSERT((no == tag.Size()));
12131 }
12132 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_GAIN_TAG_ID)) {
12133 int no = ParseIntArray(pchild, &adrc->calib[index].sw_drc_gain, tag.Size());
12134 DCT_ASSERT((no == tag.Size()));
12135 }
12136 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_SCALE_Y0_TAG_ID)) {
12137 int no = ParseIntArray(pchild, adrc->calib[index].sw_drc_scale_y, tag.Size());
12138 DCT_ASSERT((no == tag.Size()));
12139 }
12140
12141 pchild = pchild->NextSibling();
12142 }
12143 XML_CHECK_END();
12144 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12145 return (true);
12146 }
12147
parseEntrySensorDrcTuningPara(const XMLElement * pelement,void * param)12148 bool RkAiqCalibParser::parseEntrySensorDrcTuningPara
12149 (
12150 const XMLElement* pelement,
12151 void* param
12152 ) {
12153 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12154
12155 XML_CHECK_START(CALIB_SENSOR_DRC_TUNINGPARA_TAG_ID, CALIB_SENSOR_DRC_TAG_ID);
12156 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Adrc_Para_t, adrc);
12157 int index = *((int*)param);
12158 const XMLNode* pchild = pelement->FirstChild();
12159 while (pchild) {
12160 XmlTag tag = XmlTag(pchild->ToElement());
12161 const char* value = tag.Value();
12162 std::string tagname(pchild->ToElement()->Name());
12163 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12164
12165 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_SCENE_TAG_ID)) {
12166 ParseString(pchild, adrc->tuning[index].scene, sizeof(adrc->tuning[index].scene));
12167 }
12168 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_POSITION_TAG_ID)) {
12169 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_position, tag.Size());
12170 DCT_ASSERT((no == tag.Size()));
12171 }
12172 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_OFFSET_POW2_TAG_ID)) {
12173 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_offset_pow2, tag.Size());
12174 DCT_ASSERT((no == tag.Size()));
12175 }
12176 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_LPDETAIL_RATIO_TAG_ID)) {
12177 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_lpdetail_ratio, tag.Size());
12178 DCT_ASSERT((no == tag.Size()));
12179 }
12180 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_HPDETAIL_RATIO_TAG_ID)) {
12181 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_hpdetail_ratio, tag.Size());
12182 DCT_ASSERT((no == tag.Size()));
12183 }
12184 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_WEIPRE_FRAME_TAG_ID)) {
12185 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_weipre_frame, tag.Size());
12186 DCT_ASSERT((no == tag.Size()));
12187 }
12188 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_WEICUR_PIX_TAG_ID)) {
12189 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_weicur_pix, tag.Size());
12190 DCT_ASSERT((no == tag.Size()));
12191 }
12192 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_EDGE_SCL_TAG_ID)) {
12193 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_edge_scl, tag.Size());
12194 DCT_ASSERT((no == tag.Size()));
12195 }
12196 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_MOTION_SCL_TAG_ID)) {
12197 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_motion_scl, tag.Size());
12198 DCT_ASSERT((no == tag.Size()));
12199 }
12200 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_FORCE_SGM_INV0_TAG_ID)) {
12201 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_force_sgm_inv0, tag.Size());
12202 DCT_ASSERT((no == tag.Size()));
12203 }
12204 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_SPACE_SGM_INV0_TAG_ID)) {
12205 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_space_sgm_inv0, tag.Size());
12206 DCT_ASSERT((no == tag.Size()));
12207 }
12208 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_SPACE_SGM_INV1_TAG_ID)) {
12209 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_space_sgm_inv1, tag.Size());
12210 DCT_ASSERT((no == tag.Size()));
12211 }
12212 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_RANGE_SGM_INV0_TAG_ID)) {
12213 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_range_sgm_inv0, tag.Size());
12214 DCT_ASSERT((no == tag.Size()));
12215 }
12216 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_RANGE_SGM_INV1_TAG_ID)) {
12217 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_range_sgm_inv1, tag.Size());
12218 DCT_ASSERT((no == tag.Size()));
12219 }
12220 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_WEIG_BILAT_TAG_ID)) {
12221 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_weig_bilat, tag.Size());
12222 DCT_ASSERT((no == tag.Size()));
12223 }
12224 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_WEIG_MAXL_TAG_ID)) {
12225 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_weig_maxl, tag.Size());
12226 DCT_ASSERT((no == tag.Size()));
12227 }
12228 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_MIN_OGAIN_TAG_ID)) {
12229 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_min_ogain, tag.Size());
12230 DCT_ASSERT((no == tag.Size()));
12231 }
12232 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_IIR_FRAME_TAG_ID)) {
12233 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_iir_frame, tag.Size());
12234 DCT_ASSERT((no == tag.Size()));
12235 }
12236 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_GAIN_TAG_ID)) {
12237 int no = ParseIntArray(pchild, &adrc->tuning[index].sw_drc_gain, tag.Size());
12238 DCT_ASSERT((no == tag.Size()));
12239 }
12240 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DRC_SCALE_Y0_TAG_ID)) {
12241 int no = ParseIntArray(pchild, adrc->tuning[index].sw_drc_scale_y, tag.Size());
12242 DCT_ASSERT((no == tag.Size()));
12243 }
12244
12245 pchild = pchild->NextSibling();
12246 }
12247 XML_CHECK_END();
12248 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12249 return (true);
12250 }
12251
parseEntrySensorBlcModeCell(const XMLElement * pelement,void * param)12252 bool RkAiqCalibParser::parseEntrySensorBlcModeCell
12253 (
12254 const XMLElement* pelement,
12255 void* param
12256 ) {
12257 (void)param;
12258
12259 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12260
12261 int index = *((int*)param);
12262 XML_CHECK_START(CALIB_SENSOR_BLC_MODE_CELL_TAG_ID, CALIB_SENSOR_BLC_TAG_ID);
12263 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Blc_t, blc);
12264
12265 const XMLNode* pchild = pelement->FirstChild();
12266 while (pchild) {
12267 XmlTag tag = XmlTag(pchild->ToElement());
12268 std::string tagname(pchild->ToElement()->Name());
12269 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12270
12271 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BLC_MODE_NAME_TAG_ID)) {
12272 ParseString(pchild, blc->mode_cell[index].name, sizeof(blc->mode_cell[index].name));
12273 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BLC_ISO_TAG_ID)) {
12274 int no = ParseFloatArray(pchild, blc->mode_cell[index].iso, tag.Size());
12275 DCT_ASSERT((no == tag.Size()));
12276 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BLC_BLACK_LEVEL_TAG_ID)) {
12277 int no = ParseFloatArray(pchild, (float *)blc->mode_cell[index].level, tag.Size());
12278 DCT_ASSERT((no == tag.Size()));
12279 }
12280 pchild = pchild->NextSibling();
12281
12282 }
12283
12284 XML_CHECK_END();
12285 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12286 return (true);
12287 }
12288
parseEntrySensorBlc(const XMLElement * pelement,void * param)12289 bool RkAiqCalibParser::parseEntrySensorBlc
12290 (
12291 const XMLElement* pelement,
12292 void* param
12293 ) {
12294 (void)param;
12295
12296 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12297 autoTabForward();
12298
12299 XML_CHECK_START(CALIB_SENSOR_BLC_TAG_ID, CALIB_SENSOR_TAG_ID);
12300
12301 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Blc_t, blc);
12302
12303 const XMLNode* pchild = pelement->FirstChild();
12304 while (pchild) {
12305 XmlTag tag = XmlTag(pchild->ToElement());
12306 std::string tagname(pchild->ToElement()->Name());
12307 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12308
12309 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BLC_ENABLE_TAG_ID)) {
12310 int no = ParseIntArray(pchild, &blc->enable, tag.Size());
12311 DCT_ASSERT((no == tag.Size()));
12312 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BLC_MODE_CELL_TAG_ID)) {
12313 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
12314 &RkAiqCalibParser::parseEntrySensorBlcModeCell,
12315 param,
12316 (uint32_t)CALIB_SENSOR_BLC_MODE_CELL_TAG_ID,
12317 (uint32_t)CALIB_SENSOR_BLC_TAG_ID)) {
12318 LOGE("parse error in blc mode cell (%s)", tagname.c_str());
12319 return (false);
12320 }
12321 }
12322 pchild = pchild->NextSibling();
12323 }
12324 XML_CHECK_END();
12325 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12326 autoTabBackward();
12327 return (true);
12328 }
12329
parseEntrySensorLut3d(const XMLElement * pelement,void * param)12330 bool RkAiqCalibParser::parseEntrySensorLut3d
12331 (
12332 const XMLElement* pelement,
12333 void* param
12334 ) {
12335 (void)param;
12336
12337 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12338 autoTabForward();
12339
12340 XML_CHECK_START(CALIB_SENSOR_LUT3D_TAG_ID, CALIB_SENSOR_TAG_ID);
12341 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Lut3d_t, lut3d);
12342
12343 const XMLNode* pchild = pelement->FirstChild();
12344 while (pchild) {
12345 XmlTag tag = XmlTag(pchild->ToElement());
12346 std::string tagname(pchild->ToElement()->Name());
12347 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12348
12349 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LUT3D_ENABLE_TAG_ID)) {
12350 unsigned char enable = lut3d->enable;
12351 int no = ParseUcharArray(pchild, &enable, tag.Size());
12352 DCT_ASSERT((no == tag.Size()));
12353 lut3d->enable = enable;
12354 }
12355 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LUT3D_R_LUT_TAG_ID)) {
12356 int no = ParseUshortArray(pchild, lut3d->look_up_table_r, tag.Size());
12357 DCT_ASSERT((no == tag.Size()));
12358 }
12359 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LUT3D_G_LUT_TAG_ID)) {
12360 int no = ParseUshortArray(pchild, lut3d->look_up_table_g, tag.Size());
12361 DCT_ASSERT((no == tag.Size()));
12362 }
12363 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LUT3D_B_LUT_TAG_ID)) {
12364 int no = ParseUshortArray(pchild, lut3d->look_up_table_b, tag.Size());
12365 DCT_ASSERT((no == tag.Size()));
12366 }
12367 pchild = pchild->NextSibling();
12368 }
12369 XML_CHECK_END();
12370 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12371 autoTabBackward();
12372 return (true);
12373 }
12374
parseEntrySensorDpcc(const XMLElement * pelement,void * param)12375 bool RkAiqCalibParser::parseEntrySensorDpcc
12376 (
12377 const XMLElement* pelement,
12378 void* param
12379 ) {
12380 (void)param;
12381
12382 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12383 autoTabForward();
12384
12385 XML_CHECK_START(CALIB_SENSOR_DPCC_TAG_ID, CALIB_SENSOR_TAG_ID);
12386 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dpcc_t, dpcc);
12387
12388 const XMLNode* pchild = pelement->FirstChild();
12389 while (pchild) {
12390 XmlTag tag = XmlTag(pchild->ToElement());
12391 std::string tagname(pchild->ToElement()->Name());
12392 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12393
12394 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_ENABLE_TAG_ID)) {
12395 int no = ParseIntArray(pchild, &dpcc->enable, tag.Size());
12396 DCT_ASSERT((no == tag.Size()));
12397 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_VERSION_TAG_ID)) {
12398 ParseString(pchild, dpcc->version, sizeof(dpcc->version));
12399 }
12400 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_FAST_MODE_TAG_ID)) {
12401 if (!parseEntrySensorDpccFastMode(pchild->ToElement())) {
12402 LOGE("parse error in dpcc Fast Mode (%s)", tagname.c_str());
12403 return (false);
12404 }
12405 }
12406 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_EXPERT_MODE_TAG_ID)) {
12407 if (!parseEntrySensorDpccExpertMode(pchild->ToElement())) {
12408 LOGE("parse error in dpcc Expert Mode (%s)", tagname.c_str());
12409 return (false);
12410 }
12411 }
12412 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PDAF_TAG_ID)) {
12413 if (!parseEntrySensorDpccPdaf(pchild->ToElement())) {
12414 LOGE("parse error in dpcc pdaf (%s)", tagname.c_str());
12415 return (false);
12416 }
12417 }
12418 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_SENSOR_TAG_ID)) {
12419 if (!parseEntrySensorDpccSensor(pchild->ToElement())) {
12420 LOGE("parse error in DPCC Sensor (%s)", tagname.c_str());
12421 return (false);
12422 }
12423 }
12424 pchild = pchild->NextSibling();
12425 }
12426 XML_CHECK_END();
12427 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12428 autoTabBackward();
12429 return (true);
12430 }
12431
parseEntrySensorDpccFastMode(const XMLElement * pelement,void * param)12432 bool RkAiqCalibParser::parseEntrySensorDpccFastMode
12433 (
12434 const XMLElement* pelement,
12435 void* param
12436 ) {
12437 (void)param;
12438
12439 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12440 autoTabForward();
12441
12442 XML_CHECK_START(CALIB_SENSOR_DPCC_FAST_MODE_TAG_ID, CALIB_SENSOR_DPCC_TAG_ID);
12443
12444 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dpcc_t, dpcc);
12445
12446 const XMLNode* pchild = pelement->FirstChild();
12447 while (pchild) {
12448 XmlTag tag = XmlTag(pchild->ToElement());
12449 std::string tagname(pchild->ToElement()->Name());
12450 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12451
12452 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_FAST_MODE_ENABLE_TAG_ID)) {
12453 int no = ParseIntArray(pchild, &dpcc->fast.fast_mode_en, tag.Size());
12454 DCT_ASSERT((no == tag.Size()));
12455 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_FAST_MODE_ISO_TAG_ID)) {
12456 int no = ParseIntArray(pchild, dpcc->fast.ISO, tag.Size());
12457 DCT_ASSERT((no == tag.Size()));
12458 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_FAST_MODE_SINGLE_ENABLE_TAG_ID)) {
12459 int no = ParseIntArray(pchild, &dpcc->fast.fast_mode_single_en, tag.Size());
12460 DCT_ASSERT((no == tag.Size()));
12461 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_FAST_MODE_SINGLE_LEVEL_TAG_ID)) {
12462 int no = ParseIntArray(pchild, dpcc->fast.fast_mode_single_level, tag.Size());
12463 DCT_ASSERT((no == tag.Size()));
12464 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_FAST_MODE_DOUBLE_ENABLE_TAG_ID)) {
12465 int no = ParseIntArray(pchild, &dpcc->fast.fast_mode_double_en, tag.Size());
12466 DCT_ASSERT((no == tag.Size()));
12467 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_FAST_MODE_DOUBLE_LEVEL_TAG_ID)) {
12468 int no = ParseIntArray(pchild, dpcc->fast.fast_mode_double_level, tag.Size());
12469 DCT_ASSERT((no == tag.Size()));
12470 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_FAST_MODE_TRIPLE_ENABLE_TAG_ID)) {
12471 int no = ParseIntArray(pchild, &dpcc->fast.fast_mode_triple_en, tag.Size());
12472 DCT_ASSERT((no == tag.Size()));
12473 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_FAST_MODE_TRIPLE_LEVEL_TAG_ID)) {
12474 int no = ParseIntArray(pchild, dpcc->fast.fast_mode_triple_level, tag.Size());
12475 DCT_ASSERT((no == tag.Size()));
12476 }
12477
12478 pchild = pchild->NextSibling();
12479 }
12480 XML_CHECK_END();
12481 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12482 autoTabBackward();
12483 return (true);
12484 }
12485
parseEntrySensorDpccExpertMode(const XMLElement * pelement,void * param)12486 bool RkAiqCalibParser::parseEntrySensorDpccExpertMode
12487 (
12488 const XMLElement* pelement,
12489 void* param
12490 ) {
12491 (void)param;
12492
12493 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12494 autoTabForward();
12495
12496 XML_CHECK_START(CALIB_SENSOR_DPCC_EXPERT_MODE_TAG_ID, CALIB_SENSOR_DPCC_TAG_ID);
12497 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dpcc_t, dpcc);
12498
12499 const XMLNode* pchild = pelement->FirstChild();
12500 while (pchild) {
12501 XmlTag tag = XmlTag(pchild->ToElement());
12502 std::string tagname(pchild->ToElement()->Name());
12503 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12504
12505 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_ISO_TAG_ID)) {
12506 int no = ParseFloatArray(pchild, dpcc->expert.iso, tag.Size());
12507 DCT_ASSERT((no == tag.Size()));
12508 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_STAGE1_ENABLE_TAG_ID)) {
12509 int no = ParseUcharArray(pchild, dpcc->expert.stage1_Enable, tag.Size());
12510 DCT_ASSERT((no == tag.Size()));
12511 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_GRAYSCALE_MODE_TAG_ID)) {
12512 int no = ParseUcharArray(pchild, &dpcc->expert.grayscale_mode, tag.Size());
12513 DCT_ASSERT((no == tag.Size()));
12514 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RK_OUT_SEL_TAG_ID)) {
12515 int no = ParseUcharArray(pchild, dpcc->expert.rk_out_sel, tag.Size());
12516 DCT_ASSERT((no == tag.Size()));
12517 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_DPCC_OUT_SEL_TAG_ID)) {
12518 int no = ParseUcharArray(pchild, dpcc->expert.dpcc_out_sel, tag.Size());
12519 DCT_ASSERT((no == tag.Size()));
12520 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_STAGE1_RB_3X3_TAG_ID)) {
12521 int no = ParseUcharArray(pchild, dpcc->expert.stage1_rb_3x3, tag.Size());
12522 DCT_ASSERT((no == tag.Size()));
12523 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_STAGE1_G_3X3_TAG_ID)) {
12524 int no = ParseUcharArray(pchild, dpcc->expert.stage1_g_3x3, tag.Size());
12525 DCT_ASSERT((no == tag.Size()));
12526 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_STAGE1_INC_RB_CENTER_TAG_ID)) {
12527 int no = ParseUcharArray(pchild, dpcc->expert.stage1_inc_rb_center, tag.Size());
12528 DCT_ASSERT((no == tag.Size()));
12529 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_STAGE1_INC_G_CENTER_TAG_ID)) {
12530 int no = ParseUcharArray(pchild, dpcc->expert.stage1_inc_g_center, tag.Size());
12531 DCT_ASSERT((no == tag.Size()));
12532 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_STAGE1_USE_FIX_SET_TAG_ID)) {
12533 int no = ParseUcharArray(pchild, dpcc->expert.stage1_use_fix_set, tag.Size());
12534 DCT_ASSERT((no == tag.Size()));
12535 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_STAGE1_USE_SET1_TAG_ID)) {
12536 int no = ParseUcharArray(pchild, dpcc->expert.stage1_use_set1, tag.Size());
12537 DCT_ASSERT((no == tag.Size()));
12538 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_STAGE1_USE_SET2_TAG_ID)) {
12539 int no = ParseUcharArray(pchild, dpcc->expert.stage1_use_set2, tag.Size());
12540 DCT_ASSERT((no == tag.Size()));
12541 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_STAGE1_USE_SET3_TAG_ID)) {
12542 int no = ParseUcharArray(pchild, dpcc->expert.stage1_use_set3, tag.Size());
12543 DCT_ASSERT((no == tag.Size()));
12544 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_SET_CELL_TAG_ID)) {
12545 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
12546 &RkAiqCalibParser::parseEntrySensorDpccSetCell,
12547 param,
12548 (uint32_t)CALIB_SENSOR_DPCC_SET_CELL_TAG_ID,
12549 (uint32_t)CALIB_SENSOR_DPCC_EXPERT_MODE_TAG_ID)) {
12550 LOGE("parse error in dpcc set cell (%s)", tagname.c_str());
12551 return (false);
12552 }
12553 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PDAF_TAG_ID)) {
12554 if (!parseEntrySensorDpccPdaf(pchild->ToElement())) {
12555 LOGE("parse error in dpcc pdaf (%s)", tagname.c_str());
12556 return (false);
12557 }
12558 }
12559 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_SENSOR_TAG_ID)) {
12560 if (!parseEntrySensorDpccSensor(pchild->ToElement())) {
12561 LOGE("parse error in DPCC Sensor (%s)", tagname.c_str());
12562 return (false);
12563 }
12564 }
12565 pchild = pchild->NextSibling();
12566 }
12567 XML_CHECK_END();
12568 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12569 autoTabBackward();
12570 return (true);
12571 }
12572
parseEntrySensorDpccSetCell(const XMLElement * pelement,void * param)12573 bool RkAiqCalibParser::parseEntrySensorDpccSetCell
12574 (
12575 const XMLElement* pelement,
12576 void* param
12577 ) {
12578 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12579
12580 XML_CHECK_START(CALIB_SENSOR_DPCC_SET_CELL_TAG_ID, CALIB_SENSOR_DPCC_EXPERT_MODE_TAG_ID);
12581
12582 int index = *((int*)param);
12583 const XMLNode* pchild = pelement->FirstChild();
12584 while (pchild) {
12585 XmlTag tag = XmlTag(pchild->ToElement());
12586 std::string tagname(pchild->ToElement()->Name());
12587 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12588
12589 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_SET_CELL_RK_TAG_ID)) {
12590 if (!parseEntrySensorDpccSetCellRK(pchild->ToElement(), index)) {
12591 LOGE("parse error in dpcc set cell RK (%s)", tagname.c_str());
12592 return (false);
12593 }
12594 }
12595 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_SET_CELL_LC_TAG_ID)) {
12596 if (!parseEntrySensorDpccSetCellLC(pchild->ToElement(), index)) {
12597 LOGE("parse error in dpcc set cell LC (%s)", tagname.c_str());
12598 return (false);
12599 }
12600 }
12601 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_SET_CELL_PG_TAG_ID)) {
12602 if (!parseEntrySensorDpccSetCellPG(pchild->ToElement(), index)) {
12603 LOGE("parse error in dpcc set cell PG (%s)", tagname.c_str());
12604 return (false);
12605 }
12606 }
12607 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_SET_CELL_RND_TAG_ID)) {
12608 if (!parseEntrySensorDpccSetCellRND(pchild->ToElement(), index)) {
12609 LOGE("parse error in dpcc set cell RND (%s)", tagname.c_str());
12610 return (false);
12611 }
12612 }
12613 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_SET_CELL_RG_TAG_ID)) {
12614 if (!parseEntrySensorDpccSetCellRG(pchild->ToElement(), index)) {
12615 LOGE("parse error in dpcc set cell RG (%s)", tagname.c_str());
12616 return (false);
12617 }
12618 }
12619 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_SET_CELL_RO_TAG_ID)) {
12620 if (!parseEntrySensorDpccSetCellRO(pchild->ToElement(), index)) {
12621 LOGE("parse error in dpcc set cell RO (%s)", tagname.c_str());
12622 return (false);
12623 }
12624 }
12625
12626 pchild = pchild->NextSibling();
12627 }
12628 XML_CHECK_END();
12629 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12630 return (true);
12631 }
12632
parseEntrySensorDpccSetCellRK(const XMLElement * pelement,int index)12633 bool RkAiqCalibParser::parseEntrySensorDpccSetCellRK
12634 (
12635 const XMLElement* pelement,
12636 int index
12637 ) {
12638 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12639
12640 XML_CHECK_START(CALIB_SENSOR_DPCC_SET_CELL_RK_TAG_ID, CALIB_SENSOR_DPCC_SET_CELL_TAG_ID);
12641 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dpcc_t, dpcc);
12642
12643 const XMLNode* pchild = pelement->FirstChild();
12644 while (pchild) {
12645 XmlTag tag = XmlTag(pchild->ToElement());
12646 std::string tagname(pchild->ToElement()->Name());
12647 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12648
12649
12650 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RK_RED_BLUE_ENABLE_TAG_ID)) {
12651 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rk.rb_enable, tag.Size());
12652 DCT_ASSERT((no == tag.Size()));
12653 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RK_GREEN_ENABLE_TAG_ID)) {
12654 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rk.g_enable, tag.Size());
12655 DCT_ASSERT((no == tag.Size()));
12656 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RK_RED_BLUE_SW_MINDIS_TAG_ID)) {
12657 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rk.rb_sw_mindis, tag.Size());
12658 DCT_ASSERT((no == tag.Size()));
12659 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RK_GREEN_SW_MINDIS_TAG_ID)) {
12660 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rk.g_sw_mindis, tag.Size());
12661 DCT_ASSERT((no == tag.Size()));
12662 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RK_SW_DIS_SCALE_MIN_TAG_ID)) {
12663 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rk.sw_dis_scale_min, tag.Size());
12664 DCT_ASSERT((no == tag.Size()));
12665 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RK_SW_DIS_SCALE_MAX_TAG_ID)) {
12666 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rk.sw_dis_scale_max, tag.Size());
12667 DCT_ASSERT((no == tag.Size()));
12668 }
12669
12670 pchild = pchild->NextSibling();
12671 }
12672 XML_CHECK_END();
12673 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12674 return (true);
12675 }
12676
parseEntrySensorDpccSetCellLC(const XMLElement * pelement,int index)12677 bool RkAiqCalibParser::parseEntrySensorDpccSetCellLC
12678 (
12679 const XMLElement* pelement,
12680 int index
12681 ) {
12682 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12683
12684 XML_CHECK_START(CALIB_SENSOR_DPCC_SET_CELL_LC_TAG_ID, CALIB_SENSOR_DPCC_SET_CELL_TAG_ID);
12685 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dpcc_t, dpcc);
12686
12687 const XMLNode* pchild = pelement->FirstChild();
12688 while (pchild) {
12689 XmlTag tag = XmlTag(pchild->ToElement());
12690 std::string tagname(pchild->ToElement()->Name());
12691 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12692
12693
12694 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_LC_RED_BLUE_ENABLE_TAG_ID)) {
12695 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].lc.rb_enable, tag.Size());
12696 DCT_ASSERT((no == tag.Size()));
12697 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_LC_GREEN_ENABLE_TAG_ID)) {
12698 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].lc.g_enable, tag.Size());
12699 DCT_ASSERT((no == tag.Size()));
12700 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_LC_RED_BLUE_LINE_MAD_FAC_TAG_ID)) {
12701 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].lc.rb_line_mad_fac, tag.Size());
12702 DCT_ASSERT((no == tag.Size()));
12703 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_LC_GREEN_LINE_MAD_FAC_TAG_ID)) {
12704 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].lc.g_line_mad_fac, tag.Size());
12705 DCT_ASSERT((no == tag.Size()));
12706 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_LC_RED_BLUE_LINE_THR_TAG_ID)) {
12707 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].lc.rb_line_thr, tag.Size());
12708 DCT_ASSERT((no == tag.Size()));
12709 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_LC_GREEN_LINE_THR_TAG_ID)) {
12710 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].lc.g_line_thr, tag.Size());
12711 DCT_ASSERT((no == tag.Size()));
12712 }
12713
12714 pchild = pchild->NextSibling();
12715 }
12716 XML_CHECK_END();
12717 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12718 return (true);
12719 }
12720
parseEntrySensorDpccSetCellPG(const XMLElement * pelement,int index)12721 bool RkAiqCalibParser::parseEntrySensorDpccSetCellPG
12722 (
12723 const XMLElement* pelement,
12724 int index
12725 ) {
12726 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12727
12728 XML_CHECK_START(CALIB_SENSOR_DPCC_SET_CELL_PG_TAG_ID, CALIB_SENSOR_DPCC_SET_CELL_TAG_ID);
12729 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dpcc_t, dpcc);
12730
12731 const XMLNode* pchild = pelement->FirstChild();
12732 while (pchild) {
12733 XmlTag tag = XmlTag(pchild->ToElement());
12734 std::string tagname(pchild->ToElement()->Name());
12735 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12736
12737
12738 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PG_RED_BLUE_ENABLE_TAG_ID)) {
12739 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].pg.rb_enable, tag.Size());
12740 DCT_ASSERT((no == tag.Size()));
12741 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PG_GREEN_ENABLE_TAG_ID)) {
12742 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].pg.g_enable, tag.Size());
12743 DCT_ASSERT((no == tag.Size()));
12744 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PG_RED_BLUE_FAC_TAG_ID)) {
12745 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].pg.rb_pg_fac, tag.Size());
12746 DCT_ASSERT((no == tag.Size()));
12747 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PG_GREEN_FAC_TAG_ID)) {
12748 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].pg.g_pg_fac, tag.Size());
12749 DCT_ASSERT((no == tag.Size()));
12750 }
12751
12752 pchild = pchild->NextSibling();
12753 }
12754 XML_CHECK_END();
12755 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12756 return (true);
12757 }
12758
parseEntrySensorDpccSetCellRND(const XMLElement * pelement,int index)12759 bool RkAiqCalibParser::parseEntrySensorDpccSetCellRND
12760 (
12761 const XMLElement* pelement,
12762 int index
12763 ) {
12764 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12765
12766 XML_CHECK_START(CALIB_SENSOR_DPCC_SET_CELL_RND_TAG_ID, CALIB_SENSOR_DPCC_SET_CELL_TAG_ID);
12767
12768 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dpcc_t, dpcc);
12769 const XMLNode* pchild = pelement->FirstChild();
12770 while (pchild) {
12771 XmlTag tag = XmlTag(pchild->ToElement());
12772 std::string tagname(pchild->ToElement()->Name());
12773 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12774
12775
12776 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RND_RED_BLUE_ENABLE_TAG_ID)) {
12777 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rnd.rb_enable, tag.Size());
12778 DCT_ASSERT((no == tag.Size()));
12779 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RND_GREEN_ENABLE_TAG_ID)) {
12780 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rnd.g_enable, tag.Size());
12781 DCT_ASSERT((no == tag.Size()));
12782 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RND_RED_BLUE_THR_TAG_ID)) {
12783 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rnd.rb_rnd_thr, tag.Size());
12784 DCT_ASSERT((no == tag.Size()));
12785 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RND_GREEN_THR_TAG_ID)) {
12786 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rnd.g_rnd_thr, tag.Size());
12787 DCT_ASSERT((no == tag.Size()));
12788 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RND_RED_BLUE_OFFS_TAG_ID)) {
12789 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rnd.rb_rnd_offs, tag.Size());
12790 DCT_ASSERT((no == tag.Size()));
12791 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RND_GREEN_OFFS_TAG_ID)) {
12792 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rnd.g_rnd_offs, tag.Size());
12793 DCT_ASSERT((no == tag.Size()));
12794 }
12795
12796 pchild = pchild->NextSibling();
12797 }
12798 XML_CHECK_END();
12799 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12800 return (true);
12801 }
12802
parseEntrySensorDpccSetCellRG(const XMLElement * pelement,int index)12803 bool RkAiqCalibParser::parseEntrySensorDpccSetCellRG
12804 (
12805 const XMLElement* pelement,
12806 int index
12807 ) {
12808 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12809
12810 XML_CHECK_START(CALIB_SENSOR_DPCC_SET_CELL_RG_TAG_ID, CALIB_SENSOR_DPCC_SET_CELL_TAG_ID);
12811
12812 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dpcc_t, dpcc);
12813 const XMLNode* pchild = pelement->FirstChild();
12814 while (pchild) {
12815 XmlTag tag = XmlTag(pchild->ToElement());
12816 std::string tagname(pchild->ToElement()->Name());
12817 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12818
12819
12820 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RG_RED_BLUE_ENABLE_TAG_ID)) {
12821 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rg.rb_enable, tag.Size());
12822 DCT_ASSERT((no == tag.Size()));
12823 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RG_GREEN_ENABLE_TAG_ID)) {
12824 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rg.g_enable, tag.Size());
12825 DCT_ASSERT((no == tag.Size()));
12826 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RG_RED_BLUE_FAC_TAG_ID)) {
12827 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rg.rb_rg_fac, tag.Size());
12828 DCT_ASSERT((no == tag.Size()));
12829 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RG_GREEN_FAC_TAG_ID)) {
12830 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].rg.g_rg_fac, tag.Size());
12831 DCT_ASSERT((no == tag.Size()));
12832 }
12833
12834 pchild = pchild->NextSibling();
12835 }
12836 XML_CHECK_END();
12837 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12838 return (true);
12839 }
12840
parseEntrySensorDpccSetCellRO(const XMLElement * pelement,int index)12841 bool RkAiqCalibParser::parseEntrySensorDpccSetCellRO
12842 (
12843 const XMLElement* pelement,
12844 int index
12845 ) {
12846 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12847
12848 XML_CHECK_START(CALIB_SENSOR_DPCC_SET_CELL_RO_TAG_ID, CALIB_SENSOR_DPCC_SET_CELL_TAG_ID);
12849
12850 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dpcc_t, dpcc);
12851 const XMLNode* pchild = pelement->FirstChild();
12852 while (pchild) {
12853 XmlTag tag = XmlTag(pchild->ToElement());
12854 std::string tagname(pchild->ToElement()->Name());
12855 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12856
12857
12858 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RO_RED_BLUE_ENABLE_TAG_ID)) {
12859 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].ro.rb_enable, tag.Size());
12860 DCT_ASSERT((no == tag.Size()));
12861 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RO_GREEN_ENABLE_TAG_ID)) {
12862 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].ro.g_enable, tag.Size());
12863 DCT_ASSERT((no == tag.Size()));
12864 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RO_RED_BLUE_LIM_TAG_ID)) {
12865 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].ro.rb_ro_lim, tag.Size());
12866 DCT_ASSERT((no == tag.Size()));
12867 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_RO_GREEN_LIM_TAG_ID)) {
12868 int no = ParseUcharArray(pchild, (uint8_t *)dpcc->expert.set[index].ro.g_ro_lim, tag.Size());
12869 DCT_ASSERT((no == tag.Size()));
12870 }
12871
12872 pchild = pchild->NextSibling();
12873 }
12874 XML_CHECK_END();
12875 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12876 return (true);
12877 }
12878
parseEntrySensorDpccPdaf(const XMLElement * pelement,void * param)12879 bool RkAiqCalibParser::parseEntrySensorDpccPdaf
12880 (
12881 const XMLElement* pelement,
12882 void* param
12883 ) {
12884 (void)param;
12885
12886 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12887 autoTabForward();
12888
12889 XML_CHECK_START(CALIB_SENSOR_DPCC_PDAF_TAG_ID, CALIB_SENSOR_DPCC_TAG_ID);
12890 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dpcc_t, dpcc);
12891
12892 const XMLNode* pchild = pelement->FirstChild();
12893 while (pchild) {
12894 XmlTag tag = XmlTag(pchild->ToElement());
12895 std::string tagname(pchild->ToElement()->Name());
12896 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
12897
12898 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PDAF_ENABLE_TAG_ID)) {
12899 int no = ParseUcharArray(pchild, &dpcc->pdaf.en, tag.Size());
12900 DCT_ASSERT((no == tag.Size()));
12901 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PDAF_POINT_ENABLE_TAG_ID)) {
12902 int no = ParseUcharArray(pchild, dpcc->pdaf.point_en, tag.Size());
12903 DCT_ASSERT((no == tag.Size()));
12904 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PDAF_OFFSETX_TAG_ID)) {
12905 int no = ParseUshortArray(pchild, &dpcc->pdaf.offsetx, tag.Size());
12906 DCT_ASSERT((no == tag.Size()));
12907 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PDAF_OFFSETY_TAG_ID)) {
12908 int no = ParseUshortArray(pchild, &dpcc->pdaf.offsety, tag.Size());
12909 DCT_ASSERT((no == tag.Size()));
12910 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PDAF_WRAPX_TAG_ID)) {
12911 int no = ParseUcharArray(pchild, &dpcc->pdaf.wrapx, tag.Size());
12912 DCT_ASSERT((no == tag.Size()));
12913 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PDAF_WRAPY_TAG_ID)) {
12914 int no = ParseUcharArray(pchild, &dpcc->pdaf.wrapy, tag.Size());
12915 DCT_ASSERT((no == tag.Size()));
12916 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PDAF_WRAPX_NUM_TAG_ID)) {
12917 int no = ParseUshortArray(pchild, &dpcc->pdaf.wrapx_num, tag.Size());
12918 DCT_ASSERT((no == tag.Size()));
12919 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PDAF_WRAPY_NUM_TAG_ID)) {
12920 int no = ParseUshortArray(pchild, &dpcc->pdaf.wrapy_num, tag.Size());
12921 DCT_ASSERT((no == tag.Size()));
12922 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PDAF_POINT_X_TAG_ID)) {
12923 int no = ParseUcharArray(pchild, dpcc->pdaf.point_x, tag.Size());
12924 DCT_ASSERT((no == tag.Size()));
12925 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PDAF_POINT_Y_TAG_ID)) {
12926 int no = ParseUcharArray(pchild, dpcc->pdaf.point_y, tag.Size());
12927 DCT_ASSERT((no == tag.Size()));
12928 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_PDAF_POINT_FORWARD_MED_TAG_ID)) {
12929 int no = ParseUcharArray(pchild, &dpcc->pdaf.forward_med, tag.Size());
12930 DCT_ASSERT((no == tag.Size()));
12931 }
12932 pchild = pchild->NextSibling();
12933 }
12934
12935 XML_CHECK_END();
12936
12937 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12938 autoTabBackward();
12939 return (true);
12940 }
12941
parseEntrySensorDpccSensor(const XMLElement * pelement,void * param)12942 bool RkAiqCalibParser::parseEntrySensorDpccSensor
12943 (
12944 const XMLElement* pelement,
12945 void* param
12946 ) {
12947 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12948 autoTabForward();
12949
12950 XML_CHECK_START(CALIB_SENSOR_DPCC_SENSOR_TAG_ID, CALIB_SENSOR_DPCC_TAG_ID);
12951 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dpcc_t, dpcc);
12952
12953 const XMLNode* pchild = pelement->FirstChild();
12954 while (pchild) {
12955 XmlTag tag = XmlTag(pchild->ToElement());
12956 std::string Tagname(pchild->ToElement()->Name());
12957
12958 XML_CHECK_WHILE_SUBTAG_MARK((char *)(Tagname.c_str()), tag.Type(), tag.Size());
12959
12960 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_SENSOR_AUTO_ENABLE_TAG_ID)) {
12961 int no = ParseFloatArray(pchild, &dpcc->sensor_dpcc.en, tag.Size());
12962 DCT_ASSERT((no == tag.Size()));
12963 }
12964 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_SENSOR_MAX_LEVEL_TAG_ID)) {
12965 int no = ParseFloatArray(pchild, &dpcc->sensor_dpcc.max_level, tag.Size());
12966 DCT_ASSERT((no == tag.Size()));
12967 }
12968 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_ISO_TAG_ID)) {
12969 int no = ParseFloatArray(pchild, dpcc->sensor_dpcc.iso, tag.Size());
12970 DCT_ASSERT((no == tag.Size()));
12971 }
12972 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_SENSOR_LEVEL_SINGLE_TAG_ID)) {
12973 int no = ParseFloatArray(pchild, dpcc->sensor_dpcc.level_single, tag.Size());
12974 DCT_ASSERT((no == tag.Size()));
12975 }
12976 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DPCC_SENSOR_LEVEL_MULTIPLE_TAG_ID)) {
12977 int no = ParseFloatArray(pchild, dpcc->sensor_dpcc.level_multiple, tag.Size());
12978 DCT_ASSERT((no == tag.Size()));
12979 }
12980 pchild = pchild->NextSibling();
12981 }
12982
12983 XML_CHECK_END();
12984
12985 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
12986 autoTabBackward();
12987 return (true);
12988 }
12989
parseEntrySensorBayerNrSetting(const XMLElement * pelement,void * param,int index)12990 bool RkAiqCalibParser::parseEntrySensorBayerNrSetting
12991 (
12992 const XMLElement* pelement,
12993 void* param,
12994 int index
12995 ) {
12996 (void)param;
12997
12998 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
12999
13000 CalibDb_BayerNr_ModeCell_t *pModeCell = (CalibDb_BayerNr_ModeCell_t *)param;
13001
13002 XML_CHECK_START(CALIB_SENSOR_BAYERNR_SETTING_TAG_ID, CALIB_SENSOR_BAYERNR_MODE_CELL_TAG_ID);
13003 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_BayerNr_2_t, bayerNr);
13004
13005 const XMLNode* pchild = pelement->FirstChild();
13006 while (pchild) {
13007 XmlTag tag = XmlTag(pchild->ToElement());
13008 std::string tagname(pchild->ToElement()->Name());
13009 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
13010
13011 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_SETTING_SNR_MODE_TAG_ID)) {
13012 ParseString(pchild, pModeCell->setting[index].snr_mode, sizeof(pModeCell->setting[index].snr_mode));
13013 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_SETTING_SENSOR_MODE_TAG_ID)) {
13014 ParseString(pchild, pModeCell->setting[index].sensor_mode, sizeof(pModeCell->setting[index].sensor_mode));
13015 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_ISO_TAG_ID)) {
13016 int no = ParseFloatArray(pchild, pModeCell->setting[index].iso, tag.Size());
13017 DCT_ASSERT((no == tag.Size()));
13018 }
13019 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_FILTPARA_TAG_ID)) {
13020 int no = ParseFloatArray(pchild, pModeCell->setting[index].filtPara, tag.Size());
13021 DCT_ASSERT((no == tag.Size()));
13022 }
13023 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_LURATIO_TAG_ID)) {
13024 int no = ParseFloatArray(pchild, (float*)pModeCell->setting[index].luRatio, tag.Size());
13025 DCT_ASSERT((no == tag.Size()));
13026
13027 }
13028 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_FIXW_TAG_ID)) {
13029 int no = ParseFloatArray(pchild, (float*)pModeCell->setting[index].fixW, tag.Size());
13030 DCT_ASSERT((no == tag.Size()));
13031
13032 }
13033 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_LULEVEL_TAG_ID)) {
13034 int no = ParseFloatArray(pchild, pModeCell->setting[index].luLevel, tag.Size());
13035 DCT_ASSERT((no == tag.Size()));
13036
13037 }
13038 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_LULEVELVAL_TAG_ID)) {
13039 int no = ParseFloatArray(pchild, pModeCell->setting[index].luLevelVal, tag.Size());
13040 DCT_ASSERT((no == tag.Size()));
13041
13042 }
13043 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_LAMDA_TAG_ID)) {
13044 int no = ParseFloatArray(pchild, &pModeCell->setting[index].lamda, tag.Size());
13045 DCT_ASSERT((no == tag.Size()));
13046
13047 }
13048 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_GAUSS_EN_TAG_ID)) {
13049 int no = ParseUcharArray(pchild, &pModeCell->setting[index].gauss_en, tag.Size());
13050 DCT_ASSERT((no == tag.Size()));
13051
13052 }
13053 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_RGAINOFF_TAG_ID)) {
13054 int no = ParseFloatArray(pchild, &pModeCell->setting[index].RGainOff, tag.Size());
13055 DCT_ASSERT((no == tag.Size()));
13056
13057 }
13058 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_RGAINFILP_TAG_ID)) {
13059 int no = ParseFloatArray(pchild, &pModeCell->setting[index].RGainFilp, tag.Size());
13060 DCT_ASSERT((no == tag.Size()));
13061
13062 }
13063 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_BGAINOFF_TAG_ID)) {
13064 int no = ParseFloatArray(pchild, &pModeCell->setting[index].BGainOff, tag.Size());
13065 DCT_ASSERT((no == tag.Size()));
13066
13067 }
13068 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_BGAINFILP_TAG_ID)) {
13069 int no = ParseFloatArray(pchild, &pModeCell->setting[index].BGainFilp, tag.Size());
13070 DCT_ASSERT((no == tag.Size()));
13071
13072 }
13073 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_EDGESOFTNESS_TAG_ID)) {
13074 int no = ParseFloatArray(pchild, &pModeCell->setting[index].edgeSoftness, tag.Size());
13075 DCT_ASSERT((no == tag.Size()));
13076
13077 }
13078 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_GAUSSWEIGHT0_TAG_ID)) {
13079 int no = ParseFloatArray(pchild, &pModeCell->setting[index].gaussWeight0, tag.Size());
13080 DCT_ASSERT((no == tag.Size()));
13081
13082 }
13083 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_GAUSSWEIGHT1_TAG_ID)) {
13084 int no = ParseFloatArray(pchild, &pModeCell->setting[index].gaussWeight1, tag.Size());
13085 DCT_ASSERT((no == tag.Size()));
13086
13087 }
13088 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_BILEDGEFILTER_TAG_ID)) {
13089 int no = ParseFloatArray(pchild, &pModeCell->setting[index].bilEdgeFilter, tag.Size());
13090 DCT_ASSERT((no == tag.Size()));
13091
13092 }
13093 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_BILFILTERSTRENG_TAG_ID)) {
13094 int no = ParseFloatArray(pchild, pModeCell->setting[index].bilFilterStreng, tag.Size());
13095 DCT_ASSERT((no == tag.Size()));
13096
13097 }
13098 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_BILEDGESOFTRATIO_TAG_ID)) {
13099 int no = ParseFloatArray(pchild, &pModeCell->setting[index].bilEdgeSoftRatio, tag.Size());
13100 DCT_ASSERT((no == tag.Size()));
13101
13102 }
13103 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_BILREGWGT_TAG_ID)) {
13104 int no = ParseFloatArray(pchild, &pModeCell->setting[index].bilRegWgt, tag.Size());
13105 DCT_ASSERT((no == tag.Size()));
13106
13107 }
13108 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_BILEDGESOFT_TAG_ID)) {
13109 int no = ParseFloatArray(pchild, &pModeCell->setting[index].bilEdgeSoft, tag.Size());
13110 DCT_ASSERT((no == tag.Size()));
13111
13112 }
13113 pchild = pchild->NextSibling();
13114 }
13115 XML_CHECK_END();
13116 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
13117 return (true);
13118 }
13119
parseEntrySensorBayerNrModeCell(const XMLElement * pelement,void * param)13120 bool RkAiqCalibParser::parseEntrySensorBayerNrModeCell
13121 (
13122 const XMLElement* pelement,
13123 void* param
13124 ) {
13125 (void)param;
13126
13127 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
13128
13129 int index = *((int*)param);
13130 XML_CHECK_START(CALIB_SENSOR_BAYERNR_MODE_CELL_TAG_ID, CALIB_SENSOR_BAYERNR_TAG_ID);
13131 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_BayerNr_2_t, bayerNr);
13132
13133 const XMLNode* pchild = pelement->FirstChild();
13134 while (pchild) {
13135 XmlTag tag = XmlTag(pchild->ToElement());
13136 std::string tagname(pchild->ToElement()->Name());
13137 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
13138
13139 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_MODE_NAME_TAG_ID)) {
13140 ParseString(pchild, bayerNr->mode_cell[index].name, sizeof(bayerNr->mode_cell[index].name));
13141 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_SETTING_TAG_ID)) {
13142 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
13143 &RkAiqCalibParser::parseEntrySensorBayerNrSetting,
13144 &bayerNr->mode_cell[index],
13145 (uint32_t)CALIB_SENSOR_BAYERNR_SETTING_TAG_ID,
13146 (uint32_t)CALIB_SENSOR_BAYERNR_MODE_CELL_TAG_ID)) {
13147 LOGE("parse error in BayerNR setting (%s)\n", tagname.c_str());
13148 return (false);
13149 }
13150 }
13151
13152 pchild = pchild->NextSibling();
13153 }
13154
13155 XML_CHECK_END();
13156 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
13157 return (true);
13158 }
13159
parseEntrySensorBayerNr(const XMLElement * pelement,void * param)13160 bool RkAiqCalibParser::parseEntrySensorBayerNr
13161 (
13162 const XMLElement* pelement,
13163 void* param
13164 ) {
13165 (void)param;
13166
13167 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
13168 autoTabForward();
13169
13170 XML_CHECK_START(CALIB_SENSOR_BAYERNR_TAG_ID, CALIB_SENSOR_TAG_ID);
13171 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_BayerNr_2_t, bayerNr);
13172
13173 const XMLNode* pchild = pelement->FirstChild();
13174 while (pchild) {
13175 XmlTag tag = XmlTag(pchild->ToElement());
13176 std::string tagname(pchild->ToElement()->Name());
13177 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
13178
13179 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_ENABLE_TAG_ID)) {
13180 int no = ParseIntArray(pchild, &bayerNr->enable, tag.Size());
13181 DCT_ASSERT((no == tag.Size()));
13182 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_VERSION_TAG_ID)) {
13183 ParseString(pchild, bayerNr->version, sizeof(bayerNr->version));
13184 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_MODE_CELL_TAG_ID)) {
13185 if (xmlParseReadWrite == XML_PARSER_READ) {
13186 int cell_size = 0;
13187 parseCellNoElement(pchild->ToElement(), tag.Size(), cell_size);
13188 bayerNr->mode_num = cell_size;
13189 bayerNr->mode_cell = (CalibDb_BayerNr_ModeCell_t *)malloc(cell_size * sizeof(CalibDb_BayerNr_ModeCell_t));
13190 memset(bayerNr->mode_cell, 0x00, cell_size * sizeof(CalibDb_BayerNr_ModeCell_t));
13191 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
13192 &RkAiqCalibParser::parseEntrySensorBayerNrModeCell,
13193 param,
13194 (uint32_t)CALIB_SENSOR_BAYERNR_MODE_CELL_TAG_ID,
13195 (uint32_t)CALIB_SENSOR_BAYERNR_TAG_ID)) {
13196 LOGE("parse error in BayerNR Mode cell (%s)\n", tagname.c_str());
13197 return (false);
13198 }
13199 }
13200 else
13201 {
13202 if (!parseEntryCell3((XMLElement *)pchild->ToElement(), tag.Size(), bayerNr->mode_num,
13203 &RkAiqCalibParser::parseEntrySensorBayerNrModeCell,
13204 param,
13205 (uint32_t)CALIB_SENSOR_BAYERNR_MODE_CELL_TAG_ID,
13206 (uint32_t)CALIB_SENSOR_BAYERNR_TAG_ID)) {
13207 LOGE("parse error in BayerNR Mode cell (%s)\n", tagname.c_str());
13208 return (false);
13209 }
13210 }
13211 }
13212
13213 pchild = pchild->NextSibling();
13214 }
13215 XML_CHECK_END();
13216 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
13217 autoTabBackward();
13218 return (true);
13219 }
13220
parseEntrySensorLsc(const XMLElement * pelement,void * param)13221 bool RkAiqCalibParser::parseEntrySensorLsc
13222 (
13223 const XMLElement* pelement,
13224 void* param
13225 ) {
13226 (void)param;
13227
13228 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
13229 autoTabForward();
13230
13231 XML_CHECK_START(CALIB_SENSOR_LSC_TAG_ID, CALIB_SENSOR_TAG_ID);
13232 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Lsc_t, lsc);
13233
13234 unsigned char tableNum = lsc->tableAllNum;
13235 lsc->tableAllNum = 0;
13236 const XMLNode* pchild = pelement->FirstChild();
13237 while (pchild) {
13238 XmlTag tag = XmlTag(pchild->ToElement());
13239 std::string tagname(pchild->ToElement()->Name());
13240 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
13241
13242 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_ENABLE_TAG_ID)) {
13243 uint8_t enable = lsc->enable;
13244 int no = ParseUcharArray(pchild, &enable, tag.Size());
13245 DCT_ASSERT((no == tag.Size()));
13246 lsc->enable = bool(enable);
13247 //lsc->damp_enable = damp_enable;
13248 }
13249 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_DAMP_ENABLE_TAG_ID)) {
13250 uint8_t damp_enable = lsc->damp_enable;
13251 int no = ParseUcharArray(pchild, &damp_enable, tag.Size());
13252 DCT_ASSERT((no == tag.Size()));
13253 lsc->damp_enable = bool(damp_enable);
13254 //lsc->damp_enable = damp_enable;
13255 }
13256 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_ALSCCOF_TAG_ID)) {
13257 if (!parseEntrySensorLscAlscCof(pchild->ToElement())) {
13258 return (false);
13259 }
13260 }
13261 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_TAG_ID)) {
13262 if (xmlParseReadWrite == XML_PARSER_READ) // read
13263 {
13264 lsc->tableAll = (CalibDb_LscTableProfile_t*)malloc(sizeof(CalibDb_LscTableProfile_t) * tag.Size());
13265 memset(lsc->tableAll, 0, sizeof(CalibDb_LscTableProfile_t) * tag.Size());
13266 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
13267 &RkAiqCalibParser::parseEntrySensorLscTableAll,
13268 param,
13269 (uint32_t)CALIB_SENSOR_LSC_TABLEALL_TAG_ID,
13270 (uint32_t)CALIB_SENSOR_LSC_TAG_ID)) {
13271 LOGE("parse error in LSC tableAll (%s)", tagname.c_str());
13272 return (false);
13273 }
13274 }
13275 else
13276 {
13277 if (!parseEntryCell3((XMLElement *)pchild->ToElement(), tag.Size(), tableNum,
13278 &RkAiqCalibParser::parseEntrySensorLscTableAll,
13279 param,
13280 (uint32_t)CALIB_SENSOR_LSC_TABLEALL_TAG_ID,
13281 (uint32_t)CALIB_SENSOR_LSC_TAG_ID)) {
13282 LOGE("parse error in LSC tableAll (%s)", tagname.c_str());
13283 return (false);
13284 }
13285 }
13286 }
13287 pchild = pchild->NextSibling();
13288 }
13289 XML_CHECK_END();
13290 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
13291 autoTabBackward();
13292 return (true);
13293 }
parseEntrySensorLscAlscCof(const XMLElement * pelement,void * param)13294 bool RkAiqCalibParser::parseEntrySensorLscAlscCof
13295 (
13296 const XMLElement* pelement,
13297 void* param
13298 ) {
13299 (void)param;
13300
13301 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
13302 autoTabForward();
13303
13304 XML_CHECK_START(CALIB_SENSOR_LSC_ALSCCOF_TAG_ID, CALIB_SENSOR_LSC_TAG_ID);
13305 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Lsc_t, lsc);
13306
13307 unsigned char lightNum = 0;
13308 for (int i = 0; i < USED_FOR_CASE_MAX; i++)
13309 lightNum += lsc->aLscCof.illuNum[i];
13310 memset(lsc->aLscCof.illuNum, 0, sizeof(lsc->aLscCof.illuNum));
13311 unsigned char resNum = lsc->aLscCof.lscResNum;
13312 lsc->aLscCof.lscResNum = 0;
13313
13314 const XMLNode* pchild = pelement->FirstChild();
13315 while (pchild) {
13316 XmlTag tag = XmlTag(pchild->ToElement());
13317 std::string tagname(pchild->ToElement()->Name());
13318 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
13319
13320 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_ALSCCOF_IllALL_TAG_ID)) {
13321 if (xmlParseReadWrite == XML_PARSER_READ) // read
13322 {
13323 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
13324 &RkAiqCalibParser::parseEntrySensorLscAlscCofIllAll,
13325 param,
13326 (uint32_t)CALIB_SENSOR_LSC_ALSCCOF_IllALL_TAG_ID,
13327 (uint32_t)CALIB_SENSOR_LSC_ALSCCOF_TAG_ID)) {
13328 LOGE("parse error in LSC aLscCof illAll (%s)", tagname.c_str());
13329 return (false);
13330 }
13331 }
13332 else
13333 {
13334 if (!parseEntryCell3((XMLElement *)pchild->ToElement(), tag.Size(), lightNum,
13335 &RkAiqCalibParser::parseEntrySensorLscAlscCofIllAll,
13336 param,
13337 (uint32_t)CALIB_SENSOR_LSC_ALSCCOF_IllALL_TAG_ID,
13338 (uint32_t)CALIB_SENSOR_LSC_ALSCCOF_TAG_ID)) {
13339 LOGE("parse error in LSC aLscCof illAll (%s)", tagname.c_str());
13340 return (false);
13341 }
13342 }
13343 }
13344 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_ALSCCOF_RESALL_TAG_ID)) {
13345 if (xmlParseReadWrite == XML_PARSER_READ)
13346 {
13347 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
13348 &RkAiqCalibParser::parseEntrySensorLscAlscCofResAll,
13349 param,
13350 (uint32_t)CALIB_SENSOR_LSC_ALSCCOF_RESALL_TAG_ID,
13351 (uint32_t)CALIB_SENSOR_LSC_ALSCCOF_TAG_ID)) {
13352 LOGE("parse error in LSC aLscCof resolutionAll(%s)", tagname.c_str());
13353 return (false);
13354 }
13355 }
13356 else
13357 {
13358 if (!parseEntryCell3((XMLElement *)pchild->ToElement(), tag.Size(), resNum,
13359 &RkAiqCalibParser::parseEntrySensorLscAlscCofResAll,
13360 param,
13361 (uint32_t)CALIB_SENSOR_LSC_ALSCCOF_RESALL_TAG_ID,
13362 (uint32_t)CALIB_SENSOR_LSC_ALSCCOF_TAG_ID)) {
13363 LOGE("parse error in LSC aLscCof resolutionAll(%s)", tagname.c_str());
13364 return (false);
13365 }
13366 }
13367 }
13368
13369
13370 pchild = pchild->NextSibling();
13371 }
13372
13373 XML_CHECK_END();
13374 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
13375 autoTabBackward();
13376 return (true);
13377 }
parseEntrySensorLscAlscCofResAll(const XMLElement * pelement,void * param)13378 bool RkAiqCalibParser::parseEntrySensorLscAlscCofResAll
13379 (
13380 const XMLElement* pelement,
13381 void* param
13382 ) {
13383 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
13384
13385 XML_CHECK_START(CALIB_SENSOR_LSC_ALSCCOF_RESALL_TAG_ID, CALIB_SENSOR_LSC_ALSCCOF_TAG_ID);
13386 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Lsc_t, lsc);
13387
13388 int index = *((int*)param);
13389 const XMLNode* pchild = pelement->FirstChild();
13390 while (pchild) {
13391 XmlTag tag = XmlTag(pchild->ToElement());
13392 const char* value = tag.Value();
13393 std::string tagname(pchild->ToElement()->Name());
13394 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
13395 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_ALSCCOF_RESALL_NAME_TAG_ID)) {
13396 ParseString(pchild,
13397 lsc->aLscCof.lscResName[index],
13398 sizeof(lsc->aLscCof.lscResName[index]));//check
13399 }
13400 pchild = pchild->NextSibling();
13401 }
13402 XML_CHECK_END();
13403 lsc->aLscCof.lscResNum++;
13404 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
13405 return (true);
13406 }
13407
parseEntrySensorLscAlscCofIllAll(const XMLElement * pelement,void * param)13408 bool RkAiqCalibParser::parseEntrySensorLscAlscCofIllAll
13409 (
13410 const XMLElement* pelement,
13411 void* param
13412 ) {
13413 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
13414
13415 XML_CHECK_START(CALIB_SENSOR_LSC_ALSCCOF_IllALL_TAG_ID, CALIB_SENSOR_LSC_ALSCCOF_TAG_ID);
13416 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Lsc_t, lsc);
13417
13418 int index = *((int*)param);
13419 const XMLNode* pchild = pelement->FirstChild();
13420 int no1 = 0;
13421 int no2 = 0;
13422 int usedForCase = 0;
13423
13424 while (pchild) {
13425 XmlTag tag = XmlTag(pchild->ToElement());
13426 const char* value = tag.Value();
13427 std::string tagname(pchild->ToElement()->Name());
13428 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
13429
13430 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_ALSCCOF_CASE_TAG_ID)) {
13431 usedForCase = lsc->aLscCof.usedForCaseAll[index];
13432 int no = ParseIntArray(pchild, &usedForCase, tag.Size());
13433 lsc->aLscCof.usedForCaseAll[index] = usedForCase;
13434 index = lsc->aLscCof.illuNum[usedForCase];
13435 DCT_ASSERT((no == tag.Size()));
13436 }
13437 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_ALSCCOF_NAME_TAG_ID)) {
13438 ParseString(pchild,
13439 lsc->aLscCof.illAll[usedForCase][index].illuName,
13440 sizeof(lsc->aLscCof.illAll[usedForCase][index].illuName));
13441 }
13442 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_ALSCCOF_WBGAIN_TAG_ID)) {
13443 int no = ParseFloatArray(pchild, lsc->aLscCof.illAll[usedForCase][index].awbGain, tag.Size());
13444 DCT_ASSERT((no == tag.Size()));
13445 }
13446 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_ALSCCOF_TABLEUSED_TAG_ID)) {
13447 char* lsc_profiles = Toupper(value);
13448 int no = ParseLscProfileArray(pchild, lsc->aLscCof.illAll[usedForCase][index].tableUsed, LSC_PROFILES_NUM_MAX);
13449 DCT_ASSERT((no <= LSC_PROFILES_NUM_MAX));
13450 lsc->aLscCof.illAll[usedForCase][index].tableUsedNO = no;
13451 }
13452 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_ALSCCOF_GAINS_TAG_ID)) {
13453 no1 = ParseFloatArray(pchild, lsc->aLscCof.illAll[usedForCase][index].vignettingCurve.pSensorGain, tag.Size());
13454 lsc->aLscCof.illAll[usedForCase][index].vignettingCurve.arraySize = no1;
13455 DCT_ASSERT((no1 == tag.Size()));
13456 }
13457 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_ALSCCOF_VIG_TAG_ID)) {
13458 no2 = ParseFloatArray(pchild, lsc->aLscCof.illAll[usedForCase][index].vignettingCurve.pVignetting, tag.Size());
13459 lsc->aLscCof.illAll[usedForCase][index].vignettingCurve.arraySize = no2;
13460 DCT_ASSERT((no2 == tag.Size()));
13461 }
13462 else {
13463 LOGW("UNKNOWN tag: %s", tagname.c_str());
13464 }
13465 pchild = pchild->NextSibling();
13466 }
13467
13468 XML_CHECK_END();
13469
13470 DCT_ASSERT(no1 == no2);
13471 lsc->aLscCof.illuNum[usedForCase]++;
13472 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
13473 return (true);
13474 }
AwbLscGradientCheck(CalibDb_LscTableProfile_t * pLscProfile)13475 static int AwbLscGradientCheck
13476 (
13477 CalibDb_LscTableProfile_t* pLscProfile
13478 ) {
13479 uint32_t i;
13480
13481 LOGI("%s: (enter)\n", __FUNCTION__);
13482
13483 if (NULL == pLscProfile) {
13484 return (1);
13485 }
13486
13487 if (0 < pLscProfile->LscYo) {
13488 for (i = 0; i < (sizeof(pLscProfile->LscYGradTbl) / sizeof(pLscProfile->LscYGradTbl[0])); ++i) {
13489 if (0 < pLscProfile->LscYSizeTbl[i]) {
13490 pLscProfile->LscYGradTbl[i] = (uint16_t)((double)(1UL << pLscProfile->LscYo) / pLscProfile->LscYSizeTbl[i] + 0.5);
13491 }
13492 else {
13493 return (2);
13494 }
13495 }
13496 }
13497 else {
13498 memset(pLscProfile->LscYGradTbl, 0, sizeof(pLscProfile->LscYGradTbl));
13499 }
13500
13501 if (0 < pLscProfile->LscXo) {
13502 for (i = 0; i < (sizeof(pLscProfile->LscXGradTbl) / sizeof(pLscProfile->LscXGradTbl[0])); ++i) {
13503 if (0 < pLscProfile->LscXSizeTbl[i]) {
13504 pLscProfile->LscXGradTbl[i] = (uint16_t)((double)(1UL << pLscProfile->LscXo) / pLscProfile->LscXSizeTbl[i] + 0.5);
13505 }
13506 else {
13507 return (2);
13508 }
13509 }
13510 }
13511 else {
13512 memset(pLscProfile->LscXGradTbl, 0, sizeof(pLscProfile->LscXGradTbl));
13513 }
13514
13515 LOGI("%s: (exit)\n", __FUNCTION__);
13516
13517 return (0);
13518 }
13519
parseEntrySensorLscTableAll(const XMLElement * pelement,void * param)13520 bool RkAiqCalibParser::parseEntrySensorLscTableAll
13521 (
13522 const XMLElement* pelement,
13523 void* param
13524 ) {
13525 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
13526
13527 XML_CHECK_START(CALIB_SENSOR_LSC_TABLEALL_TAG_ID, CALIB_SENSOR_LSC_TAG_ID);
13528 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Lsc_t, lsc);
13529 int index = *((int*)param);
13530 const XMLNode* pchild = pelement->FirstChild();
13531 while (pchild) {
13532 XmlTag tag = XmlTag(pchild->ToElement());
13533 const char* value = tag.Value();
13534 std::string tagname(pchild->ToElement()->Name());
13535 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
13536
13537 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_NAME_TAG_ID)) {
13538 ParseString(pchild,
13539 lsc->tableAll[index].name,
13540 sizeof(lsc->tableAll[index].name));
13541 }
13542 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_RESOLUTION_TAG_ID)) {
13543 ParseString(pchild,
13544 lsc->tableAll[index].resolution,
13545 sizeof(lsc->tableAll[index].resolution));
13546
13547 }
13548 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_ILLUMINATION_TAG_ID)) {
13549 ParseString(pchild,
13550 lsc->tableAll[index].illumination,
13551 sizeof(lsc->tableAll[index].illumination));
13552
13553 }
13554 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_LSC_SECTORS_TAG_ID)) {
13555 int no = ParseUshortArray(pchild, &lsc->tableAll[index].LscSectors, tag.Size());
13556 DCT_ASSERT((no == tag.Size()));
13557
13558 }
13559 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_LSC_NO_TAG_ID)) {
13560 int no = ParseUshortArray(pchild, &lsc->tableAll[index].LscNo, tag.Size());
13561 DCT_ASSERT((no == tag.Size()));
13562
13563 }
13564 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_LSC_XO_TAG_ID)) {
13565 int no = ParseUshortArray(pchild, &lsc->tableAll[index].LscXo, tag.Size());
13566 DCT_ASSERT((no == tag.Size()));
13567
13568 }
13569 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_LSC_YO_TAG_ID)) {
13570 int no = ParseUshortArray(pchild, &lsc->tableAll[index].LscYo, tag.Size());
13571 DCT_ASSERT((no == tag.Size()));
13572
13573 }
13574 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_LSC_SECTOR_SIZE_X_TAG_ID)) {
13575 int no = ParseUshortArray(pchild, lsc->tableAll[index].LscXSizeTbl, tag.Size());
13576 DCT_ASSERT((no == tag.Size()));
13577
13578 }
13579 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_LSC_SECTOR_SIZE_Y_TAG_ID)) {
13580 int no = ParseUshortArray(pchild, lsc->tableAll[index].LscYSizeTbl, tag.Size());
13581 DCT_ASSERT((no == tag.Size()));
13582
13583 }
13584 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_LSC_VIGNETTING_TAG_ID)) {
13585 int no = ParseFloatArray(pchild, &lsc->tableAll[index].vignetting, tag.Size());
13586 DCT_ASSERT((no == tag.Size()));
13587 }
13588 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_LSC_SAMPLES_RED_TAG_ID)) {
13589 int no = ParseUshortArray(pchild, lsc->tableAll[index].LscMatrix[0].uCoeff, tag.Size());
13590 DCT_ASSERT((no == tag.Size()));
13591
13592 }
13593 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_LSC_SAMPLES_GREENR_TAG_ID)) {
13594 int no = ParseUshortArray(pchild, lsc->tableAll[index].LscMatrix[1].uCoeff, tag.Size());
13595 DCT_ASSERT((no == tag.Size()));
13596
13597 }
13598 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_LSC_SAMPLES_GREENB_TAG_ID)) {
13599 int no = ParseUshortArray(pchild, lsc->tableAll[index].LscMatrix[2].uCoeff, tag.Size());
13600 DCT_ASSERT((no == tag.Size()));
13601
13602 }
13603 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LSC_TABLEALL_LSC_SAMPLES_BLUE_TAG_ID)) {
13604 int no = ParseUshortArray(pchild, lsc->tableAll[index].LscMatrix[3].uCoeff, tag.Size());
13605 DCT_ASSERT((no == tag.Size()));
13606
13607 }
13608 else {
13609 LOGW("UNKNOWN tag: %s", tagname.c_str());
13610 }
13611 pchild = pchild->NextSibling();
13612 }
13613 XML_CHECK_END();
13614 int ret = AwbLscGradientCheck(&lsc->tableAll[index]);
13615 DCT_ASSERT(ret == 0);
13616 lsc->tableAllNum++;
13617 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
13618 return (true);
13619 }
13620
parseEntrySensorRKDM(const XMLElement * pelement,void * param)13621 bool RkAiqCalibParser::parseEntrySensorRKDM
13622 (
13623 const XMLElement* pelement,
13624 void* param
13625 ) {
13626 (void)param;
13627
13628 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
13629 autoTabForward();
13630
13631 XML_CHECK_START(CALIB_SENSOR_RKDM_TAG_ID, CALIB_SENSOR_TAG_ID);
13632 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_RKDM_t, dm);
13633
13634 const XMLNode* pchild = pelement->FirstChild();
13635 while (pchild) {
13636 XmlTag tag = XmlTag(pchild->ToElement());
13637 std::string tagname(pchild->ToElement()->Name());
13638 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
13639
13640 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_ENABLE_TAG_ID)) {
13641 int no = ParseUcharArray(pchild, &dm->debayer_en, tag.Size());
13642 DCT_ASSERT((no == tag.Size()));
13643 }
13644 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_DEBAYER_FILTER1_TAG_ID)) {
13645 int no = ParseCharArray(pchild, dm->debayer_filter1, tag.Size());
13646 DCT_ASSERT((no == tag.Size()));
13647
13648 }
13649 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_DEBAYER_FILTER2_TAG_ID)) {
13650 int no = ParseCharArray(pchild, dm->debayer_filter2, tag.Size());
13651 DCT_ASSERT((no == tag.Size()));
13652
13653 }
13654 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_DEBAYER_GAIN_OFFSET_TAG_ID)) {
13655 int no = ParseUcharArray(pchild, &dm->debayer_gain_offset, tag.Size());
13656 DCT_ASSERT((no == tag.Size()));
13657
13658 }
13659 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_ISO_TAG_ID)) {
13660 int no = ParseIntArray(pchild, dm->ISO, tag.Size());
13661 DCT_ASSERT((no == tag.Size()));
13662
13663 }
13664 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_SHARP_STRENGTH_TAG_ID)) {
13665 int no = ParseUcharArray(pchild, dm->sharp_strength, tag.Size());
13666 DCT_ASSERT((no == tag.Size()));
13667
13668 }
13669 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_DEBAYER_HF_OFFSET_TAG_ID)) {
13670 int no = ParseUshortArray(pchild, dm->debayer_hf_offset, tag.Size());
13671 DCT_ASSERT((no == tag.Size()));
13672
13673 }
13674 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_DEBAYER_OFFSET_TAG_ID)) {
13675 int no = ParseUcharArray(pchild, &dm->debayer_offset, tag.Size());
13676 DCT_ASSERT((no == tag.Size()));
13677
13678 }
13679 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_DEBAYER_CLIP_EN_TAG_ID)) {
13680 int no = ParseUcharArray(pchild, &dm->debayer_clip_en, tag.Size());
13681 DCT_ASSERT((no == tag.Size()));
13682
13683 }
13684 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_DEBAYER_FILTER_G_EN_TAG_ID)) {
13685 int no = ParseUcharArray(pchild, &dm->debayer_filter_g_en, tag.Size());
13686 DCT_ASSERT((no == tag.Size()));
13687
13688 }
13689 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_DEBAYER_FILTER_C_EN_TAG_ID)) {
13690 int no = ParseUcharArray(pchild, &dm->debayer_filter_c_en, tag.Size());
13691 DCT_ASSERT((no == tag.Size()));
13692
13693 }
13694 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_DEBAYER_THED0_TAG_ID)) {
13695 int no = ParseUcharArray(pchild, &dm->debayer_thed0, tag.Size());
13696 DCT_ASSERT((no == tag.Size()));
13697
13698 }
13699 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_DEBAYER_THED1_TAG_ID)) {
13700 int no = ParseUcharArray(pchild, &dm->debayer_thed1, tag.Size());
13701 DCT_ASSERT((no == tag.Size()));
13702
13703 }
13704 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_DEBAYER_DIST_SCALE_TAG_ID)) {
13705 int no = ParseUcharArray(pchild, &dm->debayer_dist_scale, tag.Size());
13706 DCT_ASSERT((no == tag.Size()));
13707
13708 }
13709 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_DEBAYER_CNR_STRENGTH_TAG_ID)) {
13710 int no = ParseUcharArray(pchild, &dm->debayer_cnr_strength, tag.Size());
13711 DCT_ASSERT((no == tag.Size()));
13712
13713 }
13714 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_RKDM_DEBAYER_SHIFT_NUM_TAG_ID)) {
13715 int no = ParseUcharArray(pchild, &dm->debayer_shift_num, tag.Size());
13716 DCT_ASSERT((no == tag.Size()));
13717
13718 }
13719 else {
13720 LOGW("UNKNOWN tag: %s", tagname.c_str());
13721 }
13722 pchild = pchild->NextSibling();
13723 }
13724 XML_CHECK_END();
13725 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
13726 autoTabBackward();
13727 return (true);
13728 }
13729
parseEntrySensorlumaCCMGAC(const XMLElement * pelement,void * param,int index)13730 bool RkAiqCalibParser::parseEntrySensorlumaCCMGAC
13731 (
13732 const XMLElement* pelement,
13733 void* param,
13734 int index
13735 ) {
13736 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
13737 autoTabForward();
13738
13739 XML_CHECK_START(CALIB_SENSOR_CCM_LUMA_CCM_GAIN_ALPHASCALE_CURVE_TAG_ID, CALIB_SENSOR_CCM_LUMA_CCM_TAG_ID);
13740 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Ccm_t, ccm);
13741
13742 const XMLNode* psubsubchild = pelement->FirstChild();
13743 int no1 = 0, no2 = 0;
13744 while (psubsubchild) {
13745 XmlTag subsubTag = XmlTag(psubsubchild->ToElement());
13746 std::string subsubTagname(psubsubchild->ToElement()->Name());
13747 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subsubTagname.c_str()), subsubTag.Type(), subsubTag.Size());
13748
13749 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_LUMA_CCM_GAIN_TAG_ID)) {
13750 no1 = ParseFloatArray(psubsubchild, ccm->mode_cell[index].luma_ccm.alpha_gain, subsubTag.Size());
13751 DCT_ASSERT((no1 == subsubTag.Size()));
13752 }
13753 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_LUMA_CCM_SCALE_TAG_ID)) {
13754 no2 = ParseFloatArray(psubsubchild, ccm->mode_cell[index].luma_ccm.alpha_scale, subsubTag.Size());
13755 DCT_ASSERT((no2 == subsubTag.Size()));
13756 }
13757 psubsubchild = psubsubchild->NextSibling();
13758 }
13759 DCT_ASSERT(no1 == no2);
13760 ccm->mode_cell[index].luma_ccm.gain_scale_cure_size = no1;
13761 XML_CHECK_END();
13762 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
13763 autoTabBackward();
13764 return (true);
13765 }
13766
13767
parseEntrySensorlumaCCM(const XMLElement * pelement,void * param,int index)13768 bool RkAiqCalibParser::parseEntrySensorlumaCCM
13769 (
13770 const XMLElement* pelement,
13771 void* param,
13772 int index
13773 ) {
13774 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
13775 autoTabForward();
13776
13777 XML_CHECK_START(CALIB_SENSOR_CCM_LUMA_CCM_TAG_ID, CALIB_SENSOR_CCM_MODE_CELL_TAG_ID);
13778 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Ccm_t, ccm);
13779
13780 const XMLNode* psubchild = pelement->FirstChild();
13781 while (psubchild) {
13782 XmlTag subTag = XmlTag(psubchild->ToElement());
13783 std::string subTagname(psubchild->ToElement()->Name());
13784 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
13785 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_LUMA_CCM_RGB2Y_PARA_TAG_ID)) {
13786 int no = ParseFloatArray(psubchild, ccm->mode_cell[index].luma_ccm.rgb2y_para, subTag.Size());
13787 DCT_ASSERT((no == subTag.Size()));
13788
13789 }
13790 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_LUMA_CCM_LOW_BOUND_POS_BIT_TAG_ID)) {
13791 int no = ParseFloatArray(psubchild, &ccm->mode_cell[index].luma_ccm.low_bound_pos_bit, subTag.Size());
13792 DCT_ASSERT((no == subTag.Size()));
13793
13794 }
13795 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_LUMA_CCM_Y_ALPHA_CURVE_TAG_ID)) {
13796 int no = ParseFloatArray(psubchild, ccm->mode_cell[index].luma_ccm.y_alpha_curve, subTag.Size());
13797 DCT_ASSERT((no == subTag.Size()));
13798
13799 }
13800 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_LUMA_CCM_GAIN_ALPHASCALE_CURVE_TAG_ID)) {
13801 if (!parseEntrySensorlumaCCMGAC(psubchild->ToElement(), param, index)) {
13802 LOGE("parse error in CCM lumaCCM (%s)\n", subTagname.c_str());
13803 return (false);
13804 }
13805 }
13806 psubchild = psubchild->NextSibling();
13807 }
13808
13809 XML_CHECK_END();
13810
13811 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
13812 autoTabBackward();
13813 return (true);
13814 }
13815
parseEntrySensorCCMModeCell(const XMLElement * pelement,void * param)13816 bool RkAiqCalibParser::parseEntrySensorCCMModeCell
13817 (
13818 const XMLElement* pelement,
13819 void* param
13820 ) {
13821 (void)param;
13822
13823 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
13824
13825 autoTabForward();
13826
13827 XML_CHECK_START(CALIB_SENSOR_CCM_MODE_CELL_TAG_ID, CALIB_SENSOR_CCM_TAG_ID);
13828 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Ccm_t, ccm);
13829
13830 int index = *((int*)param);
13831 bool indexValid = false;
13832 unsigned int allNum = ccm->mode_cell[index].matrixAllNum;
13833 ccm->mode_cell[index].matrixAllNum = 0;
13834
13835 const XMLNode* pchild = pelement->FirstChild();
13836 while (pchild) {
13837 XmlTag tag = XmlTag(pchild->ToElement());
13838 std::string tagname(pchild->ToElement()->Name());
13839 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
13840
13841 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_MODE_NAME_TAG_ID)) {
13842 char mode[CCM_PROFILE_NAME];
13843 //ParseString(pchild, mode, sizeof(mode));
13844 ParseString(pchild, ccm->mode_cell[index].name, sizeof(ccm->mode_cell[index].name));
13845 indexValid = true;
13846 if (0 == strcmp(ccm->mode_cell[index].name, "normal")) {
13847 index = CCM_FOR_MODE_NORMAL;
13848 }
13849 else if (0 == strcmp(ccm->mode_cell[index].name, "hdr")) {
13850 index = CCM_FOR_MODE_HDR;
13851 }
13852 else {
13853 LOGE("mode: %s in CCM ModeCell is invalid. instead normal or hdr\n", ccm->mode_cell[index].name);
13854 return(false);
13855 }
13856 }
13857 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_DAMP_ENABLE_TAG_ID) && indexValid) {
13858 uint8_t uValue = ccm->mode_cell[index].damp_enable;
13859 int no = ParseUcharArray(pchild, &uValue, tag.Size());
13860 DCT_ASSERT((no == tag.Size()));
13861 ccm->mode_cell[index].damp_enable = (bool)uValue;
13862 }
13863 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_LUMA_CCM_TAG_ID) && indexValid) {
13864 INFO_PRINT(tagname.c_str());
13865 if (!parseEntrySensorlumaCCM(pchild->ToElement(), param, index)) {
13866 LOGE("parse error in CCM lumaCCM (%s)\n", tagname.c_str());
13867 return (false);
13868 }
13869 }
13870 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_ACCMCOF_TAG_ID) && indexValid) {
13871 if (!parseEntrySensorCcmAccmCof(pchild->ToElement(), param, index)) {
13872 LOGE("parse error in CCM aCCmCof (%s)\n", tagname.c_str());
13873 return (false);
13874 }
13875 }
13876 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_MATRIXALL_TAG_ID) && indexValid) {
13877 if (xmlParseReadWrite == XML_PARSER_READ)
13878 {
13879 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
13880 &RkAiqCalibParser::parseEntrySensorCcmMatrixAll,
13881 &ccm->mode_cell[index],
13882 (uint32_t)CALIB_SENSOR_CCM_MATRIXALL_TAG_ID,
13883 (uint32_t)CALIB_SENSOR_CCM_MODE_CELL_TAG_ID)) {
13884 LOGE("parse error in CCM matrixall (%s)\n", tagname.c_str());
13885 return (false);
13886 }
13887 }
13888 else
13889 {
13890 if (!parseEntryCell4((XMLElement*)pchild->ToElement(), tag.Size(), allNum,
13891 &RkAiqCalibParser::parseEntrySensorCcmMatrixAll,
13892 &ccm->mode_cell[index],
13893 (uint32_t)CALIB_SENSOR_CCM_MATRIXALL_TAG_ID,
13894 (uint32_t)CALIB_SENSOR_CCM_MODE_CELL_TAG_ID)) {
13895 LOGE("parse error in CCM matrixall (%s)\n", tagname.c_str());
13896 return (false);
13897 }
13898 }
13899 }
13900 pchild = pchild->NextSibling();
13901 }
13902 DCT_ASSERT((indexValid == true));
13903 XML_CHECK_END();
13904 ccm->modecellNum++;
13905 ccm->mode_cell[index].valid = true;
13906 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
13907 return (true);
13908 }
13909
parseEntrySensorCCM(const XMLElement * pelement,void * param)13910 bool RkAiqCalibParser::parseEntrySensorCCM
13911 (
13912 const XMLElement* pelement,
13913 void* param
13914 ) {
13915 (void)param;
13916
13917 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
13918 autoTabForward();
13919
13920 XML_CHECK_START(CALIB_SENSOR_CCM_TAG_ID, CALIB_SENSOR_TAG_ID);
13921 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Ccm_t, ccm);
13922
13923 unsigned char cellNum = ccm->modecellNum;
13924 ccm->modecellNum = 0;
13925 const XMLNode* pchild = pelement->FirstChild();
13926 while (pchild) {
13927 XmlTag tag = XmlTag(pchild->ToElement());
13928 std::string tagname(pchild->ToElement()->Name());
13929 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
13930
13931 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_ENABLE_TAG_ID)) {
13932 uint8_t uValue = ccm->enable;
13933 int no = ParseUcharArray(pchild, &uValue, tag.Size());
13934 DCT_ASSERT((no == tag.Size()));
13935 ccm->enable = (bool)uValue;
13936 }
13937 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_MODE_CELL_TAG_ID)) {
13938 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
13939 &RkAiqCalibParser::parseEntrySensorCCMModeCell,
13940 param,
13941 (uint32_t)CALIB_SENSOR_CCM_MODE_CELL_TAG_ID,
13942 (uint32_t)CALIB_SENSOR_CCM_TAG_ID)) {
13943 LOGE("parse error in ccm mode cell (%s)", tagname.c_str());
13944 return (false);
13945 }
13946 }
13947
13948 pchild = pchild->NextSibling();
13949 }
13950 XML_CHECK_END();
13951 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
13952 autoTabBackward();
13953 return (true);
13954 }
13955
parseEntrySensorCcmAccmCof(const XMLElement * pelement,void * param,int index)13956 bool RkAiqCalibParser::parseEntrySensorCcmAccmCof
13957 (
13958 const XMLElement* pelement,
13959 void* param,
13960 int index
13961 ) {
13962 (void)param;
13963
13964 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
13965 autoTabForward();
13966
13967 XML_CHECK_START(CALIB_SENSOR_CCM_ACCMCOF_TAG_ID, CALIB_SENSOR_CCM_MODE_CELL_TAG_ID);
13968
13969 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Ccm_t, ccm);
13970 //ccm->mode_cell[index].aCcmCof.illuNum = 0;
13971
13972 const XMLNode* pchild = pelement->FirstChild();
13973 while (pchild) {
13974 XmlTag tag = XmlTag(pchild->ToElement());
13975 std::string tagname(pchild->ToElement()->Name());
13976 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
13977
13978 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_ACCMCOF_IllALL_TAG_ID)) {
13979 unsigned char lightNum = ccm->mode_cell[index].aCcmCof.illuNum;
13980 ccm->mode_cell[index].aCcmCof.illuNum = 0;
13981 if (xmlParseReadWrite == XML_PARSER_READ)
13982 {
13983 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
13984 &RkAiqCalibParser::parseEntrySensorCcmAccmCofIllAll,
13985 &ccm->mode_cell[index],
13986 (uint32_t)CALIB_SENSOR_CCM_ACCMCOF_IllALL_TAG_ID,
13987 (uint32_t)CALIB_SENSOR_CCM_ACCMCOF_TAG_ID)) {
13988 LOGE("parse error in LSC aCcmCof illAll (%s)", tagname.c_str());
13989 return (false);
13990 }
13991 }
13992 else
13993 {
13994 if (!parseEntryCell4((XMLElement*)pchild->ToElement(), tag.Size(), lightNum,
13995 &RkAiqCalibParser::parseEntrySensorCcmAccmCofIllAll,
13996 &ccm->mode_cell[index],
13997 (uint32_t)CALIB_SENSOR_CCM_ACCMCOF_IllALL_TAG_ID,
13998 (uint32_t)CALIB_SENSOR_CCM_ACCMCOF_TAG_ID)) {
13999 LOGE("parse error in LSC aCcmCof illAll (%s)", tagname.c_str());
14000 return (false);
14001 }
14002 }
14003 }
14004 pchild = pchild->NextSibling();
14005 }
14006 XML_CHECK_END();
14007 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14008 autoTabBackward();
14009 return (true);
14010 }
14011
14012
parseEntrySensorCcmAccmCofIllAll(const XMLElement * pelement,void * param,int index)14013 bool RkAiqCalibParser::parseEntrySensorCcmAccmCofIllAll
14014 (
14015 const XMLElement* pelement,
14016 void* param,
14017 int index
14018 ) {
14019 (void)param;
14020
14021 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14022
14023 CalibDb_Ccm_ModeCell_t *pModeCell = (CalibDb_Ccm_ModeCell_t *)param;
14024
14025 XML_CHECK_START(CALIB_SENSOR_CCM_ACCMCOF_IllALL_TAG_ID, CALIB_SENSOR_CCM_ACCMCOF_TAG_ID);
14026
14027
14028 //int index = *((int*)param);
14029 const XMLNode* pchild = pelement->FirstChild();
14030 int no1 = 0;
14031 int no2 = 0;
14032 while (pchild) {
14033 XmlTag tag = XmlTag(pchild->ToElement());
14034 const char* value = tag.Value();
14035 std::string tagname(pchild->ToElement()->Name());
14036 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14037 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_ACCMCOF_NAME_TAG_ID)) {
14038 ParseString(pchild,
14039 pModeCell->aCcmCof.illAll[index].illuName,
14040 sizeof(pModeCell->aCcmCof.illAll[index].illuName));
14041 }
14042 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_ACCMCOF_WBGAIN_TAG_ID)) {
14043 int no = ParseFloatArray(pchild, pModeCell->aCcmCof.illAll[index].awbGain, tag.Size());
14044 DCT_ASSERT((no == tag.Size()));
14045 }
14046 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_ACCMCOF_MATRIXUSED_TAG_ID)) {
14047 char* ccm_profiles = Toupper(value);
14048 int no = ParseLscProfileArray(pchild, pModeCell->aCcmCof.illAll[index].matrixUsed, CCM_PROFILES_NUM_MAX);
14049 DCT_ASSERT((no <= CCM_PROFILES_NUM_MAX));
14050 pModeCell->aCcmCof.illAll[index].matrixUsedNO = no;
14051 }
14052 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_ACCMCOF_GAINS_TAG_ID)) {
14053 no1 = ParseFloatArray(pchild, pModeCell->aCcmCof.illAll[index].saturationCurve.pSensorGain, tag.Size());
14054 pModeCell->aCcmCof.illAll[index].saturationCurve.arraySize = no1;
14055 DCT_ASSERT((no1 == tag.Size()));
14056 }
14057 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_ACCMCOF_SAT_TAG_ID)) {
14058 no2 = ParseFloatArray(pchild, pModeCell->aCcmCof.illAll[index].saturationCurve.pSaturation, tag.Size());
14059 pModeCell->aCcmCof.illAll[index].saturationCurve.arraySize = no2;
14060 DCT_ASSERT((no2 == tag.Size()));
14061 }
14062 pchild = pchild->NextSibling();
14063 }
14064 XML_CHECK_END();
14065
14066 DCT_ASSERT(no1 == no2);
14067 pModeCell->aCcmCof.illuNum++;
14068 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14069 return (true);
14070 }
14071
14072
parseEntrySensorCcmMatrixAll(const XMLElement * pelement,void * param,int index)14073 bool RkAiqCalibParser::parseEntrySensorCcmMatrixAll
14074 (
14075 const XMLElement* pelement,
14076 void* param,
14077 int index
14078 ) {
14079 (void)param;
14080
14081 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14082
14083 CalibDb_Ccm_ModeCell_t *pModeCell = (CalibDb_Ccm_ModeCell_t *)param;
14084
14085 XML_CHECK_START(CALIB_SENSOR_CCM_MATRIXALL_TAG_ID, CALIB_SENSOR_CCM_MODE_CELL_TAG_ID);
14086
14087 // int index = *((int*)param);
14088 const XMLNode* pchild = pelement->FirstChild();
14089 while (pchild) {
14090 XmlTag tag = XmlTag(pchild->ToElement());
14091 const char* value = tag.Value();
14092 std::string tagname(pchild->ToElement()->Name());
14093 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14094
14095 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_MATRIXALL_NAME_TAG_ID)) {
14096 ParseString(pchild,
14097 pModeCell->matrixAll[index].name,
14098 sizeof(pModeCell->matrixAll[index].name));
14099 }
14100 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_MATRIXALL_ILLUMINATION_TAG_ID)) {
14101 ParseString(pchild,
14102 pModeCell->matrixAll[index].illumination,
14103 sizeof(pModeCell->matrixAll[index].illumination));
14104 }
14105 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_MATRIXALL_SAT_TAG_ID)) {
14106 int no = ParseFloatArray(pchild, &pModeCell->matrixAll[index].saturation, 1);
14107 DCT_ASSERT((no == 1));
14108 }
14109 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_MATRIXALL_MATRIX_TAG_ID)) {
14110 int i = (sizeof(pModeCell->matrixAll[index].CrossTalkCoeff)
14111 / sizeof(pModeCell->matrixAll[index].CrossTalkCoeff.fCoeff[0]));
14112 int no = ParseFloatArray(pchild, pModeCell->matrixAll[index].CrossTalkCoeff.fCoeff, i);
14113 DCT_ASSERT((no == tag.Size()));
14114 }
14115 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CCM_MATRIXALL_OFFSET_TAG_ID))
14116 {
14117 int i = (sizeof(pModeCell->matrixAll[index].CrossTalkOffset)
14118 / sizeof(pModeCell->matrixAll[index].CrossTalkOffset.fCoeff[0]));
14119 int no = ParseFloatArray(pchild, pModeCell->matrixAll[index].CrossTalkOffset.fCoeff, i);
14120 DCT_ASSERT((no == tag.Size()));
14121 }
14122 pchild = pchild->NextSibling();
14123 }
14124 XML_CHECK_END();
14125 pModeCell->matrixAllNum++;
14126 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14127 return (true);
14128 }
14129
parseEntrySensorUVNRSetting(const XMLElement * pelement,void * param,int index)14130 bool RkAiqCalibParser::parseEntrySensorUVNRSetting
14131 (
14132 const XMLElement* pelement,
14133 void* param,
14134 int index
14135 ) {
14136 (void)param;
14137
14138 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14139
14140 CalibDb_UVNR_ModeCell_t * pModeCell = (CalibDb_UVNR_ModeCell_t *)param;
14141 XML_CHECK_START(CALIB_SENSOR_UVNR_SETTING_TAG_ID, CALIB_SENSOR_UVNR_MODE_CELL_TAG_ID);
14142
14143 const XMLNode* pchild = pelement->FirstChild();
14144 while (pchild) {
14145 XmlTag tag = XmlTag(pchild->ToElement());
14146 std::string tagname(pchild->ToElement()->Name());
14147 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14148
14149 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_SETTING_SNR_MODE_TAG_ID)) {
14150 ParseString(pchild, pModeCell->setting[index].snr_mode, sizeof(pModeCell->setting[index].snr_mode));
14151 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_SETTING_SENSOR_MODE_TAG_ID)) {
14152 ParseString(pchild, pModeCell->setting[index].sensor_mode, sizeof(pModeCell->setting[index].sensor_mode));
14153 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_ISO_TAG_ID)) {
14154 int no = ParseFloatArray(pchild, pModeCell->setting[index].ISO, tag.Size());
14155 DCT_ASSERT((no == tag.Size()));
14156 }
14157 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP0_UVGRAD_RATIO_TAG_ID)) {
14158 int no = ParseFloatArray(pchild, pModeCell->setting[index].step0_uvgrad_ratio, tag.Size());
14159 DCT_ASSERT((no == tag.Size()));
14160 }
14161 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP0_UVGRAD_OFFSET_TAG_ID)) {
14162 int no = ParseFloatArray(pchild, pModeCell->setting[index].step0_uvgrad_offset, tag.Size());
14163 DCT_ASSERT((no == tag.Size()));
14164 }
14165 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_NONMED1_TAG_ID)) {
14166 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_nonMed1, tag.Size());
14167 DCT_ASSERT((no == tag.Size()));
14168 }
14169 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_NONBF1_TAG_ID)) {
14170 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_nonBf1, tag.Size());
14171 DCT_ASSERT((no == tag.Size()));
14172 }
14173 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_DOWNSAMPLE_W_TAG_ID)) {
14174 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_downSample_w, tag.Size());
14175 DCT_ASSERT((no == tag.Size()));
14176 }
14177 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_DOWNSAMPLE_H_TAG_ID)) {
14178 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_downSample_h, tag.Size());
14179 DCT_ASSERT((no == tag.Size()));
14180 }
14181 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_DOWNSAMPLE_MEANSIZE_TAG_ID)) {
14182 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_downSample_meansize, tag.Size());
14183 DCT_ASSERT((no == tag.Size()));
14184 }
14185 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_MEDIAN_RATIO_TAG_ID)) {
14186 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_median_ratio, tag.Size());
14187 DCT_ASSERT((no == tag.Size()));
14188 }
14189 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_MEDIAN_SIZE_TAG_ID)) {
14190 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_median_size, tag.Size());
14191 DCT_ASSERT((no == tag.Size()));
14192 }
14193 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_MEDIAN_IIR_TAG_ID)) {
14194 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_median_IIR, tag.Size());
14195 DCT_ASSERT((no == tag.Size()));
14196 }
14197 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_BF_SIGMAR_TAG_ID)) {
14198 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_bf_sigmaR, tag.Size());
14199 DCT_ASSERT((no == tag.Size()));
14200 }
14201 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_BF_UVGAIN_TAG_ID)) {
14202 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_bf_uvgain, tag.Size());
14203 DCT_ASSERT((no == tag.Size()));
14204 }
14205 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_BF_RATIO_TAG_ID)) {
14206 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_bf_ratio, tag.Size());
14207 DCT_ASSERT((no == tag.Size()));
14208 }
14209 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_BF_SIZE_TAG_ID)) {
14210 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_bf_size, tag.Size());
14211 DCT_ASSERT((no == tag.Size()));
14212 }
14213 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_BF_SIGMAD_TAG_ID)) {
14214 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_bf_sigmaD, tag.Size());
14215 DCT_ASSERT((no == tag.Size()));
14216 }
14217 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_BF_ISROWIIR_TAG_ID)) {
14218 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_bf_isRowIIR, tag.Size());
14219 DCT_ASSERT((no == tag.Size()));
14220 }
14221 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP1_BF_ISYCOPY_TAG_ID)) {
14222 int no = ParseFloatArray(pchild, pModeCell->setting[index].step1_bf_isYcopy, tag.Size());
14223 DCT_ASSERT((no == tag.Size()));
14224 }
14225 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_NONEXT_BLOCK_TAG_ID)) {
14226 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_nonExt_block, tag.Size());
14227 DCT_ASSERT((no == tag.Size()));
14228 }
14229 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_NONMED_TAG_ID)) {
14230 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_nonMed, tag.Size());
14231 DCT_ASSERT((no == tag.Size()));
14232 }
14233 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_NONBF_TAG_ID)) {
14234 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_nonBf, tag.Size());
14235 DCT_ASSERT((no == tag.Size()));
14236 }
14237 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_DOWNSAMPLE_W_TAG_ID)) {
14238 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_downSample_w, tag.Size());
14239 DCT_ASSERT((no == tag.Size()));
14240 }
14241 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_DOWNSAMPLE_H_TAG_ID)) {
14242 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_downSample_h, tag.Size());
14243 DCT_ASSERT((no == tag.Size()));
14244 }
14245 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_DOWNSAMPLE_MEANSIZE_TAG_ID)) {
14246 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_downSample_meansize, tag.Size());
14247 DCT_ASSERT((no == tag.Size()));
14248 }
14249 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_MEDIAN_RATIO_TAG_ID)) {
14250 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_median_ratio, tag.Size());
14251 DCT_ASSERT((no == tag.Size()));
14252 }
14253 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_MEDIAN_SIZE_TAG_ID)) {
14254 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_median_size, tag.Size());
14255 DCT_ASSERT((no == tag.Size()));
14256 }
14257 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_MEDIAN_IIR_TAG_ID)) {
14258 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_median_IIR, tag.Size());
14259 DCT_ASSERT((no == tag.Size()));
14260 }
14261 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_BF_SIGMAR_TAG_ID)) {
14262 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_bf_sigmaR, tag.Size());
14263 DCT_ASSERT((no == tag.Size()));
14264 }
14265 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_BF_UVGAIN_TAG_ID)) {
14266 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_bf_uvgain, tag.Size());
14267 DCT_ASSERT((no == tag.Size()));
14268 }
14269 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_BF_RATIO_TAG_ID)) {
14270 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_bf_ratio, tag.Size());
14271 DCT_ASSERT((no == tag.Size()));
14272 }
14273 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_BF_SIZE_TAG_ID)) {
14274 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_bf_size, tag.Size());
14275 DCT_ASSERT((no == tag.Size()));
14276 }
14277 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_BF_SIGMAD_TAG_ID)) {
14278 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_bf_sigmaD, tag.Size());
14279 DCT_ASSERT((no == tag.Size()));
14280 }
14281 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_BF_ISROWIIR_TAG_ID)) {
14282 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_bf_isRowIIR, tag.Size());
14283 DCT_ASSERT((no == tag.Size()));
14284 }
14285 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP2_BF_ISYCOPY_TAG_ID)) {
14286 int no = ParseFloatArray(pchild, pModeCell->setting[index].step2_bf_isYcopy, tag.Size());
14287 DCT_ASSERT((no == tag.Size()));
14288 }
14289 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP3_NONBF3_TAG_ID)) {
14290 int no = ParseFloatArray(pchild, pModeCell->setting[index].step3_nonBf3, tag.Size());
14291 DCT_ASSERT((no == tag.Size()));
14292 }
14293 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP3_BF_SIGMAR_TAG_ID)) {
14294 int no = ParseFloatArray(pchild, pModeCell->setting[index].step3_bf_sigmaR, tag.Size());
14295 DCT_ASSERT((no == tag.Size()));
14296 }
14297 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP3_BF_UVGAIN_TAG_ID)) {
14298 int no = ParseFloatArray(pchild, pModeCell->setting[index].step3_bf_uvgain, tag.Size());
14299 DCT_ASSERT((no == tag.Size()));
14300 }
14301 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP3_BF_RATIO_TAG_ID)) {
14302 int no = ParseFloatArray(pchild, pModeCell->setting[index].step3_bf_ratio, tag.Size());
14303 DCT_ASSERT((no == tag.Size()));
14304 }
14305 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP3_BF_SIZE_TAG_ID)) {
14306 int no = ParseFloatArray(pchild, pModeCell->setting[index].step3_bf_size, tag.Size());
14307 DCT_ASSERT((no == tag.Size()));
14308 }
14309 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP3_BF_SIGMAD_TAG_ID)) {
14310 int no = ParseFloatArray(pchild, pModeCell->setting[index].step3_bf_sigmaD, tag.Size());
14311 DCT_ASSERT((no == tag.Size()));
14312 }
14313 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP3_BF_ISROWIIR_TAG_ID)) {
14314 int no = ParseFloatArray(pchild, pModeCell->setting[index].step3_bf_isRowIIR, tag.Size());
14315 DCT_ASSERT((no == tag.Size()));
14316 }
14317 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_STEP3_BF_ISYCOPY_TAG_ID)) {
14318 int no = ParseFloatArray(pchild, pModeCell->setting[index].step3_bf_isYcopy, tag.Size());
14319 DCT_ASSERT((no == tag.Size()));
14320 }
14321 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_KERNEL_3X3_TAG_ID)) {
14322 int no = ParseFloatArray(pchild, pModeCell->setting[index].kernel_3x3, tag.Size());
14323 DCT_ASSERT((no == tag.Size()));
14324 }
14325 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_KERNEL_5X5_TAG_ID)) {
14326 int no = ParseFloatArray(pchild, pModeCell->setting[index].kernel_5x5, tag.Size());
14327 DCT_ASSERT((no == tag.Size()));
14328 }
14329 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_KERNEL_9X9_TAG_ID)) {
14330 int no = ParseFloatArray(pchild, pModeCell->setting[index].kernel_9x9, tag.Size());
14331 DCT_ASSERT((no == tag.Size()));
14332 }
14333 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_KERNEL_9X9_NUM_TAG_ID)) {
14334 int no = ParseFloatArray(pchild, &pModeCell->setting[index].kernel_9x9_num, tag.Size());
14335 DCT_ASSERT((no == tag.Size()));
14336 }
14337 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_SIGMA_ADJ_LUMA_TAG_ID)) {
14338 int no = ParseFloatArray(pchild, pModeCell->setting[index].sigma_adj_luma, tag.Size());
14339 DCT_ASSERT((no == tag.Size()));
14340 }
14341 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_SIGMA_ADJ_RATIO_TAG_ID)) {
14342 int no = ParseFloatArray(pchild, pModeCell->setting[index].sigma_adj_ratio, tag.Size());
14343 DCT_ASSERT((no == tag.Size()));
14344 }
14345 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_THRESHOLD_ADJ_LUMA_TAG_ID)) {
14346 int no = ParseFloatArray(pchild, pModeCell->setting[index].threshold_adj_luma, tag.Size());
14347 DCT_ASSERT((no == tag.Size()));
14348 }
14349 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_THRESHOLD_ADJ_THRE_TAG_ID)) {
14350 int no = ParseFloatArray(pchild, pModeCell->setting[index].threshold_adj_thre, tag.Size());
14351 DCT_ASSERT((no == tag.Size()));
14352 }
14353 pchild = pchild->NextSibling();
14354 }
14355 XML_CHECK_END();
14356 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14357 return (true);
14358 }
14359
parseEntrySensorUVNRModeCell(const XMLElement * pelement,void * param)14360 bool RkAiqCalibParser::parseEntrySensorUVNRModeCell
14361 (
14362 const XMLElement* pelement,
14363 void* param
14364 ) {
14365 (void)param;
14366
14367 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14368
14369 int index = *((int*)param);
14370 XML_CHECK_START(CALIB_SENSOR_UVNR_MODE_CELL_TAG_ID, CALIB_SENSOR_UVNR_TAG_ID);
14371 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_UVNR_2_t, uvnr);
14372
14373 const XMLNode* pchild = pelement->FirstChild();
14374 while (pchild) {
14375 XmlTag tag = XmlTag(pchild->ToElement());
14376 std::string tagname(pchild->ToElement()->Name());
14377 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14378
14379 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_MODE_NAME_TAG_ID)) {
14380 ParseString(pchild, uvnr->mode_cell[index].name, sizeof(uvnr->mode_cell[index].name));
14381 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_SETTING_TAG_ID)) {
14382 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
14383 &RkAiqCalibParser::parseEntrySensorUVNRSetting,
14384 &uvnr->mode_cell[index],
14385 (uint32_t)CALIB_SENSOR_UVNR_SETTING_TAG_ID,
14386 (uint32_t)CALIB_SENSOR_UVNR_MODE_CELL_TAG_ID)) {
14387 LOGE("parse error in BayerNR setting (%s)\n", tagname.c_str());
14388 return (false);
14389 }
14390 }
14391
14392 pchild = pchild->NextSibling();
14393 }
14394 XML_CHECK_END();
14395 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14396 return (true);
14397 }
14398
parseEntrySensorUVNR(const XMLElement * pelement,void * param)14399 bool RkAiqCalibParser::parseEntrySensorUVNR
14400 (
14401 const XMLElement* pelement,
14402 void* param
14403 ) {
14404 (void)param;
14405
14406 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14407 autoTabForward();
14408
14409 XML_CHECK_START(CALIB_SENSOR_UVNR_TAG_ID, CALIB_SENSOR_TAG_ID);
14410 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_UVNR_2_t, uvnr);
14411
14412 const XMLNode* pchild = pelement->FirstChild();
14413 while (pchild) {
14414 XmlTag tag = XmlTag(pchild->ToElement());
14415 std::string tagname(pchild->ToElement()->Name());
14416 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14417
14418 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_ENABLE_TAG_ID)) {
14419 int no = ParseIntArray(pchild, &uvnr->enable, tag.Size());
14420 DCT_ASSERT((no == tag.Size()));
14421 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_VERSION_TAG_ID)) {
14422 ParseString(pchild, uvnr->version, sizeof(uvnr->version));
14423 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_UVNR_MODE_CELL_TAG_ID)) {
14424 if (xmlParseReadWrite == XML_PARSER_READ) {
14425 int cell_size = 0;
14426 parseCellNoElement(pchild->ToElement(), tag.Size(), cell_size);
14427 uvnr->mode_num = cell_size;
14428 uvnr->mode_cell = (CalibDb_UVNR_ModeCell_t *)malloc(cell_size * sizeof(CalibDb_UVNR_ModeCell_t));
14429 memset(uvnr->mode_cell, 0x00, cell_size * sizeof(CalibDb_UVNR_ModeCell_t));
14430 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
14431 &RkAiqCalibParser::parseEntrySensorUVNRModeCell,
14432 param,
14433 (uint32_t)CALIB_SENSOR_UVNR_MODE_CELL_TAG_ID,
14434 (uint32_t)CALIB_SENSOR_UVNR_TAG_ID)) {
14435 LOGE("parse error in BayerNR setting (%s)\n", tagname.c_str());
14436 return (false);
14437 }
14438 }
14439 else
14440 {
14441 if (!parseEntryCell3((XMLElement *)pchild->ToElement(), tag.Size(), uvnr->mode_num,
14442 &RkAiqCalibParser::parseEntrySensorUVNRModeCell,
14443 param,
14444 (uint32_t)CALIB_SENSOR_UVNR_MODE_CELL_TAG_ID,
14445 (uint32_t)CALIB_SENSOR_UVNR_TAG_ID)) {
14446 LOGE("parse error in BayerNR setting (%s)\n", tagname.c_str());
14447 return (false);
14448 }
14449 }
14450 }
14451 pchild = pchild->NextSibling();
14452 }
14453 XML_CHECK_END();
14454 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14455 autoTabBackward();
14456 return (true);
14457 }
14458
parseEntrySensorGamma(const XMLElement * pelement,void * param)14459 bool RkAiqCalibParser::parseEntrySensorGamma
14460 (
14461 const XMLElement* pelement,
14462 void* param
14463 ) {
14464 (void)param;
14465
14466 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14467 autoTabForward();
14468
14469 XML_CHECK_START(CALIB_SENSOR_GAMMA_TAG_ID, CALIB_SENSOR_TAG_ID);
14470 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Gamma_t, gamma);
14471
14472 const XMLNode* pchild = pelement->FirstChild();
14473 while (pchild) {
14474 XmlTag tag = XmlTag(pchild->ToElement());
14475 std::string tagname(pchild->ToElement()->Name());
14476 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14477 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GAMMA_GAMMA_EN_TAG_ID)) {
14478 int no = ParseUcharArray(pchild, &gamma->gamma_en, tag.Size());
14479 DCT_ASSERT((no == tag.Size()));
14480 }
14481 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GAMMA_GAMMA_OUT_SEGNUM_TAG_ID)) {
14482 int no = ParseUcharArray(pchild, &gamma->gamma_out_segnum, tag.Size());
14483 DCT_ASSERT((no == tag.Size()));
14484 }
14485 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GAMMA_GAMMA_OUT_OFFSET_TAG_ID)) {
14486 int no = ParseUcharArray(pchild, &gamma->gamma_out_offset, tag.Size());
14487 DCT_ASSERT((no == tag.Size()));
14488 }
14489 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GAMMA_CURVE_NORMAL_TAG_ID)) {
14490 int no = ParseFloatArray(pchild, gamma->curve_normal, tag.Size());
14491 DCT_ASSERT((no == tag.Size()));
14492 }
14493 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GAMMA_CURVE_HDR_TAG_ID)) {
14494 int no = ParseFloatArray(pchild, gamma->curve_hdr, tag.Size());
14495 DCT_ASSERT((no == tag.Size()));
14496 }
14497 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GAMMA_CURVE_NIGHT_TAG_ID)) {
14498 int no = ParseFloatArray(pchild, gamma->curve_night, tag.Size());
14499 DCT_ASSERT((no == tag.Size()));
14500 }
14501
14502 pchild = pchild->NextSibling();
14503 }
14504 XML_CHECK_END();
14505 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14506 autoTabBackward();
14507 return (true);
14508 }
14509
parseEntrySensorDegamma(const XMLElement * pelement,void * param)14510 bool RkAiqCalibParser::parseEntrySensorDegamma
14511 (
14512 const XMLElement* pelement,
14513 void* param
14514 ) {
14515 (void)param;
14516
14517 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14518 autoTabForward();
14519
14520 XML_CHECK_START(CALIB_SENSOR_DEGAMMA_TAG_ID, CALIB_SENSOR_TAG_ID);
14521 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Degamma_t, degamma);
14522
14523 const XMLNode* pchild = pelement->FirstChild();
14524 while (pchild) {
14525 XmlTag tag = XmlTag(pchild->ToElement());
14526 std::string tagname(pchild->ToElement()->Name());
14527 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14528 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEGAMMA_EN_TAG_ID)) {
14529 int no = ParseUcharArray(pchild, °amma->degamma_en, tag.Size());
14530 DCT_ASSERT((no == tag.Size()));
14531 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEGAMMA_MODE_CELL_TAG_ID)) {
14532 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
14533 &RkAiqCalibParser::parseEntrySensorDegammaModeCell,
14534 param,
14535 (uint32_t)CALIB_SENSOR_DEGAMMA_MODE_CELL_TAG_ID,
14536 (uint32_t)CALIB_SENSOR_DEGAMMA_TAG_ID)) {
14537 LOGE("parse error in degamma mode cell (%s)", tagname.c_str());
14538 return (false);
14539 }
14540 }
14541
14542 pchild = pchild->NextSibling();
14543 }
14544 XML_CHECK_END();
14545 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14546 autoTabBackward();
14547 return (true);
14548 }
14549
parseEntrySensorDegammaModeCell(const XMLElement * pelement,void * param)14550 bool RkAiqCalibParser::parseEntrySensorDegammaModeCell
14551 (
14552 const XMLElement* pelement,
14553 void* param
14554 ) {
14555 (void)param;
14556
14557 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14558
14559 int index = *((int*)param);
14560 XML_CHECK_START(CALIB_SENSOR_DEGAMMA_MODE_CELL_TAG_ID, CALIB_SENSOR_DEGAMMA_TAG_ID);
14561 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Degamma_t, degamma);
14562
14563 const XMLNode* pchild = pelement->FirstChild();
14564 while (pchild) {
14565 XmlTag tag = XmlTag(pchild->ToElement());
14566 std::string tagname(pchild->ToElement()->Name());
14567 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14568
14569 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEGAMMA_MODE_NAME_TAG_ID)) {
14570 ParseString(pchild, degamma->mode[index].name, sizeof(degamma->mode[index].name));
14571 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEGAMMA_SCENE_EN_TAG_ID)) {
14572 int no = ParseUcharArray(pchild, °amma->mode[index].degamma_scene_en, tag.Size());
14573 DCT_ASSERT((no == tag.Size()));
14574 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEGAMMA_CURVE_X_TAG_ID)) {
14575 int no = ParseFloatArray(pchild, degamma->mode[index].X_axis, tag.Size());
14576 DCT_ASSERT((no == tag.Size()));
14577 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEGAMMA_CURVE_R_TAG_ID)) {
14578 int no = ParseFloatArray(pchild, degamma->mode[index].curve_R, tag.Size());
14579 DCT_ASSERT((no == tag.Size()));
14580 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEGAMMA_CURVE_G_TAG_ID)) {
14581 int no = ParseFloatArray(pchild, degamma->mode[index].curve_G, tag.Size());
14582 DCT_ASSERT((no == tag.Size()));
14583 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEGAMMA_CURVE_B_TAG_ID)) {
14584 int no = ParseFloatArray(pchild, degamma->mode[index].curve_B, tag.Size());
14585 DCT_ASSERT((no == tag.Size()));
14586 }
14587 pchild = pchild->NextSibling();
14588
14589 }
14590
14591 XML_CHECK_END();
14592 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14593 return (true);
14594 }
14595
parseEntrySensorYnr(const XMLElement * pelement,void * param)14596 bool RkAiqCalibParser::parseEntrySensorYnr
14597 (
14598 const XMLElement* pelement,
14599 void* param
14600 )
14601 {
14602 (void)param;
14603
14604 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14605
14606 XML_CHECK_START(CALIB_SENSOR_YNR_TAG_ID, CALIB_SENSOR_TAG_ID);
14607 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_YNR_2_t, ynr);
14608
14609 const XMLNode* pchild = pelement->FirstChild();
14610 while (pchild) {
14611 XmlTag tag = XmlTag(pchild->ToElement());
14612 std::string tagname(pchild->ToElement()->Name());
14613 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14614
14615 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_ENABLE_TAG_ID)) {
14616 int no = ParseIntArray(pchild, &ynr->enable, tag.Size());
14617 DCT_ASSERT((no == tag.Size()));
14618 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_VERSION_TAG_ID)) {
14619 ParseString(pchild, ynr->version, sizeof(ynr->version));
14620 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_MODE_CELL_TAG_ID)) {
14621 if (xmlParseReadWrite == XML_PARSER_READ) {
14622 int cell_size = 0;
14623 parseCellNoElement(pchild->ToElement(), tag.Size(), cell_size);
14624 ynr->mode_num = cell_size;
14625 ynr->mode_cell = (CalibDb_YNR_ModeCell_t *)malloc(cell_size * sizeof(CalibDb_YNR_ModeCell_t));
14626 memset(ynr->mode_cell, 0x00, cell_size * sizeof(CalibDb_YNR_ModeCell_t));
14627 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
14628 &RkAiqCalibParser::parseEntrySensorYnrModeCell,
14629 param,
14630 (uint32_t)CALIB_SENSOR_YNR_MODE_CELL_TAG_ID,
14631 (uint32_t)CALIB_SENSOR_YNR_TAG_ID)) {
14632 LOGE("parse error in YNR mode cell (%s)", tagname.c_str());
14633 return (false);
14634 }
14635 }
14636 else
14637 {
14638 if (!parseEntryCell3((XMLElement *)pchild->ToElement(), tag.Size(), ynr->mode_num,
14639 &RkAiqCalibParser::parseEntrySensorYnrModeCell,
14640 param,
14641 (uint32_t)CALIB_SENSOR_YNR_MODE_CELL_TAG_ID,
14642 (uint32_t)CALIB_SENSOR_YNR_TAG_ID)) {
14643 LOGE("parse error in YNR mode cell (%s)", tagname.c_str());
14644 return (false);
14645 }
14646 }
14647 }
14648
14649 pchild = pchild->NextSibling();
14650 }
14651 XML_CHECK_END();
14652 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14653 return (true);
14654 }
14655
14656
14657
parseEntrySensorYnrModeCell(const XMLElement * pelement,void * param)14658 bool RkAiqCalibParser::parseEntrySensorYnrModeCell
14659 (
14660 const XMLElement* pelement,
14661 void* param
14662 )
14663 {
14664 (void)param;
14665
14666 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14667
14668 int index = *((int*)param);
14669 XML_CHECK_START(CALIB_SENSOR_YNR_MODE_CELL_TAG_ID, CALIB_SENSOR_YNR_TAG_ID);
14670 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_YNR_2_t, ynr);
14671
14672 const XMLNode* pchild = pelement->FirstChild();
14673 while (pchild) {
14674 XmlTag tag = XmlTag(pchild->ToElement());
14675 std::string tagname(pchild->ToElement()->Name());
14676 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14677
14678 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_MODE_NAME_TAG_ID)) {
14679 ParseString(pchild, ynr->mode_cell[index].name, sizeof(ynr->mode_cell[index].name));
14680 }
14681 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_SETTING_CELL_TAG_ID)) {
14682 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
14683 &RkAiqCalibParser::parseEntrySensorYnrSetting,
14684 (void *)&ynr->mode_cell[index],
14685 (uint32_t)CALIB_SENSOR_YNR_SETTING_CELL_TAG_ID,
14686 (uint32_t)CALIB_SENSOR_YNR_MODE_CELL_TAG_ID)) {
14687 LOGE("parse error in YNR setting (%s)", tagname.c_str());
14688 return (false);
14689 }
14690 }
14691
14692
14693 pchild = pchild->NextSibling();
14694 }
14695 XML_CHECK_END();
14696 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14697 return (true);
14698 }
14699
14700
parseEntrySensorYnrSetting(const XMLElement * pelement,void * param,int index)14701 bool RkAiqCalibParser::parseEntrySensorYnrSetting
14702 (
14703 const XMLElement* pelement,
14704 void* param,
14705 int index
14706 )
14707 {
14708 (void)param;
14709
14710 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14711
14712 CalibDb_YNR_ModeCell_t *pModeCell = (CalibDb_YNR_ModeCell_t *)param;
14713 XML_CHECK_START(CALIB_SENSOR_YNR_SETTING_CELL_TAG_ID, CALIB_SENSOR_YNR_MODE_CELL_TAG_ID);
14714
14715 const XMLNode* pchild = pelement->FirstChild();
14716 while (pchild) {
14717 XmlTag tag = XmlTag(pchild->ToElement());
14718 std::string tagname(pchild->ToElement()->Name());
14719 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14720
14721 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_SETTING_SNR_MODE_TAG_ID)) {
14722 ParseString(pchild, pModeCell->setting[index].snr_mode, sizeof(pModeCell->setting[index].snr_mode));
14723 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_SETTING_SENSOR_MODE_TAG_ID)) {
14724 ParseString(pchild, pModeCell->setting[index].sensor_mode, sizeof(pModeCell->setting[index].sensor_mode));
14725 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_ISO_CELL_TAG_ID)) {
14726 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
14727 &RkAiqCalibParser::parseEntrySensorYnrISO,
14728 (void*)&pModeCell->setting[index],
14729 (uint32_t)CALIB_SENSOR_YNR_ISO_CELL_TAG_ID,
14730 (uint32_t)CALIB_SENSOR_YNR_SETTING_CELL_TAG_ID)) {
14731 LOGE("parse error in YNR iso (%s)", tagname.c_str());
14732 return (false);
14733 }
14734 }
14735
14736 pchild = pchild->NextSibling();
14737 }
14738 XML_CHECK_END();
14739 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14740 return (true);
14741 }
14742
parseEntrySensorYnrISO(const XMLElement * pelement,void * param,int index)14743 bool RkAiqCalibParser::parseEntrySensorYnrISO
14744 (
14745 const XMLElement* pelement,
14746 void* param,
14747 int index
14748 ) {
14749 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14750 autoTabForward();
14751
14752 XML_CHECK_START(CALIB_SENSOR_YNR_ISO_CELL_TAG_ID, CALIB_SENSOR_YNR_SETTING_CELL_TAG_ID);
14753
14754 CalibDb_YNR_Setting_t *pSetting = (CalibDb_YNR_Setting_t *)param;
14755
14756 const XMLNode* pchild = pelement->FirstChild();
14757 while (pchild) {
14758 XmlTag tag = XmlTag(pchild->ToElement());
14759 const char* value = tag.Value();
14760 std::string tagname(pchild->ToElement()->Name());
14761 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14762
14763 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_ISO_TAG_ID)) {
14764 int no = ParseFloatArray(pchild, &pSetting->ynr_iso[index].iso, tag.Size());
14765 DCT_ASSERT((no == tag.Size()));
14766 }
14767 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_SIGMA_CURVE_TAG_ID)) {
14768 int no = ParseDoubleArray(pchild, pSetting->ynr_iso[index].sigma_curve, tag.Size());
14769 DCT_ASSERT((no == tag.Size()));
14770 }
14771 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_YNR_LCI_TAG_ID)) {
14772 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].ynr_lci, tag.Size());
14773 DCT_ASSERT((no == tag.Size()));
14774 }
14775 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_YNR_LHCI_TAG_ID)) {
14776 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].ynr_lhci, tag.Size());
14777 DCT_ASSERT((no == tag.Size()));
14778 }
14779 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_YNR_HLCI_TAG_ID)) {
14780 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].ynr_hlci, tag.Size());
14781 DCT_ASSERT((no == tag.Size()));
14782 }
14783 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_YNR_HHCI_TAG_ID)) {
14784 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].ynr_hhci, tag.Size());
14785 DCT_ASSERT((no == tag.Size()));
14786 }
14787 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_LO_LUMAPOINT_TAG_ID)) {
14788 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].lo_lumaPoint, tag.Size());
14789 DCT_ASSERT((no == tag.Size()));
14790 }
14791 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_LO_LUMARATIO_TAG_ID)) {
14792 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].lo_lumaRatio, tag.Size());
14793 DCT_ASSERT((no == tag.Size()));
14794 }
14795 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_LO_DIRECTIONSTRENGTH_TAG_ID)) {
14796 int no = ParseFloatArray(pchild, &pSetting->ynr_iso[index].lo_directionStrength, tag.Size());
14797 DCT_ASSERT((no == tag.Size()));
14798 }
14799 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_LO_BFSCALE_TAG_ID)) {
14800 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].lo_bfScale, tag.Size());
14801 DCT_ASSERT((no == tag.Size()));
14802 }
14803 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_IMERGE_RATIO_TAG_ID)) {
14804 int no = ParseFloatArray(pchild, &pSetting->ynr_iso[index].imerge_ratio, tag.Size());
14805 DCT_ASSERT((no == tag.Size()));
14806 }
14807 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_IMERGE_BOUND_TAG_ID)) {
14808 int no = ParseFloatArray(pchild, &pSetting->ynr_iso[index].imerge_bound, tag.Size());
14809 DCT_ASSERT((no == tag.Size()));
14810 }
14811 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_DENOISE_WEIGHT_TAG_ID)) {
14812 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].denoise_weight, tag.Size());
14813 DCT_ASSERT((no == tag.Size()));
14814 }
14815 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_HI_LUMAPOINT_TAG_ID)) {
14816 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].hi_lumaPoint, tag.Size());
14817 DCT_ASSERT((no == tag.Size()));
14818 }
14819 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_HI_LUMARATIO_TAG_ID)) {
14820 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].hi_lumaRatio, tag.Size());
14821 DCT_ASSERT((no == tag.Size()));
14822 }
14823 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_HI_BFSCALE_TAG_ID)) {
14824 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].hi_bfScale, tag.Size());
14825 DCT_ASSERT((no == tag.Size()));
14826 }
14827 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_HWITH_D_TAG_ID)) {
14828 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].hwith_d, tag.Size());
14829 DCT_ASSERT((no == tag.Size()));
14830 }
14831 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_HI_DENOISESTRENGTH_TAG_ID)) {
14832 int no = ParseFloatArray(pchild, &pSetting->ynr_iso[index].hi_denoiseStrength, tag.Size());
14833 DCT_ASSERT((no == tag.Size()));
14834 }
14835 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_HI_DETAILMINADJDNW_TAG_ID)) {
14836 int no = ParseFloatArray(pchild, &pSetting->ynr_iso[index].hi_detailMinAdjDnW, tag.Size());
14837 DCT_ASSERT((no == tag.Size()));
14838 }
14839 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_HI_DENOISEWEIGHT_TAG_ID)) {
14840 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].hi_denoiseWeight, tag.Size());
14841 DCT_ASSERT((no == tag.Size()));
14842 }
14843 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_Y_LUMA_POINT_TAG_ID)) {
14844 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].y_luma_point, tag.Size());
14845 DCT_ASSERT((no == tag.Size()));
14846 }
14847 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_HGRAD_Y_LEVEL1_TAG_ID)) {
14848 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].hgrad_y_level1, tag.Size());
14849 DCT_ASSERT((no == tag.Size()));
14850 }
14851 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_HGRAD_Y_LEVEL2_TAG_ID)) {
14852 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].hgrad_y_level2, tag.Size());
14853 DCT_ASSERT((no == tag.Size()));
14854 }
14855 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_HGRAD_Y_LEVEL3_TAG_ID)) {
14856 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].hgrad_y_level3, tag.Size());
14857 DCT_ASSERT((no == tag.Size()));
14858 }
14859 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_HGRAD_Y_LEVEL4_TAG_ID)) {
14860 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].hgrad_y_level4, tag.Size());
14861 DCT_ASSERT((no == tag.Size()));
14862 }
14863 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_HI_SOFT_THRESH_SCALE_TAG_ID)) {
14864 int no = ParseFloatArray(pchild, pSetting->ynr_iso[index].hi_soft_thresh_scale, tag.Size());
14865 DCT_ASSERT((no == tag.Size()));
14866 }
14867 pchild = pchild->NextSibling();
14868 }
14869
14870 XML_CHECK_END();
14871
14872 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14873 autoTabBackward();
14874 return (true);
14875 }
14876
parseEntrySensorGic(const XMLElement * pelement,void * param)14877 bool RkAiqCalibParser::parseEntrySensorGic
14878 (
14879 const XMLElement* pelement,
14880 void* param
14881 ) {
14882 (void)param;
14883
14884 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14885 autoTabForward();
14886
14887 XML_CHECK_START(CALIB_SENSOR_GIC_TAG_ID, CALIB_SENSOR_TAG_ID);
14888
14889 const XMLNode* pchild = pelement->FirstChild();
14890 while (pchild) {
14891 XmlTag tag = XmlTag(pchild->ToElement());
14892 std::string tagname(pchild->ToElement()->Name());
14893 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14894
14895 if (CHECK_ISP_HW_V20()) {
14896 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_CALIBPARA_V20_TAG_ID)) {
14897 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
14898 &RkAiqCalibParser::parseEntrySensorGicCalibParaV20,
14899 param,
14900 (uint32_t)CALIB_SENSOR_GIC_CALIBPARA_V20_TAG_ID,
14901 (uint32_t)CALIB_SENSOR_GIC_TAG_ID)) {
14902 LOGE("parse error in Gic CalibPara v20 Setting (%s)", tagname.c_str());
14903 return (false);
14904 }
14905 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_TUNINGPARA_V20_TAG_ID)) {
14906 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
14907 &RkAiqCalibParser::parseEntrySensorGicTuningParaV20,
14908 param,
14909 (uint32_t)CALIB_SENSOR_GIC_TUNINGPARA_V20_TAG_ID,
14910 (uint32_t)CALIB_SENSOR_GIC_TAG_ID)) {
14911 LOGE("parse error in Gic TuningPara v20 Setting (%s)", tagname.c_str());
14912 return (false);
14913 }
14914 }
14915 }
14916
14917
14918 if (CHECK_ISP_HW_V21()) {
14919 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_CALIBPARA_V21_TAG_ID)) {
14920 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
14921 &RkAiqCalibParser::parseEntrySensorGicCalibParaV21,
14922 param,
14923 (uint32_t)CALIB_SENSOR_GIC_CALIBPARA_V21_TAG_ID,
14924 (uint32_t)CALIB_SENSOR_GIC_TAG_ID)) {
14925 LOGE("parse error in Gic CalibPara v21 Setting (%s)", tagname.c_str());
14926 return (false);
14927 }
14928 }
14929 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_TUNINGPARA_V21_TAG_ID)) {
14930 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
14931 &RkAiqCalibParser::parseEntrySensorGicTuningParaV21,
14932 param,
14933 (uint32_t)CALIB_SENSOR_GIC_TUNINGPARA_V21_TAG_ID,
14934 (uint32_t)CALIB_SENSOR_GIC_TAG_ID)) {
14935 LOGE("parse error in Gic TuningPara v21 Setting (%s)", tagname.c_str());
14936 return (false);
14937 }
14938 }
14939 }
14940
14941 pchild = pchild->NextSibling();
14942 }
14943
14944 XML_CHECK_END();
14945
14946 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14947 autoTabBackward();
14948 return (true);
14949 }
14950
parseEntrySensorGicCalibParaV20(const XMLElement * pelement,void * param)14951 bool RkAiqCalibParser::parseEntrySensorGicCalibParaV20
14952 (
14953 const XMLElement* pelement,
14954 void* param
14955 ) {
14956 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
14957
14958 XML_CHECK_START(CALIB_SENSOR_GIC_CALIBPARA_V20_TAG_ID, CALIB_SENSOR_GIC_TAG_ID);
14959 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Gic_t, gic);
14960 int index = *((int*)param);
14961 const XMLNode* pchild = pelement->FirstChild();
14962 while (pchild) {
14963 XmlTag tag = XmlTag(pchild->ToElement());
14964 const char* value = tag.Value();
14965 std::string tagname(pchild->ToElement()->Name());
14966 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
14967
14968 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SCENE_TAG_ID)) {
14969 ParseString(pchild, gic->calib_v20[index].scene, sizeof(gic->calib_v20[index].scene));
14970 }
14971 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_ENABLE_TAG_ID)) {
14972 int no = ParseUcharArray(pchild, &gic->calib_v20[index].gic_en, tag.Size());
14973 DCT_ASSERT((no == tag.Size()));
14974 }
14975 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_EDGE_EN_TAG_ID)) {
14976 int no = ParseUcharArray(pchild, &gic->calib_v20[index].edge_en, tag.Size());
14977 DCT_ASSERT((no == tag.Size()));
14978 }
14979 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GR_RATION_TAG_ID)) {
14980 int no = ParseUcharArray(pchild, &gic->calib_v20[index].gr_ration, tag.Size());
14981 DCT_ASSERT((no == tag.Size()));
14982 }
14983 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISE_CUT_EN_TAG_ID)) {
14984 int no = ParseUcharArray(pchild, &gic->calib_v20[index].noise_cut_en, tag.Size());
14985 DCT_ASSERT((no == tag.Size()));
14986 }
14987 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SETTING_TAG_ID)) {
14988 if (!parseEntrySensorGicCalibSettingV20(pchild->ToElement(), &gic->calib_v20[index], index)) {
14989 LOGE("parse error in Gic Calib setting (%s)", tagname.c_str());
14990 return (false);
14991 }
14992 }
14993
14994 pchild = pchild->NextSibling();
14995 }
14996 XML_CHECK_END();
14997 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
14998 return (true);
14999 }
15000
parseEntrySensorGicTuningParaV20(const XMLElement * pelement,void * param)15001 bool RkAiqCalibParser::parseEntrySensorGicTuningParaV20
15002 (
15003 const XMLElement* pelement,
15004 void* param
15005 ) {
15006 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
15007
15008 XML_CHECK_START(CALIB_SENSOR_GIC_TUNINGPARA_V20_TAG_ID, CALIB_SENSOR_GIC_TAG_ID);
15009 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Gic_t, gic);
15010 int index = *((int*)param);
15011 const XMLNode* pchild = pelement->FirstChild();
15012 while (pchild) {
15013 XmlTag tag = XmlTag(pchild->ToElement());
15014 const char* value = tag.Value();
15015 std::string tagname(pchild->ToElement()->Name());
15016 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
15017
15018 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SCENE_TAG_ID)) {
15019 ParseString(pchild, gic->tuning_v20[index].scene, sizeof(gic->calib_v20[index].scene));
15020 }
15021 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_ENABLE_TAG_ID)) {
15022 int no = ParseUcharArray(pchild, &gic->tuning_v20[index].gic_en, tag.Size());
15023 DCT_ASSERT((no == tag.Size()));
15024 }
15025 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_EDGE_EN_TAG_ID)) {
15026 int no = ParseUcharArray(pchild, &gic->tuning_v20[index].edge_en, tag.Size());
15027 DCT_ASSERT((no == tag.Size()));
15028 }
15029 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GR_RATION_TAG_ID)) {
15030 int no = ParseUcharArray(pchild, &gic->tuning_v20[index].gr_ration, tag.Size());
15031 DCT_ASSERT((no == tag.Size()));
15032 }
15033 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISE_CUT_EN_TAG_ID)) {
15034 int no = ParseUcharArray(pchild, &gic->tuning_v20[index].noise_cut_en, tag.Size());
15035 DCT_ASSERT((no == tag.Size()));
15036 }
15037 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SETTING_TAG_ID)) {
15038 if (!parseEntrySensorGicTuningSettingV20(pchild->ToElement(), &gic->tuning_v20[index], index)) {
15039 LOGE("parse error in Gic Tuning setting (%s)", tagname.c_str());
15040 return (false);
15041 }
15042 }
15043
15044 pchild = pchild->NextSibling();
15045 }
15046 XML_CHECK_END();
15047 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
15048 return (true);
15049 }
15050
parseEntrySensorGicCalibSettingV20(const XMLElement * pelement,void * param,int index)15051 bool RkAiqCalibParser::parseEntrySensorGicCalibSettingV20
15052 (
15053 const XMLElement* pelement,
15054 void* param,
15055 int index
15056 ) {
15057 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
15058
15059 CalibDb_Gic_ModeCell_v20_t *pModeCell = (CalibDb_Gic_ModeCell_v20_t *)param;
15060
15061 XML_CHECK_START(CALIB_SENSOR_GIC_SETTING_TAG_ID, CALIB_SENSOR_GIC_CALIBPARA_V20_TAG_ID);
15062 const XMLNode* pchild = pelement->FirstChild();
15063 while (pchild) {
15064 XmlTag tag = XmlTag(pchild->ToElement());
15065 const char* value = tag.Value();
15066 std::string tagname(pchild->ToElement()->Name());
15067 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
15068
15069
15070 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SETTING_ISO_TAG_ID)) {
15071 int no = ParseFloatArray(pchild, pModeCell->setting.iso, tag.Size());
15072 DCT_ASSERT((no == tag.Size()));
15073 }
15074 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_BUSY_THRE_TAG_ID)) {
15075 int no = ParseFloatArray(pchild, pModeCell->setting.min_busy_thre, tag.Size());
15076 DCT_ASSERT((no == tag.Size()));
15077 }
15078 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR1_TAG_ID)) {
15079 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr1, tag.Size());
15080 DCT_ASSERT((no == tag.Size()));
15081 }
15082 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR2_TAG_ID)) {
15083 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr2, tag.Size());
15084 DCT_ASSERT((no == tag.Size()));
15085 }
15086 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD1_TAG_ID)) {
15087 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad1, tag.Size());
15088 DCT_ASSERT((no == tag.Size()));
15089 }
15090 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD2_TAG_ID)) {
15091 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad2, tag.Size());
15092 DCT_ASSERT((no == tag.Size()));
15093 }
15094 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GB_THRE_TAG_ID)) {
15095 int no = ParseFloatArray(pchild, pModeCell->setting.gb_thre, tag.Size());
15096 DCT_ASSERT((no == tag.Size()));
15097 }
15098 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MAXCORV_TAG_ID)) {
15099 int no = ParseFloatArray(pchild, pModeCell->setting.maxCorV, tag.Size());
15100 DCT_ASSERT((no == tag.Size()));
15101 }
15102 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MAXCORVBOTH_TAG_ID)) {
15103 int no = ParseFloatArray(pchild, pModeCell->setting.maxCorVboth, tag.Size());
15104 DCT_ASSERT((no == tag.Size()));
15105 }
15106 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_DARK_THRE_TAG_ID)) {
15107 int no = ParseFloatArray(pchild, pModeCell->setting.dark_thre, tag.Size());
15108 DCT_ASSERT((no == tag.Size()));
15109 }
15110 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_DARK_THREHI_TAG_ID)) {
15111 int no = ParseFloatArray(pchild, pModeCell->setting.dark_threHi, tag.Size());
15112 DCT_ASSERT((no == tag.Size()));
15113 }
15114 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD1_DARK_TAG_ID)) {
15115 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad1_dark, tag.Size());
15116 DCT_ASSERT((no == tag.Size()));
15117 }
15118 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD2_DARK_TAG_ID)) {
15119 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad2_dark, tag.Size());
15120 DCT_ASSERT((no == tag.Size()));
15121 }
15122 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR_DARK1_TAG_ID)) {
15123 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr_dark1, tag.Size());
15124 DCT_ASSERT((no == tag.Size()));
15125 }
15126 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR_DARK2_TAG_ID)) {
15127 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr_dark2, tag.Size());
15128 DCT_ASSERT((no == tag.Size()));
15129 }
15130 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISECURVE0_TAG_ID)) {
15131 int no = ParseFloatArray(pchild, pModeCell->setting.noiseCurve_0, tag.Size());
15132 DCT_ASSERT((no == tag.Size()));
15133 }
15134 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISECURVE1_TAG_ID)) {
15135 int no = ParseFloatArray(pchild, pModeCell->setting.noiseCurve_1, tag.Size());
15136 DCT_ASSERT((no == tag.Size()));
15137 }
15138 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GVALUELIMITLO_TAG_ID)) {
15139 int no = ParseFloatArray(pchild, pModeCell->setting.GValueLimitLo, tag.Size());
15140 DCT_ASSERT((no == tag.Size()));
15141 }
15142 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GVALUELIMITHI_TAG_ID)) {
15143 int no = ParseFloatArray(pchild, pModeCell->setting.GValueLimitHi, tag.Size());
15144 DCT_ASSERT((no == tag.Size()));
15145 }
15146 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_TEXTURESTRENGTH_TAG_ID)) {
15147 int no = ParseFloatArray(pchild, pModeCell->setting.textureStrength, tag.Size());
15148 DCT_ASSERT((no == tag.Size()));
15149 }
15150 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SCALELO_TAG_ID)) {
15151 int no = ParseFloatArray(pchild, pModeCell->setting.ScaleLo, tag.Size());
15152 DCT_ASSERT((no == tag.Size()));
15153 }
15154 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SCALEHI_TAG_ID)) {
15155 int no = ParseFloatArray(pchild, pModeCell->setting.ScaleHi, tag.Size());
15156 DCT_ASSERT((no == tag.Size()));
15157 }
15158 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GLOBALSTRENGTH_TAG_ID)) {
15159 int no = ParseFloatArray(pchild, pModeCell->setting.globalStrength, tag.Size());
15160 DCT_ASSERT((no == tag.Size()));
15161 }
15162 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISE_COEA_TAG_ID)) {
15163 int no = ParseFloatArray(pchild, pModeCell->setting.noise_coea, tag.Size());
15164 DCT_ASSERT((no == tag.Size()));
15165 }
15166 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISE_COEB_TAG_ID)) {
15167 int no = ParseFloatArray(pchild, pModeCell->setting.noise_coeb, tag.Size());
15168 DCT_ASSERT((no == tag.Size()));
15169 }
15170 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_DIFF_CLIP_TAG_ID)) {
15171 int no = ParseFloatArray(pchild, pModeCell->setting.diff_clip, tag.Size());
15172 DCT_ASSERT((no == tag.Size()));
15173 }
15174
15175 pchild = pchild->NextSibling();
15176 }
15177 XML_CHECK_END();
15178 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
15179 return (true);
15180 }
15181
parseEntrySensorGicTuningSettingV20(const XMLElement * pelement,void * param,int index)15182 bool RkAiqCalibParser::parseEntrySensorGicTuningSettingV20
15183 (
15184 const XMLElement* pelement,
15185 void* param,
15186 int index
15187 ) {
15188 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
15189
15190 CalibDb_Gic_ModeCell_v20_t *pModeCell = (CalibDb_Gic_ModeCell_v20_t *)param;
15191
15192 XML_CHECK_START(CALIB_SENSOR_GIC_SETTING_TAG_ID, CALIB_SENSOR_GIC_TUNINGPARA_V20_TAG_ID);
15193 const XMLNode* pchild = pelement->FirstChild();
15194 while (pchild) {
15195 XmlTag tag = XmlTag(pchild->ToElement());
15196 const char* value = tag.Value();
15197 std::string tagname(pchild->ToElement()->Name());
15198 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
15199
15200
15201 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SETTING_ISO_TAG_ID)) {
15202 int no = ParseFloatArray(pchild, pModeCell->setting.iso, tag.Size());
15203 DCT_ASSERT((no == tag.Size()));
15204 }
15205 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_BUSY_THRE_TAG_ID)) {
15206 int no = ParseFloatArray(pchild, pModeCell->setting.min_busy_thre, tag.Size());
15207 DCT_ASSERT((no == tag.Size()));
15208 }
15209 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR1_TAG_ID)) {
15210 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr1, tag.Size());
15211 DCT_ASSERT((no == tag.Size()));
15212 }
15213 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR2_TAG_ID)) {
15214 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr2, tag.Size());
15215 DCT_ASSERT((no == tag.Size()));
15216 }
15217 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD1_TAG_ID)) {
15218 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad1, tag.Size());
15219 DCT_ASSERT((no == tag.Size()));
15220 }
15221 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD2_TAG_ID)) {
15222 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad2, tag.Size());
15223 DCT_ASSERT((no == tag.Size()));
15224 }
15225 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GB_THRE_TAG_ID)) {
15226 int no = ParseFloatArray(pchild, pModeCell->setting.gb_thre, tag.Size());
15227 DCT_ASSERT((no == tag.Size()));
15228 }
15229 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MAXCORV_TAG_ID)) {
15230 int no = ParseFloatArray(pchild, pModeCell->setting.maxCorV, tag.Size());
15231 DCT_ASSERT((no == tag.Size()));
15232 }
15233 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MAXCORVBOTH_TAG_ID)) {
15234 int no = ParseFloatArray(pchild, pModeCell->setting.maxCorVboth, tag.Size());
15235 DCT_ASSERT((no == tag.Size()));
15236 }
15237 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_DARK_THRE_TAG_ID)) {
15238 int no = ParseFloatArray(pchild, pModeCell->setting.dark_thre, tag.Size());
15239 DCT_ASSERT((no == tag.Size()));
15240 }
15241 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_DARK_THREHI_TAG_ID)) {
15242 int no = ParseFloatArray(pchild, pModeCell->setting.dark_threHi, tag.Size());
15243 DCT_ASSERT((no == tag.Size()));
15244 }
15245 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD1_DARK_TAG_ID)) {
15246 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad1_dark, tag.Size());
15247 DCT_ASSERT((no == tag.Size()));
15248 }
15249 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD2_DARK_TAG_ID)) {
15250 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad2_dark, tag.Size());
15251 DCT_ASSERT((no == tag.Size()));
15252 }
15253 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR_DARK1_TAG_ID)) {
15254 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr_dark1, tag.Size());
15255 DCT_ASSERT((no == tag.Size()));
15256 }
15257 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR_DARK2_TAG_ID)) {
15258 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr_dark2, tag.Size());
15259 DCT_ASSERT((no == tag.Size()));
15260 }
15261 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISECURVE0_TAG_ID)) {
15262 int no = ParseFloatArray(pchild, pModeCell->setting.noiseCurve_0, tag.Size());
15263 DCT_ASSERT((no == tag.Size()));
15264 }
15265 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISECURVE1_TAG_ID)) {
15266 int no = ParseFloatArray(pchild, pModeCell->setting.noiseCurve_1, tag.Size());
15267 DCT_ASSERT((no == tag.Size()));
15268 }
15269 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GVALUELIMITLO_TAG_ID)) {
15270 int no = ParseFloatArray(pchild, pModeCell->setting.GValueLimitLo, tag.Size());
15271 DCT_ASSERT((no == tag.Size()));
15272 }
15273 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GVALUELIMITHI_TAG_ID)) {
15274 int no = ParseFloatArray(pchild, pModeCell->setting.GValueLimitHi, tag.Size());
15275 DCT_ASSERT((no == tag.Size()));
15276 }
15277 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_TEXTURESTRENGTH_TAG_ID)) {
15278 int no = ParseFloatArray(pchild, pModeCell->setting.textureStrength, tag.Size());
15279 DCT_ASSERT((no == tag.Size()));
15280 }
15281 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SCALELO_TAG_ID)) {
15282 int no = ParseFloatArray(pchild, pModeCell->setting.ScaleLo, tag.Size());
15283 DCT_ASSERT((no == tag.Size()));
15284 }
15285 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SCALEHI_TAG_ID)) {
15286 int no = ParseFloatArray(pchild, pModeCell->setting.ScaleHi, tag.Size());
15287 DCT_ASSERT((no == tag.Size()));
15288 }
15289 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GLOBALSTRENGTH_TAG_ID)) {
15290 int no = ParseFloatArray(pchild, pModeCell->setting.globalStrength, tag.Size());
15291 DCT_ASSERT((no == tag.Size()));
15292 }
15293 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISE_COEA_TAG_ID)) {
15294 int no = ParseFloatArray(pchild, pModeCell->setting.noise_coea, tag.Size());
15295 DCT_ASSERT((no == tag.Size()));
15296 }
15297 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISE_COEB_TAG_ID)) {
15298 int no = ParseFloatArray(pchild, pModeCell->setting.noise_coeb, tag.Size());
15299 DCT_ASSERT((no == tag.Size()));
15300 }
15301 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_DIFF_CLIP_TAG_ID)) {
15302 int no = ParseFloatArray(pchild, pModeCell->setting.diff_clip, tag.Size());
15303 DCT_ASSERT((no == tag.Size()));
15304 }
15305
15306 pchild = pchild->NextSibling();
15307 }
15308 XML_CHECK_END();
15309 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
15310 return (true);
15311 }
15312
parseEntrySensorGicCalibParaV21(const XMLElement * pelement,void * param)15313 bool RkAiqCalibParser::parseEntrySensorGicCalibParaV21
15314 (
15315 const XMLElement* pelement,
15316 void* param
15317 ) {
15318 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
15319
15320 XML_CHECK_START(CALIB_SENSOR_GIC_CALIBPARA_V21_TAG_ID, CALIB_SENSOR_GIC_TAG_ID);
15321 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Gic_Isp21_t, gic);
15322 int index = *((int*)param);
15323 const XMLNode* pchild = pelement->FirstChild();
15324 while (pchild) {
15325 XmlTag tag = XmlTag(pchild->ToElement());
15326 const char* value = tag.Value();
15327 std::string tagname(pchild->ToElement()->Name());
15328 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
15329
15330 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SCENE_TAG_ID)) {
15331 ParseString(pchild, gic->calib_v21[index].scene, sizeof(gic->calib_v21[index].scene));
15332 }
15333 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_ENABLE_TAG_ID)) {
15334 int no = ParseUcharArray(pchild, &gic->calib_v21[index].gic_en, tag.Size());
15335 DCT_ASSERT((no == tag.Size()));
15336 }
15337 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GR_RATION_TAG_ID)) {
15338 int no = ParseUcharArray(pchild, &gic->calib_v21[index].gr_ration, tag.Size());
15339 DCT_ASSERT((no == tag.Size()));
15340 }
15341 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SETTING_V21_TAG_ID)) {
15342 if (!parseEntrySensorGicCalibSettingV21(pchild->ToElement(), &gic->calib_v21[index], index)) {
15343 LOGE("parse error in Gic Calib V21 setting (%s)", tagname.c_str());
15344 return (false);
15345 }
15346 }
15347
15348 pchild = pchild->NextSibling();
15349 }
15350 XML_CHECK_END();
15351 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
15352 return (true);
15353 }
15354
parseEntrySensorGicTuningParaV21(const XMLElement * pelement,void * param)15355 bool RkAiqCalibParser::parseEntrySensorGicTuningParaV21
15356 (
15357 const XMLElement* pelement,
15358 void* param
15359 ) {
15360 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
15361
15362 XML_CHECK_START(CALIB_SENSOR_GIC_TUNINGPARA_V21_TAG_ID, CALIB_SENSOR_GIC_TAG_ID);
15363 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Gic_Isp21_t, gic);
15364 int index = *((int*)param);
15365 const XMLNode* pchild = pelement->FirstChild();
15366 while (pchild) {
15367 XmlTag tag = XmlTag(pchild->ToElement());
15368 const char* value = tag.Value();
15369 std::string tagname(pchild->ToElement()->Name());
15370 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
15371
15372 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SCENE_TAG_ID)) {
15373 ParseString(pchild, gic->tuning_v21[index].scene, sizeof(gic->tuning_v21[index].scene));
15374 }
15375 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_ENABLE_TAG_ID)) {
15376 int no = ParseUcharArray(pchild, &gic->tuning_v21[index].gic_en, tag.Size());
15377 DCT_ASSERT((no == tag.Size()));
15378 }
15379 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GR_RATION_TAG_ID)) {
15380 int no = ParseUcharArray(pchild, &gic->tuning_v21[index].gr_ration, tag.Size());
15381 DCT_ASSERT((no == tag.Size()));
15382 }
15383 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SETTING_V21_TAG_ID)) {
15384 if (!parseEntrySensorGicTuningSettingV21(pchild->ToElement(), &gic->tuning_v21[index], index)) {
15385 LOGE("parse error in Gic Tuning V21 setting (%s)", tagname.c_str());
15386 return (false);
15387 }
15388 }
15389
15390 pchild = pchild->NextSibling();
15391 }
15392 XML_CHECK_END();
15393 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
15394 return (true);
15395 }
15396
parseEntrySensorGicCalibSettingV21(const XMLElement * pelement,void * param,int index)15397 bool RkAiqCalibParser::parseEntrySensorGicCalibSettingV21
15398 (
15399 const XMLElement* pelement,
15400 void* param,
15401 int index
15402 ) {
15403 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
15404
15405 CalibDb_Gic_ModeCell_v21_t *pModeCell = (CalibDb_Gic_ModeCell_v21_t *)param;
15406
15407 XML_CHECK_START(CALIB_SENSOR_GIC_SETTING_V21_TAG_ID, CALIB_SENSOR_GIC_CALIBPARA_V21_TAG_ID);
15408 const XMLNode* pchild = pelement->FirstChild();
15409 while (pchild) {
15410 XmlTag tag = XmlTag(pchild->ToElement());
15411 const char* value = tag.Value();
15412 std::string tagname(pchild->ToElement()->Name());
15413 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
15414
15415
15416 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SETTING_ISO_TAG_ID)) {
15417 int no = ParseFloatArray(pchild, pModeCell->setting.iso, tag.Size());
15418 DCT_ASSERT((no == tag.Size()));
15419 }
15420 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_BUSY_THRE_TAG_ID)) {
15421 int no = ParseFloatArray(pchild, pModeCell->setting.min_busy_thre, tag.Size());
15422 DCT_ASSERT((no == tag.Size()));
15423 }
15424 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR1_TAG_ID)) {
15425 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr1, tag.Size());
15426 DCT_ASSERT((no == tag.Size()));
15427 }
15428 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR2_TAG_ID)) {
15429 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr2, tag.Size());
15430 DCT_ASSERT((no == tag.Size()));
15431 }
15432 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD1_TAG_ID)) {
15433 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad1, tag.Size());
15434 DCT_ASSERT((no == tag.Size()));
15435 }
15436 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD2_TAG_ID)) {
15437 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad2, tag.Size());
15438 DCT_ASSERT((no == tag.Size()));
15439 }
15440 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GB_THRE_TAG_ID)) {
15441 int no = ParseFloatArray(pchild, pModeCell->setting.gb_thre, tag.Size());
15442 DCT_ASSERT((no == tag.Size()));
15443 }
15444 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MAXCORV_TAG_ID)) {
15445 int no = ParseFloatArray(pchild, pModeCell->setting.maxCorV, tag.Size());
15446 DCT_ASSERT((no == tag.Size()));
15447 }
15448 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MAXCORVBOTH_TAG_ID)) {
15449 int no = ParseFloatArray(pchild, pModeCell->setting.maxCorVboth, tag.Size());
15450 DCT_ASSERT((no == tag.Size()));
15451 }
15452 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_DARK_THRE_TAG_ID)) {
15453 int no = ParseFloatArray(pchild, pModeCell->setting.dark_thre, tag.Size());
15454 DCT_ASSERT((no == tag.Size()));
15455 }
15456 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_DARK_THREHI_TAG_ID)) {
15457 int no = ParseFloatArray(pchild, pModeCell->setting.dark_threHi, tag.Size());
15458 DCT_ASSERT((no == tag.Size()));
15459 }
15460 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD1_DARK_TAG_ID)) {
15461 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad1_dark, tag.Size());
15462 DCT_ASSERT((no == tag.Size()));
15463 }
15464 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD2_DARK_TAG_ID)) {
15465 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad2_dark, tag.Size());
15466 DCT_ASSERT((no == tag.Size()));
15467 }
15468 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR_DARK1_TAG_ID)) {
15469 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr_dark1, tag.Size());
15470 DCT_ASSERT((no == tag.Size()));
15471 }
15472 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR_DARK2_TAG_ID)) {
15473 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr_dark2, tag.Size());
15474 DCT_ASSERT((no == tag.Size()));
15475 }
15476 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISECURVE0_TAG_ID)) {
15477 int no = ParseFloatArray(pchild, pModeCell->setting.noiseCurve_0, tag.Size());
15478 DCT_ASSERT((no == tag.Size()));
15479 }
15480 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISECURVE1_TAG_ID)) {
15481 int no = ParseFloatArray(pchild, pModeCell->setting.noiseCurve_1, tag.Size());
15482 DCT_ASSERT((no == tag.Size()));
15483 }
15484 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISESCALE_TAG_ID)) {
15485 int no = ParseFloatArray(pchild, pModeCell->setting.NoiseScale, tag.Size());
15486 DCT_ASSERT((no == tag.Size()));
15487 }
15488 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISEBASE_TAG_ID)) {
15489 int no = ParseFloatArray(pchild, pModeCell->setting.NoiseBase, tag.Size());
15490 DCT_ASSERT((no == tag.Size()));
15491 }
15492 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GLOBALSTRENGTH_TAG_ID)) {
15493 int no = ParseFloatArray(pchild, pModeCell->setting.globalStrength, tag.Size());
15494 DCT_ASSERT((no == tag.Size()));
15495 }
15496 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_DIFF_CLIP_TAG_ID)) {
15497 int no = ParseFloatArray(pchild, pModeCell->setting.diff_clip, tag.Size());
15498 DCT_ASSERT((no == tag.Size()));
15499 }
15500
15501 pchild = pchild->NextSibling();
15502 }
15503 XML_CHECK_END();
15504 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
15505 return (true);
15506 }
15507
parseEntrySensorGicTuningSettingV21(const XMLElement * pelement,void * param,int index)15508 bool RkAiqCalibParser::parseEntrySensorGicTuningSettingV21
15509 (
15510 const XMLElement* pelement,
15511 void* param,
15512 int index
15513 ) {
15514 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
15515
15516 CalibDb_Gic_ModeCell_v21_t *pModeCell = (CalibDb_Gic_ModeCell_v21_t *)param;
15517
15518 XML_CHECK_START(CALIB_SENSOR_GIC_SETTING_V21_TAG_ID, CALIB_SENSOR_GIC_TUNINGPARA_V21_TAG_ID);
15519 const XMLNode* pchild = pelement->FirstChild();
15520 while (pchild) {
15521 XmlTag tag = XmlTag(pchild->ToElement());
15522 const char* value = tag.Value();
15523 std::string tagname(pchild->ToElement()->Name());
15524 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
15525
15526
15527 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_SETTING_ISO_TAG_ID)) {
15528 int no = ParseFloatArray(pchild, pModeCell->setting.iso, tag.Size());
15529 DCT_ASSERT((no == tag.Size()));
15530 }
15531 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_BUSY_THRE_TAG_ID)) {
15532 int no = ParseFloatArray(pchild, pModeCell->setting.min_busy_thre, tag.Size());
15533 DCT_ASSERT((no == tag.Size()));
15534 }
15535 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR1_TAG_ID)) {
15536 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr1, tag.Size());
15537 DCT_ASSERT((no == tag.Size()));
15538 }
15539 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR2_TAG_ID)) {
15540 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr2, tag.Size());
15541 DCT_ASSERT((no == tag.Size()));
15542 }
15543 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD1_TAG_ID)) {
15544 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad1, tag.Size());
15545 DCT_ASSERT((no == tag.Size()));
15546 }
15547 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD2_TAG_ID)) {
15548 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad2, tag.Size());
15549 DCT_ASSERT((no == tag.Size()));
15550 }
15551 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GB_THRE_TAG_ID)) {
15552 int no = ParseFloatArray(pchild, pModeCell->setting.gb_thre, tag.Size());
15553 DCT_ASSERT((no == tag.Size()));
15554 }
15555 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MAXCORV_TAG_ID)) {
15556 int no = ParseFloatArray(pchild, pModeCell->setting.maxCorV, tag.Size());
15557 DCT_ASSERT((no == tag.Size()));
15558 }
15559 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MAXCORVBOTH_TAG_ID)) {
15560 int no = ParseFloatArray(pchild, pModeCell->setting.maxCorVboth, tag.Size());
15561 DCT_ASSERT((no == tag.Size()));
15562 }
15563 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_DARK_THRE_TAG_ID)) {
15564 int no = ParseFloatArray(pchild, pModeCell->setting.dark_thre, tag.Size());
15565 DCT_ASSERT((no == tag.Size()));
15566 }
15567 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_DARK_THREHI_TAG_ID)) {
15568 int no = ParseFloatArray(pchild, pModeCell->setting.dark_threHi, tag.Size());
15569 DCT_ASSERT((no == tag.Size()));
15570 }
15571 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD1_DARK_TAG_ID)) {
15572 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad1_dark, tag.Size());
15573 DCT_ASSERT((no == tag.Size()));
15574 }
15575 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_K_GRAD2_DARK_TAG_ID)) {
15576 int no = ParseFloatArray(pchild, pModeCell->setting.k_grad2_dark, tag.Size());
15577 DCT_ASSERT((no == tag.Size()));
15578 }
15579 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR_DARK1_TAG_ID)) {
15580 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr_dark1, tag.Size());
15581 DCT_ASSERT((no == tag.Size()));
15582 }
15583 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_MIN_GRAD_THR_DARK2_TAG_ID)) {
15584 int no = ParseFloatArray(pchild, pModeCell->setting.min_grad_thr_dark2, tag.Size());
15585 DCT_ASSERT((no == tag.Size()));
15586 }
15587 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISECURVE0_TAG_ID)) {
15588 int no = ParseFloatArray(pchild, pModeCell->setting.noiseCurve_0, tag.Size());
15589 DCT_ASSERT((no == tag.Size()));
15590 }
15591 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISECURVE1_TAG_ID)) {
15592 int no = ParseFloatArray(pchild, pModeCell->setting.noiseCurve_1, tag.Size());
15593 DCT_ASSERT((no == tag.Size()));
15594 }
15595 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISESCALE_TAG_ID)) {
15596 int no = ParseFloatArray(pchild, pModeCell->setting.NoiseScale, tag.Size());
15597 DCT_ASSERT((no == tag.Size()));
15598 }
15599 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_NOISEBASE_TAG_ID)) {
15600 int no = ParseFloatArray(pchild, pModeCell->setting.NoiseBase, tag.Size());
15601 DCT_ASSERT((no == tag.Size()));
15602 }
15603 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_GLOBALSTRENGTH_TAG_ID)) {
15604 int no = ParseFloatArray(pchild, pModeCell->setting.globalStrength, tag.Size());
15605 DCT_ASSERT((no == tag.Size()));
15606 }
15607 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_GIC_DIFF_CLIP_TAG_ID)) {
15608 int no = ParseFloatArray(pchild, pModeCell->setting.diff_clip, tag.Size());
15609 DCT_ASSERT((no == tag.Size()));
15610 }
15611 pchild = pchild->NextSibling();
15612 }
15613 XML_CHECK_END();
15614 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
15615 return (true);
15616 }
15617
parseEntrySensorMFNR(const XMLElement * pelement,void * param)15618 bool RkAiqCalibParser::parseEntrySensorMFNR
15619 (
15620 const XMLElement* pelement,
15621 void* param
15622 ) {
15623 (void)param;
15624
15625 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
15626 autoTabForward();
15627
15628 XML_CHECK_START(CALIB_SENSOR_MFNR_TAG_ID, CALIB_SENSOR_TAG_ID);
15629 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_MFNR_2_t, mfnr);
15630
15631 const XMLNode* pchild = pelement->FirstChild();
15632 while (pchild) {
15633 XmlTag tag = XmlTag(pchild->ToElement());
15634 std::string tagname(pchild->ToElement()->Name());
15635 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
15636
15637 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ENABLE_TAG_ID)) {
15638 int no = ParseIntArray(pchild, &mfnr->enable, tag.Size());
15639 DCT_ASSERT((no == tag.Size()));
15640 }
15641 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_VERSION_TAG_ID)) {
15642 ParseString(pchild, mfnr->version, sizeof(mfnr->version));
15643 }
15644 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_LOCAL_GAIN_EN_TAG_ID)) {
15645 int no = ParseUcharArray(pchild, &mfnr->local_gain_en, tag.Size());
15646 DCT_ASSERT((no == tag.Size()));
15647 }
15648 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECT_EN_TAG_ID)) {
15649 int no = ParseUcharArray(pchild, &mfnr->motion_detect_en, tag.Size());
15650 DCT_ASSERT((no == tag.Size()));
15651 }
15652 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MODE_3TO1_TAG_ID)) {
15653 int no = ParseUcharArray(pchild, &mfnr->mode_3to1, tag.Size());
15654 DCT_ASSERT((no == tag.Size()));
15655 }
15656 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MAX_LEVEL_TAG_ID)) {
15657 int no = ParseUcharArray(pchild, &mfnr->max_level, tag.Size());
15658 DCT_ASSERT((no == tag.Size()));
15659 }
15660 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MAX_LEVEL_UV_TAG_ID)) {
15661 int no = ParseUcharArray(pchild, &mfnr->max_level_uv, tag.Size());
15662 DCT_ASSERT((no == tag.Size()));
15663 }
15664 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_BACK_REF_NUM_TAG_ID)) {
15665 int no = ParseUcharArray(pchild, &mfnr->back_ref_num, tag.Size());
15666 DCT_ASSERT((no == tag.Size()));
15667 }
15668 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_AWB_UV_RATIO_TAG_ID)) {
15669 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
15670 &RkAiqCalibParser::parseEntrySensorMFNRAwbUvRatio,
15671 param,
15672 (uint32_t)CALIB_SENSOR_MFNR_AWB_UV_RATIO_TAG_ID,
15673 (uint32_t)CALIB_SENSOR_MFNR_TAG_ID)) {
15674 LOGE("parse error in MFNR awb_uv_ratio (%s)\n", tagname.c_str());
15675 return (false);
15676 }
15677 }
15678 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MODE_CELL_TAG_ID)) {
15679 if (xmlParseReadWrite == XML_PARSER_READ) {
15680 int cell_size = 0;
15681 parseCellNoElement(pchild->ToElement(), tag.Size(), cell_size);
15682 mfnr->mode_num = cell_size;
15683 mfnr->mode_cell = (CalibDb_MFNR_ModeCell_t *)malloc(cell_size * sizeof(CalibDb_MFNR_ModeCell_t));
15684 memset(mfnr->mode_cell, 0x00, cell_size * sizeof(CalibDb_MFNR_ModeCell_t));
15685 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
15686 &RkAiqCalibParser::parseEntrySensorMFNRModeCell,
15687 param,
15688 (uint32_t)CALIB_SENSOR_MFNR_MODE_CELL_TAG_ID,
15689 (uint32_t)CALIB_SENSOR_MFNR_TAG_ID)) {
15690 LOGE("parse error in MFNR MFNR_ISO (%s)\n", tagname.c_str());
15691 return (false);
15692 }
15693 }
15694 else
15695 {
15696 if (!parseEntryCell3((XMLElement *)pchild->ToElement(), tag.Size(), mfnr->mode_num,
15697 &RkAiqCalibParser::parseEntrySensorMFNRModeCell,
15698 param,
15699 (uint32_t)CALIB_SENSOR_MFNR_MODE_CELL_TAG_ID,
15700 (uint32_t)CALIB_SENSOR_MFNR_TAG_ID)) {
15701 LOGE("parse error in MFNR MFNR_ISO (%s)\n", tagname.c_str());
15702 return (false);
15703 }
15704 }
15705 }
15706
15707 pchild = pchild->NextSibling();
15708 }
15709 XML_CHECK_END();
15710 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
15711 autoTabBackward();
15712 return (true);
15713 }
15714
parseEntrySensorMFNRAwbUvRatio(const XMLElement * pelement,void * param)15715 bool RkAiqCalibParser::parseEntrySensorMFNRAwbUvRatio
15716 (
15717 const XMLElement* pelement,
15718 void* param
15719 ) {
15720 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
15721
15722
15723 XML_CHECK_START(CALIB_SENSOR_MFNR_AWB_UV_RATIO_TAG_ID, CALIB_SENSOR_MFNR_TAG_ID);
15724 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_MFNR_2_t, mfnr);
15725
15726 int index = *((int*)param);
15727 const XMLNode* pchild = pelement->FirstChild();
15728 while (pchild) {
15729 XmlTag tag = XmlTag(pchild->ToElement());
15730 const char* value = tag.Value();
15731 std::string tagname(pchild->ToElement()->Name());
15732 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
15733
15734 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_AWB_UV_RATIO_NAME_TAG_ID)) {
15735 ParseString(pchild,
15736 mfnr->uv_ratio[index].illum,
15737 sizeof(mfnr->uv_ratio[index].illum));
15738 }
15739 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_AWB_UV_RATIO_RATIO_TAG_ID)) {
15740 int no = ParseFloatArray(pchild, mfnr->uv_ratio[index].ratio, tag.Size());
15741 DCT_ASSERT((no == tag.Size()));
15742 }
15743 pchild = pchild->NextSibling();
15744 }
15745 XML_CHECK_END();
15746 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
15747 return (true);
15748 }
15749
parseEntrySensorMFNRDynamic(const XMLElement * pelement,void * param,int index)15750 bool RkAiqCalibParser::parseEntrySensorMFNRDynamic
15751 (
15752 const XMLElement* pelement,
15753 void* param,
15754 int index
15755 ) {
15756 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
15757 autoTabForward();
15758
15759 XML_CHECK_START(CALIB_SENSOR_MFNR_DYNAMIC_TAG_ID, CALIB_SENSOR_MFNR_MODE_CELL_TAG_ID);
15760 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_MFNR_2_t, mfnr);
15761
15762 const XMLNode* psubchild = pelement->FirstChild();
15763 #ifdef DEBUG_LOG
15764 LOGE("%s(%d): Tagname = [%s]\n", __FUNCTION__, __LINE__, pelement->Name());
15765 #endif
15766 while (psubchild) {
15767 XmlTag subTag = XmlTag(psubchild->ToElement());
15768 std::string subTagname(psubchild->ToElement()->Name());
15769 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
15770
15771 #ifdef DEBUG_LOG
15772 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
15773 #endif
15774
15775 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_DYNAMIC_ENABLE_TAG_ID)) {
15776 int no = ParseIntArray(psubchild, &mfnr->mode_cell[index].dynamic.enable, subTag.Size());
15777 DCT_ASSERT((no == subTag.Size()));
15778 }
15779 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_DYNAMIC_LOWTH_ISO_TAG_ID)) {
15780 int no = ParseFloatArray(psubchild, &mfnr->mode_cell[index].dynamic.lowth_iso, subTag.Size());
15781 DCT_ASSERT((no == subTag.Size()));
15782 }
15783 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_DYNAMIC_LOWTH_TIME_TAG_ID)) {
15784 int no = ParseFloatArray(psubchild, &mfnr->mode_cell[index].dynamic.lowth_time, subTag.Size());
15785 DCT_ASSERT((no == subTag.Size()));
15786 }
15787 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_DYNAMIC_HIGHTH_ISO_TAG_ID)) {
15788 int no = ParseFloatArray(psubchild, &mfnr->mode_cell[index].dynamic.highth_iso, subTag.Size());
15789 DCT_ASSERT((no == subTag.Size()));
15790 }
15791 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_DYNAMIC_HIGHTH_TIME_TAG_ID)) {
15792 int no = ParseFloatArray(psubchild, &mfnr->mode_cell[index].dynamic.highth_time, subTag.Size());
15793 DCT_ASSERT((no == subTag.Size()));
15794 }
15795 else {
15796 LOGW("%s(%d): parse error in mfnr dynamic (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
15797 }
15798 psubchild = psubchild->NextSibling();
15799 }
15800 XML_CHECK_END();
15801 autoTabBackward();
15802 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
15803 return (true);
15804 }
15805
15806
parseEntrySensorMFNRMotionDetection(const XMLElement * pelement,void * param,int index)15807 bool RkAiqCalibParser::parseEntrySensorMFNRMotionDetection
15808 (
15809 const XMLElement* pelement,
15810 void* param,
15811 int index
15812 ) {
15813 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
15814 autoTabForward();
15815
15816 XML_CHECK_START(CALIB_SENSOR_MFNR_MOTION_DETECTION_TAG_ID, CALIB_SENSOR_MFNR_MODE_CELL_TAG_ID);
15817 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_MFNR_2_t, mfnr);
15818
15819 const XMLNode* psubchild = pelement->FirstChild();
15820 #ifdef DEBUG_LOG
15821 LOGE("%s(%d): Tagname = [%s]\n", __FUNCTION__, __LINE__, pelement->Name());
15822 #endif
15823 while (psubchild) {
15824 XmlTag subTag = XmlTag(psubchild->ToElement());
15825 std::string subTagname(psubchild->ToElement()->Name());
15826 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
15827
15828 #ifdef DEBUG_LOG
15829 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
15830 #endif
15831
15832 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_ENABLE_TAG_ID)) {
15833 int no = ParseIntArray(psubchild, &mfnr->mode_cell[index].motion.enable, subTag.Size());
15834 DCT_ASSERT((no == subTag.Size()));
15835 }
15836 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_ISO_TAG_ID)) {
15837 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.iso, subTag.Size());
15838 DCT_ASSERT((no == subTag.Size()));
15839 }
15840 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_SIGMAHSCALE_TAG_ID)) {
15841 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.sigmaHScale, subTag.Size());
15842 DCT_ASSERT((no == subTag.Size()));
15843 }
15844 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_SIGMALSCALE_TAG_ID)) {
15845 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.sigmaLScale, subTag.Size());
15846 DCT_ASSERT((no == subTag.Size()));
15847 }
15848 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_LIGHT_CLP_TAG_ID)) {
15849 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.lightClp, subTag.Size());
15850 DCT_ASSERT((no == subTag.Size()));
15851 }
15852 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_UV_WEIGHT_TAG_ID)) {
15853 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.uvWeight, subTag.Size());
15854 DCT_ASSERT((no == subTag.Size()));
15855 }
15856 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_MFNR_SIGMA_SCALE_TAG_ID)) {
15857 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.mfnrSigmaScale, subTag.Size());
15858 DCT_ASSERT((no == subTag.Size()));
15859 }
15860 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_YUVNR_GAIN_SCALE0_TAG_ID)) {
15861 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.yuvnrGainScale0, subTag.Size());
15862 DCT_ASSERT((no == subTag.Size()));
15863 }
15864 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_YUVNR_GAIN_SCALE1_TAG_ID)) {
15865 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.yuvnrGainScale1, subTag.Size());
15866 DCT_ASSERT((no == subTag.Size()));
15867 }
15868 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_YUVNR_GAIN_SCALE2_TAG_ID)) {
15869 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.yuvnrGainScale2, subTag.Size());
15870 DCT_ASSERT((no == subTag.Size()));
15871 }
15872 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_RESERVED0_TAG_ID)) {
15873 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.reserved0, subTag.Size());
15874 DCT_ASSERT((no == subTag.Size()));
15875 }
15876 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_RESERVED1_TAG_ID)) {
15877 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.reserved1, subTag.Size());
15878 DCT_ASSERT((no == subTag.Size()));
15879 }
15880 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_RESERVED2_TAG_ID)) {
15881 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.reserved2, subTag.Size());
15882 DCT_ASSERT((no == subTag.Size()));
15883 }
15884 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_RESERVED3_TAG_ID)) {
15885 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.reserved3, subTag.Size());
15886 DCT_ASSERT((no == subTag.Size()));
15887 }
15888 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_RESERVED4_TAG_ID)) {
15889 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.reserved4, subTag.Size());
15890 DCT_ASSERT((no == subTag.Size()));
15891 }
15892 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_RESERVED5_TAG_ID)) {
15893 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.reserved5, subTag.Size());
15894 DCT_ASSERT((no == subTag.Size()));
15895 }
15896 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_RESERVED6_TAG_ID)) {
15897 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.reserved6, subTag.Size());
15898 DCT_ASSERT((no == subTag.Size()));
15899 }
15900 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_RESERVED7_TAG_ID)) {
15901 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.reserved7, subTag.Size());
15902 DCT_ASSERT((no == subTag.Size()));
15903 }
15904 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_RESERVED8_TAG_ID)) {
15905 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.frame_limit_uv, subTag.Size());
15906 DCT_ASSERT((no == subTag.Size()));
15907 }
15908 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_RESERVED9_TAG_ID)) {
15909 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.frame_limit_y, subTag.Size());
15910 DCT_ASSERT((no == subTag.Size()));
15911 }
15912 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_FRAME_LIMIT_Y_TAG_ID)) {
15913 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.frame_limit_y, subTag.Size());
15914 DCT_ASSERT((no == subTag.Size()));
15915 }
15916 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_FRAME_LIMIT_UV_TAG_ID)) {
15917 int no = ParseFloatArray(psubchild, mfnr->mode_cell[index].motion.frame_limit_uv, subTag.Size());
15918 DCT_ASSERT((no == subTag.Size()));
15919 }
15920 else {
15921 LOGE("%s(%d): parse error in mfnr dynamic (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
15922 }
15923 psubchild = psubchild->NextSibling();
15924 }
15925 XML_CHECK_END();
15926 autoTabBackward();
15927 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
15928 return (true);
15929 }
15930
15931
parseEntrySensorMFNRModeCell(const XMLElement * pelement,void * param)15932 bool RkAiqCalibParser::parseEntrySensorMFNRModeCell
15933 (
15934 const XMLElement* pelement,
15935 void* param
15936 ) {
15937 (void)param;
15938
15939 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
15940
15941 int index = *((int*)param);
15942 XML_CHECK_START(CALIB_SENSOR_MFNR_MODE_CELL_TAG_ID, CALIB_SENSOR_MFNR_TAG_ID);
15943 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_MFNR_2_t, mfnr);
15944
15945 const XMLNode* pchild = pelement->FirstChild();
15946 while (pchild) {
15947 XmlTag tag = XmlTag(pchild->ToElement());
15948 std::string tagname(pchild->ToElement()->Name());
15949 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
15950
15951 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MODE_NAME_TAG_ID)) {
15952 ParseString(pchild, mfnr->mode_cell[index].name, sizeof(mfnr->mode_cell[index].name));
15953 }
15954 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_DYNAMIC_TAG_ID)) {
15955 if (!parseEntrySensorMFNRDynamic(pchild->ToElement(), param, index)) {
15956 LOGE("parse error in MFNR dynamic(%s)", tagname.c_str());
15957 return (false);
15958 }
15959 }
15960 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_SETTING_TAG_ID)) {
15961 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
15962 &RkAiqCalibParser::parseEntrySensorMFNRSetting,
15963 (void *)&mfnr->mode_cell[index],
15964 (uint32_t)CALIB_SENSOR_MFNR_SETTING_TAG_ID,
15965 (uint32_t)CALIB_SENSOR_MFNR_MODE_CELL_TAG_ID)) {
15966 LOGE("parse error in MFNR MFNR_ISO (%s)\n", tagname.c_str());
15967 return (false);
15968 }
15969 }
15970 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_MOTION_DETECTION_TAG_ID)) {
15971 if (!parseEntrySensorMFNRMotionDetection(pchild->ToElement(), param, index)) {
15972 LOGE("parse error in MFNR motion detection(%s)", tagname.c_str());
15973 return (false);
15974 }
15975 }
15976
15977 pchild = pchild->NextSibling();
15978 }
15979 XML_CHECK_END();
15980 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
15981
15982 return (true);
15983
15984 }
15985
parseEntrySensorMFNRSetting(const XMLElement * pelement,void * param,int index)15986 bool RkAiqCalibParser::parseEntrySensorMFNRSetting
15987 (
15988 const XMLElement* pelement,
15989 void* param,
15990 int index
15991 ) {
15992 (void)param;
15993
15994 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
15995
15996 CalibDb_MFNR_ModeCell_t *pModeCell = (CalibDb_MFNR_ModeCell_t *)param;
15997 XML_CHECK_START(CALIB_SENSOR_MFNR_SETTING_TAG_ID, CALIB_SENSOR_MFNR_MODE_CELL_TAG_ID);
15998
15999 const XMLNode* pchild = pelement->FirstChild();
16000 while (pchild) {
16001 XmlTag tag = XmlTag(pchild->ToElement());
16002 std::string tagname(pchild->ToElement()->Name());
16003 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
16004
16005 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_SETTING_SNR_MODE_TAG_ID)) {
16006 ParseString(pchild, pModeCell->setting[index].snr_mode, sizeof(pModeCell->setting[index].snr_mode));
16007 }
16008 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_SETTING_SENSOR_MODE_TAG_ID)) {
16009 ParseString(pchild, pModeCell->setting[index].sensor_mode, sizeof(pModeCell->setting[index].sensor_mode));
16010 }
16011 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_TAG_ID)) {
16012 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
16013 &RkAiqCalibParser::parseEntrySensorMFNRISO,
16014 (void *)&pModeCell->setting[index],
16015 (uint32_t)CALIB_SENSOR_MFNR_ISO_TAG_ID,
16016 (uint32_t)CALIB_SENSOR_MFNR_SETTING_TAG_ID)) {
16017 LOGE("parse error in MFNR MFNR_ISO (%s)\n", tagname.c_str());
16018 return (false);
16019 }
16020 }
16021
16022 pchild = pchild->NextSibling();
16023 }
16024 XML_CHECK_END();
16025 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
16026
16027 return (true);
16028 }
16029
parseEntrySensorMFNRISO(const XMLElement * pelement,void * param,int index)16030 bool RkAiqCalibParser::parseEntrySensorMFNRISO
16031 (
16032 const XMLElement* pelement,
16033 void* param,
16034 int index
16035 ) {
16036 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
16037
16038 XML_CHECK_START(CALIB_SENSOR_MFNR_ISO_TAG_ID, CALIB_SENSOR_MFNR_SETTING_TAG_ID);
16039
16040 CalibDb_MFNR_Setting_t * pSetting = (CalibDb_MFNR_Setting_t *)param;
16041 const XMLNode* pchild = pelement->FirstChild();
16042 while (pchild) {
16043 XmlTag tag = XmlTag(pchild->ToElement());
16044 const char* value = tag.Value();
16045 std::string tagname(pchild->ToElement()->Name());
16046 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
16047
16048 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_ISO_TAG_ID)) {
16049 int no = ParseFloatArray(pchild, &pSetting->mfnr_iso[index].iso, tag.Size());
16050 DCT_ASSERT((no == tag.Size()));
16051 }
16052 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_WEIGHT_LIMIT_Y_TAG_ID)) {
16053 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].weight_limit_y, tag.Size());
16054 DCT_ASSERT((no == tag.Size()));
16055 }
16056 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_WEIGHT_LIMIT_UV_TAG_ID)) {
16057 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].weight_limit_uv, tag.Size());
16058 DCT_ASSERT((no == tag.Size()));
16059 }
16060 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_RATIO_FRQ_TAG_ID)) {
16061 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].ratio_frq, tag.Size());
16062 DCT_ASSERT((no == tag.Size()));
16063 }
16064 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_LUMA_W_IN_CHROMA_TAG_ID)) {
16065 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].luma_w_in_chroma, tag.Size());
16066 DCT_ASSERT((no == tag.Size()));
16067 }
16068 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_NOISE_CURVE_TAG_ID)) {
16069 int no = ParseDoubleArray(pchild, pSetting->mfnr_iso[index].noise_curve, tag.Size());
16070 DCT_ASSERT((no == tag.Size()));
16071 }
16072 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_NOISE_CURVE_X00_TAG_ID)) {
16073 int no = ParseDoubleArray(pchild, &pSetting->mfnr_iso[index].noise_curve_x00, tag.Size());
16074 DCT_ASSERT((no == tag.Size()));
16075 }
16076 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_LO_NOISEPROFILE_TAG_ID)) {
16077 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_lo_noiseprofile, tag.Size(), 5);
16078 DCT_ASSERT((no == tag.Size()));
16079 }
16080 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_HI_NOISEPROFILE_TAG_ID)) {
16081 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_hi_noiseprofile, tag.Size(), 5);
16082 DCT_ASSERT((no == tag.Size()));
16083 }
16084 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_LO_DENOISEWEIGHT_TAG_ID)) {
16085 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_lo_denoiseweight, tag.Size());
16086 DCT_ASSERT((no == tag.Size()));
16087 }
16088 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_HI_DENOISEWEIGHT_TAG_ID)) {
16089 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_hi_denoiseweight, tag.Size());
16090 DCT_ASSERT((no == tag.Size()));
16091 }
16092 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_LO_BFSCALE_TAG_ID)) {
16093 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_lo_bfscale, tag.Size());
16094 DCT_ASSERT((no == tag.Size()));
16095 }
16096 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_HI_BFSCALE_TAG_ID)) {
16097 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_hi_bfscale, tag.Size());
16098 DCT_ASSERT((no == tag.Size()));
16099 }
16100 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_LUMANRPOINT_TAG_ID)) {
16101 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_lumanrpoint, tag.Size());
16102 DCT_ASSERT((no == tag.Size()));
16103 }
16104 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_LUMANRCURVE_TAG_ID)) {
16105 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_lumanrcurve, tag.Size());
16106 DCT_ASSERT((no == tag.Size()));
16107 }
16108 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_DENOISESTRENGTH_TAG_ID)) {
16109 int no = ParseFloatArray(pchild, &pSetting->mfnr_iso[index].y_denoisestrength, tag.Size());
16110 DCT_ASSERT((no == tag.Size()));
16111 }
16112 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_LO_LVL0_GFDELTA_TAG_ID)) {
16113 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_lo_lvl0_gfdelta, tag.Size(), 5);
16114 DCT_ASSERT((no == tag.Size()));
16115 }
16116 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_HI_LVL0_GFDELTA_TAG_ID)) {
16117 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_hi_lvl0_gfdelta, tag.Size(), 5);
16118 DCT_ASSERT((no == tag.Size()));
16119 }
16120 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_LO_LVL1_GFDELTA_TAG_ID)) {
16121 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_lo_lvl1_gfdelta, tag.Size(), 5);
16122 DCT_ASSERT((no == tag.Size()));
16123 }
16124 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_HI_LVL1_GFDELTA_TAG_ID)) {
16125 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_hi_lvl1_gfdelta, tag.Size(), 5);
16126 DCT_ASSERT((no == tag.Size()));
16127 }
16128 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_LO_LVL2_GFDELTA_TAG_ID)) {
16129 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_lo_lvl2_gfdelta, tag.Size(), 5);
16130 DCT_ASSERT((no == tag.Size()));
16131 }
16132 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_HI_LVL2_GFDELTA_TAG_ID)) {
16133 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_hi_lvl2_gfdelta, tag.Size(), 5);
16134 DCT_ASSERT((no == tag.Size()));
16135 }
16136 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_LO_LVL3_GFDELTA_TAG_ID)) {
16137 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_lo_lvl3_gfdelta, tag.Size(), 5);
16138 DCT_ASSERT((no == tag.Size()));
16139 }
16140 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_Y_HI_LVL3_GFDELTA_TAG_ID)) {
16141 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].y_hi_lvl3_gfdelta, tag.Size(), 5);
16142 DCT_ASSERT((no == tag.Size()));
16143 }
16144 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_LO_NOISEPROFILE_TAG_ID)) {
16145 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_lo_noiseprofile, tag.Size(), 5);
16146 DCT_ASSERT((no == tag.Size()));
16147 }
16148 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_HI_NOISEPROFILE_TAG_ID)) {
16149 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_hi_noiseprofile, tag.Size(), 5);
16150 DCT_ASSERT((no == tag.Size()));
16151 }
16152 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_LO_DENOISEWEIGHT_TAG_ID)) {
16153 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_lo_denoiseweight, tag.Size());
16154 DCT_ASSERT((no == tag.Size()));
16155 }
16156 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_HI_DENOISEWEIGHT_TAG_ID)) {
16157 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_hi_denoiseweight, tag.Size());
16158 DCT_ASSERT((no == tag.Size()));
16159 }
16160 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_LO_BFSCALE_TAG_ID)) {
16161 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_lo_bfscale, tag.Size());
16162 DCT_ASSERT((no == tag.Size()));
16163 }
16164 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_HI_BFSCALE_TAG_ID)) {
16165 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_hi_bfscale, tag.Size());
16166 DCT_ASSERT((no == tag.Size()));
16167 }
16168 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_LUMANRPOINT_TAG_ID)) {
16169 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_lumanrpoint, tag.Size());
16170 DCT_ASSERT((no == tag.Size()));
16171 }
16172 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_LUMANRCURVE_TAG_ID)) {
16173 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_lumanrcurve, tag.Size());
16174 DCT_ASSERT((no == tag.Size()));
16175 }
16176 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_DENOISESTRENGTH_TAG_ID)) {
16177 int no = ParseFloatArray(pchild, &pSetting->mfnr_iso[index].uv_denoisestrength, tag.Size());
16178 DCT_ASSERT((no == tag.Size()));
16179 }
16180 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_LO_LVL0_GFDELTA_TAG_ID)) {
16181 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_lo_lvl0_gfdelta, tag.Size(), 5);
16182 DCT_ASSERT((no == tag.Size()));
16183 }
16184 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_HI_LVL0_GFDELTA_TAG_ID)) {
16185 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_hi_lvl0_gfdelta, tag.Size(), 5);
16186 DCT_ASSERT((no == tag.Size()));
16187 }
16188 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_LO_LVL1_GFDELTA_TAG_ID)) {
16189 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_lo_lvl1_gfdelta, tag.Size(), 5);
16190 DCT_ASSERT((no == tag.Size()));
16191 }
16192 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_HI_LVL1_GFDELTA_TAG_ID)) {
16193 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_hi_lvl1_gfdelta, tag.Size(), 5);
16194 DCT_ASSERT((no == tag.Size()));
16195 }
16196 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_LO_LVL2_GFDELTA_TAG_ID)) {
16197 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_lo_lvl2_gfdelta, tag.Size(), 5);
16198 DCT_ASSERT((no == tag.Size()));
16199 }
16200 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_UV_HI_LVL2_GFDELTA_TAG_ID)) {
16201 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].uv_hi_lvl2_gfdelta, tag.Size(), 5);
16202 DCT_ASSERT((no == tag.Size()));
16203 }
16204 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_LVL0_GFSIGMA_TAG_ID)) {
16205 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].lvl0_gfsigma, tag.Size(), 5);
16206 DCT_ASSERT((no == tag.Size()));
16207 }
16208 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_LVL1_GFSIGMA_TAG_ID)) {
16209 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].lvl1_gfsigma, tag.Size(), 5);
16210 DCT_ASSERT((no == tag.Size()));
16211 }
16212 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_LVL2_GFSIGMA_TAG_ID)) {
16213 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].lvl2_gfsigma, tag.Size(), 5);
16214 DCT_ASSERT((no == tag.Size()));
16215 }
16216 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_MFNR_ISO_LVL3_GFSIGMA_TAG_ID)) {
16217 int no = ParseFloatArray(pchild, pSetting->mfnr_iso[index].lvl3_gfsigma, tag.Size(), 5);
16218 DCT_ASSERT((no == tag.Size()));
16219 }
16220 pchild = pchild->NextSibling();
16221 }
16222 XML_CHECK_END();
16223 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
16224 return (true);
16225 }
16226
parseEntrySensorSharp(const XMLElement * pelement,void * param)16227 bool RkAiqCalibParser::parseEntrySensorSharp
16228 (
16229 const XMLElement* pelement,
16230 void* param
16231 ) {
16232 (void)param;
16233
16234 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
16235 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Sharp_2_t, sharp);
16236 autoTabForward();
16237
16238 if (xmlParseReadWrite == XML_PARSER_READ) // write
16239 {
16240 memset(sharp, 0x00, sizeof(CalibDb_Sharp_2_t));
16241 }
16242 XML_CHECK_START(CALIB_SENSOR_SHARP_TAG_ID, CALIB_SENSOR_TAG_ID);
16243
16244 const XMLNode* pchild = pelement->FirstChild();
16245 while (pchild) {
16246 XmlTag tag = XmlTag(pchild->ToElement());
16247 std::string tagname(pchild->ToElement()->Name());
16248 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
16249
16250 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_ENABLE_TAG_ID)) {
16251 int no = ParseIntArray(pchild, &sharp->enable, tag.Size());
16252 DCT_ASSERT((no == tag.Size()));
16253 }
16254 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_VERSION_TAG_ID)) {
16255 ParseString(pchild, sharp->version, sizeof(sharp->version));
16256 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_LUMA_POINT_TAG_ID)) {
16257 int no = ParseFloatArray(pchild, sharp->luma_point, tag.Size());
16258 DCT_ASSERT((no == tag.Size()));
16259 }
16260 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_MODE_CELL_TAG_ID)) {
16261 if (xmlParseReadWrite == XML_PARSER_READ) {
16262 int cell_size = 0;
16263 parseCellNoElement(pchild->ToElement(), tag.Size(), cell_size);
16264 sharp->mode_num = cell_size;
16265 sharp->mode_cell = (CalibDb_Sharp_ModeCell_t *)malloc(cell_size * sizeof(CalibDb_Sharp_ModeCell_t));
16266 memset(sharp->mode_cell, 0x00, cell_size * sizeof(CalibDb_Sharp_ModeCell_t));
16267 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
16268 &RkAiqCalibParser::parseEntrySensorSharpModeCell,
16269 param,
16270 (uint32_t)CALIB_SENSOR_SHARP_MODE_CELL_TAG_ID,
16271 (uint32_t)CALIB_SENSOR_SHARP_TAG_ID)) {
16272 LOGE("parse error in SHARP mode cell (%s)", tagname.c_str());
16273 return (false);
16274 }
16275 }
16276 else
16277 {
16278
16279 if (!parseEntryCell3((XMLElement *)pchild->ToElement(), tag.Size(), sharp->mode_num,
16280 &RkAiqCalibParser::parseEntrySensorSharpModeCell,
16281 param,
16282 (uint32_t)CALIB_SENSOR_SHARP_MODE_CELL_TAG_ID,
16283 (uint32_t)CALIB_SENSOR_SHARP_TAG_ID)) {
16284 LOGE("parse error in SHARP mode cell (%s)", tagname.c_str());
16285 return (false);
16286 }
16287 }
16288 }
16289
16290 pchild = pchild->NextSibling();
16291 }
16292 XML_CHECK_END();
16293 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
16294 autoTabBackward();
16295 return (true);
16296 }
16297
parseEntrySensorSharpModeCell(const XMLElement * pelement,void * param)16298 bool RkAiqCalibParser::parseEntrySensorSharpModeCell
16299 (
16300 const XMLElement* pelement,
16301 void* param
16302 ) {
16303 (void)param;
16304
16305 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
16306
16307 int index = *((int*)param);
16308 XML_CHECK_START(CALIB_SENSOR_SHARP_MODE_CELL_TAG_ID, CALIB_SENSOR_SHARP_TAG_ID);
16309 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Sharp_2_t, sharp);
16310 const XMLNode* pchild = pelement->FirstChild();
16311 while (pchild) {
16312 XmlTag tag = XmlTag(pchild->ToElement());
16313 std::string tagname(pchild->ToElement()->Name());
16314 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
16315
16316 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_MODE_NAME_TAG_ID)) {
16317 ParseString(pchild, sharp->mode_cell[index].name, sizeof(sharp->mode_cell[index].name));
16318 }
16319 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_GAUSS_LUMA_COEFF_TAG_ID)) {
16320 int no = ParseFloatArray(pchild, sharp->mode_cell[index].gauss_luma_coeff, tag.Size());
16321 DCT_ASSERT((no == tag.Size()));
16322 }
16323 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_MBF_COEFF_TAG_ID)) {
16324 int no = ParseFloatArray(pchild, sharp->mode_cell[index].mbf_coeff, tag.Size());
16325 DCT_ASSERT((no == tag.Size()));
16326 }
16327 #if 1
16328 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_PBF_COEFF_TAG_ID)) {
16329 int no = ParseFloatArray(pchild, sharp->mode_cell[index].pbf_coeff_l, tag.Size());
16330 DCT_ASSERT((no == tag.Size()));
16331 memcpy(sharp->mode_cell[index].pbf_coeff_h, sharp->mode_cell[index].pbf_coeff_l, sizeof(sharp->mode_cell[index].pbf_coeff_l));
16332 }
16333 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_RF_M_COEFF_TAG_ID)) {
16334 int no = ParseFloatArray(pchild, sharp->mode_cell[index].rf_m_coeff_l, tag.Size());
16335 DCT_ASSERT((no == tag.Size()));
16336 memcpy(sharp->mode_cell[index].rf_m_coeff_h, sharp->mode_cell[index].rf_m_coeff_l, sizeof(sharp->mode_cell[index].rf_m_coeff_l));
16337 }
16338
16339 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_RF_H_COEFF_TAG_ID)) {
16340 int no = ParseFloatArray(pchild, sharp->mode_cell[index].rf_h_coeff_l, tag.Size());
16341 DCT_ASSERT((no == tag.Size()));
16342 memcpy(sharp->mode_cell[index].rf_h_coeff_h, sharp->mode_cell[index].rf_h_coeff_l, sizeof(sharp->mode_cell[index].rf_h_coeff_l));
16343 }
16344 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_HBF_COEFF_TAG_ID)) {
16345 int no = ParseFloatArray(pchild, sharp->mode_cell[index].hbf_coeff_l, tag.Size());
16346 DCT_ASSERT((no == tag.Size()));
16347 memcpy(sharp->mode_cell[index].hbf_coeff_h, sharp->mode_cell[index].hbf_coeff_l, sizeof(sharp->mode_cell[index].hbf_coeff_l));
16348 }
16349 #endif
16350 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_PBF_COEFF_L_TAG_ID)) {
16351 int no = ParseFloatArray(pchild, sharp->mode_cell[index].pbf_coeff_l, tag.Size());
16352 DCT_ASSERT((no == tag.Size()));
16353 }
16354 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_PBF_COEFF_H_TAG_ID)) {
16355 int no = ParseFloatArray(pchild, sharp->mode_cell[index].pbf_coeff_h, tag.Size());
16356 DCT_ASSERT((no == tag.Size()));
16357 }
16358 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_RF_M_COEFF_L_TAG_ID)) {
16359 int no = ParseFloatArray(pchild, sharp->mode_cell[index].rf_m_coeff_l, tag.Size());
16360 DCT_ASSERT((no == tag.Size()));
16361 }
16362 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_RF_M_COEFF_H_TAG_ID)) {
16363 int no = ParseFloatArray(pchild, sharp->mode_cell[index].rf_m_coeff_h, tag.Size());
16364 DCT_ASSERT((no == tag.Size()));
16365 }
16366 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_RF_H_COEFF_L_TAG_ID)) {
16367 int no = ParseFloatArray(pchild, sharp->mode_cell[index].rf_h_coeff_l, tag.Size());
16368 DCT_ASSERT((no == tag.Size()));
16369 }
16370 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_RF_H_COEFF_H_TAG_ID)) {
16371 int no = ParseFloatArray(pchild, sharp->mode_cell[index].rf_h_coeff_h, tag.Size());
16372 DCT_ASSERT((no == tag.Size()));
16373 }
16374 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_HBF_COEFF_L_TAG_ID)) {
16375 int no = ParseFloatArray(pchild, sharp->mode_cell[index].hbf_coeff_l, tag.Size());
16376 DCT_ASSERT((no == tag.Size()));
16377 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_HBF_COEFF_H_TAG_ID)) {
16378 int no = ParseFloatArray(pchild, sharp->mode_cell[index].hbf_coeff_h, tag.Size());
16379 DCT_ASSERT((no == tag.Size()));
16380 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SETTING_TAG_ID)) {
16381 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
16382 &RkAiqCalibParser::parseEntrySensorSharpSetting,
16383 (void *)&sharp->mode_cell[index],
16384 (uint32_t)CALIB_SENSOR_SHARP_SETTING_TAG_ID,
16385 (uint32_t)CALIB_SENSOR_SHARP_MODE_CELL_TAG_ID)) {
16386 LOGE("parse error in SHARP SHARP_Setting (%s)", tagname.c_str());
16387 return (false);
16388 }
16389 }
16390 pchild = pchild->NextSibling();
16391 }
16392 XML_CHECK_END();
16393 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
16394
16395 return (true);
16396 }
16397
16398
parseEntrySensorSharpSetting(const XMLElement * pelement,void * param,int index)16399 bool RkAiqCalibParser::parseEntrySensorSharpSetting
16400 (
16401 const XMLElement* pelement,
16402 void* param,
16403 int index
16404 ) {
16405 (void)param;
16406
16407 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
16408
16409 CalibDb_Sharp_ModeCell_t *pModeCell = (CalibDb_Sharp_ModeCell_t *)param;
16410
16411 XML_CHECK_START(CALIB_SENSOR_SHARP_SETTING_TAG_ID, CALIB_SENSOR_SHARP_MODE_CELL_TAG_ID);
16412 const XMLNode* pchild = pelement->FirstChild();
16413 while (pchild) {
16414 XmlTag tag = XmlTag(pchild->ToElement());
16415 std::string tagname(pchild->ToElement()->Name());
16416 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
16417
16418 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SETTING_SNR_MODE_TAG_ID)) {
16419 ParseString(pchild, pModeCell->setting[index].snr_mode, sizeof(pModeCell->setting[index].snr_mode));
16420 }
16421 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SETTING_SENSOR_MODE_TAG_ID)) {
16422 ParseString(pchild, pModeCell->setting[index].sensor_mode, sizeof(pModeCell->setting[index].sensor_mode));
16423 }
16424 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_TAG_ID)) {
16425 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
16426 &RkAiqCalibParser::parseEntrySensorSharpISO,
16427 (void *)&pModeCell->setting[index],
16428 (uint32_t)CALIB_SENSOR_SHARP_SHARP_ISO_TAG_ID,
16429 (uint32_t)CALIB_SENSOR_SHARP_SETTING_TAG_ID)) {
16430 LOGE("parse error in SHARP SHARP_ISO (%s)", tagname.c_str());
16431 return (false);
16432 }
16433 }
16434
16435 pchild = pchild->NextSibling();
16436 }
16437 XML_CHECK_END();
16438 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
16439
16440 return (true);
16441 }
16442
parseEntrySensorSharpISO(const XMLElement * pelement,void * param,int index)16443 bool RkAiqCalibParser::parseEntrySensorSharpISO
16444 (
16445 const XMLElement* pelement,
16446 void* param,
16447 int index
16448 ) {
16449
16450 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
16451
16452 XML_CHECK_START(CALIB_SENSOR_SHARP_SHARP_ISO_TAG_ID, CALIB_SENSOR_SHARP_SETTING_TAG_ID);
16453
16454 CalibDb_Sharp_Setting_t *pSetting = (CalibDb_Sharp_Setting_t *)param;
16455 const XMLNode* pchild = pelement->FirstChild();
16456 while (pchild) {
16457 XmlTag tag = XmlTag(pchild->ToElement());
16458 const char* value = tag.Value();
16459 std::string tagname(pchild->ToElement()->Name());
16460 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
16461
16462 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_ISO_TAG_ID)) {
16463 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].iso, tag.Size());
16464 DCT_ASSERT((no == tag.Size()));
16465 }
16466 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_HRATIO_TAG_ID)) {
16467 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].hratio, tag.Size());
16468 DCT_ASSERT((no == tag.Size()));
16469 }
16470 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_LRATIO_TAG_ID)) {
16471 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].lratio, tag.Size());
16472 DCT_ASSERT((no == tag.Size()));
16473 }
16474 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_MF_SHARP_RATIO_TAG_ID)) {
16475 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].mf_sharp_ratio, tag.Size());
16476 DCT_ASSERT((no == tag.Size()));
16477 }
16478 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_HF_SHARP_RATIO_TAG_ID)) {
16479 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].hf_sharp_ratio, tag.Size());
16480 DCT_ASSERT((no == tag.Size()));
16481 }
16482 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_LUMA_SIGMA_TAG_ID)) {
16483 int no = ParseFloatArray(pchild, pSetting->sharp_iso[index].luma_sigma, tag.Size());
16484 DCT_ASSERT((no == tag.Size()));
16485 }
16486 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_PBF_GAIN_TAG_ID)) {
16487 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].pbf_gain, tag.Size());
16488 DCT_ASSERT((no == tag.Size()));
16489 }
16490 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_PBF_RATIO_TAG_ID)) {
16491 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].pbf_ratio, tag.Size());
16492 DCT_ASSERT((no == tag.Size()));
16493 }
16494 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_PBF_ADD_TAG_ID)) {
16495 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].pbf_add, tag.Size());
16496 DCT_ASSERT((no == tag.Size()));
16497 }
16498 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_MF_CLIP_POS_TAG_ID)) {
16499 int no = ParseFloatArray(pchild, pSetting->sharp_iso[index].mf_clip_pos, tag.Size());
16500 DCT_ASSERT((no == tag.Size()));
16501 }
16502 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_MF_CLIP_NEG_TAG_ID)) {
16503 int no = ParseFloatArray(pchild, pSetting->sharp_iso[index].mf_clip_neg, tag.Size());
16504 DCT_ASSERT((no == tag.Size()));
16505 }
16506 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_HF_CLIP_TAG_ID)) {
16507 int no = ParseFloatArray(pchild, pSetting->sharp_iso[index].hf_clip, tag.Size());
16508 DCT_ASSERT((no == tag.Size()));
16509 }
16510 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_MBF_GAIN_TAG_ID)) {
16511 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].mbf_gain, tag.Size());
16512 DCT_ASSERT((no == tag.Size()));
16513 }
16514 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_HBF_GAIN_TAG_ID)) {
16515 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].hbf_gain, tag.Size());
16516 DCT_ASSERT((no == tag.Size()));
16517 }
16518 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_HBF_RATIO_TAG_ID)) {
16519 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].hbf_ratio, tag.Size());
16520 DCT_ASSERT((no == tag.Size()));
16521 }
16522 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_MBF_ADD_TAG_ID)) {
16523 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].mbf_add, tag.Size());
16524 DCT_ASSERT((no == tag.Size()));
16525 }
16526 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_HBF_ADD_TAG_ID)) {
16527 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].hbf_add, tag.Size());
16528 DCT_ASSERT((no == tag.Size()));
16529 }
16530 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_ISO_LOCAL_SHARP_STRENGTH_TAG_ID)) {
16531 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].local_sharp_strength, tag.Size());
16532 DCT_ASSERT((no == tag.Size()));
16533 }
16534 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_PBF_COEFF_PERCENT_TAG_ID)) {
16535 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].pbf_coeff_percent, tag.Size());
16536 DCT_ASSERT((no == tag.Size()));
16537 }
16538 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_RF_M_COEFF_PERCENT_TAG_ID)) {
16539 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].rf_m_coeff_percent, tag.Size());
16540 DCT_ASSERT((no == tag.Size()));
16541 }
16542 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_RF_H_COEFF_PERCENT_TAG_ID)) {
16543 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].rf_h_coeff_percent, tag.Size());
16544 DCT_ASSERT((no == tag.Size()));
16545 }
16546 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_SHARP_HBF_COEFF_PERCENT_TAG_ID)) {
16547 int no = ParseFloatArray(pchild, &pSetting->sharp_iso[index].hbf_coeff_percent, tag.Size());
16548 DCT_ASSERT((no == tag.Size()));
16549 }
16550 pchild = pchild->NextSibling();
16551 }
16552 XML_CHECK_END();
16553 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
16554 return (true);
16555 }
16556
parseEntrySensorEdgeFilter(const XMLElement * pelement,void * param)16557 bool RkAiqCalibParser::parseEntrySensorEdgeFilter
16558 (
16559 const XMLElement* pelement,
16560 void* param
16561 ) {
16562 (void)param;
16563
16564 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
16565 autoTabForward();
16566
16567 XML_CHECK_START(CALIB_SENSOR_EDGEFILTER_TAG_ID, CALIB_SENSOR_TAG_ID);
16568 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_EdgeFilter_2_t, edgeFilter);
16569
16570 const XMLNode* pchild = pelement->FirstChild();
16571 while (pchild) {
16572 XmlTag tag = XmlTag(pchild->ToElement());
16573 std::string tagname(pchild->ToElement()->Name());
16574 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
16575
16576 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_ENABLE_TAG_ID)) {
16577 int no = ParseIntArray(pchild, &edgeFilter->enable, tag.Size());
16578 DCT_ASSERT((no == tag.Size()));
16579 }
16580 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_VERSION_TAG_ID)) {
16581 ParseString(pchild, edgeFilter->version, sizeof(edgeFilter->version));
16582 }
16583 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_LUMA_POINT_TAG_ID)) {
16584 int no = ParseFloatArray(pchild, edgeFilter->luma_point, tag.Size());
16585 DCT_ASSERT((no == tag.Size()));
16586 }
16587 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_MODE_CELL_TAG_ID)) {
16588 if (xmlParseReadWrite == XML_PARSER_READ) {
16589 int cell_size = 0;
16590 parseCellNoElement(pchild->ToElement(), tag.Size(), cell_size);
16591 edgeFilter->mode_num = cell_size;
16592 edgeFilter->mode_cell = (CalibDb_EdgeFilter_ModeCell_t *)malloc(cell_size * sizeof(CalibDb_EdgeFilter_ModeCell_t));
16593 memset(edgeFilter->mode_cell, 0x00, cell_size * sizeof(CalibDb_EdgeFilter_ModeCell_t));
16594 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
16595 &RkAiqCalibParser::parseEntrySensorEdgeFilterModeCell,
16596 param,
16597 (uint32_t)CALIB_SENSOR_EDGEFILTER_MODE_CELL_TAG_ID,
16598 (uint32_t)CALIB_SENSOR_EDGEFILTER_TAG_ID)) {
16599 LOGE("parse error in EDGEFILTER mode cell (%s)", tagname.c_str());
16600 return (false);
16601 }
16602 }
16603 else
16604 {
16605
16606 if (!parseEntryCell3((XMLElement *)pchild->ToElement(), tag.Size(), edgeFilter->mode_num,
16607 &RkAiqCalibParser::parseEntrySensorEdgeFilterModeCell,
16608 param,
16609 (uint32_t)CALIB_SENSOR_EDGEFILTER_MODE_CELL_TAG_ID,
16610 (uint32_t)CALIB_SENSOR_EDGEFILTER_TAG_ID)) {
16611 LOGE("parse error in EDGEFILTER mode cell (%s)", tagname.c_str());
16612 return (false);
16613 }
16614 }
16615 }
16616 pchild = pchild->NextSibling();
16617 }
16618 XML_CHECK_END();
16619 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
16620 autoTabBackward();
16621 return (true);
16622 }
16623
parseEntrySensorEdgeFilterModeCell(const XMLElement * pelement,void * param)16624 bool RkAiqCalibParser::parseEntrySensorEdgeFilterModeCell
16625 (
16626 const XMLElement* pelement,
16627 void* param
16628 ) {
16629 (void)param;
16630
16631 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
16632
16633 int index = *((int*)param);
16634
16635 XML_CHECK_START(CALIB_SENSOR_EDGEFILTER_MODE_CELL_TAG_ID, CALIB_SENSOR_EDGEFILTER_TAG_ID);
16636 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_EdgeFilter_2_t, edgeFilter);
16637
16638 const XMLNode* pchild = pelement->FirstChild();
16639 while (pchild) {
16640 XmlTag tag = XmlTag(pchild->ToElement());
16641 std::string tagname(pchild->ToElement()->Name());
16642 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
16643
16644 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_MODE_NAME_TAG_ID)) {
16645 ParseString(pchild, edgeFilter->mode_cell[index].name, sizeof(edgeFilter->mode_cell[index].name));
16646 }
16647 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_DOG_KERNEL_L_TAG_ID)) {
16648 int no = ParseFloatArray(pchild, edgeFilter->mode_cell[index].dog_kernel_l, tag.Size());
16649 DCT_ASSERT((no == tag.Size()));
16650 }
16651 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_DOG_KERNEL_H_TAG_ID)) {
16652 int no = ParseFloatArray(pchild, edgeFilter->mode_cell[index].dog_kernel_h, tag.Size());
16653 DCT_ASSERT((no == tag.Size()));
16654 }
16655 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_SETTING_TAG_ID)) {
16656 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
16657 &RkAiqCalibParser::parseEntrySensorEdgeFilterSetting,
16658 (void *)&edgeFilter->mode_cell[index],
16659 (uint32_t)CALIB_SENSOR_EDGEFILTER_SETTING_TAG_ID,
16660 (uint32_t)CALIB_SENSOR_EDGEFILTER_MODE_CELL_TAG_ID)) {
16661 LOGE("parse error in EDGEFILTER setting (%s)", tagname.c_str());
16662 return (false);
16663 }
16664 }
16665
16666 pchild = pchild->NextSibling();
16667 }
16668 XML_CHECK_END();
16669 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
16670 return (true);
16671 }
16672
parseEntrySensorEdgeFilterSetting(const XMLElement * pelement,void * param,int index)16673 bool RkAiqCalibParser::parseEntrySensorEdgeFilterSetting
16674 (
16675 const XMLElement* pelement,
16676 void* param,
16677 int index
16678 ) {
16679 (void)param;
16680
16681 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
16682
16683 CalibDb_EdgeFilter_ModeCell_t *pModeCell = (CalibDb_EdgeFilter_ModeCell_t *)param;
16684
16685 XML_CHECK_START(CALIB_SENSOR_EDGEFILTER_SETTING_TAG_ID, CALIB_SENSOR_EDGEFILTER_MODE_CELL_TAG_ID);
16686
16687 const XMLNode* pchild = pelement->FirstChild();
16688 while (pchild) {
16689 XmlTag tag = XmlTag(pchild->ToElement());
16690 std::string tagname(pchild->ToElement()->Name());
16691 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
16692
16693 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_SETTING_SNR_MODE_TAG_ID)) {
16694 ParseString(pchild, pModeCell->setting[index].snr_mode, sizeof(pModeCell->setting[index].snr_mode));
16695 }
16696 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_SETTING_SENSOR_MODE_TAG_ID)) {
16697 ParseString(pchild, pModeCell->setting[index].sensor_mode, sizeof(pModeCell->setting[index].sensor_mode));
16698 }
16699 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_TAG_ID)) {
16700 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
16701 &RkAiqCalibParser::parseEntrySensorEdgeFilterISO,
16702 (void *)&pModeCell->setting[index],
16703 (uint32_t)CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_TAG_ID,
16704 (uint32_t)CALIB_SENSOR_EDGEFILTER_SETTING_TAG_ID)) {
16705 LOGE("parse error in EDGEFILTER EDGEFILTER_ISO (%s)", tagname.c_str());
16706 return (false);
16707 }
16708 }
16709
16710 pchild = pchild->NextSibling();
16711 }
16712 XML_CHECK_END();
16713 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
16714 return (true);
16715 }
16716
parseEntrySensorEdgeFilterISO(const XMLElement * pelement,void * param,int index)16717 bool RkAiqCalibParser::parseEntrySensorEdgeFilterISO
16718 (
16719 const XMLElement* pelement,
16720 void* param,
16721 int index
16722 ) {
16723 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
16724
16725 XML_CHECK_START(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_TAG_ID,
16726 CALIB_SENSOR_EDGEFILTER_SETTING_TAG_ID);
16727
16728 CalibDb_EdgeFilter_Setting_t *pSetting = (CalibDb_EdgeFilter_Setting_t *)param;
16729 const XMLNode* pchild = pelement->FirstChild();
16730 while (pchild) {
16731 XmlTag tag = XmlTag(pchild->ToElement());
16732 const char* value = tag.Value();
16733 std::string tagname(pchild->ToElement()->Name());
16734 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
16735
16736 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_ISO_TAG_ID)) {
16737 int no = ParseFloatArray(pchild, &pSetting->edgeFilter_iso[index].iso, tag.Size());
16738 DCT_ASSERT((no == tag.Size()));
16739 }
16740 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_EDGE_THED_TAG_ID)) {
16741 int no = ParseFloatArray(pchild, &pSetting->edgeFilter_iso[index].edge_thed, tag.Size());
16742 DCT_ASSERT((no == tag.Size()));
16743 }
16744 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_SRC_WGT_TAG_ID)) {
16745 int no = ParseFloatArray(pchild, &pSetting->edgeFilter_iso[index].src_wgt, tag.Size());
16746 DCT_ASSERT((no == tag.Size()));
16747 }
16748 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_ALPHA_ADP_EN_TAG_ID)) {
16749 int no = ParseUcharArray(pchild, &pSetting->edgeFilter_iso[index].alpha_adp_en, tag.Size());
16750 DCT_ASSERT((no == tag.Size()));
16751 }
16752 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_LOCAL_ALPHA_TAG_ID)) {
16753 int no = ParseFloatArray(pchild, &pSetting->edgeFilter_iso[index].local_alpha, tag.Size());
16754 DCT_ASSERT((no == tag.Size()));
16755 }
16756 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_GLOBAL_ALPHA_TAG_ID)) {
16757 int no = ParseFloatArray(pchild, &pSetting->edgeFilter_iso[index].global_alpha, tag.Size());
16758 DCT_ASSERT((no == tag.Size()));
16759 }
16760 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_NOISE_CLIP_TAG_ID)) {
16761 int no = ParseFloatArray(pchild, pSetting->edgeFilter_iso[index].noise_clip, tag.Size());
16762 DCT_ASSERT((no == tag.Size()));
16763 }
16764 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_DOG_CLIP_POS_TAG_ID)) {
16765 int no = ParseFloatArray(pchild, pSetting->edgeFilter_iso[index].dog_clip_pos, tag.Size());
16766 DCT_ASSERT((no == tag.Size()));
16767 }
16768 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_DOG_CLIP_NEG_TAG_ID)) {
16769 int no = ParseFloatArray(pchild, pSetting->edgeFilter_iso[index].dog_clip_neg, tag.Size());
16770 DCT_ASSERT((no == tag.Size()));
16771 }
16772 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_DOG_ALPHA_TAG_ID)) {
16773 int no = ParseFloatArray(pchild, pSetting->edgeFilter_iso[index].dog_alpha, tag.Size());
16774 DCT_ASSERT((no == tag.Size()));
16775 }
16776 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_DIRECT_FILTER_COEFF_TAG_ID)) {
16777 int no = ParseFloatArray(pchild, pSetting->edgeFilter_iso[index].direct_filter_coeff, tag.Size());
16778 DCT_ASSERT((no == tag.Size()));
16779 }
16780 #if 1
16781 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_DOG_KERNEL_ROW0_TAG_ID)) {
16782 int no = ParseFloatArray(pchild, pSetting->edgeFilter_iso[index].dog_kernel_row0, tag.Size(), 6);
16783 DCT_ASSERT((no == tag.Size()));
16784 }
16785 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_DOG_KERNEL_ROW1_TAG_ID)) {
16786 int no = ParseFloatArray(pchild, pSetting->edgeFilter_iso[index].dog_kernel_row1, tag.Size(), 6);
16787 DCT_ASSERT((no == tag.Size()));
16788 }
16789 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_DOG_KERNEL_ROW2_TAG_ID)) {
16790 int no = ParseFloatArray(pchild, pSetting->edgeFilter_iso[index].dog_kernel_row2, tag.Size(), 6);
16791 DCT_ASSERT((no == tag.Size()));
16792 }
16793 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_DOG_KERNEL_ROW3_TAG_ID)) {
16794 int no = ParseFloatArray(pchild, pSetting->edgeFilter_iso[index].dog_kernel_row3, tag.Size(), 6);
16795 DCT_ASSERT((no == tag.Size()));
16796 }
16797 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_DOG_KERNEL_ROW4_TAG_ID)) {
16798 int no = ParseFloatArray(pchild, pSetting->edgeFilter_iso[index].dog_kernel_row4, tag.Size(), 6);
16799 DCT_ASSERT((no == tag.Size()));
16800 }
16801 #endif
16802 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EDGEFILTER_EDGEFILTER_ISO_DOG_KERNEL_PERCENT_TAG_ID)) {
16803 int no = ParseFloatArray(pchild, &pSetting->edgeFilter_iso[index].dog_kernel_percent, tag.Size());
16804 DCT_ASSERT((no == tag.Size()));
16805 }
16806 pchild = pchild->NextSibling();
16807 }
16808 XML_CHECK_END();
16809 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
16810 return (true);
16811 }
16812
parseEntrySensorDehaze(const XMLElement * pelement,void * param)16813 bool RkAiqCalibParser::parseEntrySensorDehaze
16814 (
16815 const XMLElement* pelement,
16816 void* param
16817 ) {
16818 (void)param;
16819
16820 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
16821 autoTabForward();
16822
16823 XML_CHECK_START(CALIB_SENSOR_DEHAZE_TAG_ID, CALIB_SENSOR_TAG_ID);
16824
16825 const XMLNode* pchild = pelement->FirstChild();
16826 while (pchild) {
16827 XmlTag tag = XmlTag(pchild->ToElement());
16828 std::string tagname(pchild->ToElement()->Name());
16829 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
16830
16831 if (CHECK_ISP_HW_V20()) {
16832 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_CALIBPARA_V20_TAG_ID)) {
16833 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
16834 &RkAiqCalibParser::parseEntrySensorDehazeCalibParaV20,
16835 param,
16836 (uint32_t)CALIB_SENSOR_DEHAZE_CALIBPARA_V20_TAG_ID,
16837 (uint32_t)CALIB_SENSOR_DEHAZE_TAG_ID)) {
16838 LOGE("parse error in Dehaze CalibPara v20 Setting (%s)", tagname.c_str());
16839 return (false);
16840 }
16841 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_TUNINGPARA_V20_TAG_ID)) {
16842 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
16843 &RkAiqCalibParser::parseEntrySensorDehazeTuningParaV20,
16844 param,
16845 (uint32_t)CALIB_SENSOR_DEHAZE_TUNINGPARA_V20_TAG_ID,
16846 (uint32_t)CALIB_SENSOR_DEHAZE_TAG_ID)) {
16847 LOGE("parse error in Dehaze TuningPara v20 Setting (%s)", tagname.c_str());
16848 return (false);
16849 }
16850 }
16851 }
16852
16853 if (CHECK_ISP_HW_V21()) {
16854 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_CALIBPARA_V21_TAG_ID)) {
16855 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
16856 &RkAiqCalibParser::parseEntrySensorDehazeCalibParaV21,
16857 param,
16858 (uint32_t)CALIB_SENSOR_DEHAZE_CALIBPARA_V21_TAG_ID,
16859 (uint32_t)CALIB_SENSOR_DEHAZE_TAG_ID)) {
16860 LOGE("parse error in Dehaze CalibPara v21 Setting (%s)", tagname.c_str());
16861 return (false);
16862 }
16863 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_TUNINGPARA_V21_TAG_ID)) {
16864 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
16865 &RkAiqCalibParser::parseEntrySensorDehazeTuningParaV21,
16866 param,
16867 (uint32_t)CALIB_SENSOR_DEHAZE_TUNINGPARA_V21_TAG_ID,
16868 (uint32_t)CALIB_SENSOR_DEHAZE_TAG_ID)) {
16869 LOGE("parse error in Dehaze TuningPara v21 Setting (%s)", tagname.c_str());
16870 return (false);
16871 }
16872 }
16873 }
16874
16875 pchild = pchild->NextSibling();
16876 }
16877
16878 XML_CHECK_END();
16879
16880 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
16881 autoTabBackward();
16882 return (true);
16883 }
16884
parseEntrySensorDehazeCalibParaV20(const XMLElement * pelement,void * param)16885 bool RkAiqCalibParser::parseEntrySensorDehazeCalibParaV20
16886 (
16887 const XMLElement* pelement,
16888 void* param
16889 ) {
16890 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
16891
16892 XML_CHECK_START(CALIB_SENSOR_DEHAZE_CALIBPARA_V20_TAG_ID, CALIB_SENSOR_DEHAZE_TAG_ID);
16893 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dehaze_t, dehaze);
16894 int index = *((int*)param);
16895 const XMLNode* pchild = pelement->FirstChild();
16896 while (pchild) {
16897 XmlTag tag = XmlTag(pchild->ToElement());
16898 const char* value = tag.Value();
16899 std::string tagname(pchild->ToElement()->Name());
16900 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
16901
16902 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SCENE_TAG_ID)) {
16903 ParseString(pchild, dehaze->calib_v20[index].scene, sizeof(dehaze->calib_v20[index].scene));
16904 }
16905 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_EN_TAG_ID)) {
16906 int no = ParseFloatArray(pchild, &dehaze->calib_v20[index].en, tag.Size());
16907 DCT_ASSERT((no == tag.Size()));
16908 }
16909 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_CFG_ALPHA_TAG_ID)) {
16910 int no = ParseFloatArray(pchild, &dehaze->calib_v20[index].cfg_alpha, tag.Size());
16911 DCT_ASSERT((no == tag.Size()));
16912 }
16913 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TAG_ID)) {
16914 if (!parseEntrySensorDehazeSettingV20(pchild->ToElement(), &dehaze->calib_v20[index], index)) {
16915 LOGE("parse error in Dehaze setting (%s)", tagname.c_str());
16916 return (false);
16917 }
16918 }
16919 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_TAG_ID)) {
16920 if (!parseEntrySensorEnhanceSettingV20(pchild->ToElement(), &dehaze->calib_v20[index], index)) {
16921 LOGE("parse error in Enhance setting (%s)", tagname.c_str());
16922 return (false);
16923 }
16924 }
16925 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_TAG_ID)) {
16926 if (!parseEntrySensorHistSettingV20(pchild->ToElement(), &dehaze->calib_v20[index], index)) {
16927 LOGE("parse error in Hist setting (%s)", tagname.c_str());
16928 return (false);
16929 }
16930 }
16931
16932 pchild = pchild->NextSibling();
16933 }
16934 XML_CHECK_END();
16935 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
16936 return (true);
16937 }
16938
parseEntrySensorDehazeTuningParaV20(const XMLElement * pelement,void * param)16939 bool RkAiqCalibParser::parseEntrySensorDehazeTuningParaV20
16940 (
16941 const XMLElement* pelement,
16942 void* param
16943 ) {
16944 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
16945
16946 XML_CHECK_START(CALIB_SENSOR_DEHAZE_TUNINGPARA_V20_TAG_ID, CALIB_SENSOR_DEHAZE_TAG_ID);
16947 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dehaze_t, dehaze);
16948 int index = *((int*)param);
16949 const XMLNode* pchild = pelement->FirstChild();
16950 while (pchild) {
16951 XmlTag tag = XmlTag(pchild->ToElement());
16952 const char* value = tag.Value();
16953 std::string tagname(pchild->ToElement()->Name());
16954 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
16955
16956 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SCENE_TAG_ID)) {
16957 ParseString(pchild, dehaze->tuning_v20[index].scene, sizeof(dehaze->tuning_v20[index].scene));
16958 }
16959 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_EN_TAG_ID)) {
16960 int no = ParseFloatArray(pchild, &dehaze->tuning_v20[index].en, tag.Size());
16961 DCT_ASSERT((no == tag.Size()));
16962 }
16963 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_CFG_ALPHA_TAG_ID)) {
16964 int no = ParseFloatArray(pchild, &dehaze->tuning_v20[index].cfg_alpha, tag.Size());
16965 DCT_ASSERT((no == tag.Size()));
16966 }
16967 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TAG_ID)) {
16968 if (!parseEntrySensorDehazeTuningSettingV20(pchild->ToElement(), &dehaze->tuning_v20[index], index)) {
16969 LOGE("parse error in Dehaze setting (%s)", tagname.c_str());
16970 return (false);
16971 }
16972 }
16973 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_TAG_ID)) {
16974 if (!parseEntrySensorEnhanceTuningSettingV20(pchild->ToElement(), &dehaze->tuning_v20[index], index)) {
16975 LOGE("parse error in Enhance setting (%s)", tagname.c_str());
16976 return (false);
16977 }
16978 }
16979 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_TAG_ID)) {
16980 if (!parseEntrySensorHistTuningSettingV20(pchild->ToElement(), &dehaze->tuning_v20[index], index)) {
16981 LOGE("parse error in Hist setting (%s)", tagname.c_str());
16982 return (false);
16983 }
16984 }
16985
16986 pchild = pchild->NextSibling();
16987 }
16988 XML_CHECK_END();
16989 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
16990 return (true);
16991 }
16992
parseEntrySensorDehazeCalibParaV21(const XMLElement * pelement,void * param)16993 bool RkAiqCalibParser::parseEntrySensorDehazeCalibParaV21
16994 (
16995 const XMLElement* pelement,
16996 void* param
16997 ) {
16998 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
16999
17000 XML_CHECK_START(CALIB_SENSOR_DEHAZE_CALIBPARA_V21_TAG_ID, CALIB_SENSOR_DEHAZE_TAG_ID);
17001 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dehaze_Isp21_t, dehaze);
17002 int index = *((int*)param);
17003 const XMLNode* pchild = pelement->FirstChild();
17004 while (pchild) {
17005 XmlTag tag = XmlTag(pchild->ToElement());
17006 const char* value = tag.Value();
17007 std::string tagname(pchild->ToElement()->Name());
17008 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
17009
17010 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SCENE_TAG_ID)) {
17011 ParseString(pchild, dehaze->calib_v21[index].scene, sizeof(dehaze->calib_v21[index].scene));
17012 }
17013 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_EN_TAG_ID)) {
17014 int no = ParseFloatArray(pchild, &dehaze->calib_v21[index].en, tag.Size());
17015 DCT_ASSERT((no == tag.Size()));
17016 }
17017 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_CFG_ALPHA_TAG_ID)) {
17018 int no = ParseFloatArray(pchild, &dehaze->calib_v21[index].cfg_alpha, tag.Size());
17019 DCT_ASSERT((no == tag.Size()));
17020 }
17021 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_V21_SETTING_TAG_ID)) {
17022 if (!parseEntrySensorDehazeSettingV21(pchild->ToElement(), &dehaze->calib_v21[index], index)) {
17023 LOGE("parse error in Dehaze V21 setting (%s)", tagname.c_str());
17024 return (false);
17025 }
17026 }
17027 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_V21_SETTING_TAG_ID)) {
17028 if (!parseEntrySensorEnhanceSettingV21(pchild->ToElement(), &dehaze->calib_v21[index], index)) {
17029 LOGE("parse error in Enhance V21 setting (%s)", tagname.c_str());
17030 return (false);
17031 }
17032 }
17033 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_V21_SETTING_TAG_ID)) {
17034 if (!parseEntrySensorHistSettingV21(pchild->ToElement(), &dehaze->calib_v21[index], index)) {
17035 LOGE("parse error in Hist V21 setting (%s)", tagname.c_str());
17036 return (false);
17037 }
17038 }
17039
17040 pchild = pchild->NextSibling();
17041 }
17042 XML_CHECK_END();
17043 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
17044 return (true);
17045 }
17046
parseEntrySensorDehazeTuningParaV21(const XMLElement * pelement,void * param)17047 bool RkAiqCalibParser::parseEntrySensorDehazeTuningParaV21
17048 (
17049 const XMLElement* pelement,
17050 void* param
17051 ) {
17052 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
17053
17054 XML_CHECK_START(CALIB_SENSOR_DEHAZE_TUNINGPARA_V21_TAG_ID, CALIB_SENSOR_DEHAZE_TAG_ID);
17055 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Dehaze_Isp21_t, dehaze);
17056 int index = *((int*)param);
17057 const XMLNode* pchild = pelement->FirstChild();
17058 while (pchild) {
17059 XmlTag tag = XmlTag(pchild->ToElement());
17060 const char* value = tag.Value();
17061 std::string tagname(pchild->ToElement()->Name());
17062 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
17063
17064 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SCENE_TAG_ID)) {
17065 ParseString(pchild, dehaze->tuning_v21[index].scene, sizeof(dehaze->tuning_v21[index].scene));
17066 }
17067 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_EN_TAG_ID)) {
17068 int no = ParseFloatArray(pchild, &dehaze->tuning_v21[index].en, tag.Size());
17069 DCT_ASSERT((no == tag.Size()));
17070 }
17071 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_CFG_ALPHA_TAG_ID)) {
17072 int no = ParseFloatArray(pchild, &dehaze->tuning_v21[index].cfg_alpha, tag.Size());
17073 DCT_ASSERT((no == tag.Size()));
17074 }
17075 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_V21_SETTING_TAG_ID)) {
17076 if (!parseEntrySensorDehazeTuningSettingV21(pchild->ToElement(), &dehaze->tuning_v21[index], index)) {
17077 LOGE("parse error in Dehaze V21 setting (%s)", tagname.c_str());
17078 return (false);
17079 }
17080 }
17081 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_V21_SETTING_TAG_ID)) {
17082 if (!parseEntrySensorEnhanceTuningSettingV21(pchild->ToElement(), &dehaze->tuning_v21[index], index)) {
17083 LOGE("parse error in Enhance V21 setting (%s)", tagname.c_str());
17084 return (false);
17085 }
17086 }
17087 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_V21_SETTING_TAG_ID)) {
17088 if (!parseEntrySensorHistTuningSettingV21(pchild->ToElement(), &dehaze->tuning_v21[index], index)) {
17089 LOGE("parse error in Hist V21 setting (%s)", tagname.c_str());
17090 return (false);
17091 }
17092 }
17093
17094 pchild = pchild->NextSibling();
17095 }
17096 XML_CHECK_END();
17097 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
17098 return (true);
17099 }
17100
parseEntrySensorDehazeSettingV20(const XMLElement * pelement,void * param,int index)17101 bool RkAiqCalibParser::parseEntrySensorDehazeSettingV20
17102 (
17103 const XMLElement* pelement,
17104 void* param,
17105 int index
17106 ) {
17107 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
17108
17109 CalibDb_Dehaze_ModeCell_v20_t *pModeCell = (CalibDb_Dehaze_ModeCell_v20_t *)param;
17110
17111 XML_CHECK_START(CALIB_SENSOR_DEHAZE_SETTING_TAG_ID, CALIB_SENSOR_DEHAZE_CALIBPARA_V20_TAG_ID);
17112 const XMLNode* pchild = pelement->FirstChild();
17113 while (pchild) {
17114 XmlTag tag = XmlTag(pchild->ToElement());
17115 const char* value = tag.Value();
17116 std::string tagname(pchild->ToElement()->Name());
17117 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
17118
17119 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_EN_TAG_ID)) {
17120 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.en, tag.Size());
17121 DCT_ASSERT((no == tag.Size()));
17122 }
17123 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_ISO_TAG_ID)) {
17124 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.iso, tag.Size());
17125 DCT_ASSERT((no == tag.Size()));
17126 }
17127 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_MIN_TH_TAG_ID)) {
17128 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_min_th, tag.Size());
17129 DCT_ASSERT((no == tag.Size()));
17130 }
17131 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_MAX_TH_TAG_ID)) {
17132 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_max_th, tag.Size());
17133 DCT_ASSERT((no == tag.Size()));
17134 }
17135 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_YHIST_TH_TAG_ID)) {
17136 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.yhist_th, tag.Size());
17137 DCT_ASSERT((no == tag.Size()));
17138 }
17139 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_YBLK_TH_TAG_ID)) {
17140 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.yblk_th, tag.Size());
17141 DCT_ASSERT((no == tag.Size()));
17142 }
17143 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DARK_TH_TAG_ID)) {
17144 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dark_th, tag.Size());
17145 DCT_ASSERT((no == tag.Size()));
17146 }
17147 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_BRIGHT_MIN_TAG_ID)) {
17148 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.bright_min, tag.Size());
17149 DCT_ASSERT((no == tag.Size()));
17150 }
17151 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_BRIGHT_MAX_TAG_ID)) {
17152 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.bright_max, tag.Size());
17153 DCT_ASSERT((no == tag.Size()));
17154 }
17155 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_WT_MAX_TAG_ID)) {
17156 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.wt_max, tag.Size());
17157 DCT_ASSERT((no == tag.Size()));
17158 }
17159 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_MIN_TAG_ID)) {
17160 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_min, tag.Size());
17161 DCT_ASSERT((no == tag.Size()));
17162 }
17163 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_MAX_TAG_ID)) {
17164 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_max, tag.Size());
17165 DCT_ASSERT((no == tag.Size()));
17166 }
17167 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TMAX_BASE_TAG_ID)) {
17168 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.tmax_base, tag.Size());
17169 DCT_ASSERT((no == tag.Size()));
17170 }
17171 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TMAX_OFF_TAG_ID)) {
17172 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.tmax_off, tag.Size());
17173 DCT_ASSERT((no == tag.Size()));
17174 }
17175 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TMAX_MAX_TAG_ID)) {
17176 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.tmax_max, tag.Size());
17177 DCT_ASSERT((no == tag.Size()));
17178 }
17179 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_CFG_WT_TAG_ID)) {
17180 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.cfg_wt, tag.Size());
17181 DCT_ASSERT((no == tag.Size()));
17182 }
17183 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_CFG_AIR_TAG_ID)) {
17184 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.cfg_air, tag.Size());
17185 DCT_ASSERT((no == tag.Size()));
17186 }
17187 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_CFG_TMAX_TAG_ID)) {
17188 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.cfg_tmax, tag.Size());
17189 DCT_ASSERT((no == tag.Size()));
17190 }
17191 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_THED_TAG_ID)) {
17192 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_thed, tag.Size());
17193 DCT_ASSERT((no == tag.Size()));
17194 }
17195 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_WEITCUR_TAG_ID)) {
17196 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_weitcur, tag.Size());
17197 DCT_ASSERT((no == tag.Size()));
17198 }
17199 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_THED_TAG_ID)) {
17200 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_thed, tag.Size());
17201 DCT_ASSERT((no == tag.Size()));
17202 }
17203 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_WEITCUR_TAG_ID)) {
17204 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_weitcur, tag.Size());
17205 DCT_ASSERT((no == tag.Size()));
17206 }
17207 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_STAB_FNUM_TAG_ID)) {
17208 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.stab_fnum, tag.Size());
17209 DCT_ASSERT((no == tag.Size()));
17210 }
17211 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_SIGMA_TAG_ID)) {
17212 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.sigma, tag.Size());
17213 DCT_ASSERT((no == tag.Size()));
17214 }
17215 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_WT_SIGMA_TAG_ID)) {
17216 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.wt_sigma, tag.Size());
17217 DCT_ASSERT((no == tag.Size()));
17218 }
17219 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_AIR_SIGMA_TAG_ID)) {
17220 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.air_sigma, tag.Size());
17221 DCT_ASSERT((no == tag.Size()));
17222 }
17223 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_TMAX_SIGMA_TAG_ID)) {
17224 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.tmax_sigma, tag.Size());
17225 DCT_ASSERT((no == tag.Size()));
17226 }
17227
17228 pchild = pchild->NextSibling();
17229 }
17230 XML_CHECK_END();
17231 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
17232 return (true);
17233 }
17234
parseEntrySensorDehazeTuningSettingV20(const XMLElement * pelement,void * param,int index)17235 bool RkAiqCalibParser::parseEntrySensorDehazeTuningSettingV20
17236 (
17237 const XMLElement* pelement,
17238 void* param,
17239 int index
17240 ) {
17241 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
17242
17243 CalibDb_Dehaze_ModeCell_v20_t *pModeCell = (CalibDb_Dehaze_ModeCell_v20_t *)param;
17244
17245 XML_CHECK_START(CALIB_SENSOR_DEHAZE_SETTING_TAG_ID, CALIB_SENSOR_DEHAZE_TUNINGPARA_V20_TAG_ID);
17246 const XMLNode* pchild = pelement->FirstChild();
17247 while (pchild) {
17248 XmlTag tag = XmlTag(pchild->ToElement());
17249 const char* value = tag.Value();
17250 std::string tagname(pchild->ToElement()->Name());
17251 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
17252
17253 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_EN_TAG_ID)) {
17254 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.en, tag.Size());
17255 DCT_ASSERT((no == tag.Size()));
17256 }
17257 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_ISO_TAG_ID)) {
17258 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.iso, tag.Size());
17259 DCT_ASSERT((no == tag.Size()));
17260 }
17261 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_MIN_TH_TAG_ID)) {
17262 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_min_th, tag.Size());
17263 DCT_ASSERT((no == tag.Size()));
17264 }
17265 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_MAX_TH_TAG_ID)) {
17266 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_max_th, tag.Size());
17267 DCT_ASSERT((no == tag.Size()));
17268 }
17269 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_YHIST_TH_TAG_ID)) {
17270 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.yhist_th, tag.Size());
17271 DCT_ASSERT((no == tag.Size()));
17272 }
17273 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_YBLK_TH_TAG_ID)) {
17274 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.yblk_th, tag.Size());
17275 DCT_ASSERT((no == tag.Size()));
17276 }
17277 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DARK_TH_TAG_ID)) {
17278 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dark_th, tag.Size());
17279 DCT_ASSERT((no == tag.Size()));
17280 }
17281 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_BRIGHT_MIN_TAG_ID)) {
17282 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.bright_min, tag.Size());
17283 DCT_ASSERT((no == tag.Size()));
17284 }
17285 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_BRIGHT_MAX_TAG_ID)) {
17286 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.bright_max, tag.Size());
17287 DCT_ASSERT((no == tag.Size()));
17288 }
17289 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_WT_MAX_TAG_ID)) {
17290 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.wt_max, tag.Size());
17291 DCT_ASSERT((no == tag.Size()));
17292 }
17293 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_MIN_TAG_ID)) {
17294 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_min, tag.Size());
17295 DCT_ASSERT((no == tag.Size()));
17296 }
17297 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_MAX_TAG_ID)) {
17298 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_max, tag.Size());
17299 DCT_ASSERT((no == tag.Size()));
17300 }
17301 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TMAX_BASE_TAG_ID)) {
17302 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.tmax_base, tag.Size());
17303 DCT_ASSERT((no == tag.Size()));
17304 }
17305 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TMAX_OFF_TAG_ID)) {
17306 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.tmax_off, tag.Size());
17307 DCT_ASSERT((no == tag.Size()));
17308 }
17309 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TMAX_MAX_TAG_ID)) {
17310 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.tmax_max, tag.Size());
17311 DCT_ASSERT((no == tag.Size()));
17312 }
17313 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_CFG_WT_TAG_ID)) {
17314 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.cfg_wt, tag.Size());
17315 DCT_ASSERT((no == tag.Size()));
17316 }
17317 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_CFG_AIR_TAG_ID)) {
17318 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.cfg_air, tag.Size());
17319 DCT_ASSERT((no == tag.Size()));
17320 }
17321 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_CFG_TMAX_TAG_ID)) {
17322 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.cfg_tmax, tag.Size());
17323 DCT_ASSERT((no == tag.Size()));
17324 }
17325 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_THED_TAG_ID)) {
17326 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_thed, tag.Size());
17327 DCT_ASSERT((no == tag.Size()));
17328 }
17329 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_WEITCUR_TAG_ID)) {
17330 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_weitcur, tag.Size());
17331 DCT_ASSERT((no == tag.Size()));
17332 }
17333 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_THED_TAG_ID)) {
17334 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_thed, tag.Size());
17335 DCT_ASSERT((no == tag.Size()));
17336 }
17337 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_WEITCUR_TAG_ID)) {
17338 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_weitcur, tag.Size());
17339 DCT_ASSERT((no == tag.Size()));
17340 }
17341 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_STAB_FNUM_TAG_ID)) {
17342 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.stab_fnum, tag.Size());
17343 DCT_ASSERT((no == tag.Size()));
17344 }
17345 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_SIGMA_TAG_ID)) {
17346 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.sigma, tag.Size());
17347 DCT_ASSERT((no == tag.Size()));
17348 }
17349 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_WT_SIGMA_TAG_ID)) {
17350 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.wt_sigma, tag.Size());
17351 DCT_ASSERT((no == tag.Size()));
17352 }
17353 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_AIR_SIGMA_TAG_ID)) {
17354 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.air_sigma, tag.Size());
17355 DCT_ASSERT((no == tag.Size()));
17356 }
17357 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_TMAX_SIGMA_TAG_ID)) {
17358 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.tmax_sigma, tag.Size());
17359 DCT_ASSERT((no == tag.Size()));
17360 }
17361
17362 pchild = pchild->NextSibling();
17363 }
17364 XML_CHECK_END();
17365 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
17366 return (true);
17367 }
17368
parseEntrySensorDehazeSettingV21(const XMLElement * pelement,void * param,int index)17369 bool RkAiqCalibParser::parseEntrySensorDehazeSettingV21
17370 (
17371 const XMLElement* pelement,
17372 void* param,
17373 int index
17374 ) {
17375 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
17376
17377 CalibDb_Dehaze_ModeCell_v21_t *pModeCell = (CalibDb_Dehaze_ModeCell_v21_t *)param;
17378
17379 XML_CHECK_START(CALIB_SENSOR_DEHAZE_V21_SETTING_TAG_ID, CALIB_SENSOR_DEHAZE_CALIBPARA_V21_TAG_ID);
17380 const XMLNode* pchild = pelement->FirstChild();
17381 while (pchild) {
17382 XmlTag tag = XmlTag(pchild->ToElement());
17383 const char* value = tag.Value();
17384 std::string tagname(pchild->ToElement()->Name());
17385 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
17386
17387 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_EN_TAG_ID)) {
17388 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.en, tag.Size());
17389 DCT_ASSERT((no == tag.Size()));
17390 }
17391 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_ISO_TAG_ID)) {
17392 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.iso, tag.Size());
17393 DCT_ASSERT((no == tag.Size()));
17394 }
17395 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_LC_EN_TAG_ID)) {
17396 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_lc_en, tag.Size());
17397 DCT_ASSERT((no == tag.Size()));
17398 }
17399 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_MIN_TH_TAG_ID)) {
17400 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_min_th, tag.Size());
17401 DCT_ASSERT((no == tag.Size()));
17402 }
17403 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_MAX_TH_TAG_ID)) {
17404 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_max_th, tag.Size());
17405 DCT_ASSERT((no == tag.Size()));
17406 }
17407 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_YHIST_TH_TAG_ID)) {
17408 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.yhist_th, tag.Size());
17409 DCT_ASSERT((no == tag.Size()));
17410 }
17411 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_YBLK_TH_TAG_ID)) {
17412 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.yblk_th, tag.Size());
17413 DCT_ASSERT((no == tag.Size()));
17414 }
17415 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DARK_TH_TAG_ID)) {
17416 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dark_th, tag.Size());
17417 DCT_ASSERT((no == tag.Size()));
17418 }
17419 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_BRIGHT_MIN_TAG_ID)) {
17420 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.bright_min, tag.Size());
17421 DCT_ASSERT((no == tag.Size()));
17422 }
17423 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_BRIGHT_MAX_TAG_ID)) {
17424 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.bright_max, tag.Size());
17425 DCT_ASSERT((no == tag.Size()));
17426 }
17427 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_WT_MAX_TAG_ID)) {
17428 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.wt_max, tag.Size());
17429 DCT_ASSERT((no == tag.Size()));
17430 }
17431 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_MIN_TAG_ID)) {
17432 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_min, tag.Size());
17433 DCT_ASSERT((no == tag.Size()));
17434 }
17435 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_MAX_TAG_ID)) {
17436 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_max, tag.Size());
17437 DCT_ASSERT((no == tag.Size()));
17438 }
17439 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TMAX_BASE_TAG_ID)) {
17440 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.tmax_base, tag.Size());
17441 DCT_ASSERT((no == tag.Size()));
17442 }
17443 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TMAX_OFF_TAG_ID)) {
17444 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.tmax_off, tag.Size());
17445 DCT_ASSERT((no == tag.Size()));
17446 }
17447 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TMAX_MAX_TAG_ID)) {
17448 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.tmax_max, tag.Size());
17449 DCT_ASSERT((no == tag.Size()));
17450 }
17451 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_CFG_WT_TAG_ID)) {
17452 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.cfg_wt, tag.Size());
17453 DCT_ASSERT((no == tag.Size()));
17454 }
17455 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_CFG_AIR_TAG_ID)) {
17456 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.cfg_air, tag.Size());
17457 DCT_ASSERT((no == tag.Size()));
17458 }
17459 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_CFG_TMAX_TAG_ID)) {
17460 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.cfg_tmax, tag.Size());
17461 DCT_ASSERT((no == tag.Size()));
17462 }
17463 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_WEITCUR_TAG_ID)) {
17464 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_weitcur, tag.Size());
17465 DCT_ASSERT((no == tag.Size()));
17466 }
17467 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_BF_WEIGHT_TAG_ID)) {
17468 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.bf_weight, tag.Size());
17469 DCT_ASSERT((no == tag.Size()));
17470 }
17471 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_RANGE_SIGMA_TAG_ID)) {
17472 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.range_sigma, tag.Size());
17473 DCT_ASSERT((no == tag.Size()));
17474 }
17475 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_SPACE_SIGMA_PRE_TAG_ID)) {
17476 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.space_sigma_pre, tag.Size());
17477 DCT_ASSERT((no == tag.Size()));
17478 }
17479 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_SPACE_SIGMA_CUR_TAG_ID)) {
17480 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.space_sigma_cur, tag.Size());
17481 DCT_ASSERT((no == tag.Size()));
17482 }
17483 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_STAB_FNUM_TAG_ID)) {
17484 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.stab_fnum, tag.Size());
17485 DCT_ASSERT((no == tag.Size()));
17486 }
17487 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_SIGMA_TAG_ID)) {
17488 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.sigma, tag.Size());
17489 DCT_ASSERT((no == tag.Size()));
17490 }
17491 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_WT_SIGMA_TAG_ID)) {
17492 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.wt_sigma, tag.Size());
17493 DCT_ASSERT((no == tag.Size()));
17494 }
17495 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_AIR_SIGMA_TAG_ID)) {
17496 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.air_sigma, tag.Size());
17497 DCT_ASSERT((no == tag.Size()));
17498 }
17499 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_TMAX_SIGMA_TAG_ID)) {
17500 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.tmax_sigma, tag.Size());
17501 DCT_ASSERT((no == tag.Size()));
17502 }
17503 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_PRE_WET_TAG_ID)) {
17504 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.pre_wet, tag.Size());
17505 DCT_ASSERT((no == tag.Size()));
17506 }
17507
17508 pchild = pchild->NextSibling();
17509 }
17510 XML_CHECK_END();
17511 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
17512 return (true);
17513 }
17514
parseEntrySensorDehazeTuningSettingV21(const XMLElement * pelement,void * param,int index)17515 bool RkAiqCalibParser::parseEntrySensorDehazeTuningSettingV21
17516 (
17517 const XMLElement* pelement,
17518 void* param,
17519 int index
17520 ) {
17521 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
17522
17523 CalibDb_Dehaze_ModeCell_v21_t *pModeCell = (CalibDb_Dehaze_ModeCell_v21_t *)param;
17524
17525 XML_CHECK_START(CALIB_SENSOR_DEHAZE_V21_SETTING_TAG_ID, CALIB_SENSOR_DEHAZE_TUNINGPARA_V21_TAG_ID);
17526 const XMLNode* pchild = pelement->FirstChild();
17527 while (pchild) {
17528 XmlTag tag = XmlTag(pchild->ToElement());
17529 const char* value = tag.Value();
17530 std::string tagname(pchild->ToElement()->Name());
17531 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
17532
17533 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_EN_TAG_ID)) {
17534 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.en, tag.Size());
17535 DCT_ASSERT((no == tag.Size()));
17536 }
17537 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_ISO_TAG_ID)) {
17538 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.iso, tag.Size());
17539 DCT_ASSERT((no == tag.Size()));
17540 }
17541 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_LC_EN_TAG_ID)) {
17542 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_lc_en, tag.Size());
17543 DCT_ASSERT((no == tag.Size()));
17544 }
17545 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_MIN_TH_TAG_ID)) {
17546 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_min_th, tag.Size());
17547 DCT_ASSERT((no == tag.Size()));
17548 }
17549 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_MAX_TH_TAG_ID)) {
17550 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_max_th, tag.Size());
17551 DCT_ASSERT((no == tag.Size()));
17552 }
17553 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_YHIST_TH_TAG_ID)) {
17554 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.yhist_th, tag.Size());
17555 DCT_ASSERT((no == tag.Size()));
17556 }
17557 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_YBLK_TH_TAG_ID)) {
17558 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.yblk_th, tag.Size());
17559 DCT_ASSERT((no == tag.Size()));
17560 }
17561 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DARK_TH_TAG_ID)) {
17562 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dark_th, tag.Size());
17563 DCT_ASSERT((no == tag.Size()));
17564 }
17565 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_BRIGHT_MIN_TAG_ID)) {
17566 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.bright_min, tag.Size());
17567 DCT_ASSERT((no == tag.Size()));
17568 }
17569 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_BRIGHT_MAX_TAG_ID)) {
17570 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.bright_max, tag.Size());
17571 DCT_ASSERT((no == tag.Size()));
17572 }
17573 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_WT_MAX_TAG_ID)) {
17574 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.wt_max, tag.Size());
17575 DCT_ASSERT((no == tag.Size()));
17576 }
17577 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_MIN_TAG_ID)) {
17578 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_min, tag.Size());
17579 DCT_ASSERT((no == tag.Size()));
17580 }
17581 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_AIR_MAX_TAG_ID)) {
17582 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.air_max, tag.Size());
17583 DCT_ASSERT((no == tag.Size()));
17584 }
17585 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TMAX_BASE_TAG_ID)) {
17586 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.tmax_base, tag.Size());
17587 DCT_ASSERT((no == tag.Size()));
17588 }
17589 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TMAX_OFF_TAG_ID)) {
17590 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.tmax_off, tag.Size());
17591 DCT_ASSERT((no == tag.Size()));
17592 }
17593 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_TMAX_MAX_TAG_ID)) {
17594 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.tmax_max, tag.Size());
17595 DCT_ASSERT((no == tag.Size()));
17596 }
17597 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_CFG_WT_TAG_ID)) {
17598 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.cfg_wt, tag.Size());
17599 DCT_ASSERT((no == tag.Size()));
17600 }
17601 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_CFG_AIR_TAG_ID)) {
17602 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.cfg_air, tag.Size());
17603 DCT_ASSERT((no == tag.Size()));
17604 }
17605 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_CFG_TMAX_TAG_ID)) {
17606 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.cfg_tmax, tag.Size());
17607 DCT_ASSERT((no == tag.Size()));
17608 }
17609 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_DC_WEITCUR_TAG_ID)) {
17610 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.dc_weitcur, tag.Size());
17611 DCT_ASSERT((no == tag.Size()));
17612 }
17613 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_BF_WEIGHT_TAG_ID)) {
17614 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.bf_weight, tag.Size());
17615 DCT_ASSERT((no == tag.Size()));
17616 }
17617 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_RANGE_SIGMA_TAG_ID)) {
17618 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.range_sigma, tag.Size());
17619 DCT_ASSERT((no == tag.Size()));
17620 }
17621 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_SPACE_SIGMA_PRE_TAG_ID)) {
17622 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.space_sigma_pre, tag.Size());
17623 DCT_ASSERT((no == tag.Size()));
17624 }
17625 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_DEHAZE_SETTING_SPACE_SIGMA_CUR_TAG_ID)) {
17626 int no = ParseFloatArray(pchild, pModeCell->dehaze_setting.space_sigma_cur, tag.Size());
17627 DCT_ASSERT((no == tag.Size()));
17628 }
17629 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_STAB_FNUM_TAG_ID)) {
17630 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.stab_fnum, tag.Size());
17631 DCT_ASSERT((no == tag.Size()));
17632 }
17633 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_SIGMA_TAG_ID)) {
17634 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.sigma, tag.Size());
17635 DCT_ASSERT((no == tag.Size()));
17636 }
17637 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_WT_SIGMA_TAG_ID)) {
17638 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.wt_sigma, tag.Size());
17639 DCT_ASSERT((no == tag.Size()));
17640 }
17641 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_AIR_SIGMA_TAG_ID)) {
17642 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.air_sigma, tag.Size());
17643 DCT_ASSERT((no == tag.Size()));
17644 }
17645 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_TMAX_SIGMA_TAG_ID)) {
17646 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.tmax_sigma, tag.Size());
17647 DCT_ASSERT((no == tag.Size()));
17648 }
17649 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IIR_SETTING_PRE_WET_TAG_ID)) {
17650 int no = ParseFloatArray(pchild, &pModeCell->dehaze_setting.IIR_setting.pre_wet, tag.Size());
17651 DCT_ASSERT((no == tag.Size()));
17652 }
17653
17654 pchild = pchild->NextSibling();
17655 }
17656 XML_CHECK_END();
17657 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
17658 return (true);
17659 }
17660
parseEntrySensorEnhanceSettingV20(const XMLElement * pelement,void * param,int index)17661 bool RkAiqCalibParser::parseEntrySensorEnhanceSettingV20
17662 (
17663 const XMLElement* pelement,
17664 void* param,
17665 int index
17666 ) {
17667 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
17668
17669 CalibDb_Dehaze_ModeCell_v20_t *pModeCell = (CalibDb_Dehaze_ModeCell_v20_t *)param;
17670
17671 XML_CHECK_START(CALIB_SENSOR_ENHANCE_SETTING_TAG_ID, CALIB_SENSOR_DEHAZE_CALIBPARA_V20_TAG_ID);
17672 const XMLNode* pchild = pelement->FirstChild();
17673 while (pchild) {
17674 XmlTag tag = XmlTag(pchild->ToElement());
17675 const char* value = tag.Value();
17676 std::string tagname(pchild->ToElement()->Name());
17677 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
17678
17679 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_EN_TAG_ID)) {
17680 int no = ParseFloatArray(pchild, &pModeCell->enhance_setting.en, tag.Size());
17681 DCT_ASSERT((no == tag.Size()));
17682 }
17683 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_ISO_TAG_ID)) {
17684 int no = ParseFloatArray(pchild, pModeCell->enhance_setting.iso, tag.Size());
17685 DCT_ASSERT((no == tag.Size()));
17686 }
17687 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_ENHANCE_VALUE_TAG_ID)) {
17688 int no = ParseFloatArray(pchild, pModeCell->enhance_setting.enhance_value, tag.Size());
17689 DCT_ASSERT((no == tag.Size()));
17690 }
17691
17692 pchild = pchild->NextSibling();
17693 }
17694 XML_CHECK_END();
17695 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
17696 return (true);
17697 }
17698
parseEntrySensorEnhanceTuningSettingV20(const XMLElement * pelement,void * param,int index)17699 bool RkAiqCalibParser::parseEntrySensorEnhanceTuningSettingV20
17700 (
17701 const XMLElement* pelement,
17702 void* param,
17703 int index
17704 ) {
17705 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
17706
17707 CalibDb_Dehaze_ModeCell_v20_t *pModeCell = (CalibDb_Dehaze_ModeCell_v20_t *)param;
17708
17709 XML_CHECK_START(CALIB_SENSOR_ENHANCE_SETTING_TAG_ID, CALIB_SENSOR_DEHAZE_TUNINGPARA_V20_TAG_ID);
17710 const XMLNode* pchild = pelement->FirstChild();
17711 while (pchild) {
17712 XmlTag tag = XmlTag(pchild->ToElement());
17713 const char* value = tag.Value();
17714 std::string tagname(pchild->ToElement()->Name());
17715 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
17716
17717 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_EN_TAG_ID)) {
17718 int no = ParseFloatArray(pchild, &pModeCell->enhance_setting.en, tag.Size());
17719 DCT_ASSERT((no == tag.Size()));
17720 }
17721 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_ISO_TAG_ID)) {
17722 int no = ParseFloatArray(pchild, pModeCell->enhance_setting.iso, tag.Size());
17723 DCT_ASSERT((no == tag.Size()));
17724 }
17725 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_ENHANCE_VALUE_TAG_ID)) {
17726 int no = ParseFloatArray(pchild, pModeCell->enhance_setting.enhance_value, tag.Size());
17727 DCT_ASSERT((no == tag.Size()));
17728 }
17729
17730 pchild = pchild->NextSibling();
17731 }
17732 XML_CHECK_END();
17733 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
17734 return (true);
17735 }
17736
parseEntrySensorEnhanceSettingV21(const XMLElement * pelement,void * param,int index)17737 bool RkAiqCalibParser::parseEntrySensorEnhanceSettingV21
17738 (
17739 const XMLElement* pelement,
17740 void* param,
17741 int index
17742 ) {
17743 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
17744
17745 CalibDb_Dehaze_ModeCell_v21_t *pModeCell = (CalibDb_Dehaze_ModeCell_v21_t *)param;
17746
17747 XML_CHECK_START(CALIB_SENSOR_ENHANCE_V21_SETTING_TAG_ID, CALIB_SENSOR_DEHAZE_CALIBPARA_V21_TAG_ID);
17748 const XMLNode* pchild = pelement->FirstChild();
17749 while (pchild) {
17750 XmlTag tag = XmlTag(pchild->ToElement());
17751 const char* value = tag.Value();
17752 std::string tagname(pchild->ToElement()->Name());
17753 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
17754
17755 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_EN_TAG_ID)) {
17756 int no = ParseFloatArray(pchild, &pModeCell->enhance_setting.en, tag.Size());
17757 DCT_ASSERT((no == tag.Size()));
17758 }
17759 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_ISO_TAG_ID)) {
17760 int no = ParseFloatArray(pchild, pModeCell->enhance_setting.iso, tag.Size());
17761 DCT_ASSERT((no == tag.Size()));
17762 }
17763 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_ENHANCE_VALUE_TAG_ID)) {
17764 int no = ParseFloatArray(pchild, pModeCell->enhance_setting.enhance_value, tag.Size());
17765 DCT_ASSERT((no == tag.Size()));
17766 }
17767 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_ENHANCE_CHROMA_TAG_ID)) {
17768 int no = ParseFloatArray(pchild, pModeCell->enhance_setting.enhance_chroma, tag.Size());
17769 DCT_ASSERT((no == tag.Size()));
17770 }
17771 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_ENHANCE_CURVE_TAG_ID)) {
17772 int no = ParseFloatArray(pchild, pModeCell->enhance_setting.enhance_curve, tag.Size());
17773 DCT_ASSERT((no == tag.Size()));
17774 }
17775
17776 pchild = pchild->NextSibling();
17777 }
17778 XML_CHECK_END();
17779 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
17780 return (true);
17781 }
17782
parseEntrySensorEnhanceTuningSettingV21(const XMLElement * pelement,void * param,int index)17783 bool RkAiqCalibParser::parseEntrySensorEnhanceTuningSettingV21
17784 (
17785 const XMLElement* pelement,
17786 void* param,
17787 int index
17788 ) {
17789 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
17790
17791 CalibDb_Dehaze_ModeCell_v21_t *pModeCell = (CalibDb_Dehaze_ModeCell_v21_t *)param;
17792
17793 XML_CHECK_START(CALIB_SENSOR_ENHANCE_V21_SETTING_TAG_ID, CALIB_SENSOR_DEHAZE_TUNINGPARA_V21_TAG_ID);
17794 const XMLNode* pchild = pelement->FirstChild();
17795 while (pchild) {
17796 XmlTag tag = XmlTag(pchild->ToElement());
17797 const char* value = tag.Value();
17798 std::string tagname(pchild->ToElement()->Name());
17799 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
17800
17801 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_EN_TAG_ID)) {
17802 int no = ParseFloatArray(pchild, &pModeCell->enhance_setting.en, tag.Size());
17803 DCT_ASSERT((no == tag.Size()));
17804 }
17805 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_ISO_TAG_ID)) {
17806 int no = ParseFloatArray(pchild, pModeCell->enhance_setting.iso, tag.Size());
17807 DCT_ASSERT((no == tag.Size()));
17808 }
17809 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_ENHANCE_VALUE_TAG_ID)) {
17810 int no = ParseFloatArray(pchild, pModeCell->enhance_setting.enhance_value, tag.Size());
17811 DCT_ASSERT((no == tag.Size()));
17812 }
17813 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_ENHANCE_CHROMA_TAG_ID)) {
17814 int no = ParseFloatArray(pchild, pModeCell->enhance_setting.enhance_chroma, tag.Size());
17815 DCT_ASSERT((no == tag.Size()));
17816 }
17817 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ENHANCE_SETTING_ENHANCE_CURVE_TAG_ID)) {
17818 int no = ParseFloatArray(pchild, pModeCell->enhance_setting.enhance_curve, tag.Size());
17819 DCT_ASSERT((no == tag.Size()));
17820 }
17821
17822 pchild = pchild->NextSibling();
17823 }
17824 XML_CHECK_END();
17825 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
17826 return (true);
17827 }
17828
parseEntrySensorHistSettingV20(const XMLElement * pelement,void * param,int index)17829 bool RkAiqCalibParser::parseEntrySensorHistSettingV20
17830 (
17831 const XMLElement* pelement,
17832 void* param,
17833 int index
17834 ) {
17835 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
17836
17837 CalibDb_Dehaze_ModeCell_v20_t *pModeCell = (CalibDb_Dehaze_ModeCell_v20_t *)param;
17838
17839 XML_CHECK_START(CALIB_SENSOR_HIST_SETTING_TAG_ID, CALIB_SENSOR_DEHAZE_CALIBPARA_V20_TAG_ID);
17840 const XMLNode* pchild = pelement->FirstChild();
17841 while (pchild) {
17842 XmlTag tag = XmlTag(pchild->ToElement());
17843 const char* value = tag.Value();
17844 std::string tagname(pchild->ToElement()->Name());
17845 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
17846
17847 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_EN_TAG_ID)) {
17848 int no = ParseFloatArray(pchild, &pModeCell->hist_setting.en, tag.Size());
17849 DCT_ASSERT((no == tag.Size()));
17850 }
17851 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_ISO_TAG_ID)) {
17852 int no = ParseFloatArray(pchild, pModeCell->hist_setting.iso, tag.Size());
17853 DCT_ASSERT((no == tag.Size()));
17854 }
17855 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_CHANNEL_TAG_ID)) {
17856 int no = ParseUcharArray(pchild, pModeCell->hist_setting.hist_channel, tag.Size());
17857 DCT_ASSERT((no == tag.Size()));
17858 }
17859 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_PARA_EN_TAG_ID)) {
17860 int no = ParseUcharArray(pchild, pModeCell->hist_setting.hist_para_en, tag.Size());
17861 DCT_ASSERT((no == tag.Size()));
17862 }
17863 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_GRATIO_TAG_ID)) {
17864 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_gratio, tag.Size());
17865 DCT_ASSERT((no == tag.Size()));
17866 }
17867 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_TH_OFF_TAG_ID)) {
17868 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_th_off, tag.Size());
17869 DCT_ASSERT((no == tag.Size()));
17870 }
17871 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_K_TAG_ID)) {
17872 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_k, tag.Size());
17873 DCT_ASSERT((no == tag.Size()));
17874 }
17875 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_MIN_TAG_ID)) {
17876 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_min, tag.Size());
17877 DCT_ASSERT((no == tag.Size()));
17878 }
17879 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_SCALE_TAG_ID)) {
17880 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_scale, tag.Size());
17881 DCT_ASSERT((no == tag.Size()));
17882 }
17883 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_CFG_GRATIO_TAG_ID)) {
17884 int no = ParseFloatArray(pchild, pModeCell->hist_setting.cfg_gratio, tag.Size());
17885 DCT_ASSERT((no == tag.Size()));
17886 }
17887
17888 pchild = pchild->NextSibling();
17889
17890 }
17891
17892 XML_CHECK_END();
17893 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
17894 return (true);
17895 }
17896
parseEntrySensorHistTuningSettingV20(const XMLElement * pelement,void * param,int index)17897 bool RkAiqCalibParser::parseEntrySensorHistTuningSettingV20
17898 (
17899 const XMLElement* pelement,
17900 void* param,
17901 int index
17902 ) {
17903 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
17904
17905 CalibDb_Dehaze_ModeCell_v20_t *pModeCell = (CalibDb_Dehaze_ModeCell_v20_t *)param;
17906
17907 XML_CHECK_START(CALIB_SENSOR_HIST_SETTING_TAG_ID, CALIB_SENSOR_DEHAZE_TUNINGPARA_V20_TAG_ID);
17908 const XMLNode* pchild = pelement->FirstChild();
17909 while (pchild) {
17910 XmlTag tag = XmlTag(pchild->ToElement());
17911 const char* value = tag.Value();
17912 std::string tagname(pchild->ToElement()->Name());
17913 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
17914
17915 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_EN_TAG_ID)) {
17916 int no = ParseFloatArray(pchild, &pModeCell->hist_setting.en, tag.Size());
17917 DCT_ASSERT((no == tag.Size()));
17918 }
17919 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_ISO_TAG_ID)) {
17920 int no = ParseFloatArray(pchild, pModeCell->hist_setting.iso, tag.Size());
17921 DCT_ASSERT((no == tag.Size()));
17922 }
17923 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_CHANNEL_TAG_ID)) {
17924 int no = ParseUcharArray(pchild, pModeCell->hist_setting.hist_channel, tag.Size());
17925 DCT_ASSERT((no == tag.Size()));
17926 }
17927 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_PARA_EN_TAG_ID)) {
17928 int no = ParseUcharArray(pchild, pModeCell->hist_setting.hist_para_en, tag.Size());
17929 DCT_ASSERT((no == tag.Size()));
17930 }
17931 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_GRATIO_TAG_ID)) {
17932 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_gratio, tag.Size());
17933 DCT_ASSERT((no == tag.Size()));
17934 }
17935 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_TH_OFF_TAG_ID)) {
17936 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_th_off, tag.Size());
17937 DCT_ASSERT((no == tag.Size()));
17938 }
17939 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_K_TAG_ID)) {
17940 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_k, tag.Size());
17941 DCT_ASSERT((no == tag.Size()));
17942 }
17943 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_MIN_TAG_ID)) {
17944 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_min, tag.Size());
17945 DCT_ASSERT((no == tag.Size()));
17946 }
17947 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_SCALE_TAG_ID)) {
17948 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_scale, tag.Size());
17949 DCT_ASSERT((no == tag.Size()));
17950 }
17951 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_CFG_GRATIO_TAG_ID)) {
17952 int no = ParseFloatArray(pchild, pModeCell->hist_setting.cfg_gratio, tag.Size());
17953 DCT_ASSERT((no == tag.Size()));
17954 }
17955
17956 pchild = pchild->NextSibling();
17957
17958 }
17959
17960 XML_CHECK_END();
17961 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
17962 return (true);
17963 }
17964
parseEntrySensorHistSettingV21(const XMLElement * pelement,void * param,int index)17965 bool RkAiqCalibParser::parseEntrySensorHistSettingV21
17966 (
17967 const XMLElement* pelement,
17968 void* param,
17969 int index
17970 ) {
17971 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
17972
17973 CalibDb_Dehaze_ModeCell_v21_t *pModeCell = (CalibDb_Dehaze_ModeCell_v21_t *)param;
17974
17975 XML_CHECK_START(CALIB_SENSOR_HIST_V21_SETTING_TAG_ID, CALIB_SENSOR_DEHAZE_CALIBPARA_V21_TAG_ID);
17976 const XMLNode* pchild = pelement->FirstChild();
17977 while (pchild) {
17978 XmlTag tag = XmlTag(pchild->ToElement());
17979 const char* value = tag.Value();
17980 std::string tagname(pchild->ToElement()->Name());
17981 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
17982
17983 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_EN_TAG_ID)) {
17984 int no = ParseFloatArray(pchild, &pModeCell->hist_setting.en, tag.Size());
17985 DCT_ASSERT((no == tag.Size()));
17986 }
17987 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_ISO_TAG_ID)) {
17988 int no = ParseFloatArray(pchild, pModeCell->hist_setting.iso, tag.Size());
17989 DCT_ASSERT((no == tag.Size()));
17990 }
17991 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_PARA_EN_TAG_ID)) {
17992 int no = ParseUcharArray(pchild, pModeCell->hist_setting.hist_para_en, tag.Size());
17993 DCT_ASSERT((no == tag.Size()));
17994 }
17995 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_GRATIO_TAG_ID)) {
17996 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_gratio, tag.Size());
17997 DCT_ASSERT((no == tag.Size()));
17998 }
17999 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_TH_OFF_TAG_ID)) {
18000 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_th_off, tag.Size());
18001 DCT_ASSERT((no == tag.Size()));
18002 }
18003 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_K_TAG_ID)) {
18004 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_k, tag.Size());
18005 DCT_ASSERT((no == tag.Size()));
18006 }
18007 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_MIN_TAG_ID)) {
18008 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_min, tag.Size());
18009 DCT_ASSERT((no == tag.Size()));
18010 }
18011 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_SCALE_TAG_ID)) {
18012 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_scale, tag.Size());
18013 DCT_ASSERT((no == tag.Size()));
18014 }
18015 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_CFG_GRATIO_TAG_ID)) {
18016 int no = ParseFloatArray(pchild, pModeCell->hist_setting.cfg_gratio, tag.Size());
18017 DCT_ASSERT((no == tag.Size()));
18018 }
18019
18020 pchild = pchild->NextSibling();
18021
18022 }
18023
18024
18025 XML_CHECK_END();
18026 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18027 return (true);
18028 }
18029
parseEntrySensorHistTuningSettingV21(const XMLElement * pelement,void * param,int index)18030 bool RkAiqCalibParser::parseEntrySensorHistTuningSettingV21
18031 (
18032 const XMLElement* pelement,
18033 void* param,
18034 int index
18035 ) {
18036 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18037
18038 CalibDb_Dehaze_ModeCell_v21_t *pModeCell = (CalibDb_Dehaze_ModeCell_v21_t *)param;
18039
18040 XML_CHECK_START(CALIB_SENSOR_HIST_V21_SETTING_TAG_ID, CALIB_SENSOR_DEHAZE_TUNINGPARA_V21_TAG_ID);
18041 const XMLNode* pchild = pelement->FirstChild();
18042 while (pchild) {
18043 XmlTag tag = XmlTag(pchild->ToElement());
18044 const char* value = tag.Value();
18045 std::string tagname(pchild->ToElement()->Name());
18046 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
18047
18048 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_EN_TAG_ID)) {
18049 int no = ParseFloatArray(pchild, &pModeCell->hist_setting.en, tag.Size());
18050 DCT_ASSERT((no == tag.Size()));
18051 }
18052 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_ISO_TAG_ID)) {
18053 int no = ParseFloatArray(pchild, pModeCell->hist_setting.iso, tag.Size());
18054 DCT_ASSERT((no == tag.Size()));
18055 }
18056 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_PARA_EN_TAG_ID)) {
18057 int no = ParseUcharArray(pchild, pModeCell->hist_setting.hist_para_en, tag.Size());
18058 DCT_ASSERT((no == tag.Size()));
18059 }
18060 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_GRATIO_TAG_ID)) {
18061 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_gratio, tag.Size());
18062 DCT_ASSERT((no == tag.Size()));
18063 }
18064 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_TH_OFF_TAG_ID)) {
18065 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_th_off, tag.Size());
18066 DCT_ASSERT((no == tag.Size()));
18067 }
18068 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_K_TAG_ID)) {
18069 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_k, tag.Size());
18070 DCT_ASSERT((no == tag.Size()));
18071 }
18072 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_MIN_TAG_ID)) {
18073 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_min, tag.Size());
18074 DCT_ASSERT((no == tag.Size()));
18075 }
18076 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_HIST_SCALE_TAG_ID)) {
18077 int no = ParseFloatArray(pchild, pModeCell->hist_setting.hist_scale, tag.Size());
18078 DCT_ASSERT((no == tag.Size()));
18079 }
18080 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_HIST_SETTING_CFG_GRATIO_TAG_ID)) {
18081 int no = ParseFloatArray(pchild, pModeCell->hist_setting.cfg_gratio, tag.Size());
18082 DCT_ASSERT((no == tag.Size()));
18083 }
18084
18085 pchild = pchild->NextSibling();
18086
18087 }
18088
18089
18090 XML_CHECK_END();
18091 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18092 return (true);
18093 }
18094
parseEntrySensorAfWindow(const XMLElement * pelement,void * param)18095 bool RkAiqCalibParser::parseEntrySensorAfWindow
18096 (
18097 const XMLElement* pelement,
18098 void* param
18099 ) {
18100 (void)param;
18101
18102 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18103 autoTabForward();
18104
18105 XML_CHECK_START(CALIB_SENSOR_AF_WINDOW_TAG_ID, CALIB_SENSOR_AF_TAG_ID);
18106 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_AF_t, af);
18107
18108 const XMLNode* psecsubchild = pelement->FirstChild();
18109 while (psecsubchild) {
18110 XmlTag secsubtag = XmlTag(psecsubchild->ToElement());
18111 std::string secsubTagname(psecsubchild->ToElement()->Name());
18112 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubtag.Type(), secsubtag.Size());
18113
18114 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_H_OFFS_TAG_ID)) {
18115 int no = ParseUshortArray(psecsubchild, &af->win_h_offs, secsubtag.Size());
18116 DCT_ASSERT((no == secsubtag.Size()));
18117 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_V_OFFS_TAG_ID)) {
18118 int no = ParseUshortArray(psecsubchild, &af->win_v_offs, secsubtag.Size());
18119 DCT_ASSERT((no == secsubtag.Size()));
18120 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_H_SIZE_TAG_ID)) {
18121 int no = ParseUshortArray(psecsubchild, &af->win_h_size, secsubtag.Size());
18122 DCT_ASSERT((no == secsubtag.Size()));
18123 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_V_SIZE_TAG_ID)) {
18124 int no = ParseUshortArray(psecsubchild, &af->win_v_size, secsubtag.Size());
18125 DCT_ASSERT((no == secsubtag.Size()));
18126 }
18127 psecsubchild = psecsubchild->NextSibling();
18128 }
18129
18130 XML_CHECK_END();
18131 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18132 autoTabBackward();
18133 return (true);
18134 }
18135
parseEntrySensorAfFixedMode(const XMLElement * pelement,void * param)18136 bool RkAiqCalibParser::parseEntrySensorAfFixedMode
18137 (
18138 const XMLElement* pelement,
18139 void* param
18140 ) {
18141 (void)param;
18142
18143 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18144 autoTabForward();
18145
18146 XML_CHECK_START(CALIB_SENSOR_AF_FIXED_MODE_TAG_ID, CALIB_SENSOR_AF_TAG_ID);
18147 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_AF_t, af);
18148
18149 const XMLNode* psecsubchild = pelement->FirstChild();
18150 while (psecsubchild) {
18151 XmlTag secsubtag = XmlTag(psecsubchild->ToElement());
18152 std::string secsubTagname(psecsubchild->ToElement()->Name());
18153 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubtag.Type(), secsubtag.Size());
18154 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_DEF_CODE_TAG_ID)) {
18155 int no = ParseUcharArray(psecsubchild, &af->fixed_mode.code, secsubtag.Size());
18156 DCT_ASSERT((no == secsubtag.Size()));
18157 }
18158 psecsubchild = psecsubchild->NextSibling();
18159 }
18160
18161 XML_CHECK_END();
18162 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18163 autoTabBackward();
18164 return (true);
18165 }
18166
parseEntrySensorAfMacroMode(const XMLElement * pelement,void * param)18167 bool RkAiqCalibParser::parseEntrySensorAfMacroMode
18168 (
18169 const XMLElement* pelement,
18170 void* param
18171 ) {
18172 (void)param;
18173
18174 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18175 autoTabForward();
18176
18177 XML_CHECK_START(CALIB_SENSOR_AF_MACRO_MODE_TAG_ID, CALIB_SENSOR_AF_TAG_ID);
18178 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_AF_t, af);
18179
18180 const XMLNode* psecsubchild = pelement->FirstChild();
18181 while (psecsubchild) {
18182 XmlTag secsubtag = XmlTag(psecsubchild->ToElement());
18183 std::string secsubTagname(psecsubchild->ToElement()->Name());
18184 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubtag.Type(), secsubtag.Size());
18185 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_DEF_CODE_TAG_ID)) {
18186 int no = ParseUcharArray(psecsubchild, &af->macro_mode.code, secsubtag.Size());
18187 DCT_ASSERT((no == secsubtag.Size()));
18188 }
18189 psecsubchild = psecsubchild->NextSibling();
18190 }
18191
18192 XML_CHECK_END();
18193 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18194 autoTabBackward();
18195 return (true);
18196 }
18197
parseEntrySensorAfInfinityMode(const XMLElement * pelement,void * param)18198 bool RkAiqCalibParser::parseEntrySensorAfInfinityMode
18199 (
18200 const XMLElement* pelement,
18201 void* param
18202 ) {
18203 (void)param;
18204
18205 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18206 autoTabForward();
18207
18208 XML_CHECK_START(CALIB_SENSOR_AF_INFINITY_MODE_TAG_ID, CALIB_SENSOR_AF_TAG_ID);
18209 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_AF_t, af);
18210
18211 const XMLNode* psecsubchild = pelement->FirstChild();
18212 while (psecsubchild) {
18213 XmlTag secsubtag = XmlTag(psecsubchild->ToElement());
18214 std::string secsubTagname(psecsubchild->ToElement()->Name());
18215 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubtag.Type(), secsubtag.Size());
18216 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_DEF_CODE_TAG_ID)) {
18217 int no = ParseUcharArray(psecsubchild, &af->infinity_mode.code, secsubtag.Size());
18218 DCT_ASSERT((no == secsubtag.Size()));
18219 }
18220 psecsubchild = psecsubchild->NextSibling();
18221 }
18222
18223 XML_CHECK_END();
18224 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18225 autoTabBackward();
18226 return (true);
18227 }
18228
parseEntrySensorAfContrastAf(const XMLElement * pelement,void * param)18229 bool RkAiqCalibParser::parseEntrySensorAfContrastAf
18230 (
18231 const XMLElement* pelement,
18232 void* param
18233 ) {
18234 (void)param;
18235
18236 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18237 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_AF_t, af);
18238 autoTabForward();
18239
18240 XML_CHECK_START(CALIB_SENSOR_AF_CONTRAST_AF_TAG_ID, CALIB_SENSOR_AF_TAG_ID);
18241
18242 const XMLNode* psecsubchild = pelement->FirstChild();
18243 while (psecsubchild) {
18244 XmlTag secsubtag = XmlTag(psecsubchild->ToElement());
18245 std::string secsubTagname(psecsubchild->ToElement()->Name());
18246 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubtag.Type(), secsubtag.Size());
18247 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_CONTRAST_ENABLE_TAG_ID)) {
18248 int no = ParseUcharArray(psecsubchild, &af->contrast_af.enable, secsubtag.Size());
18249 DCT_ASSERT((no == secsubtag.Size()));
18250 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_SEARCH_STRATEGY_TAG_ID)) {
18251 char* value = Toupper(secsubtag.Value());
18252 std::string s_value(value);
18253 if (s_value == CALIB_SENSOR_AF_SEARCH_STRATEGY_ADAPTIVE) {
18254 af->contrast_af.Afss = CAM_AFM_FSS_ADAPTIVE_RANGE;
18255 } else if (s_value == CALIB_SENSOR_AF_SEARCH_STRATEGY_HILLCLIMB) {
18256 af->contrast_af.Afss = CAM_AFM_FSS_HILLCLIMBING;
18257 } else if (s_value == CALIB_SENSOR_AF_SEARCH_STRATEGY_FULL) {
18258 af->contrast_af.Afss = CAM_AFM_FSS_FULLRANGE;
18259 } else if (s_value == CALIB_SENSOR_AF_SEARCH_STRATEGY_MUTIWIN) {
18260 af->contrast_af.Afss = CAM_AFM_FSS_MUTIWINDOW;
18261 }
18262 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_FULL_DIR_TAG_ID)) {
18263 char* value = Toupper(secsubtag.Value());
18264 std::string s_value(value);
18265 if (s_value == CALIB_SENSOR_AF_DIR_POSITIVE) {
18266 af->contrast_af.FullDir = CAM_AFM_POSITIVE_SEARCH;
18267 } else if (s_value == CALIB_SENSOR_AF_DIR_NEGATIVE) {
18268 af->contrast_af.FullDir = CAM_AFM_NEGATIVE_SEARCH;
18269 } else if (s_value == CALIB_SENSOR_AF_DIR_ADAPTIVE) {
18270 af->contrast_af.FullDir = CAM_AFM_ADAPTIVE_SEARCH;
18271 }
18272 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_FULL_RANGE_TBL_TAG_ID)) {
18273 int ArraySize = secsubtag.Size();
18274 af->contrast_af.FullSteps = ArraySize;
18275 int no = ParseUshortArray(psecsubchild, af->contrast_af.FullRangeTbl, ArraySize);
18276 DCT_ASSERT((no == secsubtag.Size()));
18277 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_ADAPTIVE_DIR_TAG_ID)) {
18278 char* value = Toupper(secsubtag.Value());
18279 std::string s_value(value);
18280 if (s_value == CALIB_SENSOR_AF_DIR_POSITIVE) {
18281 af->contrast_af.AdaptiveDir = CAM_AFM_POSITIVE_SEARCH;
18282 } else if (s_value == CALIB_SENSOR_AF_DIR_NEGATIVE) {
18283 af->contrast_af.AdaptiveDir = CAM_AFM_NEGATIVE_SEARCH;
18284 } else if (s_value == CALIB_SENSOR_AF_DIR_ADAPTIVE) {
18285 af->contrast_af.AdaptiveDir = CAM_AFM_ADAPTIVE_SEARCH;
18286 }
18287 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_ADAPTIVE_RANGE_TBL_TAG_ID)) {
18288 int ArraySize = secsubtag.Size();
18289 af->contrast_af.AdaptiveSteps = ArraySize;
18290 int no = ParseUshortArray(psecsubchild, af->contrast_af.AdaptRangeTbl, ArraySize);
18291 DCT_ASSERT((no == secsubtag.Size()));
18292 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_TRIG_THERS_TAG_ID)) {
18293 int no = ParseFloatArray(psecsubchild, &af->contrast_af.TrigThers, secsubtag.Size());
18294 DCT_ASSERT((no == secsubtag.Size()));
18295 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_LUMA_TRIG_THERS_TAG_ID)) {
18296 int no = ParseFloatArray(psecsubchild, &af->contrast_af.LumaTrigThers, secsubtag.Size());
18297 DCT_ASSERT((no == secsubtag.Size()));
18298 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_STABLE_THERS_TAG_ID)) {
18299 int no = ParseFloatArray(psecsubchild, &af->contrast_af.StableThers, secsubtag.Size());
18300 DCT_ASSERT((no == secsubtag.Size()));
18301 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_STABLE_FRAMES_TAG_ID)) {
18302 int no = ParseUshortArray(psecsubchild, &af->contrast_af.StableFrames, secsubtag.Size());
18303 DCT_ASSERT((no == secsubtag.Size()));
18304 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_STABLE_TIME_TAG_ID)) {
18305 int no = ParseUshortArray(psecsubchild, &af->contrast_af.StableTime, secsubtag.Size());
18306 DCT_ASSERT((no == secsubtag.Size()));
18307 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_SCENE_DIFF_ENABLE_TAG_ID)) {
18308 int no = ParseUcharArray(psecsubchild, &af->contrast_af.SceneDiffEnable, secsubtag.Size());
18309 DCT_ASSERT((no == secsubtag.Size()));
18310 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_SCENE_DIFF_THERS_TAG_ID)) {
18311 int no = ParseFloatArray(psecsubchild, &af->contrast_af.SceneDiffThers, secsubtag.Size());
18312 DCT_ASSERT((no == secsubtag.Size()));
18313 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_SCENE_DIFF_BLK_THERS_TAG_ID)) {
18314 int no = ParseUshortArray(psecsubchild, &af->contrast_af.SceneDiffBlkThers, secsubtag.Size());
18315 DCT_ASSERT((no == secsubtag.Size()));
18316 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_CENTER_SCENE_DIFF_THERS_TAG_ID)) {
18317 int no = ParseFloatArray(psecsubchild, &af->contrast_af.CenterSceneDiffThers, secsubtag.Size());
18318 DCT_ASSERT((no == secsubtag.Size()));
18319 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_VALID_MAX_MIN_RATIO_TAG_ID)) {
18320 int no = ParseFloatArray(psecsubchild, &af->contrast_af.ValidMaxMinRatio, secsubtag.Size());
18321 DCT_ASSERT((no == secsubtag.Size()));
18322 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_VALID_VALUE_THERS_TAG_ID)) {
18323 int no = ParseFloatArray(psecsubchild, &af->contrast_af.ValidValueThers, secsubtag.Size());
18324 DCT_ASSERT((no == secsubtag.Size()));
18325 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_OUT_FOCUS_VALUE_TAG_ID)) {
18326 int no = ParseFloatArray(psecsubchild, &af->contrast_af.OutFocusValue, secsubtag.Size());
18327 DCT_ASSERT((no == secsubtag.Size()));
18328 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_OUT_FOCUS_POS_TAG_ID)) {
18329 int no = ParseUshortArray(psecsubchild, &af->contrast_af.OutFocusPos, secsubtag.Size());
18330 DCT_ASSERT((no == secsubtag.Size()));
18331 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_FLAT_VALUE_TAG_ID)) {
18332 int no = ParseFloatArray(psecsubchild, &af->contrast_af.FlatValue, secsubtag.Size());
18333 DCT_ASSERT((no == secsubtag.Size()));
18334 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_WEIGHT_ENABLE_TAG_ID)) {
18335 int no = ParseUcharArray(psecsubchild, &af->contrast_af.WeightEnable, secsubtag.Size());
18336 DCT_ASSERT((no == secsubtag.Size()));
18337 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_WEIGHT_MATRIX_TAG_ID)) {
18338 int no = ParseUshortArray(psecsubchild, af->contrast_af.Weight, secsubtag.Size());
18339 DCT_ASSERT((no == secsubtag.Size()));
18340 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_SEARCH_PAUSE_LUMA_ENABLE_TAG_ID)) {
18341 int no = ParseUcharArray(psecsubchild, &af->contrast_af.SearchPauseLumaEnable, secsubtag.Size());
18342 DCT_ASSERT((no == secsubtag.Size()));
18343 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_SEARCH_PAUSE_LUMA_THERS_TAG_ID)) {
18344 int no = ParseFloatArray(psecsubchild, &af->contrast_af.SearchPauseLumaThers, secsubtag.Size());
18345 DCT_ASSERT((no == secsubtag.Size()));
18346 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_SEARCH_PAUSE_LUMA_STABLE_FRAMES_TAG_ID)) {
18347 int no = ParseUshortArray(psecsubchild, &af->contrast_af.SearchLumaStableFrames, secsubtag.Size());
18348 DCT_ASSERT((no == secsubtag.Size()));
18349 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_SEARCH_PAUSE_LUMA_STABLE_THERS_TAG_ID)) {
18350 int no = ParseFloatArray(psecsubchild, &af->contrast_af.SearchLumaStableThers, secsubtag.Size());
18351 DCT_ASSERT((no == secsubtag.Size()));
18352 }
18353 psecsubchild = psecsubchild->NextSibling();
18354 }
18355
18356 XML_CHECK_END();
18357 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18358 autoTabBackward();
18359 return (true);
18360 }
18361
parseEntrySensorAfLaserAf(const XMLElement * pelement,void * param)18362 bool RkAiqCalibParser::parseEntrySensorAfLaserAf
18363 (
18364 const XMLElement* pelement,
18365 void* param
18366 ) {
18367 (void)param;
18368
18369 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18370 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_AF_t, af);
18371 autoTabForward();
18372
18373 XML_CHECK_START(CALIB_SENSOR_AF_LASER_AF_TAG_ID, CALIB_SENSOR_AF_TAG_ID);
18374
18375 const XMLNode* psecsubchild = pelement->FirstChild();
18376 while (psecsubchild) {
18377 XmlTag secsubtag = XmlTag(psecsubchild->ToElement());
18378 std::string secsubTagname(psecsubchild->ToElement()->Name());
18379 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubtag.Type(), secsubtag.Size());
18380 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_LASERAF_ENABLE_TAG_ID)) {
18381 int no = ParseUcharArray(psecsubchild, &af->laser_af.enable, secsubtag.Size());
18382 DCT_ASSERT((no == secsubtag.Size()));
18383 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_LASER_AF_VCMDOT_TAG_ID)) {
18384 int no = ParseFloatArray(psecsubchild, af->laser_af.vcmDot, secsubtag.Size());
18385 DCT_ASSERT((no == secsubtag.Size()));
18386 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_LASER_AF_DISTANCEDOT_TAG_ID)) {
18387 int no = ParseFloatArray(psecsubchild, af->laser_af.distanceDot, secsubtag.Size());
18388 DCT_ASSERT((no == secsubtag.Size()));
18389 }
18390 psecsubchild = psecsubchild->NextSibling();
18391 }
18392
18393 XML_CHECK_END();
18394 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18395 autoTabBackward();
18396 return (true);
18397 }
18398
parseEntrySensorAfPdaf(const XMLElement * pelement,void * param)18399 bool RkAiqCalibParser::parseEntrySensorAfPdaf
18400 (
18401 const XMLElement* pelement,
18402 void* param
18403 ) {
18404 (void)param;
18405
18406 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18407 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_AF_t, af);
18408 autoTabForward();
18409
18410 XML_CHECK_START(CALIB_SENSOR_AF_PDAF_TAG_ID, CALIB_SENSOR_AF_TAG_ID);
18411
18412 const XMLNode* psecsubchild = pelement->FirstChild();
18413 while (psecsubchild) {
18414 XmlTag secsubtag = XmlTag(psecsubchild->ToElement());
18415 std::string secsubTagname(psecsubchild->ToElement()->Name());
18416 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubtag.Type(), secsubtag.Size());
18417 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_PDAF_ENABLE_TAG_ID)) {
18418 int no = ParseUcharArray(psecsubchild, &af->pdaf.enable, secsubtag.Size());
18419 DCT_ASSERT((no == secsubtag.Size()));
18420 }
18421 psecsubchild = psecsubchild->NextSibling();
18422 }
18423
18424 XML_CHECK_END();
18425 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18426 autoTabBackward();
18427 return (true);
18428 }
18429
parseEntrySensorAfVcmCfg(const XMLElement * pelement,void * param)18430 bool RkAiqCalibParser::parseEntrySensorAfVcmCfg
18431 (
18432 const XMLElement* pelement,
18433 void* param
18434 ) {
18435 (void)param;
18436
18437 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18438 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_AF_t, af);
18439 autoTabForward();
18440
18441 XML_CHECK_START(CALIB_SENSOR_AF_VCM_TAG_ID, CALIB_SENSOR_AF_TAG_ID);
18442
18443 const XMLNode* psecsubchild = pelement->FirstChild();
18444 while (psecsubchild) {
18445 XmlTag secsubtag = XmlTag(psecsubchild->ToElement());
18446 std::string secsubTagname(psecsubchild->ToElement()->Name());
18447 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubtag.Type(), secsubtag.Size());
18448 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_VCM_START_CURRENT_TAG_ID)) {
18449 int no = ParseIntArray(psecsubchild, &af->vcmcfg.start_current, secsubtag.Size());
18450 DCT_ASSERT((no == secsubtag.Size()));
18451 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_VCM_RATED_CURRENT_TAG_ID)) {
18452 int no = ParseIntArray(psecsubchild, &af->vcmcfg.rated_current, secsubtag.Size());
18453 DCT_ASSERT((no == secsubtag.Size()));
18454 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_VCM_STEP_MODE_TAG_ID)) {
18455 int no = ParseIntArray(psecsubchild, &af->vcmcfg.step_mode, secsubtag.Size());
18456 DCT_ASSERT((no == secsubtag.Size()));
18457 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_EXTRA_DELAY_TAG_ID)) {
18458 int no = ParseIntArray(psecsubchild, &af->vcmcfg.extra_delay, secsubtag.Size());
18459 DCT_ASSERT((no == secsubtag.Size()));
18460 }
18461 psecsubchild = psecsubchild->NextSibling();
18462 }
18463
18464 XML_CHECK_END();
18465 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18466 autoTabBackward();
18467 return (true);
18468 }
18469
parseEntrySensorAfMeasISO(const XMLElement * pelement,void * param)18470 bool RkAiqCalibParser::parseEntrySensorAfMeasISO
18471 (
18472 const XMLElement* pelement,
18473 void* param
18474 ) {
18475
18476 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18477
18478 XML_CHECK_START(CALIB_SENSOR_AF_MEAS_ISO_TAG_ID, CALIB_SENSOR_AF_TAG_ID);
18479 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_AF_t, af);
18480
18481 int index = *((int*)param);
18482 const XMLNode* pchild = pelement->FirstChild();
18483 while (pchild) {
18484 XmlTag tag = XmlTag(pchild->ToElement());
18485 const char* value = tag.Value();
18486 std::string tagname(pchild->ToElement()->Name());
18487 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
18488
18489 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_MEAS_ISO_ISO_TAG_ID)) {
18490 int no = ParseIntArray(pchild, &af->measiso_cfg[index].iso, tag.Size());
18491 DCT_ASSERT((no == tag.Size()));
18492 }
18493 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_MEAS_ISO_AFMTHRES_TAG_ID)) {
18494 int no = ParseUshortArray(pchild, &af->measiso_cfg[index].afmThres, tag.Size());
18495 DCT_ASSERT((no == tag.Size()));
18496 }
18497 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_MEAS_ISO_GAMMA_Y_TAG_ID)) {
18498 int no = ParseUshortArray(pchild, af->measiso_cfg[index].gammaY, tag.Size());
18499 DCT_ASSERT((no == tag.Size()));
18500 }
18501 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_MEAS_ISO_GAUSS_WEIGHT_TAG_ID)) {
18502 int no = ParseUcharArray(pchild, af->measiso_cfg[index].gaussWeight, tag.Size());
18503 DCT_ASSERT((no == tag.Size()));
18504 }
18505 pchild = pchild->NextSibling();
18506 }
18507 XML_CHECK_END();
18508 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18509 return (true);
18510 }
18511
parseEntrySensorAfZoomFocusTbl(const XMLElement * pelement,void * param)18512 bool RkAiqCalibParser::parseEntrySensorAfZoomFocusTbl
18513 (
18514 const XMLElement* pelement,
18515 void* param
18516 ) {
18517 (void)param;
18518 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18519 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_AF_t, af);
18520 autoTabForward();
18521 XML_CHECK_START(CALIB_SENSOR_AF_ZOOM_FOCUS_TBL_TAG_ID, CALIB_SENSOR_AF_TAG_ID);
18522 const XMLNode* psecsubchild = pelement->FirstChild();
18523 while (psecsubchild) {
18524 XmlTag secsubtag = XmlTag(psecsubchild->ToElement());
18525 std::string secsubTagname(psecsubchild->ToElement()->Name());
18526 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubtag.Type(), secsubtag.Size());
18527 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_ZOOM_FOCUS_FOCUS_LENGTH_TAG_ID)) {
18528 int no = ParseFloatArray(psecsubchild, af->zoomfocus_tbl.focal_length, secsubtag.Size());
18529 af->zoomfocus_tbl.tbl_len = no;
18530 DCT_ASSERT((no == secsubtag.Size()));
18531 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_ZOOM_FOCUS_ZOOMPOS_TAG_ID)) {
18532 int no = ParseIntArray(psecsubchild, af->zoomfocus_tbl.zoom_pos, secsubtag.Size());
18533 DCT_ASSERT((no == secsubtag.Size()));
18534 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_ZOOM_FOCUS_FOCUSINFPOS_TAG_ID)) {
18535 int no = ParseIntArray(psecsubchild, af->zoomfocus_tbl.focus_infpos, secsubtag.Size());
18536 DCT_ASSERT((no == secsubtag.Size()));
18537 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_ZOOM_FOCUS_FOCUSMACROPOS_TAG_ID)) {
18538 int no = ParseIntArray(psecsubchild, af->zoomfocus_tbl.focus_macropos, secsubtag.Size());
18539 DCT_ASSERT((no == secsubtag.Size()));
18540 }
18541 psecsubchild = psecsubchild->NextSibling();
18542 }
18543 XML_CHECK_END();
18544 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18545 autoTabBackward();
18546 return (true);
18547 }
18548
parseEntrySensorAf(const XMLElement * pelement,void * param)18549 bool RkAiqCalibParser::parseEntrySensorAf
18550 (
18551 const XMLElement* pelement,
18552 void* param
18553 ) {
18554 (void)param;
18555
18556 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18557 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_AF_t, af);
18558 autoTabForward();
18559
18560 XML_CHECK_START(CALIB_SENSOR_AF_TAG_ID, CALIB_SENSOR_TAG_ID);
18561
18562 const XMLNode* pchild = pelement->FirstChild();
18563 af->af_mode = -1;
18564 while (pchild) {
18565 XmlTag tag = XmlTag(pchild->ToElement());
18566 std::string tagname(pchild->ToElement()->Name());
18567 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
18568
18569 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_MODE_TAG_ID)) {
18570 int no = ParseCharArray(pchild, &af->af_mode, tag.Size());
18571 DCT_ASSERT((no == tag.Size()));
18572 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_WINDOW_TAG_ID)) {
18573 if (!parseEntrySensorAfWindow(pchild->ToElement())) {
18574 LOGE("parse error in Af (%s)", tagname.c_str());
18575 return (false);
18576 }
18577 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_FIXED_MODE_TAG_ID)) {
18578 if (!parseEntrySensorAfFixedMode(pchild->ToElement())) {
18579 LOGE("parse error in Af (%s)", tagname.c_str());
18580 return (false);
18581 }
18582 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_MACRO_MODE_TAG_ID)) {
18583 if (!parseEntrySensorAfMacroMode(pchild->ToElement())) {
18584 LOGE("parse error in Af (%s)", tagname.c_str());
18585 return (false);
18586 }
18587 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_INFINITY_MODE_TAG_ID)) {
18588 if (!parseEntrySensorAfInfinityMode(pchild->ToElement())) {
18589 LOGE("parse error in Af (%s)", tagname.c_str());
18590 return (false);
18591 }
18592 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_CONTRAST_AF_TAG_ID)) {
18593 if (!parseEntrySensorAfContrastAf(pchild->ToElement())) {
18594 LOGE("parse error in Af (%s)", tagname.c_str());
18595 return (false);
18596 }
18597 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_LASER_AF_TAG_ID)) {
18598 if (!parseEntrySensorAfLaserAf(pchild->ToElement())) {
18599 LOGE("parse error in Af (%s)", tagname.c_str());
18600 return (false);
18601 }
18602 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_PDAF_TAG_ID)) {
18603 if (!parseEntrySensorAfPdaf(pchild->ToElement())) {
18604 LOGE("parse error in Af (%s)", tagname.c_str());
18605 return (false);
18606 }
18607 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_VCM_TAG_ID)) {
18608 if (!parseEntrySensorAfVcmCfg(pchild->ToElement())) {
18609 LOGE("parse error in Af (%s)", tagname.c_str());
18610 return (false);
18611 }
18612 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_MEAS_ISO_TAG_ID)) {
18613 if (!parseEntryCell(pchild->ToElement(), tag.Size(),
18614 &RkAiqCalibParser::parseEntrySensorAfMeasISO,
18615 param,
18616 (uint32_t)CALIB_SENSOR_AF_MEAS_ISO_TAG_ID,
18617 (uint32_t)CALIB_SENSOR_AF_TAG_ID)) {
18618 LOGE("parse error in Af meas_iso (%s)", tagname.c_str());
18619 return (false);
18620 }
18621 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_AF_ZOOM_FOCUS_TBL_TAG_ID)) {
18622 if (!parseEntrySensorAfZoomFocusTbl(pchild->ToElement())) {
18623 LOGE("parse error in Af (%s)", tagname.c_str());
18624 return (false);
18625 }
18626 }
18627 pchild = pchild->NextSibling();
18628 }
18629 XML_CHECK_END();
18630 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18631 autoTabBackward();
18632 return (true);
18633 }
18634
parseEntrySensorLdch(const XMLElement * pelement,void * param)18635 bool RkAiqCalibParser::parseEntrySensorLdch
18636 (
18637 const XMLElement* pelement,
18638 void* param
18639 ) {
18640 (void)param;
18641
18642 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18643 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_LDCH_t, aldch);
18644 autoTabForward();
18645
18646 XML_CHECK_START(CALIB_SENSOR_LDCH_TAG_ID, CALIB_SENSOR_TAG_ID);
18647
18648 const XMLNode* pchild = pelement->FirstChild();
18649 while (pchild) {
18650 XmlTag tag = XmlTag(pchild->ToElement());
18651 std::string tagname(pchild->ToElement()->Name());
18652 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
18653 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LDCH_ENABLE_TAG_ID)) {
18654 int no = ParseUcharArray(pchild, &aldch->ldch_en, tag.Size());
18655 DCT_ASSERT((no == tag.Size()));
18656 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LDCH_MESH_FILE_TAG_ID)) {
18657 char mesh_filename[256];
18658 ParseString(pchild, aldch->meshfile, sizeof(mesh_filename));
18659 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LDCH_CORRECT_LEVEL_TAG_ID)) {
18660 int no = ParseIntArray(pchild, &aldch->correct_level, tag.Size());
18661 DCT_ASSERT((no == tag.Size()));
18662 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LDCH_CORRECT_LEVEL_MAX_TAG_ID)) {
18663 int no = ParseIntArray(pchild, &aldch->correct_level_max, tag.Size());
18664 DCT_ASSERT((no == tag.Size()));
18665 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LDCH_LIGHT_CENTER_TAG_ID)) {
18666 int no = ParseDoubleArray(pchild, aldch->light_center, tag.Size());
18667 DCT_ASSERT((no == tag.Size()));
18668 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LDCH_DISTORTION_COEFF_ID)) {
18669 int no = ParseDoubleArray(pchild, aldch->coefficient, tag.Size());
18670 DCT_ASSERT((no == tag.Size()));
18671 }
18672 pchild = pchild->NextSibling();
18673 }
18674 XML_CHECK_END();
18675 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18676 autoTabBackward();
18677 return (true);
18678 }
18679
parseEntrySensorLumaDetect(const XMLElement * pelement,void * param)18680 bool RkAiqCalibParser::parseEntrySensorLumaDetect
18681 (
18682 const XMLElement* pelement,
18683 void* param
18684 ) {
18685 (void)param;
18686
18687 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18688 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_LUMA_DETECT_t, lumaDetect);
18689 autoTabForward();
18690
18691 XML_CHECK_START(CALIB_SENSOR_LUMA_DETECT_TAG_ID, CALIB_SENSOR_TAG_ID);
18692
18693 const XMLNode* pchild = pelement->FirstChild();
18694 while (pchild) {
18695 XmlTag tag = XmlTag(pchild->ToElement());
18696 std::string tagname(pchild->ToElement()->Name());
18697 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
18698 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LUMA_DETECT_ENABLE_TAG_ID)) {
18699 int no = ParseUcharArray(pchild, &lumaDetect->luma_detect_en, tag.Size());
18700 DCT_ASSERT((no == tag.Size()));
18701 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LUMA_DETECT_FIXED_TIMES_TAG_ID)) {
18702 int no = ParseIntArray(pchild, &lumaDetect->fixed_times, tag.Size());
18703 DCT_ASSERT((no == tag.Size()));
18704 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LUMA_DETECT_THRESHOLD_TAG_ID)) {
18705 int no = ParseFloatArray(pchild, &lumaDetect->mutation_threshold, tag.Size());
18706 DCT_ASSERT((no == tag.Size()));
18707 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_LUMA_DETECT_THRESHOLD_LEVEL2_TAG_ID)) {
18708 int no = ParseFloatArray(pchild, &lumaDetect->mutation_threshold_level2, tag.Size());
18709 DCT_ASSERT((no == tag.Size()));
18710 }
18711 pchild = pchild->NextSibling();
18712 }
18713 XML_CHECK_END();
18714 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18715 autoTabBackward();
18716 return (true);
18717 }
18718
parseEntrySensorFec(const XMLElement * pelement,void * param)18719 bool RkAiqCalibParser::parseEntrySensorFec
18720 (
18721 const XMLElement* pelement,
18722 void* param
18723 ) {
18724 (void)param;
18725
18726 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18727 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_FEC_t, afec);
18728 autoTabForward();
18729
18730 XML_CHECK_START(CALIB_SENSOR_FEC_TAG_ID, CALIB_SENSOR_TAG_ID);
18731
18732 const XMLNode* pchild = pelement->FirstChild();
18733 while (pchild) {
18734 XmlTag tag = XmlTag(pchild->ToElement());
18735 std::string tagname(pchild->ToElement()->Name());
18736 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
18737
18738 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_FEC_ENABLE_TAG_ID)) {
18739 int no = ParseUcharArray(pchild, &afec->fec_en, tag.Size());
18740 DCT_ASSERT((no == tag.Size()));
18741 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_FEC_MESH_FILE_TAG_ID)) {
18742 char mesh_filename[256];
18743 ParseString(pchild, afec->meshfile, sizeof(mesh_filename));
18744 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_FEC_CORRECT_LEVEL_TAG_ID)) {
18745 int no = ParseIntArray(pchild, &afec->correct_level, tag.Size());
18746 DCT_ASSERT((no == tag.Size()));
18747 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_FEC_LIGHT_CENTER_TAG_ID)) {
18748 int no = ParseDoubleArray(pchild, afec->light_center, tag.Size());
18749 DCT_ASSERT((no == tag.Size()));
18750 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_FEC_DISTORTION_COEFF_ID)) {
18751 int no = ParseDoubleArray(pchild, afec->coefficient, tag.Size());
18752 DCT_ASSERT((no == tag.Size()));
18753 }
18754 pchild = pchild->NextSibling();
18755 }
18756 XML_CHECK_END();
18757 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18758 autoTabBackward();
18759 return (true);
18760 }
18761
parseEntrySensorEis(const XMLElement * pelement,void * param)18762 bool RkAiqCalibParser::parseEntrySensorEis
18763 (
18764 const XMLElement* pelement,
18765 void* param
18766 ) {
18767 (void)pelement;
18768 (void)param;
18769
18770 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18771 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_EIS_t, aeis);
18772 autoTabForward();
18773
18774 XML_CHECK_START(CALIB_SENSOR_EIS_TAG_ID, CALIB_SENSOR_TAG_ID);
18775
18776 const XMLNode* pchild = pelement->FirstChild();
18777 while (pchild) {
18778 XmlTag tag = XmlTag(pchild->ToElement());
18779 std::string tagname(pchild->ToElement()->Name());
18780 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
18781
18782 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_EIS_ENABLE_TAG_ID)) {
18783 int no = ParseUcharArray(pchild, &aeis->eis_en, tag.Size());
18784 DCT_ASSERT((no == tag.Size()));
18785 }
18786 pchild = pchild->NextSibling();
18787 }
18788 XML_CHECK_END();
18789 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18790 autoTabBackward();
18791 return (true);
18792 }
18793
parseEntrySensorOrb(const XMLElement * pelement,void * param)18794 bool RkAiqCalibParser::parseEntrySensorOrb
18795 (
18796 const XMLElement* pelement,
18797 void* param
18798 ) {
18799 (void)param;
18800
18801 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18802 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ORB_t, orb);
18803 autoTabForward();
18804
18805 XML_CHECK_START(CALIB_SENSOR_ORB_TAG_ID, CALIB_SENSOR_TAG_ID);
18806
18807 const XMLNode* pchild = pelement->FirstChild();
18808 while (pchild) {
18809 XmlTag tag = XmlTag(pchild->ToElement());
18810 std::string tagname(pchild->ToElement()->Name());
18811 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
18812 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_ORB_ENABLE_TAG_ID)) {
18813 int no = ParseUcharArray(pchild, &orb->orb_en, tag.Size());
18814 DCT_ASSERT((no == tag.Size()));
18815 }
18816 pchild = pchild->NextSibling();
18817 }
18818 XML_CHECK_END();
18819 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18820 autoTabBackward();
18821 return (true);
18822 }
18823
parseEntrySensorCpsl(const XMLElement * pelement,void * param)18824 bool RkAiqCalibParser::parseEntrySensorCpsl
18825 (
18826 const XMLElement* pelement,
18827 void* param
18828 ) {
18829 (void)param;
18830
18831 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18832 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Cpsl_t, cpsl);
18833 autoTabForward();
18834
18835 XML_CHECK_START(CALIB_SENSOR_CPSL_TAG_ID, CALIB_SENSOR_TAG_ID);
18836
18837 const XMLNode* pchild = pelement->FirstChild();
18838 while (pchild) {
18839 XmlTag tag = XmlTag(pchild->ToElement());
18840 std::string tagname(pchild->ToElement()->Name());
18841 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
18842 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPSL_ENABLE_TAG_ID)) {
18843 int no = ParseUcharArray(pchild, &cpsl->support_en, tag.Size());
18844 DCT_ASSERT((no == tag.Size()));
18845 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPSL_MODE_TAG_ID)) {
18846 int no = ParseIntArray(pchild, &cpsl->mode, tag.Size());
18847 DCT_ASSERT((no == tag.Size()));
18848 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPSL_FORCE_GRAY_TAG_ID)) {
18849 int no = ParseUcharArray(pchild, &cpsl->gray, tag.Size());
18850 DCT_ASSERT((no == tag.Size()));
18851 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPSL_LGHT_SRC_TAG_ID)) {
18852 int no = ParseIntArray(pchild, &cpsl->lght_src, tag.Size());
18853 DCT_ASSERT((no == tag.Size()));
18854 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPSL_AUTO_ADJUST_SENS_TAG_ID)) {
18855 int no = ParseFloatArray(pchild, &cpsl->ajust_sens, tag.Size());
18856 DCT_ASSERT((no == tag.Size()));
18857 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPSL_AUTO_ON2OFF_TH_TAG_ID)) {
18858 int no = ParseUintArray(pchild, &cpsl->on2off_th, tag.Size());
18859 DCT_ASSERT((no == tag.Size()));
18860 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPSL_AUTO_OFF2ON_TH_TAG_ID)) {
18861 int no = ParseUintArray(pchild, &cpsl->off2on_th, tag.Size());
18862 DCT_ASSERT((no == tag.Size()));
18863 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPSL_AUTO_SW_INTERVAL_TAG_ID)) {
18864 int no = ParseUintArray(pchild, &cpsl->sw_interval, tag.Size());
18865 DCT_ASSERT((no == tag.Size()));
18866 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPSL_MANUAL_ON_TAG_ID)) {
18867 int no = ParseUcharArray(pchild, &cpsl->cpsl_on, tag.Size());
18868 DCT_ASSERT((no == tag.Size()));
18869 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPSL_MANUAL_STRENGTH_TAG_ID)) {
18870 int no = ParseFloatArray(pchild, &cpsl->strength, tag.Size());
18871 DCT_ASSERT((no == tag.Size()));
18872 }
18873 pchild = pchild->NextSibling();
18874 }
18875 XML_CHECK_END();
18876 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18877
18878 autoTabBackward();
18879 return (true);
18880 }
18881
parseEntrySensorColorAsGrey(const XMLElement * pelement,void * param)18882 bool RkAiqCalibParser::parseEntrySensorColorAsGrey
18883 (
18884 const XMLElement* pelement,
18885 void* param
18886 ) {
18887 (void)param;
18888
18889 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18890 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ColorAsGrey_t, colorAsGrey);
18891 autoTabForward();
18892 XML_CHECK_START(CALIB_SENSOR_COLOR_AS_GREY_TAG_ID, CALIB_SENSOR_TAG_ID);
18893 const XMLNode* pchild = pelement->FirstChild();
18894 while (pchild) {
18895 XmlTag tag = XmlTag(pchild->ToElement());
18896 std::string tagname(pchild->ToElement()->Name());
18897 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
18898 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_COLOR_AS_GREY_ENABLE_TAG_ID)) {
18899 int no = ParseIntArray(pchild, &colorAsGrey->enable, tag.Size());
18900 DCT_ASSERT((no == tag.Size()));
18901 }
18902 pchild = pchild->NextSibling();
18903 }
18904 XML_CHECK_END();
18905 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18906 autoTabBackward();
18907 return (true);
18908 }
18909
parseEntryBayernrV2Setting_2D(const XMLElement * pelement,void * param,int index)18910 bool RkAiqCalibParser::parseEntryBayernrV2Setting_2D
18911 (
18912 const XMLElement* pelement,
18913 void* param,
18914 int index
18915 )
18916 {
18917 (void)param;
18918
18919 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18920
18921 XML_CHECK_START(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_SETTING_TAG_ID, CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_TAG_ID);
18922 CALIBDB_MODULE_PTR_HELPER_RET(list_head, list_bayernr_v2);
18923
18924 CalibDb_Bayernr_V2_t *pProfile = (CalibDb_Bayernr_V2_t *)param;
18925 Calibdb_Bayernr_2Dparams_V2_t *pParam = (Calibdb_Bayernr_2Dparams_V2_t *)malloc(sizeof(Calibdb_Bayernr_2Dparams_V2_t));
18926 if(NULL == pParam) {
18927 LOGE("%s(%d): malloc fail(exit)\n", __FUNCTION__, __LINE__);
18928 return false;
18929 }
18930 memset(pParam, 0x00, sizeof(Calibdb_Bayernr_2Dparams_V2_t));
18931
18932 const XMLNode* pchild = pelement->FirstChild();
18933 while (pchild) {
18934 XmlTag tag = XmlTag(pchild->ToElement());
18935 std::string tagname(pchild->ToElement()->Name());
18936 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
18937
18938 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_SNR_MODE_TAG_ID)) {
18939 ParseString(pchild, pParam->snr_mode, sizeof(pParam->snr_mode));
18940 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_SENSOR_MODE_TAG_ID)) {
18941 ParseString(pchild, pParam->sensor_mode, sizeof(pParam->sensor_mode));
18942 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_ISO_TAG_ID)) {
18943 int no = ParseFloatArray(pchild, pParam->iso, tag.Size());
18944 DCT_ASSERT((no == tag.Size()));
18945 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_FILTER_STRENGTH_TAG_ID)) {
18946 int no = ParseFloatArray(pchild, pParam->bayernrv2_filter_strength_r, tag.Size());
18947 DCT_ASSERT((no == tag.Size()));
18948 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_GAUSS_GUIDE_TAG_ID)) {
18949 int no = ParseIntArray(pchild, pParam->bayernrv2_gauss_guide_r, tag.Size());
18950 DCT_ASSERT((no == tag.Size()));
18951 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_LUMA_POINT_TAG_ID)) {
18952 int no = ParseIntArray(pchild, pParam->bayernrv2_filter_lumapoint_r, tag.Size());
18953 DCT_ASSERT((no == tag.Size()));
18954 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_SIGMA_TAG_ID)) {
18955 int no = ParseIntArray(pchild, (int *)pParam->bayernrv2_filter_sigma_r, tag.Size());
18956 DCT_ASSERT((no == tag.Size()));
18957 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_EDGESOFTS_TAG_ID)) {
18958 int no = ParseFloatArray(pchild, pParam->bayernrv2_filter_edgesofts_r, tag.Size());
18959 DCT_ASSERT((no == tag.Size()));
18960 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_RATIO_TAG_ID)) {
18961 int no = ParseFloatArray(pchild, pParam->bayernrv2_filter_soft_threshold_ratio_r, tag.Size());
18962 DCT_ASSERT((no == tag.Size()));
18963 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_WEIGHT_TAG_ID)) {
18964 int no = ParseFloatArray(pchild, pParam->bayernrv2_filter_out_wgt_r, tag.Size());
18965 DCT_ASSERT((no == tag.Size()));
18966 }
18967
18968 pchild = pchild->NextSibling();
18969 }
18970 XML_CHECK_END();
18971
18972 if (pParam) {
18973 list_prepare_item(&pParam->listItem);
18974 list_add_tail(&pParam->listItem, &pProfile->st2DParams.listHead);
18975 }
18976
18977 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
18978 return (true);
18979 }
18980
18981
parseEntryBayernrV2Setting_3D(const XMLElement * pelement,void * param,int index)18982 bool RkAiqCalibParser::parseEntryBayernrV2Setting_3D
18983 (
18984 const XMLElement* pelement,
18985 void* param,
18986 int index
18987 )
18988 {
18989 (void)param;
18990
18991 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
18992
18993 XML_CHECK_START(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_SETTING_TAG_ID, CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_TAG_ID);
18994
18995 CalibDb_Bayernr_V2_t *pProfile = (CalibDb_Bayernr_V2_t *)param;
18996 CalibDb_Bayernr_3DParams_V2_t *pParam = (CalibDb_Bayernr_3DParams_V2_t *)malloc(sizeof(CalibDb_Bayernr_3DParams_V2_t));
18997 if(NULL == pParam) {
18998 LOGE("%s(%d): malloc fail(exit)\n", __FUNCTION__, __LINE__);
18999 return false;
19000 }
19001 memset(pParam, 0x00, sizeof(CalibDb_Bayernr_3DParams_V2_t));
19002
19003 const XMLNode* pchild = pelement->FirstChild();
19004 while (pchild) {
19005 XmlTag tag = XmlTag(pchild->ToElement());
19006 std::string tagname(pchild->ToElement()->Name());
19007 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
19008
19009 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_SNR_MODE_TAG_ID)) {
19010 ParseString(pchild, pParam->snr_mode, sizeof(pParam->snr_mode));
19011 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_SENSOR_MODE_TAG_ID)) {
19012 ParseString(pchild, pParam->sensor_mode, sizeof(pParam->sensor_mode));
19013 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_ISO_TAG_ID)) {
19014 int no = ParseFloatArray(pchild, pParam->iso, tag.Size());
19015 DCT_ASSERT((no == tag.Size()));
19016 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_FILTER_STRENGTH_TAG_ID)) {
19017 int no = ParseFloatArray(pchild, pParam->bayernrv2_tnr_filter_strength_r, tag.Size());
19018 DCT_ASSERT((no == tag.Size()));
19019 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_SP_FILTER_STRENGTH_TAG_ID)) {
19020 int no = ParseFloatArray(pchild, pParam->bayernrv2_tnr_sp_filter_strength_r, tag.Size());
19021 DCT_ASSERT((no == tag.Size()));
19022 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_LO_CLIPWGT_TAG_ID)) {
19023 int no = ParseFloatArray(pchild, pParam->bayernrv2_tnr_lo_clipwgt_r, tag.Size());
19024 DCT_ASSERT((no == tag.Size()));
19025 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_HI_CLIPWGT_TAG_ID)) {
19026 int no = ParseFloatArray(pchild, pParam->bayernrv2_tnr_hi_clipwgt_r, tag.Size());
19027 DCT_ASSERT((no == tag.Size()));
19028 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_SOFTWGT_TAG_ID)) {
19029 int no = ParseFloatArray(pchild, pParam->bayernrv2_tnr_softwgt_r, tag.Size());
19030 DCT_ASSERT((no == tag.Size()));
19031 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_LUMA_POINT_TAG_ID)) {
19032 int no = ParseIntArray(pchild, pParam->bayernrv2_lumapoint_r, tag.Size());
19033 DCT_ASSERT((no == tag.Size()));
19034 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_SIGMA_TAG_ID)) {
19035 int no = ParseIntArray(pchild, (int *)pParam->bayernrv2_sigma_r, tag.Size());
19036 DCT_ASSERT((no == tag.Size()));
19037 }
19038
19039 pchild = pchild->NextSibling();
19040 }
19041 XML_CHECK_END();
19042
19043 if (pParam) {
19044 list_prepare_item(&pParam->listItem);
19045 list_add_tail(&pParam->listItem, &pProfile->st3DParams.listHead);
19046 }
19047 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19048 return (true);
19049 }
19050
parseEntrySensorBayernrV2Setting2D(const XMLElement * pelement,void * param)19051 bool RkAiqCalibParser::parseEntrySensorBayernrV2Setting2D
19052 (
19053 const XMLElement* pelement,
19054 void* param
19055 ) {
19056 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19057 autoTabForward();
19058
19059 XML_CHECK_START(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_TAG_ID, CALIB_SENSOR_BAYERNR_V2_TAG_ID);
19060
19061 CalibDb_Bayernr_V2_t *pBayernrProfile = (CalibDb_Bayernr_V2_t *)param;
19062
19063 const XMLNode* psubchild = pelement->FirstChild();
19064
19065 while (psubchild) {
19066 XmlTag subTag = XmlTag(psubchild->ToElement());
19067 std::string subTagname(psubchild->ToElement()->Name());
19068 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
19069 #ifdef DEBUG_LOG
19070 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
19071 #endif
19072 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_ENABLE_TAG_ID)) {
19073 int no = ParseIntArray(psubchild, &pBayernrProfile->st2DParams.bayernrv2_2dnr_enable, subTag.Size());
19074 DCT_ASSERT((no == subTag.Size()));
19075 }
19076 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_SETTING_TAG_ID)) {
19077 if (!parseEntryCell2(psubchild->ToElement(), subTag.Size(),
19078 &RkAiqCalibParser::parseEntryBayernrV2Setting_2D,
19079 param,
19080 (uint32_t)CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_SETTING_TAG_ID,
19081 (uint32_t)CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_TAG_ID)) {
19082 LOGE("parse error in bayernrV2 setting (%s)", subTagname.c_str());
19083 return (false);
19084 }
19085 }
19086 else {
19087 LOGE("%s(%d): parse error in stManual (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
19088 }
19089 psubchild = psubchild->NextSibling();
19090 }
19091
19092 XML_CHECK_END();
19093 autoTabBackward();
19094 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19095 return (true);
19096 }
19097
parseEntrySensorBayernrV2Setting3D(const XMLElement * pelement,void * param)19098 bool RkAiqCalibParser::parseEntrySensorBayernrV2Setting3D
19099 (
19100 const XMLElement* pelement,
19101 void* param
19102 ) {
19103 LOGD("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19104 autoTabForward();
19105
19106 XML_CHECK_START(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_TAG_ID, CALIB_SENSOR_BAYERNR_V2_TAG_ID);
19107
19108 CalibDb_Bayernr_V2_t *pBayernrProfile = (CalibDb_Bayernr_V2_t *)param;
19109
19110 const XMLNode* psubchild = pelement->FirstChild();
19111
19112 while (psubchild) {
19113 XmlTag subTag = XmlTag(psubchild->ToElement());
19114 std::string subTagname(psubchild->ToElement()->Name());
19115 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
19116 #ifdef DEBUG_LOG
19117 LOGE("%s(%d): subTagname = %s\n", __FUNCTION__, __LINE__, subTagname.c_str());
19118 #endif
19119 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_ENABLE_TAG_ID)) {
19120 int no = ParseIntArray(psubchild, &pBayernrProfile->st3DParams.bayernrv2_tnr_enable, subTag.Size());
19121 DCT_ASSERT((no == subTag.Size()));
19122 }
19123 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_SETTING_TAG_ID)) {
19124 if (!parseEntryCell2(psubchild->ToElement(), subTag.Size(),
19125 &RkAiqCalibParser::parseEntryBayernrV2Setting_3D,
19126 param,
19127 (uint32_t)CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_SETTING_TAG_ID,
19128 (uint32_t)CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_TAG_ID)) {
19129 LOGE("parse error in bayernrV2 setting (%s)", subTagname.c_str());
19130 return (false);
19131 }
19132 }
19133 else {
19134 LOGE("%s(%d): parse error in stManual (unknow tag: %s )\n", __FUNCTION__, __LINE__, subTagname.c_str());
19135 }
19136 psubchild = psubchild->NextSibling();
19137 }
19138
19139 XML_CHECK_END();
19140 autoTabBackward();
19141 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19142 return (true);
19143 }
19144
19145
parseEntrySensorBayernrV2(const XMLElement * pelement,void * param)19146 bool RkAiqCalibParser::parseEntrySensorBayernrV2
19147 (
19148 const XMLElement* pelement,
19149 void* param
19150 ) {
19151 (void)param;
19152
19153 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19154 CALIBDB_MODULE_PTR_HELPER_RET(list_head, list_bayernr_v2);
19155 autoTabForward();
19156 XML_CHECK_START(CALIB_SENSOR_BAYERNR_V2_TAG_ID, CALIB_SENSOR_TAG_ID);
19157 const XMLNode* pchild = pelement->FirstChild();
19158 CalibDb_Bayernr_V2_t *pBayernrProfile = (CalibDb_Bayernr_V2_t *)malloc(sizeof(CalibDb_Bayernr_V2_t));
19159 if(NULL == pBayernrProfile) {
19160 LOGE("%s(%d): malloc fail(exit)\n", __FUNCTION__, __LINE__);
19161 return false;
19162 }
19163 memset(pBayernrProfile, 0x00, sizeof(CalibDb_Bayernr_V2_t));
19164 INIT_LIST_HEAD(&pBayernrProfile->st2DParams.listHead);
19165 INIT_LIST_HEAD(&pBayernrProfile->st3DParams.listHead);
19166
19167 while (pchild) {
19168 XmlTag tag = XmlTag(pchild->ToElement());
19169 std::string tagname(pchild->ToElement()->Name());
19170 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
19171 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_MODE_NAME_TAG_ID)) {
19172 ParseString(pchild, pBayernrProfile->modeName, sizeof(pBayernrProfile->modeName));
19173 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR2D_TAG_ID)) {
19174 if (!parseEntrySensorBayernrV2Setting2D(pchild->ToElement(), (void *)pBayernrProfile)) {
19175 LOGE("parse error in bayernr 2D param (%s)", tagname.c_str());
19176 return (false);
19177 }
19178 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_BAYERNR_V2_BAYERNR3D_TAG_ID)) {
19179 if (!parseEntrySensorBayernrV2Setting3D(pchild->ToElement(), (void *)pBayernrProfile)) {
19180 LOGE("parse error in bayernr 3D param (%s)", tagname.c_str());
19181 return (false);
19182 }
19183 }
19184 pchild = pchild->NextSibling();
19185 }
19186 XML_CHECK_END();
19187
19188 bool result = CamCalibdbAddBayernrV2Profile(list_bayernr_v2, pBayernrProfile);
19189 DCT_ASSERT(result == true);
19190
19191 // free linked ecm_schemes
19192 struct list_head* l_2d = pBayernrProfile->st2DParams.listHead.next;
19193 while (l_2d != &pBayernrProfile->st2DParams.listHead) {
19194 struct list_head* temp = l_2d->next;
19195 Calibdb_Bayernr_2Dparams_V2_t *pTempParam = container_of(l_2d, Calibdb_Bayernr_2Dparams_V2_t, listItem);
19196 list_del(l_2d);
19197 free(pTempParam);
19198 l_2d = temp;
19199 }
19200
19201 struct list_head* l_3d = pBayernrProfile->st3DParams.listHead.next;
19202 while (l_3d != &pBayernrProfile->st3DParams.listHead) {
19203 struct list_head* temp = l_3d->next;
19204 CalibDb_Bayernr_3DParams_V2_t *pTempParam = container_of(l_3d, CalibDb_Bayernr_3DParams_V2_t, listItem);
19205 list_del(l_3d);
19206 free(pTempParam);
19207 l_3d = temp;
19208 }
19209
19210 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19211 autoTabBackward();
19212 return (true);
19213 }
19214
19215
parseEntryYnrV2Setting(const XMLElement * pelement,void * param,int index)19216 bool RkAiqCalibParser::parseEntryYnrV2Setting
19217 (
19218 const XMLElement* pelement,
19219 void* param,
19220 int index
19221 )
19222 {
19223 (void)param;
19224
19225 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19226
19227 XML_CHECK_START(CALIB_SENSOR_YNR_V2_SETTING_TAG_ID, CALIB_SENSOR_YNR_V2_TAG_ID);
19228
19229 Calibdb_Ynr_V2_t *pProfile = (Calibdb_Ynr_V2_t *)param;
19230 Calibdb_Ynr_params_V2_t *pParam = (Calibdb_Ynr_params_V2_t *)malloc(sizeof(Calibdb_Ynr_params_V2_t));
19231 if(NULL == pParam) {
19232 LOGE("%s(%d): malloc fail(exit)\n", __FUNCTION__, __LINE__);
19233 return false;
19234 }
19235 memset(pParam, 0x00, sizeof(Calibdb_Ynr_params_V2_t));
19236
19237 const XMLNode* pchild = pelement->FirstChild();
19238 while (pchild) {
19239 XmlTag tag = XmlTag(pchild->ToElement());
19240 std::string tagname(pchild->ToElement()->Name());
19241 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
19242
19243 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_SNR_MODE_TAG_ID)) {
19244 ParseString(pchild, pParam->snr_mode, sizeof(pParam->snr_mode));
19245 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_SENSOR_MODE_TAG_ID)) {
19246 ParseString(pchild, pParam->sensor_mode, sizeof(pParam->sensor_mode));
19247 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_ISO_TAG_ID)) {
19248 int no = ParseFloatArray(pchild, pParam->iso, tag.Size());
19249 DCT_ASSERT((no == tag.Size()));
19250 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_BFT3X3_BYPASS_TAG_ID)) {
19251 int no = ParseIntArray(pchild, pParam->ynr_bft3x3_bypass_V2, tag.Size());
19252 DCT_ASSERT((no == tag.Size()));
19253 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_LBFT5X5_BYPASS_TAG_ID)) {
19254 int no = ParseIntArray(pchild, pParam->ynr_lbft5x5_bypass_V2, tag.Size());
19255 DCT_ASSERT((no == tag.Size()));
19256 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_LGFT3X3_BYPASS_TAG_ID)) {
19257 int no = ParseIntArray(pchild, pParam->ynr_lgft3x3_bypass_V2, tag.Size());
19258 DCT_ASSERT((no == tag.Size()));
19259 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_FLT1X1_BYPASS_TAG_ID)) {
19260 int no = ParseIntArray(pchild, pParam->ynr_flt1x1_bypass_V2, tag.Size());
19261 DCT_ASSERT((no == tag.Size()));
19262 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_SFT5X5_BYPASS_TAG_ID)) {
19263 int no = ParseIntArray(pchild, pParam->ynr_sft5x5_bypass_V2, tag.Size());
19264 DCT_ASSERT((no == tag.Size()));
19265 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_RNR_STRENGTH_TAG_ID)) {
19266 int no = ParseFloatArray(pchild, (float *)pParam->ynr_rnr_strength_V2, tag.Size());
19267 DCT_ASSERT((no == tag.Size()));
19268 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_SIGMA_CURVE_TAG_ID)) {
19269 int no = ParseFloatArray(pchild, (float *)pParam->sigmaCurve, tag.Size());
19270 DCT_ASSERT((no == tag.Size()));
19271 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_YNR_CI_TAG_ID)) {
19272 int no = ParseFloatArray(pchild, (float *)pParam->ciISO_V2, tag.Size());
19273 DCT_ASSERT((no == tag.Size()));
19274 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_LOW_BF_TAG_ID)) {
19275 int no = ParseFloatArray(pchild, (float *)pParam->ynr_low_bf_V2, tag.Size());
19276 DCT_ASSERT((no == tag.Size()));
19277 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_LOW_THRED_ADJ_TAG_ID)) {
19278 int no = ParseFloatArray(pchild, pParam->ynr_low_thred_adj_V2, tag.Size());
19279 DCT_ASSERT((no == tag.Size()));
19280 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_LOW_PEAK_SUPRESS_TAG_ID)) {
19281 int no = ParseFloatArray(pchild, pParam->ynr_low_peak_supress_V2, tag.Size());
19282 DCT_ASSERT((no == tag.Size()));
19283 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_LOW_EDGE_ADJ_THRESH_TAG_ID)) {
19284 int no = ParseFloatArray(pchild, pParam->ynr_low_edge_adj_thresh_V2, tag.Size());
19285 DCT_ASSERT((no == tag.Size()));
19286 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_LOW_CENTRE_WEIGHT_TAG_ID)) {
19287 int no = ParseFloatArray(pchild, pParam->ynr_low_center_weight_V2, tag.Size());
19288 DCT_ASSERT((no == tag.Size()));
19289 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_LOW_DIST_ADJ_TAG_ID)) {
19290 int no = ParseFloatArray(pchild, pParam->ynr_low_dist_adj_V2, tag.Size());
19291 DCT_ASSERT((no == tag.Size()));
19292 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_LOW_WEIGHT_TAG_ID)) {
19293 int no = ParseFloatArray(pchild, pParam->ynr_low_weight_V2, tag.Size());
19294 DCT_ASSERT((no == tag.Size()));
19295 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_LOW_FILT_STRENGTH_TAG_ID)) {
19296 int no = ParseFloatArray(pchild, (float *)pParam->ynr_low_filt_strength_V2, tag.Size());
19297 DCT_ASSERT((no == tag.Size()));
19298 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_LOW_BI_WEIGHT_TAG_ID)) {
19299 int no = ParseFloatArray(pchild, pParam->ynr_low_bi_weight_V2, tag.Size());
19300 DCT_ASSERT((no == tag.Size()));
19301 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_BASE_FILT_WEIGHT_TAG_ID)) {
19302 int no = ParseFloatArray(pchild, (float *)pParam->ynr_base_filter_weight_V2, tag.Size());
19303 DCT_ASSERT((no == tag.Size()));
19304 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_HIGH_THRED_ADJ_TAG_ID)) {
19305 int no = ParseFloatArray(pchild, pParam->ynr_high_thred_adj_V2, tag.Size());
19306 DCT_ASSERT((no == tag.Size()));
19307 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_HIGH_WEIGHT_TAG_ID)) {
19308 int no = ParseFloatArray(pchild, pParam->ynr_high_weight_V2, tag.Size());
19309 DCT_ASSERT((no == tag.Size()));
19310 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_HIGH_DIRECTION_WEIGHT_TAG_ID)) {
19311 int no = ParseFloatArray(pchild, (float *)pParam->ynr_direction_weight_V2, tag.Size());
19312 DCT_ASSERT((no == tag.Size()));
19313 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_HI_MIN_ADJ_TAG_ID)) {
19314 int no = ParseFloatArray(pchild, pParam->ynr_hi_min_adj_V2, tag.Size());
19315 DCT_ASSERT((no == tag.Size()));
19316 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_HI_EDGE_THRED_TAG_ID)) {
19317 int no = ParseFloatArray(pchild, pParam->ynr_hi_edge_thed_V2, tag.Size());
19318 DCT_ASSERT((no == tag.Size()));
19319 }
19320
19321 pchild = pchild->NextSibling();
19322 }
19323 XML_CHECK_END();
19324
19325 if (pParam) {
19326 list_prepare_item(&pParam->listItem);
19327 list_add_tail(&pParam->listItem, &pProfile->listHead);
19328 }
19329 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19330 return (true);
19331 }
19332
parseEntrySensorYnrV2(const XMLElement * pelement,void * param)19333 bool RkAiqCalibParser::parseEntrySensorYnrV2
19334 (
19335 const XMLElement* pelement,
19336 void* param
19337 ) {
19338 (void)param;
19339
19340 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19341 CALIBDB_MODULE_PTR_HELPER_RET(list_head, list_ynr_v2);
19342 autoTabForward();
19343 XML_CHECK_START(CALIB_SENSOR_YNR_V2_TAG_ID, CALIB_SENSOR_TAG_ID);
19344 const XMLNode* pchild = pelement->FirstChild();
19345 Calibdb_Ynr_V2_t *pYnrProfile = (Calibdb_Ynr_V2_t *)malloc(sizeof(Calibdb_Ynr_V2_t));
19346 if(NULL == pYnrProfile) {
19347 LOGE("%s(%d): malloc fail(exit)\n", __FUNCTION__, __LINE__);
19348 return false;
19349 }
19350 memset(pYnrProfile, 0x00, sizeof(Calibdb_Ynr_V2_t));
19351 INIT_LIST_HEAD(&pYnrProfile->listHead);
19352
19353 while (pchild) {
19354 XmlTag tag = XmlTag(pchild->ToElement());
19355 std::string tagname(pchild->ToElement()->Name());
19356
19357 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
19358
19359 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_MODE_NAME_TAG_ID)) {
19360 ParseString(pchild, pYnrProfile->modeName, sizeof(pYnrProfile->modeName));
19361 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_ENABLE_TAG_ID)) {
19362 int no = ParseIntArray(pchild, &pYnrProfile->enable, tag.Size());
19363 DCT_ASSERT((no == tag.Size()));
19364 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_YNR_V2_SETTING_TAG_ID)) {
19365 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
19366 &RkAiqCalibParser::parseEntryYnrV2Setting,
19367 pYnrProfile,
19368 (uint32_t)CALIB_SENSOR_YNR_V2_SETTING_TAG_ID,
19369 (uint32_t)CALIB_SENSOR_YNR_V2_TAG_ID)) {
19370 LOGE("parse error in ynrV2 setting (%s)", tagname.c_str());
19371 return (false);
19372 }
19373 }
19374 pchild = pchild->NextSibling();
19375 }
19376 XML_CHECK_END();
19377
19378 bool result = CamCalibdbAddYnrV2Profile(list_ynr_v2, pYnrProfile);
19379 DCT_ASSERT(result == true);
19380
19381 // free linked ecm_schemes
19382 struct list_head* l_item = pYnrProfile->listHead.next;
19383 while (l_item != &pYnrProfile->listHead) {
19384 struct list_head* temp = l_item->next;
19385 Calibdb_Ynr_params_V2_t *pTempParam = container_of(l_item, Calibdb_Ynr_params_V2_t, listItem);
19386 list_del(l_item);
19387 free(pTempParam);
19388 l_item = temp;
19389 }
19390
19391
19392 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19393 autoTabBackward();
19394 return (true);
19395 }
19396
19397
parseEntryCnrV1Setting(const XMLElement * pelement,void * param,int index)19398 bool RkAiqCalibParser::parseEntryCnrV1Setting
19399 (
19400 const XMLElement* pelement,
19401 void* param,
19402 int index
19403 )
19404 {
19405 (void)param;
19406
19407 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19408
19409 XML_CHECK_START(CALIB_SENSOR_CNR_V1_SETTING_TAG_ID, CALIB_SENSOR_CNR_V1_TAG_ID);
19410
19411 Calibdb_Cnr_V1_t *pProfile = (Calibdb_Cnr_V1_t *)param;
19412 Calibdb_Cnr_params_V1_t *pParam = (Calibdb_Cnr_params_V1_t *)malloc(sizeof(Calibdb_Cnr_params_V1_t));
19413 if(NULL == pParam) {
19414 LOGE("%s(%d): malloc fail(exit)\n", __FUNCTION__, __LINE__);
19415 return false;
19416 }
19417 memset(pParam, 0x00, sizeof(Calibdb_Cnr_params_V1_t));
19418
19419 const XMLNode* pchild = pelement->FirstChild();
19420 while (pchild) {
19421 XmlTag tag = XmlTag(pchild->ToElement());
19422 std::string tagname(pchild->ToElement()->Name());
19423 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
19424
19425 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_SNR_MODE_TAG_ID)) {
19426 ParseString(pchild, pParam->snr_mode, sizeof(pParam->snr_mode));
19427 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_SENSOR_MODE_TAG_ID)) {
19428 ParseString(pchild, pParam->sensor_mode, sizeof(pParam->sensor_mode));
19429 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_ISO_TAG_ID)) {
19430 int no = ParseFloatArray(pchild, pParam->iso, tag.Size());
19431 DCT_ASSERT((no == tag.Size()));
19432 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_HF_BYPASS_TAG_ID)) {
19433 int no = ParseIntArray(pchild, pParam->rkcnr_hq_bila_bypass, tag.Size());
19434 DCT_ASSERT((no == tag.Size()));
19435 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_LF_BYPASS_TAG_ID)) {
19436 int no = ParseIntArray(pchild, pParam->rkcnr_lq_bila_bypass, tag.Size());
19437 DCT_ASSERT((no == tag.Size()));
19438 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_CNR_EXGAIN_TAG_ID)) {
19439 int no = ParseFloatArray(pchild, pParam->rkcnr_exgain, tag.Size());
19440 DCT_ASSERT((no == tag.Size()));
19441 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_CNR_G_GAIN_TAG_ID)) {
19442 int no = ParseFloatArray(pchild, pParam->rkcnr_g_gain, tag.Size());
19443 DCT_ASSERT((no == tag.Size()));
19444 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_COLOR_SAT_ADJ_TAG_ID)) {
19445 int no = ParseFloatArray(pchild, pParam->ratio, tag.Size());
19446 DCT_ASSERT((no == tag.Size()));
19447 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_COLOR_SAT_ADJ_ALPHA_TAG_ID)) {
19448 int no = ParseFloatArray(pchild, pParam->offset, tag.Size());
19449 DCT_ASSERT((no == tag.Size()));
19450 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_HF_SPIKERS_REDUCION_STRENGTH_TAG_ID)) {
19451 int no = ParseFloatArray(pchild, pParam->medRatio1, tag.Size());
19452 DCT_ASSERT((no == tag.Size()));
19453 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_HF_DENOISE_STRENGTH_TAG_ID)) {
19454 int no = ParseFloatArray(pchild, pParam->sigmaR1, tag.Size());
19455 DCT_ASSERT((no == tag.Size()));
19456 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_HF_COLOR_SAT_TAG_ID)) {
19457 int no = ParseFloatArray(pchild, pParam->uvgain1, tag.Size());
19458 DCT_ASSERT((no == tag.Size()));
19459 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_HF_DENOISE_ALPHA_TAG_ID)) {
19460 int no = ParseFloatArray(pchild, pParam->bfRatio1, tag.Size());
19461 DCT_ASSERT((no == tag.Size()));
19462 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_HF_BF_WGT_CLIP_TAG_ID)) {
19463 int no = ParseIntArray(pchild, pParam->hbf_wgt_clip, tag.Size());
19464 DCT_ASSERT((no == tag.Size()));
19465 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_THUMB_SPIKERS_REDUCION_STRENGTH_TAG_ID)) {
19466 int no = ParseFloatArray(pchild, pParam->medRatio2, tag.Size());
19467 DCT_ASSERT((no == tag.Size()));
19468 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_THUMB_DENOISE_STRENGTH_TAG_ID)) {
19469 int no = ParseFloatArray(pchild, pParam->sigmaR2, tag.Size());
19470 DCT_ASSERT((no == tag.Size()));
19471 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_THUMB_COLOR_SAT_TAG_ID)) {
19472 int no = ParseFloatArray(pchild, pParam->uvgain2, tag.Size());
19473 DCT_ASSERT((no == tag.Size()));
19474 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_LF_DENOISE_STRENGTH_TAG_ID)) {
19475 int no = ParseFloatArray(pchild, pParam->sigmaR3, tag.Size());
19476 DCT_ASSERT((no == tag.Size()));
19477 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_LF_COLOR_SAT_TAG_ID)) {
19478 int no = ParseFloatArray(pchild, pParam->uvgain3, tag.Size());
19479 DCT_ASSERT((no == tag.Size()));
19480 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_LF_DENOISE_ALPHA_TAG_ID)) {
19481 int no = ParseFloatArray(pchild, pParam->bfRatio3, tag.Size());
19482 DCT_ASSERT((no == tag.Size()));
19483 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_KERNEL_5X5_TAG_ID)) {
19484 int no = ParseFloatArray(pchild, pParam->kernel_5x5_table, tag.Size());
19485 DCT_ASSERT((no == tag.Size()));
19486 }
19487 pchild = pchild->NextSibling();
19488 }
19489 XML_CHECK_END();
19490
19491 if (pParam) {
19492 list_prepare_item(&pParam->listItem);
19493 list_add_tail(&pParam->listItem, &pProfile->listHead);
19494 }
19495 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19496 return (true);
19497 }
19498
19499
parseEntrySensorCnrV1(const XMLElement * pelement,void * param)19500 bool RkAiqCalibParser::parseEntrySensorCnrV1
19501 (
19502 const XMLElement* pelement,
19503 void* param
19504 ) {
19505 (void)param;
19506
19507 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19508 CALIBDB_MODULE_PTR_HELPER_RET(list_head, list_cnr_v1);
19509 autoTabForward();
19510 XML_CHECK_START(CALIB_SENSOR_CNR_V1_TAG_ID, CALIB_SENSOR_TAG_ID);
19511 const XMLNode* pchild = pelement->FirstChild();
19512 Calibdb_Cnr_V1_t *pCnrProfile = (Calibdb_Cnr_V1_t *)malloc(sizeof(Calibdb_Cnr_V1_t));
19513 if(NULL == pCnrProfile) {
19514 LOGE("%s(%d): malloc fail(exit)\n", __FUNCTION__, __LINE__);
19515 return false;
19516 }
19517 memset(pCnrProfile, 0x00, sizeof(Calibdb_Cnr_V1_t));
19518 INIT_LIST_HEAD(&pCnrProfile->listHead);
19519
19520 while (pchild) {
19521 XmlTag tag = XmlTag(pchild->ToElement());
19522 std::string tagname(pchild->ToElement()->Name());
19523
19524 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
19525
19526 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_MODE_NAME_TAG_ID)) {
19527 ParseString(pchild, pCnrProfile->modeName, sizeof(pCnrProfile->modeName));
19528 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_ENABLE_TAG_ID)) {
19529 int no = ParseIntArray(pchild, &pCnrProfile->enable, tag.Size());
19530 DCT_ASSERT((no == tag.Size()));
19531 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CNR_V1_SETTING_TAG_ID)) {
19532 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
19533 &RkAiqCalibParser::parseEntryCnrV1Setting,
19534 pCnrProfile,
19535 (uint32_t)CALIB_SENSOR_CNR_V1_SETTING_TAG_ID,
19536 (uint32_t)CALIB_SENSOR_CNR_V1_TAG_ID)) {
19537 LOGE("parse error in sharpV3 setting (%s)", tagname.c_str());
19538 return (false);
19539 }
19540 }
19541 pchild = pchild->NextSibling();
19542 }
19543 XML_CHECK_END();
19544
19545 bool result = CamCalibdbAddCnrV1Profile(list_cnr_v1, pCnrProfile);
19546 DCT_ASSERT(result == true);
19547
19548 // free linked ecm_schemes
19549 struct list_head* l_item = pCnrProfile->listHead.next;
19550 while (l_item != &pCnrProfile->listHead) {
19551 struct list_head* temp = l_item->next;
19552 Calibdb_Cnr_params_V1_t *pTempParam = container_of(l_item, Calibdb_Cnr_params_V1_t, listItem);
19553 list_del(l_item);
19554 free(pTempParam);
19555 l_item = temp;
19556 }
19557
19558
19559 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19560 autoTabBackward();
19561 return (true);
19562 }
19563
19564
parseEntrySharpV3Setting(const XMLElement * pelement,void * param,int index)19565 bool RkAiqCalibParser::parseEntrySharpV3Setting
19566 (
19567 const XMLElement* pelement,
19568 void* param,
19569 int index
19570 )
19571 {
19572 (void)param;
19573
19574 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19575
19576 XML_CHECK_START(CALIB_SENSOR_SHARP_V3_SETTING_TAG_ID, CALIB_SENSOR_SHARP_V3_TAG_ID);
19577
19578 Calibdb_Sharp_V3_t *pProfile = (Calibdb_Sharp_V3_t *)param;
19579 Calibdb_Sharp_params_V3_t *pParam = (Calibdb_Sharp_params_V3_t *)malloc(sizeof(Calibdb_Sharp_params_V3_t));
19580 if(NULL == pParam) {
19581 LOGE("%s(%d): malloc fail(exit)\n", __FUNCTION__, __LINE__);
19582 return false;
19583 }
19584 memset(pParam, 0x00, sizeof(Calibdb_Sharp_params_V3_t));
19585
19586 const XMLNode* pchild = pelement->FirstChild();
19587 while (pchild) {
19588 XmlTag tag = XmlTag(pchild->ToElement());
19589 std::string tagname(pchild->ToElement()->Name());
19590 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
19591
19592 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_SNR_MODE_TAG_ID)) {
19593 ParseString(pchild, pParam->snr_mode, sizeof(pParam->snr_mode));
19594 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_SENSOR_MODE_TAG_ID)) {
19595 ParseString(pchild, pParam->sensor_mode, sizeof(pParam->sensor_mode));
19596 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_ISO_TAG_ID)) {
19597 int no = ParseFloatArray(pchild, pParam->iso, tag.Size());
19598 DCT_ASSERT((no == tag.Size()));
19599 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_LUMA_POINT_TAG_ID)) {
19600 int no = ParseShortArray(pchild, pParam->luma_point, tag.Size());
19601 DCT_ASSERT((no == tag.Size()));
19602 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_LUMA_SIGMA_TAG_ID)) {
19603 int no = ParseShortArray(pchild, (short *)pParam->luma_sigma, tag.Size());
19604 DCT_ASSERT((no == tag.Size()));
19605 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_PBF_GAIN_TAG_ID)) {
19606 int no = ParseFloatArray(pchild, pParam->pbf_gain, tag.Size());
19607 DCT_ASSERT((no == tag.Size()));
19608 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_PBF_ADD_TAG_ID)) {
19609 int no = ParseFloatArray(pchild, pParam->pbf_add, tag.Size());
19610 DCT_ASSERT((no == tag.Size()));
19611 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_PBF_RATIO_TAG_ID)) {
19612 int no = ParseFloatArray(pchild, pParam->pbf_ratio, tag.Size());
19613 DCT_ASSERT((no == tag.Size()));
19614 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_GAUSS_RATIO_TAG_ID)) {
19615 int no = ParseFloatArray(pchild, pParam->gaus_ratio, tag.Size());
19616 DCT_ASSERT((no == tag.Size()));
19617 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_SHARP_RATIO_TAG_ID)) {
19618 int no = ParseFloatArray(pchild, pParam->sharp_ratio, tag.Size());
19619 DCT_ASSERT((no == tag.Size()));
19620 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_HF_CLIP_TAG_ID)) {
19621 int no = ParseShortArray(pchild, (short *)pParam->lum_clip_h, tag.Size());
19622 DCT_ASSERT((no == tag.Size()));
19623 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_BF_GAIN_TAG_ID)) {
19624 int no = ParseFloatArray(pchild, pParam->bf_gain, tag.Size());
19625 DCT_ASSERT((no == tag.Size()));
19626 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_BF_ADD_TAG_ID)) {
19627 int no = ParseFloatArray(pchild, pParam->bf_add, tag.Size());
19628 DCT_ASSERT((no == tag.Size()));
19629 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_BF_RATIO_TAG_ID)) {
19630 int no = ParseFloatArray(pchild, pParam->bf_ratio, tag.Size());
19631 DCT_ASSERT((no == tag.Size()));
19632 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_LOCAL_STRENGTH_TAG_ID)) {
19633 int no = ParseShortArray(pchild, (short *)pParam->ehf_th, tag.Size());
19634 DCT_ASSERT((no == tag.Size()));
19635 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_PREFILTER_COEFF_TAG_ID)) {
19636 int no = ParseFloatArray(pchild, (float *)pParam->kernel_pre_bila_filter, tag.Size());
19637 DCT_ASSERT((no == tag.Size()));
19638 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_GAUSSFILTER_COEFF_TAG_ID)) {
19639 int no = ParseFloatArray(pchild, (float *)pParam->kernel_bila_filter, tag.Size());
19640 DCT_ASSERT((no == tag.Size()));
19641 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_HBFFILTER_COEFF_TAG_ID)) {
19642 int no = ParseFloatArray(pchild, (float *)pParam->kernel_range_filter, tag.Size());
19643 DCT_ASSERT((no == tag.Size()));
19644 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_SHARP_RATIO_H_TAG_ID)) {
19645 int no = ParseFloatArray(pchild, pParam->sharp_ratio_h, tag.Size());
19646 DCT_ASSERT((no == tag.Size()));
19647 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_SHARP_RATIO_M_TAG_ID)) {
19648 int no = ParseFloatArray(pchild, pParam->sharp_ratio_m, tag.Size());
19649 DCT_ASSERT((no == tag.Size()));
19650 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_SHARP_RATIO_L_TAG_ID)) {
19651 int no = ParseFloatArray(pchild, pParam->sharp_ratio_l, tag.Size());
19652 DCT_ASSERT((no == tag.Size()));
19653 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_CLIP_HF_TAG_ID)) {
19654 int no = ParseShortArray(pchild, (short *)pParam->clip_hf, tag.Size());
19655 DCT_ASSERT((no == tag.Size()));
19656 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_CLIP_MF_TAG_ID)) {
19657 int no = ParseShortArray(pchild, (short *)pParam->clip_mf, tag.Size());
19658 DCT_ASSERT((no == tag.Size()));
19659 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_CLIP_LF_TAG_ID)) {
19660 int no = ParseShortArray(pchild, (short *)pParam->clip_lf, tag.Size());
19661 DCT_ASSERT((no == tag.Size()));
19662 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_LOCAL_WGT_TAG_ID)) {
19663 int no = ParseShortArray(pchild, (short *)pParam->local_wgt, tag.Size());
19664 DCT_ASSERT((no == tag.Size()));
19665 }
19666 pchild = pchild->NextSibling();
19667 }
19668 XML_CHECK_END();
19669
19670 if (pParam) {
19671 list_prepare_item(&pParam->listItem);
19672 list_add_tail(&pParam->listItem, &pProfile->listHead);
19673 }
19674 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19675 return (true);
19676 }
19677
19678
parseEntrySensorSharpV3(const XMLElement * pelement,void * param)19679 bool RkAiqCalibParser::parseEntrySensorSharpV3
19680 (
19681 const XMLElement* pelement,
19682 void* param
19683 ) {
19684 (void)param;
19685
19686 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19687 CALIBDB_MODULE_PTR_HELPER_RET(list_head, list_sharp_v3);
19688 autoTabForward();
19689 XML_CHECK_START(CALIB_SENSOR_SHARP_V3_TAG_ID, CALIB_SENSOR_TAG_ID);
19690 const XMLNode* pchild = pelement->FirstChild();
19691 Calibdb_Sharp_V3_t *pSharpProfile = (Calibdb_Sharp_V3_t *)malloc(sizeof(Calibdb_Sharp_V3_t));
19692 if(NULL == pSharpProfile) {
19693 LOGE("%s(%d): malloc fail(exit)\n", __FUNCTION__, __LINE__);
19694 return false;
19695 }
19696 memset(pSharpProfile, 0x00, sizeof(Calibdb_Sharp_V3_t));
19697 INIT_LIST_HEAD(&pSharpProfile->listHead);
19698
19699 while (pchild) {
19700 XmlTag tag = XmlTag(pchild->ToElement());
19701 std::string tagname(pchild->ToElement()->Name());
19702
19703 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
19704
19705 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_MODE_NAME_TAG_ID)) {
19706 ParseString(pchild, pSharpProfile->modeName, sizeof(pSharpProfile->modeName));
19707 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_ENABLE_TAG_ID)) {
19708 int no = ParseIntArray(pchild, &pSharpProfile->enable, tag.Size());
19709 DCT_ASSERT((no == tag.Size()));
19710 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_SHARP_V3_SETTING_TAG_ID)) {
19711 if (!parseEntryCell2(pchild->ToElement(), tag.Size(),
19712 &RkAiqCalibParser::parseEntrySharpV3Setting,
19713 pSharpProfile,
19714 (uint32_t)CALIB_SENSOR_SHARP_V3_SETTING_TAG_ID,
19715 (uint32_t)CALIB_SENSOR_SHARP_V3_TAG_ID)) {
19716 LOGE("parse error in SharpV3 setting (%s)", tagname.c_str());
19717 return (false);
19718 }
19719 }
19720 pchild = pchild->NextSibling();
19721 }
19722 XML_CHECK_END();
19723
19724 bool result = CamCalibdbAddSharpV3Profile(list_sharp_v3, pSharpProfile);
19725 DCT_ASSERT(result == true);
19726
19727 // free linked ecm_schemes
19728 struct list_head* l_item = pSharpProfile->listHead.next;
19729 while (l_item != &pSharpProfile->listHead) {
19730 struct list_head* temp = l_item->next;
19731 Calibdb_Sharp_params_V3_t *pTempParam = container_of(l_item, Calibdb_Sharp_params_V3_t, listItem);
19732 list_del(l_item);
19733 free(pTempParam);
19734 l_item = temp;
19735 }
19736
19737
19738 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19739 autoTabBackward();
19740 return (true);
19741 }
parseEntrySensorIE(const XMLElement * pelement,void * param)19742 bool RkAiqCalibParser::parseEntrySensorIE
19743 (
19744 const XMLElement* pelement,
19745 void* param
19746 ) {
19747 (void)param;
19748
19749 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19750 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_IE_t, ie);
19751 autoTabForward();
19752 XML_CHECK_START(CALIB_SENSOR_IE_TAG_ID, CALIB_SENSOR_TAG_ID);
19753 const XMLNode* pchild = pelement->FirstChild();
19754 while (pchild) {
19755 XmlTag tag = XmlTag(pchild->ToElement());
19756 std::string tagname(pchild->ToElement()->Name());
19757 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
19758 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IE_ENABLE_TAG_ID)) {
19759 int no = ParseIntArray(pchild, &ie->enable, tag.Size());
19760 DCT_ASSERT((no == tag.Size()));
19761 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_IE_MODE_TAG_ID)) {
19762 int no = ParseIntArray(pchild, &ie->mode, tag.Size());
19763 DCT_ASSERT((no == tag.Size()));
19764 }
19765 pchild = pchild->NextSibling();
19766 }
19767 XML_CHECK_END();
19768 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19769 autoTabBackward();
19770 return (true);
19771 }
19772
parseEntrySensorCproc(const XMLElement * pelement,void * param)19773 bool RkAiqCalibParser::parseEntrySensorCproc
19774 (
19775 const XMLElement* pelement,
19776 void* param
19777 ) {
19778 (void)param;
19779
19780 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19781 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_cProc_t, cProc);
19782 autoTabForward();
19783 XML_CHECK_START(CALIB_SENSOR_CPROC_TAG_ID, CALIB_SENSOR_TAG_ID);
19784 const XMLNode* pchild = pelement->FirstChild();
19785 while (pchild) {
19786 XmlTag tag = XmlTag(pchild->ToElement());
19787 std::string tagname(pchild->ToElement()->Name());
19788 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
19789 if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPROC_ENABLE_TAG_ID)) {
19790 int no = ParseUcharArray(pchild, &cProc->enable, tag.Size());
19791 DCT_ASSERT((no == tag.Size()));
19792 }
19793 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPROC_BRIGHTNESS_TAG_ID)) {
19794 int no = ParseUcharArray(pchild, &cProc->brightness, tag.Size());
19795 DCT_ASSERT((no == tag.Size()));
19796 }
19797 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPROC_CONTRAST_TAG_ID)) {
19798 int no = ParseUcharArray(pchild, &cProc->contrast, tag.Size());
19799 DCT_ASSERT((no == tag.Size()));
19800 }
19801 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPROC_SATURATION_TAG_ID)) {
19802 int no = ParseUcharArray(pchild, &cProc->saturation, tag.Size());
19803 DCT_ASSERT((no == tag.Size()));
19804 }
19805 else if (XML_CHECK_TAGID_COMPARE(CALIB_SENSOR_CPROC_HUE_TAG_ID)) {
19806 int no = ParseUcharArray(pchild, &cProc->hue, tag.Size());
19807 DCT_ASSERT((no == tag.Size()));
19808 }
19809 pchild = pchild->NextSibling();
19810 }
19811 XML_CHECK_END();
19812 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19813 autoTabBackward();
19814 return (true);
19815 }
19816
parseEntrySystemHDR(const XMLElement * pelement,void * param)19817 bool RkAiqCalibParser::parseEntrySystemHDR
19818 (
19819 const XMLElement* pelement,
19820 void* param
19821 ) {
19822 (void)param;
19823
19824 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19825 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_System_t, sysContrl);
19826 autoTabForward();
19827
19828 XML_CHECK_START(CALIB_SYSTEM_HDR_TAG_ID, CALIB_SYSTEM_TAG_ID);
19829
19830 const XMLNode* psecsubchild = pelement->FirstChild();
19831 while (psecsubchild) {
19832 XmlTag subTag = XmlTag(psecsubchild->ToElement());
19833 const char* value = subTag.Value();
19834 std::string subTagname(psecsubchild->ToElement()->Name());
19835 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
19836 if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_HDR_ENABLE_TAG_ID)) {
19837 int no = ParseUcharArray(psecsubchild, &sysContrl->hdr_en, subTag.Size());
19838 DCT_ASSERT((no == subTag.Size()));
19839 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_HDR_SUPPORT_MODE_TAG_ID)) {
19840 char hdr_mode[32];
19841 ParseString(psecsubchild, hdr_mode, sizeof(hdr_mode));
19842 if (xmlParseReadWrite == XML_PARSER_READ) {
19843 if (0 == strcasecmp(hdr_mode, HDR_MODE_2_FRAME_STR))
19844 sysContrl->hdr_mode = RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR;
19845 else if (0 == strcasecmp(hdr_mode, HDR_MODE_2_LINE_STR))
19846 sysContrl->hdr_mode = RK_AIQ_ISP_HDR_MODE_2_LINE_HDR;
19847 else if (0 == strcasecmp(hdr_mode, HDR_MODE_3_FRAME_STR))
19848 sysContrl->hdr_mode = RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR;
19849 else if (0 == strcasecmp(hdr_mode, HDR_MODE_3_LINE_STR))
19850 sysContrl->hdr_mode = RK_AIQ_ISP_HDR_MODE_3_LINE_HDR;
19851 }
19852 else if (xmlParseReadWrite == XML_PARSER_WRITE) {
19853 XMLNode *pNode = (XMLNode*)psecsubchild;
19854 char tmpStr[64];
19855 memset(tmpStr, 0, 64);
19856 if (sysContrl->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR)
19857 strcpy(tmpStr, HDR_MODE_2_FRAME_STR);
19858 else if (sysContrl->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR)
19859 strcpy(tmpStr, HDR_MODE_2_LINE_STR);
19860 else if (sysContrl->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR)
19861 strcpy(tmpStr, HDR_MODE_3_FRAME_STR);
19862 else if (sysContrl->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR)
19863 strcpy(tmpStr, HDR_MODE_3_LINE_STR);
19864 ParseString(psecsubchild, tmpStr, strlen(tmpStr));
19865 }
19866 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_HDR_LINE_MODE_TAG_ID)) {
19867 char line_mode[16];
19868 ParseString(psecsubchild, line_mode, sizeof(line_mode));
19869 if (xmlParseReadWrite == XML_PARSER_READ) {
19870 if (0 == strcasecmp(line_mode, HDR_LINE_MODE_DCG_STR))
19871 sysContrl->line_mode = RKAIQ_SENSOR_HDR_MODE_DCG;
19872 else if (0 == strcasecmp(line_mode, HDR_LINE_MODE_STAGGER_STR))
19873 sysContrl->line_mode = RKAIQ_SENSOR_HDR_MODE_STAGGER;
19874 }
19875 else if (xmlParseReadWrite == XML_PARSER_WRITE) {
19876 XMLNode *pNode = (XMLNode*)psecsubchild;
19877 if (sysContrl->line_mode == RKAIQ_SENSOR_HDR_MODE_DCG)
19878 pNode->FirstChild()->SetValue(HDR_LINE_MODE_DCG_STR);
19879 else if (sysContrl->line_mode == RKAIQ_SENSOR_HDR_MODE_STAGGER)
19880 pNode->FirstChild()->SetValue(HDR_LINE_MODE_STAGGER_STR);
19881 }
19882 }
19883 psecsubchild = psecsubchild->NextSibling();
19884 }
19885
19886 XML_CHECK_END();
19887
19888 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19889 autoTabBackward();
19890 return (true);
19891 }
19892
parseEntrySystemDcgNormalGainCtrl(const XMLElement * pelement,void * param)19893 bool RkAiqCalibParser::parseEntrySystemDcgNormalGainCtrl
19894 (
19895 const XMLElement* pelement,
19896 void* param
19897 ) {
19898 (void)param;
19899
19900 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19901 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_System_t, sysContrl);
19902 autoTabForward();
19903
19904 XML_CHECK_START(CALIB_SYSTEM_DCG_GAINCTRL_TAG_ID, CALIB_SYSTEM_DCG_SETTING_NORMAL_TAG_ID);
19905
19906 const XMLNode* pthrdsubchild = pelement->FirstChild();
19907 while (pthrdsubchild) {
19908 XmlTag secsubTag = XmlTag(pthrdsubchild->ToElement());
19909 const char* value = secsubTag.Value();
19910 std::string secsubTagname(pthrdsubchild->ToElement()->Name());
19911 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
19912 if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_ENABLE_TAG_ID)) {
19913 uint8_t tmp = sysContrl->dcg.Normal.gainCtrl_en;
19914 int no = ParseUcharArray(pthrdsubchild, &tmp, secsubTag.Size());
19915 sysContrl->dcg.Normal.gainCtrl_en = (tmp == 1) ? true : false;
19916 DCT_ASSERT((no == secsubTag.Size()));
19917 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_LCG2HCG_TH_TAG_ID)) {
19918 int no = ParseFloatArray(pthrdsubchild, &sysContrl->dcg.Normal.lcg2hcg_gain_th, secsubTag.Size());
19919 DCT_ASSERT((no == secsubTag.Size()));
19920 } else if(XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_HCG2LCG_TH_TAG_ID)) {
19921 int no = ParseFloatArray(pthrdsubchild, &sysContrl->dcg.Normal.hcg2lcg_gain_th, secsubTag.Size());
19922 DCT_ASSERT((no == secsubTag.Size()));
19923 }
19924 pthrdsubchild = pthrdsubchild->NextSibling();
19925 }
19926
19927 const XMLNode* pchild = pelement->FirstChild();
19928
19929
19930 XML_CHECK_END();
19931
19932 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19933 autoTabBackward();
19934 return (true);
19935 }
parseEntrySystemDcgHdrGainCtrl(const XMLElement * pelement,void * param)19936 bool RkAiqCalibParser::parseEntrySystemDcgHdrGainCtrl
19937 (
19938 const XMLElement* pelement,
19939 void* param
19940 ) {
19941 (void)param;
19942
19943 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19944 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_System_t, sysContrl);
19945 autoTabForward();
19946
19947 XML_CHECK_START(CALIB_SYSTEM_DCG_GAINCTRL_TAG_ID, CALIB_SYSTEM_DCG_SETTING_HDR_TAG_ID);
19948
19949 const XMLNode* pthrdsubchild = pelement->FirstChild();
19950 while (pthrdsubchild) {
19951 XmlTag secsubTag = XmlTag(pthrdsubchild->ToElement());
19952 const char* value = secsubTag.Value();
19953 std::string secsubTagname(pthrdsubchild->ToElement()->Name());
19954 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
19955 if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_ENABLE_TAG_ID)) {
19956 uint8_t tmp = sysContrl->dcg.Hdr.gainCtrl_en;
19957 int no = ParseUcharArray(pthrdsubchild, &tmp, secsubTag.Size());
19958 sysContrl->dcg.Hdr.gainCtrl_en = (tmp == 1) ? true : false;
19959 DCT_ASSERT((no == secsubTag.Size()));
19960 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_LCG2HCG_TH_TAG_ID)) {
19961 int no = ParseFloatArray(pthrdsubchild, &sysContrl->dcg.Hdr.lcg2hcg_gain_th, secsubTag.Size());
19962 DCT_ASSERT((no == secsubTag.Size()));
19963 } else if(XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_HCG2LCG_TH_TAG_ID)) {
19964 int no = ParseFloatArray(pthrdsubchild, &sysContrl->dcg.Hdr.hcg2lcg_gain_th, secsubTag.Size());
19965 DCT_ASSERT((no == secsubTag.Size()));
19966 }
19967 pthrdsubchild = pthrdsubchild->NextSibling();
19968 }
19969
19970 const XMLNode* pchild = pelement->FirstChild();
19971
19972
19973 XML_CHECK_END();
19974
19975 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
19976 autoTabBackward();
19977 return (true);
19978 }
19979
parseEntrySystemDcgHdrEnvCtrl(const XMLElement * pelement,void * param)19980 bool RkAiqCalibParser::parseEntrySystemDcgHdrEnvCtrl
19981 (
19982 const XMLElement* pelement,
19983 void* param
19984 ) {
19985 (void)param;
19986
19987 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
19988 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_System_t, sysContrl);
19989 autoTabForward();
19990
19991 XML_CHECK_START(CALIB_SYSTEM_DCG_ENVCTRL_TAG_ID, CALIB_SYSTEM_DCG_SETTING_HDR_TAG_ID);
19992
19993 const XMLNode* pthrdsubchild = pelement->FirstChild();
19994 while (pthrdsubchild) {
19995 XmlTag secsubTag = XmlTag(pthrdsubchild->ToElement());
19996 const char* value = secsubTag.Value();
19997 std::string secsubTagname(pthrdsubchild->ToElement()->Name());
19998 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
19999 if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_ENABLE_TAG_ID)) {
20000 uint8_t tmp = sysContrl->dcg.Hdr.envCtrl_en;
20001 int no = ParseUcharArray(pthrdsubchild, &tmp, secsubTag.Size());
20002 sysContrl->dcg.Hdr.envCtrl_en = (tmp == 1) ? true : false;
20003 DCT_ASSERT((no == secsubTag.Size()));
20004 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_LCG2HCG_TH_TAG_ID)) {
20005 int no = ParseFloatArray(pthrdsubchild, &sysContrl->dcg.Hdr.lcg2hcg_env_th, secsubTag.Size());
20006 DCT_ASSERT((no == secsubTag.Size()));
20007 } else if(XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_HCG2LCG_TH_TAG_ID)) {
20008 int no = ParseFloatArray(pthrdsubchild, &sysContrl->dcg.Hdr.hcg2lcg_env_th, secsubTag.Size());
20009 DCT_ASSERT((no == secsubTag.Size()));
20010 }
20011 pthrdsubchild = pthrdsubchild->NextSibling();
20012 }
20013
20014 XML_CHECK_END();
20015
20016 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20017 autoTabBackward();
20018 return (true);
20019 }
20020
parseEntrySystemDcgNormalEnvCtrl(const XMLElement * pelement,void * param)20021 bool RkAiqCalibParser::parseEntrySystemDcgNormalEnvCtrl
20022 (
20023 const XMLElement* pelement,
20024 void* param
20025 ) {
20026 (void)param;
20027
20028 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20029 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_System_t, sysContrl);
20030 autoTabForward();
20031
20032 XML_CHECK_START(CALIB_SYSTEM_DCG_ENVCTRL_TAG_ID, CALIB_SYSTEM_DCG_SETTING_NORMAL_TAG_ID);
20033
20034 const XMLNode* pthrdsubchild = pelement->FirstChild();
20035 while (pthrdsubchild) {
20036 XmlTag secsubTag = XmlTag(pthrdsubchild->ToElement());
20037 const char* value = secsubTag.Value();
20038 std::string secsubTagname(pthrdsubchild->ToElement()->Name());
20039 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
20040 if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_ENABLE_TAG_ID)) {
20041 uint8_t tmp = sysContrl->dcg.Normal.envCtrl_en;
20042 int no = ParseUcharArray(pthrdsubchild, &tmp, secsubTag.Size());
20043 sysContrl->dcg.Normal.envCtrl_en = (tmp == 1) ? true : false;
20044 DCT_ASSERT((no == secsubTag.Size()));
20045 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_LCG2HCG_TH_TAG_ID)) {
20046 int no = ParseFloatArray(pthrdsubchild, &sysContrl->dcg.Normal.lcg2hcg_env_th, secsubTag.Size());
20047 DCT_ASSERT((no == secsubTag.Size()));
20048 } else if(XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_HCG2LCG_TH_TAG_ID)) {
20049 int no = ParseFloatArray(pthrdsubchild, &sysContrl->dcg.Normal.hcg2lcg_env_th, secsubTag.Size());
20050 DCT_ASSERT((no == secsubTag.Size()));
20051 }
20052 pthrdsubchild = pthrdsubchild->NextSibling();
20053 }
20054
20055 XML_CHECK_END();
20056
20057 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20058 autoTabBackward();
20059 return (true);
20060 }
20061
parseEntrySystemDcgHdrSetting(const XMLElement * pelement,void * param)20062 bool RkAiqCalibParser::parseEntrySystemDcgHdrSetting
20063 (
20064 const XMLElement* pelement,
20065 void* param
20066 ) {
20067 (void)param;
20068
20069 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20070 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_System_t, sysContrl);
20071 autoTabForward();
20072
20073 XML_CHECK_START(CALIB_SYSTEM_DCG_SETTING_HDR_TAG_ID, CALIB_SYSTEM_DCG_SETTING_TAG_ID);
20074
20075 const XMLNode* psecsubchild = pelement->FirstChild();
20076 while (psecsubchild) {
20077 XmlTag subTag = XmlTag(psecsubchild->ToElement());
20078 const char* value = subTag.Value();
20079 std::string subTagname(psecsubchild->ToElement()->Name());
20080 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
20081 if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_SUPPORT_EN_TAG_ID)) {
20082 uint8_t tmp = sysContrl->dcg.Hdr.support_en;
20083 int no = ParseUcharArray(psecsubchild, &tmp, subTag.Size());
20084 sysContrl->dcg.Hdr.support_en = (tmp == 1) ? true : false;
20085 DCT_ASSERT((no == subTag.Size()));
20086 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_OPTYPE_TAG_ID)) {
20087 char* value = Toupper(subTag.Value());
20088 std::string s_value(value);
20089 if (xmlParseReadWrite == XML_PARSER_READ)
20090 {
20091 if (s_value == CALIB_SYSTEM_DCG_OPTYPE_AUTO) {
20092 sysContrl->dcg.Hdr.dcg_optype = RK_AIQ_OP_MODE_AUTO;
20093 }
20094 else if (s_value == CALIB_SYSTEM_DCG_OPTYPE_MANUAL) {
20095 sysContrl->dcg.Hdr.dcg_optype = RK_AIQ_OP_MODE_MANUAL;
20096 }
20097 else {
20098 sysContrl->dcg.Hdr.dcg_optype = RK_AIQ_OP_MODE_INVALID;
20099 LOGE("%s(%d): invalid dcg Hdr.OpType = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
20100 }
20101 }
20102 else if (xmlParseReadWrite == XML_PARSER_WRITE)
20103 {
20104 XMLNode *pNode = (XMLNode*)psecsubchild;
20105 if (sysContrl->dcg.Hdr.dcg_optype == RK_AIQ_OP_MODE_AUTO) {
20106 pNode->FirstChild()->SetValue(CALIB_SYSTEM_DCG_OPTYPE_AUTO);
20107 }
20108 else if (sysContrl->dcg.Hdr.dcg_optype == RK_AIQ_OP_MODE_MANUAL) {
20109 pNode->FirstChild()->SetValue(CALIB_SYSTEM_DCG_OPTYPE_MANUAL);
20110 }
20111 else {
20112 pNode->FirstChild()->SetValue("Invalid");
20113 LOGE("%s(%d): (XML Write)invalid dcg Hdr.OpType = %d\n", __FUNCTION__, __LINE__, sysContrl->dcg.Hdr.dcg_optype);
20114 }
20115 }
20116 }
20117 else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_MODE_INIT_TAG_ID)) {
20118 int no = ParseIntArray(psecsubchild, sysContrl->dcg.Hdr.dcg_mode.Coeff, subTag.Size());
20119 DCT_ASSERT((no == subTag.Size()));
20120 }
20121 else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_RATIO_TAG_ID)) {
20122 int no = ParseFloatArray(psecsubchild, &sysContrl->dcg.Hdr.dcg_ratio, subTag.Size());
20123 DCT_ASSERT((no == subTag.Size()));
20124 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_SYNC_SWITCH_TAG_ID)) {
20125 uint8_t tmp = sysContrl->dcg.Hdr.sync_switch;
20126 int no = ParseUcharArray(psecsubchild, &tmp, subTag.Size());
20127 sysContrl->dcg.Hdr.sync_switch = (tmp == 1) ? true : false;
20128 DCT_ASSERT((no == subTag.Size()));
20129 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_GAINCTRL_TAG_ID)) {
20130 if (!parseEntrySystemDcgHdrGainCtrl(psecsubchild->ToElement())) {
20131 LOGE("parse error in System DCG HdrGainCtrl (%s)", subTagname.c_str());
20132 return (false);
20133 }
20134 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_ENVCTRL_TAG_ID)) {
20135 if (!parseEntrySystemDcgHdrEnvCtrl(psecsubchild->ToElement())) {
20136 LOGE("parse error in System DCG HdrEnvCtrl (%s)", subTagname.c_str());
20137 return (false);
20138 }
20139 }
20140 psecsubchild = psecsubchild->NextSibling();
20141 }
20142
20143 XML_CHECK_END();
20144
20145 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20146 autoTabBackward();
20147 return (true);
20148 }
parseEntrySystemDcgNormalSetting(const XMLElement * pelement,void * param)20149 bool RkAiqCalibParser::parseEntrySystemDcgNormalSetting
20150 (
20151 const XMLElement* pelement,
20152 void* param
20153 ) {
20154 (void)param;
20155
20156 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20157 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_System_t, sysContrl);
20158 autoTabForward();
20159
20160 XML_CHECK_START(CALIB_SYSTEM_DCG_SETTING_NORMAL_TAG_ID, CALIB_SYSTEM_DCG_SETTING_TAG_ID);
20161
20162 const XMLNode* psecsubchild = pelement->FirstChild();
20163 while (psecsubchild) {
20164 XmlTag subTag = XmlTag(psecsubchild->ToElement());
20165 const char* value = subTag.Value();
20166 std::string subTagname(psecsubchild->ToElement()->Name());
20167 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
20168 if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_SUPPORT_EN_TAG_ID)) {
20169 uint8_t tmp = sysContrl->dcg.Normal.support_en;
20170 int no = ParseUcharArray(psecsubchild, &tmp, subTag.Size());
20171 sysContrl->dcg.Normal.support_en = (tmp == 1) ? true : false;
20172 DCT_ASSERT((no == subTag.Size()));
20173 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_OPTYPE_TAG_ID)) {
20174 char* value = Toupper(subTag.Value());
20175 std::string s_value(value);
20176 if (xmlParseReadWrite == XML_PARSER_READ)
20177 {
20178 if (s_value == CALIB_SYSTEM_DCG_OPTYPE_AUTO) {
20179 sysContrl->dcg.Normal.dcg_optype = RK_AIQ_OP_MODE_AUTO;
20180 }
20181 else if (s_value == CALIB_SYSTEM_DCG_OPTYPE_MANUAL) {
20182 sysContrl->dcg.Normal.dcg_optype = RK_AIQ_OP_MODE_MANUAL;
20183 }
20184 else {
20185 sysContrl->dcg.Normal.dcg_optype = RK_AIQ_OP_MODE_INVALID;
20186 LOGE("%s(%d): invalid dcg OpType = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
20187 }
20188 }
20189 else if (xmlParseReadWrite == XML_PARSER_WRITE)
20190 {
20191 XMLNode *pNode = (XMLNode*)psecsubchild;
20192 if (sysContrl->dcg.Normal.dcg_optype == RK_AIQ_OP_MODE_AUTO) {
20193 pNode->FirstChild()->SetValue(CALIB_SYSTEM_DCG_OPTYPE_AUTO);
20194 }
20195 else if (sysContrl->dcg.Normal.dcg_optype == RK_AIQ_OP_MODE_MANUAL) {
20196 pNode->FirstChild()->SetValue(CALIB_SYSTEM_DCG_OPTYPE_MANUAL);
20197 }
20198 else {
20199 pNode->FirstChild()->SetValue("Invalid");
20200 LOGE("%s(%d): (XML Write)invalid dcg OpType = %d\n", __FUNCTION__, __LINE__, sysContrl->dcg.Normal.dcg_optype);
20201 }
20202 }
20203 }
20204 else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_MODE_INIT_TAG_ID)) {
20205 int no = ParseIntArray(psecsubchild, sysContrl->dcg.Normal.dcg_mode.Coeff, subTag.Size());
20206 DCT_ASSERT((no == subTag.Size()));
20207 }
20208 else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_RATIO_TAG_ID)) {
20209 int no = ParseFloatArray(psecsubchild, &sysContrl->dcg.Normal.dcg_ratio, subTag.Size());
20210 DCT_ASSERT((no == subTag.Size()));
20211 }
20212 else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_GAINCTRL_TAG_ID)) {
20213 if (!parseEntrySystemDcgNormalGainCtrl(psecsubchild->ToElement())) {
20214 LOGE("parse error in System DCG NormalGainCtrl(%s)", subTagname.c_str());
20215 return (false);
20216 }
20217 }
20218 else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_ENVCTRL_TAG_ID)) {
20219 if (!parseEntrySystemDcgNormalEnvCtrl(psecsubchild->ToElement())) {
20220 LOGE("parse error in System DCG NormalEnvCtrl(%s)", subTagname.c_str());
20221 return (false);
20222 }
20223 }
20224 psecsubchild = psecsubchild->NextSibling();
20225 }
20226
20227 XML_CHECK_END();
20228
20229 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20230 autoTabBackward();
20231 return (true);
20232 }
parseEntrySystemDcgSetting(const XMLElement * pelement,void * param)20233 bool RkAiqCalibParser::parseEntrySystemDcgSetting
20234 (
20235 const XMLElement* pelement,
20236 void* param
20237 ) {
20238 (void)param;
20239
20240 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20241 autoTabForward();
20242
20243 XML_CHECK_START(CALIB_SYSTEM_DCG_SETTING_TAG_ID, CALIB_SYSTEM_TAG_ID);
20244
20245 const XMLNode* psecsubchild = pelement->FirstChild();
20246 while (psecsubchild) {
20247 XmlTag subTag = XmlTag(psecsubchild->ToElement());
20248 const char* value = subTag.Value();
20249 std::string subTagname(psecsubchild->ToElement()->Name());
20250 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
20251 if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_SETTING_NORMAL_TAG_ID)) {
20252 if (!parseEntrySystemDcgNormalSetting(psecsubchild->ToElement())) {
20253 LOGE("parse error in Dcg NormalSetting (%s)", subTagname.c_str());
20254 return (false);
20255 }
20256 } else if(XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_SETTING_HDR_TAG_ID)) {
20257 if (!parseEntrySystemDcgHdrSetting(psecsubchild->ToElement())) {
20258 LOGE("parse error in Dcg HdrSetting (%s)", subTagname.c_str());
20259 return (false);
20260 }
20261 }
20262 psecsubchild = psecsubchild->NextSibling();
20263 }
20264
20265 XML_CHECK_END();
20266
20267 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20268 autoTabBackward();
20269 return (true);
20270 }
parseEntrySystemExpDelayHdr(const XMLElement * pelement,void * param)20271 bool RkAiqCalibParser::parseEntrySystemExpDelayHdr
20272 (
20273 const XMLElement* pelement,
20274 void* param
20275 ) {
20276 (void)param;
20277
20278 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20279 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_System_t, sysContrl);
20280 autoTabForward();
20281
20282 XML_CHECK_START(CALIB_SYSTEM_EXP_DELAY_HDR_TAG_ID, CALIB_SYSTEM_EXP_DELAY_TAG_ID);
20283
20284 const XMLNode* psecsubchild = pelement->FirstChild();
20285 while (psecsubchild) {
20286 XmlTag subTag = XmlTag(psecsubchild->ToElement());
20287 const char* value = subTag.Value();
20288 std::string subTagname(psecsubchild->ToElement()->Name());
20289 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
20290 if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_EXP_DELAY_TIME_TAG_ID)) {
20291 int no = ParseIntArray(psecsubchild, &sysContrl->exp_delay.Hdr.time_delay, subTag.Size());
20292 DCT_ASSERT((no == subTag.Size()));
20293 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_EXP_DELAY_GAIN_TAG_ID)) {
20294 int no = ParseIntArray(psecsubchild, &sysContrl->exp_delay.Hdr.gain_delay, subTag.Size());
20295 DCT_ASSERT((no == subTag.Size()));
20296 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_EXP_DELAY_DCG_TAG_ID)) {
20297 int no = ParseIntArray(psecsubchild, &sysContrl->exp_delay.Hdr.dcg_delay, subTag.Size());
20298 DCT_ASSERT((no == subTag.Size()));
20299 }
20300 psecsubchild = psecsubchild->NextSibling();
20301 }
20302 XML_CHECK_END();
20303 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20304 autoTabBackward();
20305 return (true);
20306 }
parseEntrySystemExpDelayNormal(const XMLElement * pelement,void * param)20307 bool RkAiqCalibParser::parseEntrySystemExpDelayNormal
20308 (
20309 const XMLElement* pelement,
20310 void* param
20311 ) {
20312 (void)param;
20313
20314 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20315 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_System_t, sysContrl);
20316 autoTabForward();
20317
20318 XML_CHECK_START(CALIB_SYSTEM_EXP_DELAY_NORMAL_TAG_ID, CALIB_SYSTEM_EXP_DELAY_TAG_ID);
20319
20320 const XMLNode* psecsubchild = pelement->FirstChild();
20321 while (psecsubchild) {
20322 XmlTag subTag = XmlTag(psecsubchild->ToElement());
20323 const char* value = subTag.Value();
20324 std::string subTagname(psecsubchild->ToElement()->Name());
20325 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
20326 if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_EXP_DELAY_TIME_TAG_ID)) {
20327 int no = ParseIntArray(psecsubchild, &sysContrl->exp_delay.Normal.time_delay, subTag.Size());
20328 DCT_ASSERT((no == subTag.Size()));
20329 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_EXP_DELAY_GAIN_TAG_ID)) {
20330 int no = ParseIntArray(psecsubchild, &sysContrl->exp_delay.Normal.gain_delay, subTag.Size());
20331 DCT_ASSERT((no == subTag.Size()));
20332 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_EXP_DELAY_DCG_TAG_ID)) {
20333 int no = ParseIntArray(psecsubchild, &sysContrl->exp_delay.Normal.dcg_delay, subTag.Size());
20334 DCT_ASSERT((no == subTag.Size()));
20335 }
20336 psecsubchild = psecsubchild->NextSibling();
20337 }
20338 XML_CHECK_END();
20339 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20340 autoTabBackward();
20341 return (true);
20342 }
20343
parseEntrySystemExpDelay(const XMLElement * pelement,void * param)20344 bool RkAiqCalibParser::parseEntrySystemExpDelay
20345 (
20346 const XMLElement* pelement,
20347 void* param
20348 ) {
20349 (void)param;
20350
20351 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20352 autoTabForward();
20353
20354 XML_CHECK_START(CALIB_SYSTEM_EXP_DELAY_TAG_ID, CALIB_SYSTEM_TAG_ID);
20355
20356 const XMLNode* psecsubchild = pelement->FirstChild();
20357 while (psecsubchild) {
20358 XmlTag subTag = XmlTag(psecsubchild->ToElement());
20359 const char* value = subTag.Value();
20360 std::string subTagname(psecsubchild->ToElement()->Name());
20361 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
20362 if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_EXP_DELAY_NORMAL_TAG_ID)) {
20363 if (!parseEntrySystemExpDelayNormal(psecsubchild->ToElement())) {
20364 LOGE("parse error in ExpDelay Normal setting (%s)", subTagname.c_str());
20365 return (false);
20366 }
20367 } else if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_EXP_DELAY_HDR_TAG_ID)) {
20368 if (!parseEntrySystemExpDelayHdr(psecsubchild->ToElement())) {
20369 LOGE("parse error in ExpDelay Hdr setting (%s)", subTagname.c_str());
20370 return (false);
20371 }
20372 }
20373 psecsubchild = psecsubchild->NextSibling();
20374 }
20375 XML_CHECK_END();
20376 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20377 autoTabBackward();
20378 return (true);
20379 }
20380
parseEntrySystem(const XMLElement * pelement,void * param)20381 bool RkAiqCalibParser::parseEntrySystem
20382 (
20383 const XMLElement* pelement,
20384 void* param
20385 ) {
20386 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20387 autoTabForward();
20388
20389 XML_CHECK_START(CALIB_SYSTEM_TAG_ID, CALIB_FILESTART_TAG_ID);
20390
20391 const XMLNode* pchild = pelement->FirstChild();
20392 while (pchild) {
20393 XmlTag tag = XmlTag(pchild->ToElement());
20394 std::string tagname(pchild->ToElement()->Name());
20395 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
20396 if (XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_HDR_TAG_ID)) {
20397 if (!parseEntrySystemHDR(pchild->ToElement())) {
20398 LOGE("parse error in System (%s)", tagname.c_str());
20399 return (false);
20400 }
20401 } else if(XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_DCG_SETTING_TAG_ID)) {
20402 if (!parseEntrySystemDcgSetting(pchild->ToElement())) {
20403 LOGE("parse error in System (%s)", tagname.c_str());
20404 return (false);
20405 }
20406 } else if(XML_CHECK_TAGID_COMPARE(CALIB_SYSTEM_EXP_DELAY_TAG_ID)) {
20407 if (!parseEntrySystemExpDelay(pchild->ToElement())) {
20408 LOGE("parse error in System (%s)", tagname.c_str());
20409 return (false);
20410 }
20411 }
20412 pchild = pchild->NextSibling();
20413 }
20414
20415 XML_CHECK_END();
20416
20417 autoTabBackward();
20418 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20419 return (true);
20420 }
20421
parseEntryExpSetGain2Reg(const XMLElement * pelement,void * param)20422 bool RkAiqCalibParser::parseEntryExpSetGain2Reg
20423 (
20424 const XMLElement* pelement,
20425 void* param
20426 ) {
20427 (void)param;
20428
20429 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20430 autoTabForward();
20431
20432 XML_CHECK_START(CALIB_EXPSET_GAIN2REG_TAG_ID, CALIB_EXPSET_TAG_ID);
20433 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
20434
20435 const XMLNode* pthrdsubchild = pelement->FirstChild();
20436 while (pthrdsubchild) {
20437 XmlTag secsubTag = XmlTag(pthrdsubchild->ToElement());
20438 const char* value = secsubTag.Value();
20439 std::string secsubTagname(pthrdsubchild->ToElement()->Name());
20440 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
20441 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_GAIN2REG_ISLINEAR_TAG_ID)) {
20442 uint8_t tempVal = expset->Gain2Reg.IsLinear;
20443 int no = ParseUcharArray(pthrdsubchild, &tempVal, 1);
20444 expset->Gain2Reg.IsLinear = (tempVal == 0 ? false : true);
20445 DCT_ASSERT((no == secsubTag.Size()));
20446 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_GAIN2REG_LINEAR_TAG_ID)) {
20447 if (xmlParseReadWrite == XML_PARSER_READ) {
20448 int i = secsubTag.Size();
20449 int no = ParseFloatArray(pthrdsubchild, expset->Gain2Reg.pGainRange, i);
20450 DCT_ASSERT((no == secsubTag.Size()));
20451 DCT_ASSERT((no <= CALD_AEC_GAIN_RANGE_MAX_LEN));
20452 DCT_ASSERT(((i % 7) == 0));
20453 expset->Gain2Reg.array_size = i;
20454 }
20455 else if (xmlParseReadWrite == XML_PARSER_WRITE) {
20456 char str[10];
20457 int i = expset->Gain2Reg.array_size;
20458 DCT_ASSERT(((i % 7) == 0));
20459 snprintf(str, sizeof(str), "[%u 7]", (i / 7));
20460 XMLElement* pElement = (((XMLNode*)pthrdsubchild)->ToElement());
20461 pElement->SetAttribute(CALIB_ATTRIBUTE_SIZE, str);
20462 int no = ParseFloatArray(pthrdsubchild, expset->Gain2Reg.pGainRange, i);
20463 DCT_ASSERT((no <= CALD_AEC_GAIN_RANGE_MAX_LEN));
20464 }
20465 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_GAIN2REG_NONLINEAR_TAG_ID)) {
20466 char* value = Toupper(secsubTag.Value());
20467 std::string s_value(value);
20468 if (xmlParseReadWrite == XML_PARSER_READ)
20469 {
20470 if (s_value == CALIB_EXPSET_GAINRANGE_NONLINEAR_DB) {
20471 expset->Gain2Reg.GainMode = RKAIQ_EXPGAIN_MODE_NONLINEAR_DB;
20472 }
20473 else {
20474 expset->Gain2Reg.GainMode = RKAIQ_EXPGAIN_MODE_NONLINEAR_DB;
20475 LOGE("%s(%d): invalid GainRange Mode = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
20476 }
20477 }
20478 else if (xmlParseReadWrite == XML_PARSER_WRITE)
20479 {
20480 XMLNode *pNode = (XMLNode*)pthrdsubchild;
20481 if (expset->Gain2Reg.GainMode == RKAIQ_EXPGAIN_MODE_NONLINEAR_DB) {
20482 pNode->FirstChild()->SetValue(CALIB_EXPSET_GAINRANGE_NONLINEAR_DB);
20483 }
20484 else {
20485 pNode->FirstChild()->SetValue("Invalid");
20486 LOGE("%s(%d): (XML Write)invalid GainRange Mode = %d\n", __FUNCTION__, __LINE__, expset->Gain2Reg.GainMode);
20487 }
20488 }
20489 }
20490 pthrdsubchild = pthrdsubchild->NextSibling();
20491 }
20492 XML_CHECK_END();
20493 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20494 autoTabBackward();
20495 return (true);
20496 }
20497
parseEntryExpSetGainSet(const XMLElement * pelement,void * param)20498 bool RkAiqCalibParser::parseEntryExpSetGainSet
20499 (
20500 const XMLElement* pelement,
20501 void* param
20502 ) {
20503 (void)param;
20504
20505 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20506 autoTabForward();
20507 XML_CHECK_START(CALIB_EXPSET_GAINSET_TAG_ID, CALIB_EXPSET_TAG_ID);
20508 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
20509
20510 const XMLNode* psubchild = pelement->FirstChild();
20511 while (psubchild) {
20512 XmlTag secsubTag = XmlTag(psubchild->ToElement());
20513 const char* value = secsubTag.Value();
20514 std::string secsubTagname(psubchild->ToElement()->Name());
20515 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
20516 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISAGAIN_RANGE_TAG_ID)) {
20517 float tempVal[2] = { expset->CISGainSet.CISAgainRange.Min, expset->CISGainSet.CISAgainRange.Max };
20518 int no = ParseFloatArray(psubchild, tempVal, secsubTag.Size());
20519 DCT_ASSERT((no == secsubTag.Size()));
20520 expset->CISGainSet.CISAgainRange.Min = tempVal[0];
20521 expset->CISGainSet.CISAgainRange.Max = tempVal[1];
20522 }
20523 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISEXTRAAGAIN_RANGE_TAG_ID)) {
20524 float tempVal[2] = { expset->CISGainSet.CISExtraAgainRange.Min, expset->CISGainSet.CISExtraAgainRange.Max };
20525 int no = ParseFloatArray(psubchild, tempVal, secsubTag.Size());
20526 DCT_ASSERT((no == secsubTag.Size()));
20527 expset->CISGainSet.CISExtraAgainRange.Min = tempVal[0];
20528 expset->CISGainSet.CISExtraAgainRange.Max = tempVal[1];
20529 }
20530 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISDGAIN_RANGE_TAG_ID)) {
20531 float tempVal[2] = { expset->CISGainSet.CISDgainRange.Min, expset->CISGainSet.CISDgainRange.Max };
20532 int no = ParseFloatArray(psubchild, tempVal, secsubTag.Size());
20533 DCT_ASSERT((no == secsubTag.Size()));
20534 expset->CISGainSet.CISDgainRange.Min = tempVal[0];
20535 expset->CISGainSet.CISDgainRange.Max = tempVal[1];
20536 }
20537 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISISPDGAIN_RANGE_TAG_ID)) {
20538 float tempVal[2] = { expset->CISGainSet.CISIspDgainRange.Min, expset->CISGainSet.CISIspDgainRange.Max };
20539 int no = ParseFloatArray(psubchild, tempVal, secsubTag.Size());
20540 DCT_ASSERT((no == secsubTag.Size()));
20541 expset->CISGainSet.CISIspDgainRange.Min = tempVal[0];
20542 expset->CISGainSet.CISIspDgainRange.Max = tempVal[1];
20543 }
20544 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISHDRGAININDSETEN_TAG_ID)) {
20545 int no = ParseUcharArray(psubchild, &expset->CISGainSet.CISHdrGainIndSetEn, secsubTag.Size());
20546 DCT_ASSERT((no == secsubTag.Size()));
20547 }
20548 psubchild = psubchild->NextSibling();
20549 }
20550 XML_CHECK_END();
20551
20552 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20553 autoTabBackward();
20554 return (true);
20555 }
20556
parseEntryExpSetTimeSet(const XMLElement * pelement,void * param)20557 bool RkAiqCalibParser::parseEntryExpSetTimeSet
20558 (
20559 const XMLElement* pelement,
20560 void* param
20561 ) {
20562 (void)param;
20563
20564 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20565 autoTabForward();
20566
20567 XML_CHECK_START(CALIB_EXPSET_TIMESET_TAG_ID, CALIB_EXPSET_TAG_ID);
20568
20569 const XMLNode* psubchild = pelement->FirstChild();
20570 while (psubchild) {
20571 XmlTag secsubTag = XmlTag(psubchild->ToElement());
20572 const char* value = secsubTag.Value();
20573 std::string secsubTagname(psubchild->ToElement()->Name());
20574 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
20575
20576 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_TIMESET_NORMAL_TAG_ID)) {
20577 if (!parseEntryExpSetNormalTimeSet(psubchild->ToElement())) {
20578 LOGE("parse error in SensorInfo TIMESET (%s)", secsubTagname.c_str());
20579 return (false);
20580 }
20581 }
20582 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_TIMESET_HDR_TAG_ID)) {
20583 if (!parseEntryCell(psubchild->ToElement(), secsubTag.Size(),
20584 &RkAiqCalibParser::parseEntryExpSetHdrTimeSet,
20585 param,
20586 (uint32_t)CALIB_EXPSET_TIMESET_HDR_TAG_ID,
20587 (uint32_t)CALIB_EXPSET_TIMESET_TAG_ID)) {
20588 LOGE("parse error in SensorInfo Hdr TIMESET (%s)", secsubTagname.c_str());
20589 return (false);
20590 }
20591 }
20592
20593 psubchild = psubchild->NextSibling();
20594 }
20595
20596 XML_CHECK_END();
20597
20598 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20599 autoTabBackward();
20600 return (true);
20601 }
20602
parseEntryExpSetNormalTimeSet(const XMLElement * pelement,void * param)20603 bool RkAiqCalibParser::parseEntryExpSetNormalTimeSet
20604 (
20605 const XMLElement* pelement,
20606 void* param
20607 ) {
20608 (void)param;
20609
20610 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20611 autoTabForward();
20612
20613 XML_CHECK_START(CALIB_EXPSET_TIMESET_NORMAL_TAG_ID, CALIB_EXPSET_TIMESET_TAG_ID);
20614 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
20615
20616 const XMLNode* psubchild = pelement->FirstChild();
20617 while (psubchild) {
20618 XmlTag secsubTag = XmlTag(psubchild->ToElement());
20619 const char* value = secsubTag.Value();
20620 std::string secsubTagname(psubchild->ToElement()->Name());
20621 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
20622
20623 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISLINTIMEREG_MAXFAC_TAG_ID)) {
20624 int i = (sizeof(expset->CISTimeSet.Normal.CISLinTimeRegMaxFac) / sizeof(expset->CISTimeSet.Normal.CISLinTimeRegMaxFac.fCoeff[0]));
20625 int no = ParseFloatArray(psubchild, expset->CISTimeSet.Normal.CISLinTimeRegMaxFac.fCoeff, i);
20626 DCT_ASSERT((no == secsubTag.Size()));
20627 }
20628 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISTIMEREG_ODEVITY_TAG_ID)) {
20629 int i = (sizeof(expset->CISTimeSet.Normal.CISTimeRegOdevity) / sizeof(expset->CISTimeSet.Normal.CISTimeRegOdevity.fCoeff[0]));
20630 int no = ParseFloatArray(psubchild, expset->CISTimeSet.Normal.CISTimeRegOdevity.fCoeff, i);
20631 DCT_ASSERT((no == secsubTag.Size()));
20632 }
20633 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISTIMEREG_UNEQUALEN_TAG_ID)) {
20634 int no = ParseUcharArray(psubchild, &expset->CISTimeSet.Normal.CISTimeRegUnEqualEn, 1);
20635 DCT_ASSERT((no == secsubTag.Size()));
20636 }
20637 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISTIMEREG_MIN_TAG_ID)) {
20638 int no = ParseUshortArray(psubchild, &expset->CISTimeSet.Normal.CISTimeRegMin, 1);
20639 DCT_ASSERT((no == secsubTag.Size()));
20640 }
20641 psubchild = psubchild->NextSibling();
20642 }
20643
20644 XML_CHECK_END();
20645
20646 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20647 autoTabBackward();
20648 return (true);
20649 }
20650
parseEntryExpSetHdrTimeSet(const XMLElement * pelement,void * param)20651 bool RkAiqCalibParser::parseEntryExpSetHdrTimeSet
20652 (
20653 const XMLElement* pelement,
20654 void* param
20655 ) {
20656
20657 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20658 autoTabForward();
20659 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
20660
20661 XML_CHECK_START(CALIB_EXPSET_TIMESET_HDR_TAG_ID, CALIB_EXPSET_TIMESET_TAG_ID);
20662 int index = *((int*)param);
20663 const XMLNode* psubchild = pelement->FirstChild();
20664 bool indexValid = false;
20665
20666 while (psubchild) {
20667 XmlTag secsubTag = XmlTag(psubchild->ToElement());
20668 const char* value = secsubTag.Value();
20669 std::string secsubTagname(psubchild->ToElement()->Name());
20670 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
20671
20672 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_NAME_TAG_ID)) {
20673 char name[20];
20674 ParseString(psubchild, name, sizeof(name));
20675 if (0 == strcmp(name, "2frame")) {
20676 index = EXPSET_HDR_TWO_FRAME;
20677 }
20678 else if (0 == strcmp(name, "3frame")) {
20679 index = EXPSET_HDR_THREE_FRAME;
20680 }
20681 else {
20682 LOGE("name: %s in expset HdrTimeSet is invalid\n", name);
20683 return(false);
20684 }
20685 indexValid = true;
20686 ParseString(psubchild, expset->CISTimeSet.Hdr[index].name, sizeof(expset->CISTimeSet.Hdr[index].name));
20687 }
20688 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISHDRTIMEREG_SUMFAC_TAG_ID) && indexValid) {
20689 int i = (sizeof(expset->CISTimeSet.Hdr[index].CISHdrTimeRegSumFac) / sizeof(expset->CISTimeSet.Hdr[index].CISHdrTimeRegSumFac.fCoeff[0]));
20690 int no = ParseFloatArray(psubchild, expset->CISTimeSet.Hdr[index].CISHdrTimeRegSumFac.fCoeff, i);
20691 DCT_ASSERT((no == secsubTag.Size()));
20692 }
20693 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISTIMEREG_ODEVITY_TAG_ID) && indexValid) {
20694 int i = (sizeof(expset->CISTimeSet.Hdr[index].CISTimeRegOdevity) / sizeof(expset->CISTimeSet.Hdr[index].CISTimeRegOdevity.fCoeff[0]));
20695 int no = ParseFloatArray(psubchild, expset->CISTimeSet.Hdr[index].CISTimeRegOdevity.fCoeff, i);
20696 DCT_ASSERT((no == secsubTag.Size()));
20697 }
20698 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISTIMEREG_UNEQUALEN_TAG_ID) && indexValid) {
20699 int no = ParseUcharArray(psubchild, &expset->CISTimeSet.Hdr[index].CISTimeRegUnEqualEn, 1);
20700 DCT_ASSERT((no == secsubTag.Size()));
20701 }
20702 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISTIMEREG_MIN_TAG_ID) && indexValid) {
20703 int no = ParseUshortArray(psubchild, &expset->CISTimeSet.Hdr[index].CISTimeRegMin, 1);
20704 DCT_ASSERT((no == secsubTag.Size()));
20705 }
20706 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISTIMEREG_MAX_TAG_ID) && indexValid) {
20707 int i = (sizeof(expset->CISTimeSet.Hdr[index].CISTimeRegMax) / sizeof(expset->CISTimeSet.Hdr[index].CISTimeRegMax.Coeff[0]));
20708 int no = ParseShortArray(psubchild, expset->CISTimeSet.Hdr[index].CISTimeRegMax.Coeff, i);
20709 DCT_ASSERT((no == secsubTag.Size()));
20710 }
20711 psubchild = psubchild->NextSibling();
20712 }
20713
20714 XML_CHECK_END();
20715
20716 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20717 autoTabBackward();
20718 return (true);
20719 }
20720
parseEntryExpSetHdrSet(const XMLElement * pelement,void * param)20721 bool RkAiqCalibParser::parseEntryExpSetHdrSet
20722 (
20723 const XMLElement* pelement,
20724 void* param
20725 ) {
20726 (void)param;
20727
20728 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20729 autoTabForward();
20730
20731 XML_CHECK_START(CALIB_EXPSET_HDRSET_TAG_ID, CALIB_EXPSET_TAG_ID);
20732 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
20733
20734 const XMLNode* psecsubchild = pelement->FirstChild();
20735 while (psecsubchild) {
20736 XmlTag subTag = XmlTag(psecsubchild->ToElement());
20737 const char* value = subTag.Value();
20738 std::string subTagname(psecsubchild->ToElement()->Name());
20739 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
20740 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_HDRSET_ENABLE_TAG_ID)) {
20741 int no = ParseUcharArray(psecsubchild, &expset->CISHdrSet.hdr_en, subTag.Size());
20742 DCT_ASSERT((no == subTag.Size()));
20743 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_HDRSET_SUPPORT_MODE_TAG_ID)) {
20744 char hdr_mode[32];
20745 ParseString(psecsubchild, hdr_mode, sizeof(hdr_mode));
20746 if (xmlParseReadWrite == XML_PARSER_READ) {
20747 if (0 == strcasecmp(hdr_mode, CALIB_EXPSET_HDRSET_MODE_2_FRAME))
20748 expset->CISHdrSet.hdr_mode = RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR;
20749 else if (0 == strcasecmp(hdr_mode, CALIB_EXPSET_HDRSET_MODE_2_LINE))
20750 expset->CISHdrSet.hdr_mode = RK_AIQ_ISP_HDR_MODE_2_LINE_HDR;
20751 else if (0 == strcasecmp(hdr_mode, CALIB_EXPSET_HDRSET_MODE_3_FRAME))
20752 expset->CISHdrSet.hdr_mode = RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR;
20753 else if (0 == strcasecmp(hdr_mode, CALIB_EXPSET_HDRSET_MODE_3_LINE))
20754 expset->CISHdrSet.hdr_mode = RK_AIQ_ISP_HDR_MODE_3_LINE_HDR;
20755 }
20756 else if (xmlParseReadWrite == XML_PARSER_WRITE) {
20757 XMLNode *pNode = (XMLNode*)psecsubchild;
20758 char tmpStr[64];
20759 memset(tmpStr, 0, 64);
20760 if (expset->CISHdrSet.hdr_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR)
20761 strcpy(tmpStr, CALIB_EXPSET_HDRSET_MODE_2_FRAME);
20762 else if (expset->CISHdrSet.hdr_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR)
20763 strcpy(tmpStr, CALIB_EXPSET_HDRSET_MODE_2_LINE);
20764 else if (expset->CISHdrSet.hdr_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR)
20765 strcpy(tmpStr, CALIB_EXPSET_HDRSET_MODE_3_FRAME);
20766 else if (expset->CISHdrSet.hdr_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR)
20767 strcpy(tmpStr, CALIB_EXPSET_HDRSET_MODE_3_LINE);
20768 ParseString(psecsubchild, tmpStr, strlen(tmpStr));
20769 }
20770 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_HDRSET_LINE_MODE_TAG_ID)) {
20771 char line_mode[16];
20772 ParseString(psecsubchild, line_mode, sizeof(line_mode));
20773 if (xmlParseReadWrite == XML_PARSER_READ) {
20774 if (0 == strcasecmp(line_mode, CALIB_EXPSET_HDRSET_LINE_MODE_DCG))
20775 expset->CISHdrSet.line_mode = RKAIQ_SENSOR_HDR_MODE_DCG;
20776 else if (0 == strcasecmp(line_mode, CALIB_EXPSET_HDRSET_LINE_MODE_STAGGER))
20777 expset->CISHdrSet.line_mode = RKAIQ_SENSOR_HDR_MODE_STAGGER;
20778 }
20779 else if (xmlParseReadWrite == XML_PARSER_WRITE) {
20780 XMLNode *pNode = (XMLNode*)psecsubchild;
20781 if (expset->CISHdrSet.line_mode == RKAIQ_SENSOR_HDR_MODE_DCG)
20782 pNode->FirstChild()->SetValue(CALIB_EXPSET_HDRSET_LINE_MODE_DCG);
20783 else if (expset->CISHdrSet.line_mode == RKAIQ_SENSOR_HDR_MODE_STAGGER)
20784 pNode->FirstChild()->SetValue(CALIB_EXPSET_HDRSET_LINE_MODE_STAGGER);
20785 }
20786 }
20787 psecsubchild = psecsubchild->NextSibling();
20788 }
20789
20790 XML_CHECK_END();
20791
20792 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20793 autoTabBackward();
20794 return (true);
20795 }
20796
parseEntryExpSetDcgNormalGainCtrl(const XMLElement * pelement,void * param)20797 bool RkAiqCalibParser::parseEntryExpSetDcgNormalGainCtrl
20798 (
20799 const XMLElement* pelement,
20800 void* param
20801 ) {
20802 (void)param;
20803
20804 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20805 autoTabForward();
20806
20807 XML_CHECK_START(CALIB_EXPSET_DCGSET_GAINCTRL_TAG_ID, CALIB_EXPSET_DCGSET_NORMAL_TAG_ID);
20808 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
20809
20810 const XMLNode* pthrdsubchild = pelement->FirstChild();
20811 while (pthrdsubchild) {
20812 XmlTag secsubTag = XmlTag(pthrdsubchild->ToElement());
20813 const char* value = secsubTag.Value();
20814 std::string secsubTagname(pthrdsubchild->ToElement()->Name());
20815 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
20816 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_ENABLE_TAG_ID)) {
20817 uint8_t tmp = expset->CISDcgSet.Normal.gainCtrl_en;
20818 int no = ParseUcharArray(pthrdsubchild, &tmp, secsubTag.Size());
20819 expset->CISDcgSet.Normal.gainCtrl_en = (tmp == 1) ? true : false;
20820 DCT_ASSERT((no == secsubTag.Size()));
20821 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_LCG2HCG_TH_TAG_ID)) {
20822 int no = ParseFloatArray(pthrdsubchild, &expset->CISDcgSet.Normal.lcg2hcg_gain_th, secsubTag.Size());
20823 DCT_ASSERT((no == secsubTag.Size()));
20824 } else if(XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_HCG2LCG_TH_TAG_ID)) {
20825 int no = ParseFloatArray(pthrdsubchild, &expset->CISDcgSet.Normal.hcg2lcg_gain_th, secsubTag.Size());
20826 DCT_ASSERT((no == secsubTag.Size()));
20827 }
20828 pthrdsubchild = pthrdsubchild->NextSibling();
20829 }
20830
20831 const XMLNode* pchild = pelement->FirstChild();
20832
20833
20834 XML_CHECK_END();
20835
20836 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20837 autoTabBackward();
20838 return (true);
20839 }
parseEntryExpSetDcgHdrGainCtrl(const XMLElement * pelement,void * param)20840 bool RkAiqCalibParser::parseEntryExpSetDcgHdrGainCtrl
20841 (
20842 const XMLElement* pelement,
20843 void* param
20844 ) {
20845 (void)param;
20846
20847 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20848 autoTabForward();
20849
20850 XML_CHECK_START(CALIB_EXPSET_DCGSET_GAINCTRL_TAG_ID, CALIB_EXPSET_DCGSET_HDR_TAG_ID);
20851 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
20852
20853 const XMLNode* pthrdsubchild = pelement->FirstChild();
20854 while (pthrdsubchild) {
20855 XmlTag secsubTag = XmlTag(pthrdsubchild->ToElement());
20856 const char* value = secsubTag.Value();
20857 std::string secsubTagname(pthrdsubchild->ToElement()->Name());
20858 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
20859 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_ENABLE_TAG_ID)) {
20860 uint8_t tmp = expset->CISDcgSet.Hdr.gainCtrl_en;
20861 int no = ParseUcharArray(pthrdsubchild, &tmp, secsubTag.Size());
20862 expset->CISDcgSet.Hdr.gainCtrl_en = (tmp == 1) ? true : false;
20863 DCT_ASSERT((no == secsubTag.Size()));
20864 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_LCG2HCG_TH_TAG_ID)) {
20865 int no = ParseFloatArray(pthrdsubchild, &expset->CISDcgSet.Hdr.lcg2hcg_gain_th, secsubTag.Size());
20866 DCT_ASSERT((no == secsubTag.Size()));
20867 } else if(XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_HCG2LCG_TH_TAG_ID)) {
20868 int no = ParseFloatArray(pthrdsubchild, &expset->CISDcgSet.Hdr.hcg2lcg_gain_th, secsubTag.Size());
20869 DCT_ASSERT((no == secsubTag.Size()));
20870 }
20871 pthrdsubchild = pthrdsubchild->NextSibling();
20872 }
20873
20874 XML_CHECK_END();
20875
20876 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20877 autoTabBackward();
20878 return (true);
20879 }
20880
parseEntryExpSetDcgHdrEnvCtrl(const XMLElement * pelement,void * param)20881 bool RkAiqCalibParser::parseEntryExpSetDcgHdrEnvCtrl
20882 (
20883 const XMLElement* pelement,
20884 void* param
20885 ) {
20886 (void)param;
20887
20888 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20889 autoTabForward();
20890
20891 XML_CHECK_START(CALIB_EXPSET_DCGSET_ENVCTRL_TAG_ID, CALIB_EXPSET_DCGSET_HDR_TAG_ID);
20892 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
20893
20894 const XMLNode* pthrdsubchild = pelement->FirstChild();
20895 while (pthrdsubchild) {
20896 XmlTag secsubTag = XmlTag(pthrdsubchild->ToElement());
20897 const char* value = secsubTag.Value();
20898 std::string secsubTagname(pthrdsubchild->ToElement()->Name());
20899 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
20900 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_ENABLE_TAG_ID)) {
20901 uint8_t tmp = expset->CISDcgSet.Hdr.envCtrl_en;
20902 int no = ParseUcharArray(pthrdsubchild, &tmp, secsubTag.Size());
20903 expset->CISDcgSet.Hdr.envCtrl_en = (tmp == 1) ? true : false;
20904 DCT_ASSERT((no == secsubTag.Size()));
20905 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_LCG2HCG_TH_TAG_ID)) {
20906 int no = ParseFloatArray(pthrdsubchild, &expset->CISDcgSet.Hdr.lcg2hcg_env_th, secsubTag.Size());
20907 DCT_ASSERT((no == secsubTag.Size()));
20908 } else if(XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_HCG2LCG_TH_TAG_ID)) {
20909 int no = ParseFloatArray(pthrdsubchild, &expset->CISDcgSet.Hdr.hcg2lcg_env_th, secsubTag.Size());
20910 DCT_ASSERT((no == secsubTag.Size()));
20911 }
20912 pthrdsubchild = pthrdsubchild->NextSibling();
20913 }
20914
20915 XML_CHECK_END();
20916
20917 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20918 autoTabBackward();
20919 return (true);
20920 }
20921
parseEntryExpSetDcgNormalEnvCtrl(const XMLElement * pelement,void * param)20922 bool RkAiqCalibParser::parseEntryExpSetDcgNormalEnvCtrl
20923 (
20924 const XMLElement* pelement,
20925 void* param
20926 ) {
20927 (void)param;
20928
20929 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20930 autoTabForward();
20931
20932 XML_CHECK_START(CALIB_EXPSET_DCGSET_ENVCTRL_TAG_ID, CALIB_EXPSET_DCGSET_NORMAL_TAG_ID);
20933 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
20934
20935 const XMLNode* pthrdsubchild = pelement->FirstChild();
20936 while (pthrdsubchild) {
20937 XmlTag secsubTag = XmlTag(pthrdsubchild->ToElement());
20938 const char* value = secsubTag.Value();
20939 std::string secsubTagname(pthrdsubchild->ToElement()->Name());
20940 XML_CHECK_WHILE_SUBTAG_MARK((char *)(secsubTagname.c_str()), secsubTag.Type(), secsubTag.Size());
20941 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_ENABLE_TAG_ID)) {
20942 uint8_t tmp = expset->CISDcgSet.Normal.envCtrl_en;
20943 int no = ParseUcharArray(pthrdsubchild, &tmp, secsubTag.Size());
20944 expset->CISDcgSet.Normal.envCtrl_en = (tmp == 1) ? true : false;
20945 DCT_ASSERT((no == secsubTag.Size()));
20946 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_LCG2HCG_TH_TAG_ID)) {
20947 int no = ParseFloatArray(pthrdsubchild, &expset->CISDcgSet.Normal.lcg2hcg_env_th, secsubTag.Size());
20948 DCT_ASSERT((no == secsubTag.Size()));
20949 } else if(XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_HCG2LCG_TH_TAG_ID)) {
20950 int no = ParseFloatArray(pthrdsubchild, &expset->CISDcgSet.Normal.hcg2lcg_env_th, secsubTag.Size());
20951 DCT_ASSERT((no == secsubTag.Size()));
20952 }
20953 pthrdsubchild = pthrdsubchild->NextSibling();
20954 }
20955
20956 XML_CHECK_END();
20957
20958 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
20959 autoTabBackward();
20960 return (true);
20961 }
20962
parseEntryExpSetDcgHdrSet(const XMLElement * pelement,void * param)20963 bool RkAiqCalibParser::parseEntryExpSetDcgHdrSet
20964 (
20965 const XMLElement* pelement,
20966 void* param
20967 ) {
20968 (void)param;
20969
20970 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
20971 autoTabForward();
20972
20973 XML_CHECK_START(CALIB_EXPSET_DCGSET_HDR_TAG_ID, CALIB_EXPSET_DCGSET_TAG_ID);
20974 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
20975
20976 const XMLNode* psecsubchild = pelement->FirstChild();
20977 while (psecsubchild) {
20978 XmlTag subTag = XmlTag(psecsubchild->ToElement());
20979 const char* value = subTag.Value();
20980 std::string subTagname(psecsubchild->ToElement()->Name());
20981 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
20982 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_SUPPORT_EN_TAG_ID)) {
20983 uint8_t tmp = expset->CISDcgSet.Hdr.support_en;
20984 int no = ParseUcharArray(psecsubchild, &tmp, subTag.Size());
20985 expset->CISDcgSet.Hdr.support_en = (tmp == 1) ? true : false;
20986 DCT_ASSERT((no == subTag.Size()));
20987 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_OPTYPE_TAG_ID)) {
20988 char* value = Toupper(subTag.Value());
20989 std::string s_value(value);
20990 if (xmlParseReadWrite == XML_PARSER_READ)
20991 {
20992 if (s_value == CALIB_EXPSET_DCGSET_OPTYPE_AUTO) {
20993 expset->CISDcgSet.Hdr.dcg_optype = RK_AIQ_OP_MODE_AUTO;
20994 }
20995 else if (s_value == CALIB_EXPSET_DCGSET_OPTYPE_MANUAL) {
20996 expset->CISDcgSet.Hdr.dcg_optype = RK_AIQ_OP_MODE_MANUAL;
20997 }
20998 else {
20999 expset->CISDcgSet.Hdr.dcg_optype = RK_AIQ_OP_MODE_INVALID;
21000 LOGE("%s(%d): invalid dcg Hdr.OpType = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
21001 }
21002 }
21003 else if (xmlParseReadWrite == XML_PARSER_WRITE)
21004 {
21005 XMLNode *pNode = (XMLNode*)psecsubchild;
21006 if (expset->CISDcgSet.Hdr.dcg_optype == RK_AIQ_OP_MODE_AUTO) {
21007 pNode->FirstChild()->SetValue(CALIB_EXPSET_DCGSET_OPTYPE_AUTO);
21008 }
21009 else if (expset->CISDcgSet.Hdr.dcg_optype == RK_AIQ_OP_MODE_MANUAL) {
21010 pNode->FirstChild()->SetValue(CALIB_EXPSET_DCGSET_OPTYPE_MANUAL);
21011 }
21012 else {
21013 pNode->FirstChild()->SetValue("Invalid");
21014 LOGE("%s(%d): (XML Write)invalid dcg Hdr.OpType = %d\n", __FUNCTION__, __LINE__, expset->CISDcgSet.Hdr.dcg_optype);
21015 }
21016 }
21017 }
21018 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_MODE_INIT_TAG_ID)) {
21019 int no = ParseIntArray(psecsubchild, expset->CISDcgSet.Hdr.dcg_mode.Coeff, subTag.Size());
21020 DCT_ASSERT((no == subTag.Size()));
21021 }
21022 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_RATIO_TAG_ID)) {
21023 int no = ParseFloatArray(psecsubchild, &expset->CISDcgSet.Hdr.dcg_ratio, subTag.Size());
21024 DCT_ASSERT((no == subTag.Size()));
21025 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_SYNC_SWITCH_TAG_ID)) {
21026 uint8_t tmp = expset->CISDcgSet.Hdr.sync_switch;
21027 int no = ParseUcharArray(psecsubchild, &tmp, subTag.Size());
21028 expset->CISDcgSet.Hdr.sync_switch = (tmp == 1) ? true : false;
21029 DCT_ASSERT((no == subTag.Size()));
21030 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_GAINCTRL_TAG_ID)) {
21031 if (!parseEntryExpSetDcgHdrGainCtrl(psecsubchild->ToElement())) {
21032 LOGE("parse error in ExpSet DCG HdrGainCtrl (%s)", subTagname.c_str());
21033 return (false);
21034 }
21035 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_ENVCTRL_TAG_ID)) {
21036 if (!parseEntryExpSetDcgHdrEnvCtrl(psecsubchild->ToElement())) {
21037 LOGE("parse error in ExpSet DCG HdrEnvCtrl (%s)", subTagname.c_str());
21038 return (false);
21039 }
21040 }
21041 psecsubchild = psecsubchild->NextSibling();
21042 }
21043
21044 XML_CHECK_END();
21045
21046 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
21047 autoTabBackward();
21048 return (true);
21049 }
parseEntryExpSetDcgNormalSet(const XMLElement * pelement,void * param)21050 bool RkAiqCalibParser::parseEntryExpSetDcgNormalSet
21051 (
21052 const XMLElement* pelement,
21053 void* param
21054 ) {
21055 (void)param;
21056
21057 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
21058 autoTabForward();
21059
21060 XML_CHECK_START(CALIB_EXPSET_DCGSET_NORMAL_TAG_ID, CALIB_EXPSET_DCGSET_TAG_ID);
21061 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
21062
21063 const XMLNode* psecsubchild = pelement->FirstChild();
21064 while (psecsubchild) {
21065 XmlTag subTag = XmlTag(psecsubchild->ToElement());
21066 const char* value = subTag.Value();
21067 std::string subTagname(psecsubchild->ToElement()->Name());
21068 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
21069 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_SUPPORT_EN_TAG_ID)) {
21070 uint8_t tmp = expset->CISDcgSet.Normal.support_en;
21071 int no = ParseUcharArray(psecsubchild, &tmp, subTag.Size());
21072 expset->CISDcgSet.Normal.support_en = (tmp == 1) ? true : false;
21073 DCT_ASSERT((no == subTag.Size()));
21074 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_OPTYPE_TAG_ID)) {
21075 char* value = Toupper(subTag.Value());
21076 std::string s_value(value);
21077 if (xmlParseReadWrite == XML_PARSER_READ)
21078 {
21079 if (s_value == CALIB_EXPSET_DCGSET_OPTYPE_AUTO) {
21080 expset->CISDcgSet.Normal.dcg_optype = RK_AIQ_OP_MODE_AUTO;
21081 }
21082 else if (s_value == CALIB_EXPSET_DCGSET_OPTYPE_MANUAL) {
21083 expset->CISDcgSet.Normal.dcg_optype = RK_AIQ_OP_MODE_MANUAL;
21084 }
21085 else {
21086 expset->CISDcgSet.Normal.dcg_optype = RK_AIQ_OP_MODE_INVALID;
21087 LOGE("%s(%d): invalid dcg OpType = %s\n", __FUNCTION__, __LINE__, s_value.c_str());
21088 }
21089 }
21090 else if (xmlParseReadWrite == XML_PARSER_WRITE)
21091 {
21092 XMLNode *pNode = (XMLNode*)psecsubchild;
21093 if (expset->CISDcgSet.Normal.dcg_optype == RK_AIQ_OP_MODE_AUTO) {
21094 pNode->FirstChild()->SetValue(CALIB_EXPSET_DCGSET_OPTYPE_AUTO);
21095 }
21096 else if (expset->CISDcgSet.Normal.dcg_optype == RK_AIQ_OP_MODE_MANUAL) {
21097 pNode->FirstChild()->SetValue(CALIB_EXPSET_DCGSET_OPTYPE_MANUAL);
21098 }
21099 else {
21100 pNode->FirstChild()->SetValue("Invalid");
21101 LOGE("%s(%d): (XML Write)invalid dcg OpType = %d\n", __FUNCTION__, __LINE__, expset->CISDcgSet.Normal.dcg_optype);
21102 }
21103 }
21104 }
21105 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_MODE_INIT_TAG_ID)) {
21106 int no = ParseIntArray(psecsubchild, expset->CISDcgSet.Normal.dcg_mode.Coeff, subTag.Size());
21107 DCT_ASSERT((no == subTag.Size()));
21108 }
21109 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_RATIO_TAG_ID)) {
21110 int no = ParseFloatArray(psecsubchild, &expset->CISDcgSet.Normal.dcg_ratio, subTag.Size());
21111 DCT_ASSERT((no == subTag.Size()));
21112 }
21113 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_GAINCTRL_TAG_ID)) {
21114 if (!parseEntryExpSetDcgNormalGainCtrl(psecsubchild->ToElement())) {
21115 LOGE("parse error in ExpSet DCG NormalGainCtrl(%s)", subTagname.c_str());
21116 return (false);
21117 }
21118 }
21119 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_ENVCTRL_TAG_ID)) {
21120 if (!parseEntryExpSetDcgNormalEnvCtrl(psecsubchild->ToElement())) {
21121 LOGE("parse error in ExpSet DCG NormalEnvCtrl(%s)", subTagname.c_str());
21122 return (false);
21123 }
21124 }
21125 psecsubchild = psecsubchild->NextSibling();
21126 }
21127
21128 XML_CHECK_END();
21129
21130 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
21131 autoTabBackward();
21132 return (true);
21133 }
parseEntryExpSetDcgSet(const XMLElement * pelement,void * param)21134 bool RkAiqCalibParser::parseEntryExpSetDcgSet
21135 (
21136 const XMLElement* pelement,
21137 void* param
21138 ) {
21139 (void)param;
21140
21141 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
21142 autoTabForward();
21143
21144 XML_CHECK_START(CALIB_EXPSET_DCGSET_TAG_ID, CALIB_EXPSET_TAG_ID);
21145
21146 const XMLNode* psecsubchild = pelement->FirstChild();
21147 while (psecsubchild) {
21148 XmlTag subTag = XmlTag(psecsubchild->ToElement());
21149 const char* value = subTag.Value();
21150 std::string subTagname(psecsubchild->ToElement()->Name());
21151 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
21152 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_NORMAL_TAG_ID)) {
21153 if (!parseEntryExpSetDcgNormalSet(psecsubchild->ToElement())) {
21154 LOGE("parse error in Dcg NormalSet (%s)", subTagname.c_str());
21155 return (false);
21156 }
21157 } else if(XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_HDR_TAG_ID)) {
21158 if (!parseEntryExpSetDcgHdrSet(psecsubchild->ToElement())) {
21159 LOGE("parse error in Dcg HdrSet (%s)", subTagname.c_str());
21160 return (false);
21161 }
21162 }
21163 psecsubchild = psecsubchild->NextSibling();
21164 }
21165
21166 XML_CHECK_END();
21167
21168 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
21169 autoTabBackward();
21170 return (true);
21171 }
parseEntryExpSetExpUpdateHdr(const XMLElement * pelement,void * param)21172 bool RkAiqCalibParser::parseEntryExpSetExpUpdateHdr
21173 (
21174 const XMLElement* pelement,
21175 void* param
21176 ) {
21177 (void)param;
21178
21179 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
21180 autoTabForward();
21181
21182 XML_CHECK_START(CALIB_EXPSET_EXP_UPDATE_HDR_TAG_ID, CALIB_EXPSET_EXP_UPDATE_TAG_ID);
21183 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
21184
21185 const XMLNode* psecsubchild = pelement->FirstChild();
21186 while (psecsubchild) {
21187 XmlTag subTag = XmlTag(psecsubchild->ToElement());
21188 const char* value = subTag.Value();
21189 std::string subTagname(psecsubchild->ToElement()->Name());
21190 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
21191 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_EXP_UPDATE_TIME_TAG_ID)) {
21192 int no = ParseIntArray(psecsubchild, &expset->CISExpUpdate.Hdr.time_update, subTag.Size());
21193 DCT_ASSERT((no == subTag.Size()));
21194 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_EXP_UPDATE_GAIN_TAG_ID)) {
21195 int no = ParseIntArray(psecsubchild, &expset->CISExpUpdate.Hdr.gain_update, subTag.Size());
21196 DCT_ASSERT((no == subTag.Size()));
21197 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_EXP_UPDATE_DCG_TAG_ID)) {
21198 int no = ParseIntArray(psecsubchild, &expset->CISExpUpdate.Hdr.dcg_update, subTag.Size());
21199 DCT_ASSERT((no == subTag.Size()));
21200 }
21201 psecsubchild = psecsubchild->NextSibling();
21202 }
21203 XML_CHECK_END();
21204 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
21205 autoTabBackward();
21206 return (true);
21207 }
parseEntryExpSetExpUpdateNormal(const XMLElement * pelement,void * param)21208 bool RkAiqCalibParser::parseEntryExpSetExpUpdateNormal
21209 (
21210 const XMLElement* pelement,
21211 void* param
21212 ) {
21213 (void)param;
21214
21215 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
21216 autoTabForward();
21217
21218 XML_CHECK_START(CALIB_EXPSET_EXP_UPDATE_NORMAL_TAG_ID, CALIB_EXPSET_EXP_UPDATE_TAG_ID);
21219 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
21220
21221 const XMLNode* psecsubchild = pelement->FirstChild();
21222 while (psecsubchild) {
21223 XmlTag subTag = XmlTag(psecsubchild->ToElement());
21224 const char* value = subTag.Value();
21225 std::string subTagname(psecsubchild->ToElement()->Name());
21226 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
21227 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_EXP_UPDATE_TIME_TAG_ID)) {
21228 int no = ParseIntArray(psecsubchild, &expset->CISExpUpdate.Normal.time_update, subTag.Size());
21229 DCT_ASSERT((no == subTag.Size()));
21230 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_EXP_UPDATE_GAIN_TAG_ID)) {
21231 int no = ParseIntArray(psecsubchild, &expset->CISExpUpdate.Normal.gain_update, subTag.Size());
21232 DCT_ASSERT((no == subTag.Size()));
21233 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_EXP_UPDATE_DCG_TAG_ID)) {
21234 int no = ParseIntArray(psecsubchild, &expset->CISExpUpdate.Normal.dcg_update, subTag.Size());
21235 DCT_ASSERT((no == subTag.Size()));
21236 }
21237 psecsubchild = psecsubchild->NextSibling();
21238 }
21239 XML_CHECK_END();
21240 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
21241 autoTabBackward();
21242 return (true);
21243 }
21244
parseEntryExpSetExpUpdate(const XMLElement * pelement,void * param)21245 bool RkAiqCalibParser::parseEntryExpSetExpUpdate
21246 (
21247 const XMLElement* pelement,
21248 void* param
21249 ) {
21250 (void)param;
21251
21252 LOGD( "%s(%d): (enter)\n", __FUNCTION__, __LINE__);
21253 autoTabForward();
21254
21255 XML_CHECK_START(CALIB_EXPSET_EXP_UPDATE_TAG_ID, CALIB_EXPSET_TAG_ID);
21256
21257 const XMLNode* psecsubchild = pelement->FirstChild();
21258 while (psecsubchild) {
21259 XmlTag subTag = XmlTag(psecsubchild->ToElement());
21260 const char* value = subTag.Value();
21261 std::string subTagname(psecsubchild->ToElement()->Name());
21262 XML_CHECK_WHILE_SUBTAG_MARK((char *)(subTagname.c_str()), subTag.Type(), subTag.Size());
21263 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_EXP_UPDATE_NORMAL_TAG_ID)) {
21264 if (!parseEntryExpSetExpUpdateNormal(psecsubchild->ToElement())) {
21265 LOGE("parse error in ExpUpdate NormalSet (%s)", subTagname.c_str());
21266 return (false);
21267 }
21268 } else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_EXP_UPDATE_HDR_TAG_ID)) {
21269 if (!parseEntryExpSetExpUpdateHdr(psecsubchild->ToElement())) {
21270 LOGE("parse error in ExpUpdate HdrSet (%s)", subTagname.c_str());
21271 return (false);
21272 }
21273 }
21274 psecsubchild = psecsubchild->NextSibling();
21275 }
21276 XML_CHECK_END();
21277 LOGD( "%s(%d): (exit)\n", __FUNCTION__, __LINE__);
21278 autoTabBackward();
21279 return (true);
21280 }
21281
parseEntryExpSet(const XMLElement * pelement,void * param)21282 bool RkAiqCalibParser::parseEntryExpSet
21283 (
21284 const XMLElement* pelement,
21285 void* param
21286 ) {
21287 (void)param;
21288
21289 LOGI("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
21290 autoTabForward();
21291
21292 XML_CHECK_START(CALIB_EXPSET_TAG_ID, CALIB_FILESTART_TAG_ID);
21293 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_ExpSet_para_t, expset);
21294
21295 const XMLNode* pchild = pelement->FirstChild();
21296 while (pchild) {
21297 XmlTag tag = XmlTag(pchild->ToElement());
21298 std::string tagname(pchild->ToElement()->Name());
21299 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
21300 #ifdef DEBUG_LOG
21301 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, tagname.c_str());
21302 #endif
21303 if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_GAIN2REG_TAG_ID)) {
21304 if (!parseEntryExpSetGain2Reg(pchild->ToElement())) {
21305 LOGE("parse error in ExpSet Gain2Reg (%s)", tagname.c_str());
21306 return (false);
21307 }
21308 }
21309 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_TIME2REG_TAG_ID)) {
21310 int i = (sizeof(expset->Time2Reg) / sizeof(expset->Time2Reg[0]));
21311 int no = ParseFloatArray(pchild, expset->Time2Reg, i);
21312 DCT_ASSERT((no == tag.Size()));
21313 }
21314 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_GAINSET_TAG_ID)) {
21315 if (!parseEntryExpSetGainSet(pchild->ToElement())) {
21316 LOGE("parse error in ExpSet GainSet (%s)", tagname.c_str());
21317 return (false);
21318 }
21319 }
21320 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_TIMESET_TAG_ID)) {
21321 if (!parseEntryExpSetTimeSet(pchild->ToElement())) {
21322 LOGE("parse error in ExpSet Timeet (%s)", tagname.c_str());
21323 return (false);
21324 }
21325 }
21326 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISMINFPS_TAG_ID)) {
21327 int no = ParseFloatArray(pchild, &expset->CISMinFps, 1);
21328 DCT_ASSERT((no == tag.Size()));
21329 }
21330 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_CISFLIP_TAG_ID)) {
21331 int no = ParseUcharArray(pchild, &expset->CISFlip, 1);
21332 DCT_ASSERT((no == tag.Size()));
21333 }
21334 else if (XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_HDRSET_TAG_ID)) {
21335 if (!parseEntryExpSetHdrSet(pchild->ToElement())) {
21336 LOGE("parse error in ExpSet HdrSet (%s)", tagname.c_str());
21337 return (false);
21338 }
21339 }
21340 else if(XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_DCGSET_TAG_ID)) {
21341 if (!parseEntryExpSetDcgSet(pchild->ToElement())) {
21342 LOGE("parse error in ExpSet DcgSet (%s)", tagname.c_str());
21343 return (false);
21344 }
21345 }
21346 else if(XML_CHECK_TAGID_COMPARE(CALIB_EXPSET_EXP_UPDATE_TAG_ID)) {
21347 if (!parseEntryExpSetExpUpdate(pchild->ToElement())) {
21348 LOGE("parse error in ExpSet ExpUpdate(%s)", tagname.c_str());
21349 return (false);
21350 }
21351 }
21352 else {
21353 redirectOut
21354 << "parse error in ExpSet section (unknow tag: "
21355 << tagname
21356 << ")"
21357 << std::endl;
21358 }
21359 pchild = pchild->NextSibling();
21360 }
21361 XML_CHECK_END();
21362 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
21363 autoTabBackward();
21364 return (true);
21365 }
21366
parseEntryModuleInfo(const XMLElement * pelement,void * param)21367 bool RkAiqCalibParser::parseEntryModuleInfo
21368 (
21369 const XMLElement* pelement,
21370 void* param
21371 ) {
21372 (void)param;
21373
21374 LOGI("%s(%d): (enter)\n", __FUNCTION__, __LINE__);
21375 autoTabForward();
21376
21377 XML_CHECK_START(CALIB_MODULEINFO_TAG_ID, CALIB_FILESTART_TAG_ID);
21378 CALIBDB_MODULE_PTR_HELPER_RET(CalibDb_Module_Info_t, module);
21379
21380 const XMLNode* pchild = pelement->FirstChild();
21381 while (pchild) {
21382 XmlTag tag = XmlTag(pchild->ToElement());
21383 std::string tagname(pchild->ToElement()->Name());
21384 XML_CHECK_WHILE_SUBTAG_MARK((char *)(tagname.c_str()), tag.Type(), tag.Size());
21385 #ifdef DEBUG_LOG
21386 LOGE("%s(%d): Tagname = %s\n", __FUNCTION__, __LINE__, tagname.c_str());
21387 #endif
21388 if (XML_CHECK_TAGID_COMPARE(CALIB_MODULEINFO_FNUMBER_TAG_ID)) {
21389 int no = ParseFloatArray(pchild, &module->FNumber, 1);
21390 DCT_ASSERT((no == tag.Size()));
21391 }
21392 else if (XML_CHECK_TAGID_COMPARE(CALIB_MODULEINFO_EFL_TAG_ID)) {
21393 int no = ParseFloatArray(pchild, &module->EFL, 1);
21394 DCT_ASSERT((no == tag.Size()));
21395 }
21396 else if (XML_CHECK_TAGID_COMPARE(CALIB_MODULEINFO_LENS_TRANSMITTANCE_TAG_ID)) {
21397 int no = ParseFloatArray(pchild, &module->LensT, 1);
21398 DCT_ASSERT((no == tag.Size()));
21399 }
21400 else if (XML_CHECK_TAGID_COMPARE(CALIB_MODULEINFO_IRCUT_TRANSMITTANCE_TAG_ID)) {
21401 int no = ParseFloatArray(pchild, &module->IRCutT, 1);
21402 DCT_ASSERT((no == tag.Size()));
21403 }
21404 else {
21405 redirectOut
21406 << "parse error in ModuleInfo section (unknow tag: "
21407 << tagname
21408 << ")"
21409 << std::endl;
21410 }
21411 pchild = pchild->NextSibling();
21412 }
21413 XML_CHECK_END();
21414 LOGD("%s(%d): (exit)\n", __FUNCTION__, __LINE__);
21415 autoTabBackward();
21416 return (true);
21417 }
21418
updateXmlParseReadWriteFlag(int flag)21419 void RkAiqCalibParser::updateXmlParseReadWriteFlag(int flag)
21420 {
21421 xmlParseReadWrite = flag;
21422 }
21423
21424
21425 #undef DCT_ASSERT
21426 };
21427