summaryrefslogtreecommitdiff
path: root/tvapi/libtv/vpp/CPQdb.cpp (plain)
blob: f60802d82004e0ab9c1462ff09904891422c3c24
1/*
2 * CPQdb.cpp
3 *
4 * d on: 2011-12-13
5 * Author: casey
6 *
7 * change 2015.04
8 * showbo
9 */
10
11#define LOG_TAG "CPQdb"
12
13#include <stdio.h>
14#include <string.h>
15#include <stdlib.h>
16#include <sys/stat.h>
17#include <errno.h>
18#include "CPQdb.h"
19#include "../tvutils/tvutils.h"
20#include "../tvconfig/tvconfig.h"
21
22#if (PQ_NO_ANDROID == 0)
23#include <android/log.h>
24#include "CTvLog.h"
25#endif
26
27#if (PQ_NO_ANDROID == 1)
28using namespace std;
29#endif
30
31//#define CPQDB_DEBUG
32
33#define BRIGHTNESS_ID 0
34#define CONTRAST_ID 1
35#define SATURATION_ID 1
36#define HUE_ID 0
37#define SHARPNESS_ID 1
38
39//static char *str_buf[256];
40
41#define ID_FIELD "TableID"
42#define NR_LEVEL_NAME "NRLevel"
43#define CM_LEVEL_NAME "CMLevel"
44#define LEVEL_NAME "Level"
45#define ADC_SETTING "ADC_Settings"
46#define CVD2_SETTING "CVD2_Settings"
47#define PORT "Port"
48#define FORMAT "Format"
49
50#define CC_LINE_MAX_LEN (1024)
51
52#define LOG_TAG "CPQdb"
53//#define CPQDB_DEBUG
54
55
56/*int get_pq_from_file(const char *file_name, const char *screen_size, char *key_str_buf[]) {
57 FILE *fp = NULL;
58 int flag = -1;
59 char *str = NULL;
60 char r_line_buf[CC_LINE_MAX_LEN];
61
62 if (file_name == NULL || screen_size == NULL || key_str_buf == NULL) {
63 return -1;
64 }
65
66 fp = fopen(file_name, "r");
67 if (fp == NULL) {
68 LOGE("%s: open file \"%s\" error(%s).\n", "TV", file_name, strerror(errno));
69 return -1;
70 }
71
72 while (fgets(r_line_buf, CC_LINE_MAX_LEN, fp)) {
73 LOGD("%s, fgets_buf = %s\n","TV", r_line_buf);
74 if (NULL != strstr(r_line_buf, screen_size)) {
75 LOGD("%s, screen_size_buf = %s\n","TV", r_line_buf);
76 str = (char*)malloc(strlen(r_line_buf));
77 memset(str, 0, strlen(str));
78 if (NULL != str) {
79 strcpy(str, r_line_buf);
80 key_str_buf[0] = str;
81 LOGD("%s, key_str_buf[0] = %s\n","TV", key_str_buf[0]);
82 }
83 flag = 0;
84 break;
85 }
86 }
87
88 if (flag != 0)
89 key_str_buf[0] = NULL;
90
91 fclose(fp);
92 fp = NULL;
93
94 return flag;
95 }*/
96
97/*int getFileSizeSystemCall(char * strFileName)
98 {
99 struct stat temp;
100 stat(strFileName, &temp);
101 return temp.st_size;
102 }*/
103
104CPqData::CPqData()
105{
106 int i = 0, j = 0;
107
108 for (i = 0; i < 15; i++) {
109 pq_bri_data[i].TotalNode = 0;
110 pq_bri_data[i].NodeValue = 0;
111 pq_bri_data[i].IndexValue = 0;
112 pq_bri_data[i].RegValue = 0;
113 pq_bri_data[i].step = 0;
114
115 pq_con_data[i].TotalNode = 0;
116 pq_con_data[i].NodeValue = 0;
117 pq_con_data[i].IndexValue = 0;
118 pq_con_data[i].RegValue = 0;
119 pq_con_data[i].step = 0;
120
121 pq_sat_data[i].TotalNode = 0;
122 pq_sat_data[i].NodeValue = 0;
123 pq_sat_data[i].IndexValue = 0;
124 pq_sat_data[i].RegValue = 0;
125 pq_sat_data[i].step = 0;
126
127 pq_hue_data[i].TotalNode = 0;
128 pq_hue_data[i].NodeValue = 0;
129 pq_hue_data[i].IndexValue = 0;
130 pq_hue_data[i].RegValue = 0;
131 pq_hue_data[i].step = 0;
132 }
133
134 for (i = 0; i < 10; i++) {
135 pq_sharpness_reg_data[i].length = 0;
136 pq_sharpness_reg_data_1[i].length = 0;
137 for (j = 0; j < 50; j++) {
138 pq_sharpness_reg_data[i].reg_data[j].TotalNode = 0;
139 pq_sharpness_reg_data_1[i].reg_data[j].TotalNode = 0;
140 pq_sharpness_reg_data[i].reg_data[j].Value.type = 0;
141 pq_sharpness_reg_data_1[i].reg_data[j].Value.type = 0;
142 pq_sharpness_reg_data[i].reg_data[j].Value.addr = 0;
143 pq_sharpness_reg_data_1[i].reg_data[j].Value.addr = 0;
144 pq_sharpness_reg_data[i].reg_data[j].Value.mask = 0;
145 pq_sharpness_reg_data_1[i].reg_data[j].Value.mask = 0;
146 pq_sharpness_reg_data[i].reg_data[j].Value.val = 0;
147 pq_sharpness_reg_data_1[i].reg_data[j].Value.val = 0;
148 pq_sharpness_reg_data[i].reg_data[j].NodeValue = 0;
149 pq_sharpness_reg_data_1[i].reg_data[j].NodeValue = 0;
150 pq_sharpness_reg_data[i].reg_data[j].IndexValue = 0;
151 pq_sharpness_reg_data_1[i].reg_data[j].IndexValue = 0;
152 pq_sharpness_reg_data[i].reg_data[j].step = 0;
153 pq_sharpness_reg_data_1[i].reg_data[j].step = 0;
154 }
155 }
156}
157
158CPqData::~CPqData()
159{
160}
161
162int CPqData::openPqDB(const char *db_path)
163{
164 int rval;
165 project_info_t tmp_info;
166 char SYSTEM_PQ[128] = { 0 };
167 char tmp_buf[128] = { 0 };
168
169 strcpy(PQ_DB_PATH, db_path);
170 strcpy(SYSTEM_PQ, "/system/etc/pq.db");
171
172 if (GetProjectInfo(&tmp_info) == 0) {
173 strcpy(tmp_buf, "/system/etc/");
174 strcat(tmp_buf, tmp_info.panel_type);
175 strcat(tmp_buf, ".db");
176 if (access(tmp_buf, 0) == 0) {
177 strncpy(SYSTEM_PQ, tmp_buf, sizeof(SYSTEM_PQ) - 1);
178 }
179 }
180
181 LOGD("openPqDB path = %s = %s", db_path, PQ_DB_PATH);
182 if (access(PQ_DB_PATH, 0) < 0) {
183 CFile file(SYSTEM_PQ);
184 if (file.copyTo(PQ_DB_PATH) != 0) {
185 LOGE("%s, copy file \"%s\" to \"%s\" error", __FUNCTION__, SYSTEM_PQ, PQ_DB_PATH);
186 return -1;
187 } else {
188 LOGD("%s, copy file \"%s\" to \"%s\" ok", __FUNCTION__, SYSTEM_PQ, PQ_DB_PATH);
189 }
190 }
191
192 closeDb();
193 rval = openDb(PQ_DB_PATH);
194
195 char *err;
196 bool isOk = integrityCheck();
197 if (!isOk) {
198 CFile file(SYSTEM_PQ);
199 if (file.copyTo(PQ_DB_PATH) != 0) {
200 LOGE("%s, copy file = %s , error", __FUNCTION__, SYSTEM_PQ);
201 return -1;
202 } else {
203 closeDb();
204 rval = openDb(PQ_DB_PATH);
205 LOGD("%s, copy file = %s , ok", __FUNCTION__, SYSTEM_PQ);
206 }
207 }
208 return rval;
209}
210int CPqData::reopenDB()
211{
212 int rval = openDb(PQ_DB_PATH);
213 return rval;
214}
215
216int CPqData::getRegValues(const char *table_name, tvin_port_t source, tvin_sig_fmt_t signal,
217 is_3d_type_t is2dOr3d, tvin_trans_fmt_t trans_fmt __unused, am_regs_t *regs)
218{
219 CSqlite::Cursor c_tablelist, c_reg_list;
220 int index_am_reg = 0;
221 char sqlmaster[256];
222 int mode = is2dOr3d;//Check2Dor3D(status, trans_fmt);
223 if (table_name == NULL || !strlen(table_name)) {
224 LOGE("%s, table_name is null\n", __FUNCTION__);
225 return index_am_reg;
226 }
227
228 getSqlParams(__FUNCTION__, sqlmaster,
229 "select TableName from %s where "
230 "TVIN_PORT = %d and "
231 "TVIN_SIG_FMT = %d and "
232 "TVIN_TRANS_FMT = %d ;", table_name, source, signal, mode);
233 this->select(sqlmaster, c_tablelist);
234 if (c_tablelist.moveToFirst()) { //for table list
235 do {
236 getSqlParams(__FUNCTION__, sqlmaster,
237 "select RegType, RegAddr, RegMask, RegValue from %s;",
238 c_tablelist.getString(0).string());
239 this->select(sqlmaster, c_reg_list);
240
241 if (c_reg_list.moveToFirst()) { //reg list for each table
242 int index_type = 0;//c_reg_list.getColumnIndex("RegType");
243 int index_addr = 1;//c_reg_list.getColumnIndex("RegAddr");
244 int index_mask = 2;//c_reg_list.getColumnIndex("RegMask");
245 int index_val = 3;//c_reg_list.getColumnIndex("RegValue");
246 do {
247 regs->am_reg[index_am_reg].type = c_reg_list.getUInt(index_type);
248 regs->am_reg[index_am_reg].addr = c_reg_list.getUInt(index_addr);
249 regs->am_reg[index_am_reg].mask = c_reg_list.getUInt(index_mask);
250 regs->am_reg[index_am_reg].val = c_reg_list.getUInt(index_val);
251 index_am_reg++;
252 } while (c_reg_list.moveToNext());
253 }
254 } while (c_tablelist.moveToNext());
255 }
256 //
257 regs->length = index_am_reg;
258 LOGD("%s, length = %d", __FUNCTION__, regs->length);
259 return index_am_reg;
260}
261
262int CPqData::getRegValuesByValue(const char *name, const char *f_name, const char *f2_name,
263 const int val, const int val2, am_regs_t *regs)
264{
265 CSqlite::Cursor c_reg_list;
266 char sqlmaster[256];
267 int rval = -1;
268 //first get table name
269 if ((strlen(f2_name) == 0) && (val2 == 0))
270 getSqlParams(__FUNCTION__, sqlmaster,
271 "select RegType, RegAddr, RegMask, RegValue from %s where %s = %d;", name, f_name,
272 val);
273 else
274 getSqlParams(__FUNCTION__, sqlmaster,
275 "select RegType, RegAddr, RegMask, RegValue from %s where %s = %d and %s = %d;",
276 name, f_name, val, f2_name, val2);
277
278 rval = this->select(sqlmaster, c_reg_list);
279 int count = c_reg_list.getCount();
280 if (count > REGS_MAX_NUMBER) {
281 LOGD("%s, regs is too more, in pq.db count = %d", __FUNCTION__, count);
282 return -1;
283 }
284 int index_am_reg = 0;
285 if (c_reg_list.moveToFirst()) { //reg list for each table
286 int index_type = 0;//c_reg_list.getColumnIndex("RegType");
287 int index_addr = 1;//c_reg_list.getColumnIndex("RegAddr");
288 int index_mask = 2;//c_reg_list.getColumnIndex("RegMask");
289 int index_val = 3;//c_reg_list.getColumnIndex("RegValue");
290 do {
291 regs->am_reg[index_am_reg].type = c_reg_list.getUInt(index_type);
292 regs->am_reg[index_am_reg].addr = c_reg_list.getUInt(index_addr);
293 regs->am_reg[index_am_reg].mask = c_reg_list.getUInt(index_mask);
294 regs->am_reg[index_am_reg].val = c_reg_list.getUInt(index_val);
295 index_am_reg++;
296 } while (c_reg_list.moveToNext());
297 } else
298 rval = -1;
299 //
300 regs->length = index_am_reg;
301 LOGD("%s, length = %d", __FUNCTION__, regs->length);
302 return rval;
303}
304
305int CPqData::getRegValuesByValue_long(const char *name, const char *f_name, const char *f2_name,
306 const int val, const int val2, am_regs_t *regs, am_regs_t *regs_1)
307{
308 CSqlite::Cursor c_reg_list;
309 char sqlmaster[256];
310 int rval = -1;
311 //first get table name
312 if ((strlen(f2_name) == 0) && (val2 == 0))
313 getSqlParams(__FUNCTION__, sqlmaster,
314 "select RegType, RegAddr, RegMask, RegValue from %s where %s = %d;", name, f_name,
315 val);
316 else
317 getSqlParams(__FUNCTION__, sqlmaster,
318 "select RegType, RegAddr, RegMask, RegValue from %s where %s = %d and %s = %d;",
319 name, f_name, val, f2_name, val2);
320
321 rval = this->select(sqlmaster, c_reg_list);
322
323 int index_am_reg = 0;
324 int count = c_reg_list.getCount();
325 if (count > 1024) {
326 LOGD("%s, regs is too more, in pq.db count = %d", __FUNCTION__, count);
327 return -1;
328 }
329 if (c_reg_list.moveToFirst()) { //reg list for each table
330 int index_type = 0;//c_reg_list.getColumnIndex("RegType");
331 int index_addr = 1;//c_reg_list.getColumnIndex("RegAddr");
332 int index_mask = 2;//c_reg_list.getColumnIndex("RegMask");
333 int index_val = 3;//c_reg_list.getColumnIndex("RegValue");
334 do {
335 if (index_am_reg < 512) {
336 regs->am_reg[index_am_reg].type = c_reg_list.getUInt(index_type);
337 regs->am_reg[index_am_reg].addr = c_reg_list.getUInt(index_addr);
338 regs->am_reg[index_am_reg].mask = c_reg_list.getUInt(index_mask);
339 regs->am_reg[index_am_reg].val = c_reg_list.getUInt(index_val);
340 } else if (index_am_reg >= 512 && index_am_reg < 1024) {
341 regs_1->am_reg[index_am_reg - 512].type = c_reg_list.getUInt(index_type);
342 regs_1->am_reg[index_am_reg - 512].addr = c_reg_list.getUInt(index_addr);
343 regs_1->am_reg[index_am_reg - 512].mask = c_reg_list.getUInt(index_mask);
344 regs_1->am_reg[index_am_reg - 512].val = c_reg_list.getUInt(index_val);
345 } else {
346 }
347 index_am_reg++;
348 } while (c_reg_list.moveToNext());
349 } else
350 rval = -1;
351 //
352 if (count < 512) {
353 regs->length = index_am_reg;
354 } else if (index_am_reg >= 512 && index_am_reg < 1024) {
355 regs->length = 512;
356 regs_1->length = index_am_reg - 512;
357 }
358 LOGD("%s, length = %d", __FUNCTION__, index_am_reg);
359 return rval;
360}
361
362int CPqData::PQ_GetBaseColorParams(vpp_color_basemode_t basemode, tvin_port_t source_port,
363 tvin_sig_fmt_t sig_fmt, is_3d_type_t is2dOr3d,
364 tvin_trans_fmt_t trans_fmt __unused, am_regs_t *regs)
365{
366 CSqlite::Cursor c;
367 char sqlmaster[256];
368 int mode = is2dOr3d;//Check2Dor3D(status, trans_fmt);
369 int rval = -1;
370 getSqlParams(__FUNCTION__, sqlmaster,
371 "select TableName from GeneralColormanagementTable where "
372 "TVIN_PORT = %d and "
373 "TVIN_SIG_FMT = %d and "
374 "TVIN_TRANS_FMT = %d ;", source_port, sig_fmt, mode);
375
376 this->select(sqlmaster, c);
377
378 if (c.moveToFirst()) {
379 int index_TableName = 0;//c.getColumnIndex("TableName");
380 rval = getRegValuesByValue(c.getString(index_TableName), CM_LEVEL_NAME, "", (int) basemode,
381 0, regs);
382 }
383 return rval;
384}
385
386int CPqData::PQ_GetCM2Params(vpp_color_management2_t basemode, tvin_port_t source_port,
387 tvin_sig_fmt_t sig_fmt, is_3d_type_t is2dOr3d,
388 tvin_trans_fmt_t trans_fmt __unused, am_regs_t *regs)
389{
390 CSqlite::Cursor c;
391 char sqlmaster[256];
392 int mode = is2dOr3d;//Check2Dor3D(status, trans_fmt);
393 int rval = -1;
394 if (source_port >= TVIN_PORT_CVBS0 && source_port <= TVIN_PORT_CVBS7) {
395 if (source_port != TVIN_PORT_CVBS3) {
396 source_port = TVIN_PORT_CVBS1;
397 }
398 } else if (source_port >= TVIN_PORT_HDMI0 && source_port <= TVIN_PORT_HDMI7) {
399 source_port = TVIN_PORT_HDMI0;
400 } else if (source_port > TVIN_PORT_DTV || source_port < TVIN_PORT_NULL) {
401 source_port = TVIN_PORT_MPEG0;
402 }
403
404 if (sig_fmt >= TVIN_SIG_FMT_MAX) {
405 sig_fmt = TVIN_SIG_FMT_NULL;
406 }
407
408 getSqlParams(__FUNCTION__, sqlmaster, "select TableName from GeneralCM2Table where "
409 "TVIN_PORT = %d and "
410 "TVIN_SIG_FMT = %d and "
411 "TVIN_TRANS_FMT = %d ;", source_port, sig_fmt, mode);
412
413 rval = this->select(sqlmaster, c);
414
415 if (c.moveToFirst()) {
416 int index_TableName = 0;//c.getColumnIndex("TableName");
417 rval = getRegValuesByValue(c.getString(index_TableName), CM_LEVEL_NAME, "", (int) basemode,
418 0, regs);
419 }
420 return rval;
421}
422
423int CPqData::PQ_GetNR2Params(vpp_noise_reduction2_mode_t nr_mode, tvin_port_t source_port,
424 tvin_sig_fmt_t sig_fmt, is_3d_type_t is2dOr3d,
425 tvin_trans_fmt_t trans_fmt __unused, am_regs_t *regs)
426{
427 CSqlite::Cursor c;
428 char sqlmaster[256];
429 int mode = is2dOr3d;//Check2Dor3D(status, trans_fmt);
430 int rval = -1;
431
432 if (source_port >= TVIN_PORT_CVBS0 && source_port <= TVIN_PORT_CVBS7) {
433 if (source_port != TVIN_PORT_CVBS3) {
434 source_port = TVIN_PORT_CVBS1;
435 }
436 } else if (source_port >= TVIN_PORT_HDMI0 && source_port <= TVIN_PORT_HDMI7) {
437 source_port = TVIN_PORT_HDMI0;
438 } else if (source_port > TVIN_PORT_DTV || source_port < TVIN_PORT_NULL) {
439 source_port = TVIN_PORT_MPEG0;
440 }
441
442 getSqlParams(__FUNCTION__, sqlmaster, "select TableName from GeneralNR2Table where "
443 "TVIN_PORT = %d and "
444 "TVIN_SIG_FMT = %d and "
445 "TVIN_TRANS_FMT = %d ;", source_port, sig_fmt, mode);
446
447 rval = this->select(sqlmaster, c);
448
449 if (c.moveToFirst()) {
450 int index_TableName = 0;//c.getColumnIndex("TableName");
451 rval = getRegValuesByValue(c.getString(index_TableName), LEVEL_NAME, "", (int) nr_mode, 0,
452 regs);
453 }
454 return rval;
455}
456
457int CPqData::PQ_GetXVYCCParams(vpp_xvycc_mode_t xvycc_mode, tvin_port_t source_port,
458 tvin_sig_fmt_t sig_fmt, is_3d_type_t is2dOr3d,
459 tvin_trans_fmt_t trans_fmt __unused, am_regs_t *regs,
460 am_regs_t *regs_1)
461{
462 CSqlite::Cursor c;
463 char sqlmaster[256];
464 int mode = is2dOr3d;//Check2Dor3D(status, trans_fmt);
465 int rval = -1;
466
467 if (source_port >= TVIN_PORT_CVBS0 && source_port <= TVIN_PORT_CVBS7) {
468 if (source_port != TVIN_PORT_CVBS3) {
469 source_port = TVIN_PORT_CVBS1;
470 }
471 } else if (source_port >= TVIN_PORT_HDMI0 && source_port <= TVIN_PORT_HDMI7) {
472 source_port = TVIN_PORT_HDMI0;
473 } else if (source_port > TVIN_PORT_DTV || source_port < TVIN_PORT_NULL) {
474 source_port = TVIN_PORT_MPEG0;
475 }
476
477 getSqlParams(__FUNCTION__, sqlmaster, "select TableName from GeneralXVYCCTable where "
478 "TVIN_PORT = %d and "
479 "TVIN_SIG_FMT = %d and "
480 "TVIN_TRANS_FMT = %d ;", source_port, sig_fmt, mode);
481
482 rval = this->select(sqlmaster, c);
483
484 if (c.moveToFirst()) {
485 int index_TableName = 0;//c.getColumnIndex("TableName");
486 rval = getRegValuesByValue_long(c.getString(index_TableName), LEVEL_NAME, "",
487 (int) xvycc_mode, 0, regs, regs_1);
488 }
489 return rval;
490}
491
492int CPqData::PQ_GetMCDIParams(vpp_mcdi_mode_t mcdi_mode, tvin_port_t source_port,
493 tvin_sig_fmt_t sig_fmt, is_3d_type_t is2dOr3d,
494 tvin_trans_fmt_t trans_fmt __unused, am_regs_t *regs)
495{
496 CSqlite::Cursor c;
497 char sqlmaster[256];
498 int mode = is2dOr3d;//Check2Dor3D(status, trans_fmt);
499 int rval = -1;
500
501 if (source_port >= TVIN_PORT_CVBS0 && source_port <= TVIN_PORT_CVBS7) {
502 if (source_port != TVIN_PORT_CVBS3) {
503 source_port = TVIN_PORT_CVBS1;
504 }
505 } else if (source_port >= TVIN_PORT_HDMI0 && source_port <= TVIN_PORT_HDMI7) {
506 source_port = TVIN_PORT_HDMI0;
507 } else if (source_port > TVIN_PORT_DTV || source_port < TVIN_PORT_NULL) {
508 source_port = TVIN_PORT_MPEG0;
509 }
510
511 getSqlParams(__FUNCTION__, sqlmaster, "select TableName from GeneralMCDITable where "
512 "TVIN_PORT = %d and "
513 "TVIN_SIG_FMT = %d and "
514 "TVIN_TRANS_FMT = %d ;", source_port, sig_fmt, mode);
515
516 rval = this->select(sqlmaster, c);
517
518 if (c.moveToFirst()) {
519 int index_TableName = 0;//c.getColumnIndex("TableName");
520 rval = getRegValuesByValue(c.getString(index_TableName), LEVEL_NAME, "", (int) mcdi_mode,
521 0, regs);
522 }
523 return rval;
524}
525
526int CPqData::PQ_GetDeblockParams(vpp_deblock_mode_t deb_mode, tvin_port_t source_port,
527 tvin_sig_fmt_t sig_fmt, is_3d_type_t is2dOr3d,
528 tvin_trans_fmt_t trans_fmt __unused, am_regs_t *regs)
529{
530 CSqlite::Cursor c;
531 char sqlmaster[256];
532 int mode = is2dOr3d;//Check2Dor3D(status, trans_fmt);
533 int rval = -1;
534
535 getSqlParams(__FUNCTION__, sqlmaster, "select TableName from GeneralDeblockTable where "
536 "TVIN_PORT = %d and "
537 "TVIN_SIG_FMT = %d and "
538 "TVIN_TRANS_FMT = %d ;", source_port, sig_fmt, is2dOr3d);
539
540 rval = this->select(sqlmaster, c);
541
542 if (c.moveToFirst()) {
543 rval = getRegValuesByValue(c.getString(0), LEVEL_NAME, "", (int)deb_mode, 0, regs);
544 }
545 return rval;
546}
547
548int CPqData::PQ_GetColorTemperatureParams(vpp_color_temperature_mode_t Tempmode,
549 tvin_port_t source_port, tvin_sig_fmt_t sig_fmt, tvin_trans_fmt_t trans_fmt,
550 tcon_rgb_ogo_t *params)
551{
552 CSqlite::Cursor c;
553 char sqlmaster[256];
554
555 int rval = -1;
556
557 //default
558 params->en = 1;
559 params->r_pre_offset = 0;
560 params->g_pre_offset = 0;
561 params->b_pre_offset = 0;
562 params->r_gain = 1024;
563 params->g_gain = 1024;
564 params->b_gain = 1024;
565 params->r_post_offset = 0;
566 params->g_post_offset = 0;
567 params->b_post_offset = 0;
568
569 getSqlParams(__FUNCTION__, sqlmaster, "select TableName from GeneralWhiteBalanceTable where "
570 "TVIN_PORT = %d and "
571 "TVIN_SIG_FMT = %d and "
572 "TVIN_TRANS_FMT = %d;", source_port, sig_fmt, trans_fmt);
573
574 rval = this->select(sqlmaster, c);
575
576 if (c.moveToFirst()) {
577 int index_TableName = 0;//c.getColumnIndex("TableName");
578 getSqlParams(
579 __FUNCTION__,
580 sqlmaster,
581 "select Enable, R_Pre_Offset, G_Pre_Offset, B_Pre_Offset, R_Gain, G_Gain, B_Gain, R_Post_Offset, G_Post_Offset, B_Post_Offset from %s where "
582 "Level = %d and def = 0;", c.getString(index_TableName).string(),
583 (int) Tempmode);
584
585 rval = this->select(sqlmaster, c);
586
587 if (c.moveToFirst()) {
588 params->en = c.getInt(0);//index 0
589 params->r_pre_offset = c.getInt(1);
590 params->g_pre_offset = c.getInt(2);
591 params->b_pre_offset = c.getInt(3);
592 params->r_gain = c.getInt(4);
593 params->g_gain = c.getInt(5);
594 params->b_gain = c.getInt(6);
595 params->r_post_offset = c.getInt(7);
596 params->g_post_offset = c.getInt(8);
597 params->b_post_offset = c.getInt(9);//index 9
598 }
599 }
600 return rval;
601}
602int CPqData::PQ_SetColorTemperatureParams(vpp_color_temperature_mode_t Tempmode,
603 tvin_port_t source_port, tvin_sig_fmt_t sig_fmt, tvin_trans_fmt_t trans_fmt,
604 tcon_rgb_ogo_t params)
605{
606 CSqlite::Cursor c;
607 char sqlmaster[256];
608 char sql[512];
609
610 int rval = -1;
611
612 getSqlParams(__FUNCTION__, sqlmaster, "select TableName from GeneralWhiteBalanceTable where "
613 "TVIN_PORT = %d and "
614 "TVIN_SIG_FMT = %d and "
615 "TVIN_TRANS_FMT = %d;", source_port, sig_fmt, trans_fmt);
616
617 rval = this->select(sqlmaster, c);
618
619 if (c.moveToFirst()) {
620 int index_TableName = 0;//c.getColumnIndex("TableName");
621 getSqlParams(
622 __FUNCTION__,
623 sql,
624 "update %s set Enable = %d, "
625 "R_Pre_Offset = %d, G_Pre_Offset = %d, B_Pre_Offset = %d, R_Gain = %d, G_Gain = %d, B_Gain = %d, "
626 "R_Post_Offset = %d, G_Post_Offset = %d, B_Post_Offset = %d where Level = %d and def = 0;",
627 c.getString(index_TableName).string(), params.en, params.r_pre_offset,
628 params.g_pre_offset, params.b_pre_offset, params.r_gain, params.g_gain,
629 params.b_gain, params.r_post_offset, params.g_post_offset, params.b_post_offset,
630 Tempmode);
631
632 rval = this->exeSql(sql);
633 }
634 return rval;
635}
636
637int CPqData::PQ_ResetAllColorTemperatureParams(void)
638{
639 CSqlite::Cursor c;
640 char sqlmaster[512];
641
642 int rval = -1;
643
644 getSqlParams(__FUNCTION__, sqlmaster,
645 "select distinct TableName from GeneralWhiteBalanceTable ;");
646
647 rval = this->select(sqlmaster, c);
648
649 if (c.moveToFirst()) {
650 int index_TableName = 0;//c.getColumnIndex("TableName");
651 do { //delete
652 getSqlParams(
653 __FUNCTION__,
654 sqlmaster,
655 "delete from %s where def = 0;"
656 "insert into %s( Level , Enable , R_Pre_Offset, G_Pre_Offset, B_Pre_Offset, R_Gain, G_Gain, B_Gain, R_Post_Offset, G_Post_Offset, B_Post_Offset, def ) "
657 "select Level, Enable, R_Pre_Offset, G_Pre_Offset, B_Pre_Offset, R_Gain, G_Gain, B_Gain, R_Post_Offset, G_Post_Offset, B_Post_Offset, 0 from %s where def = 1;",
658 c.getString(index_TableName).string(), c.getString(index_TableName).string(),
659 c.getString(index_TableName).string());
660 rval = this->exeSql(sqlmaster);
661 } while (c.moveToNext());
662 }
663 return rval;
664}
665
666int CPqData::PQ_GetDNLPParams(tvin_port_t source_port, tvin_sig_fmt_t fmt, is_3d_type_t is2dOr3d,
667 tvin_trans_fmt_t trans_fmt __unused, ve_dnlp_t *params,
668 ve_dnlp_table_t *newParams, int *dnlpFlag)
669{
670 CSqlite::Cursor c;
671 char sqlmaster[256];
672 int mode = is2dOr3d;//Check2Dor3D(status, trans_fmt);
673 int rval = -1;
674 //default
675 params->en = 0;
676 params->rt = VE_DNLP_RT_0S;
677 params->rl = VE_DNLP_RL_01;
678 params->black = VE_DNLP_EXT_00;
679 params->white = VE_DNLP_EXT_00;
680
681 mode = is2dOr3d;//Check2Dor3D(status, trans_fmt);//(status << 16)|trans_fmt;
682
683 getSqlParams(__FUNCTION__, sqlmaster, "select TableName from GeneralDNLPTable where "
684 "TVIN_PORT = %d and "
685 "TVIN_SIG_FMT = %d and "
686 "TVIN_TRANS_FMT = %d ;", source_port, fmt, mode);
687
688 rval = this->select(sqlmaster, c);
689
690 if (c.moveToFirst()) {
691 int index_TableName = 0;//c.getColumnIndex("TableName");
692 getSqlParams(__FUNCTION__, sqlmaster, "select value from %s ",
693 c.getString(index_TableName).string());
694
695 rval = this->select(sqlmaster, c);
696 int count = c.getCount();
697 if (count == 1) {
698 int val;
699 c.moveToFirst();
700 val = c.getInt(0);//index 0
701 *dnlpFlag = 0;
702 params->en = (val & 0xf0000000) >> 28;
703 params->rt = (ve_dnlp_rt_e)((val & 0x0f000000) >> 24);
704 params->rl = (ve_dnlp_rl_e)((val & 0x00ff0000) >> 16);
705 params->black = (ve_dnlp_ext_e)((val & 0x0000ff00) >> 8);
706 params->white = (ve_dnlp_ext_e)((val & 0x000000ff) >> 0);
707 } else if (count > 1) {
708 c.moveToFirst();
709 c.moveToNext();
710 *dnlpFlag = 1;
711 newParams->en = c.getInt(0);
712 c.moveToNext();
713 newParams->method = c.getInt(0);
714 c.moveToNext();
715 newParams->cliprate = c.getInt(0);
716 c.moveToNext();
717 newParams->lowrange = c.getInt(0);
718 c.moveToNext();
719 newParams->hghrange = c.getInt(0);
720 c.moveToNext();
721 newParams->lowalpha = c.getInt(0);
722 c.moveToNext();
723 newParams->midalpha = c.getInt(0);
724 c.moveToNext();
725 newParams->hghalpha = c.getInt(0);
726 c.moveToNext();
727 newParams->adj_level = c.getInt(0);
728 c.moveToNext();
729 newParams->new_adj_level = c.getInt(0);
730 c.moveToNext();
731 newParams->new_mvreflsh = c.getInt(0);
732 c.moveToNext();
733 newParams->new_gmma_rate = c.getInt(0);
734 c.moveToNext();
735 newParams->new_lowalpha = c.getInt(0);
736 c.moveToNext();
737 newParams->new_hghalpha = c.getInt(0);
738 c.moveToNext();
739 newParams->new_sbgnbnd = c.getInt(0);
740 c.moveToNext();
741 newParams->new_sendbnd = c.getInt(0);
742 c.moveToNext();
743 newParams->new_clashBgn = c.getInt(0);
744 c.moveToNext();
745 newParams->new_clashEnd = c.getInt(0);
746 c.moveToNext();
747 newParams->new_cliprate = c.getInt(0);
748 c.moveToNext();
749 newParams->new_mtdbld_rate = c.getInt(0);
750 c.moveToNext();
751 newParams->new_blkgma_rate = c.getInt(0);
752 }
753 }
754 return rval;
755}
756
757int CPqData::PQ_SetNoLineAllBrightnessParams(tv_source_input_type_t source_type, int osd0,
758 int osd25, int osd50, int osd75, int osd100)
759{
760 return SetNonlinearMapping(TVPQ_DATA_BRIGHTNESS, source_type, osd0, osd25, osd50, osd75, osd100);
761}
762
763int CPqData::PQ_GetNoLineAllBrightnessParams(tv_source_input_type_t source_type, int *osd0,
764 int *osd25, int *osd50, int *osd75, int *osd100)
765{
766 int osdvalue[5] = { 0 };
767 int rval;
768 rval = GetNonlinearMappingByOSDFac(TVPQ_DATA_BRIGHTNESS, source_type, osdvalue);
769 *osd0 = osdvalue[0];
770 *osd25 = osdvalue[1];
771 *osd50 = osdvalue[2];
772 *osd75 = osdvalue[3];
773 *osd100 = osdvalue[4];
774 if (rval) {
775 LOGE("PQ_GetNoLineAllBrightnessParams Error %d\n", rval);
776 }
777 return rval;
778
779}
780
781int CPqData::PQ_GetBrightnessParams(tvin_port_t source_port, tvin_sig_fmt_t sig_fmt __unused,
782 is_3d_type_t is2dOr3d __unused, tvin_trans_fmt_t trans_fmt __unused,
783 int level, int *params)
784{
785 int val;
786
787 GetNonlinearMapping(TVPQ_DATA_BRIGHTNESS, source_port, level, &val);
788 *params = CaculateLevelParam(pq_bri_data, bri_nodes, val);
789 return 0;
790
791}
792
793int CPqData::PQ_SetBrightnessParams(tvin_port_t source_port __unused, tvin_sig_fmt_t sig_fmt __unused,
794 is_3d_type_t is2dOr3d __unused, tvin_trans_fmt_t trans_fmt __unused,
795 int level __unused, int params __unused)
796{
797 return 0;
798}
799
800int CPqData::PQ_SetNoLineAllContrastParams(tv_source_input_type_t source_type, int osd0, int osd25,
801 int osd50, int osd75, int osd100)
802{
803 return SetNonlinearMapping(TVPQ_DATA_CONTRAST, source_type, osd0, osd25, osd50, osd75, osd100);
804}
805
806int CPqData::PQ_GetNoLineAllContrastParams(tv_source_input_type_t source_type, int *osd0,
807 int *osd25, int *osd50, int *osd75, int *osd100)
808{
809 int osdvalue[5] = { 0 };
810 int rval;
811 rval = GetNonlinearMappingByOSDFac(TVPQ_DATA_CONTRAST, source_type, osdvalue);
812 *osd0 = osdvalue[0];
813 *osd25 = osdvalue[1];
814 *osd50 = osdvalue[2];
815 *osd75 = osdvalue[3];
816 *osd100 = osdvalue[4];
817 if (rval) {
818 LOGE("PQ_GetNoLineAllContrastParams Error %d\n", rval);
819 }
820 return rval;
821}
822
823int CPqData::PQ_GetContrastParams(tvin_port_t source_port, tvin_sig_fmt_t sig_fmt __unused,
824 is_3d_type_t is2dOr3d __unused, tvin_trans_fmt_t trans_fmt __unused,
825 int level, int *params)
826{
827 int val;
828
829 GetNonlinearMapping(TVPQ_DATA_CONTRAST, source_port, level, &val);
830 *params = CaculateLevelParam(pq_con_data, con_nodes, val);
831 return 0;
832}
833
834int CPqData::PQ_SetContrastParams(tvin_port_t source_port __unused, tvin_sig_fmt_t sig_fmt __unused,
835 is_3d_type_t is2dOr3d __unused, tvin_trans_fmt_t trans_fmt __unused,
836 int level __unused, int params __unused)
837{
838 return 0;
839}
840
841int CPqData::PQ_SetNoLineAllSaturationParams(tv_source_input_type_t source_type, int osd0,
842 int osd25, int osd50, int osd75, int osd100)
843{
844 return SetNonlinearMapping(TVPQ_DATA_SATURATION, source_type, osd0, osd25, osd50, osd75, osd100);
845}
846
847int CPqData::PQ_GetNoLineAllSaturationParams(tv_source_input_type_t source_type, int *osd0,
848 int *osd25, int *osd50, int *osd75, int *osd100)
849{
850 int osdvalue[5] = { 0 };
851 int rval;
852 rval = GetNonlinearMappingByOSDFac(TVPQ_DATA_SATURATION, source_type, osdvalue);
853 *osd0 = osdvalue[0];
854 *osd25 = osdvalue[1];
855 *osd50 = osdvalue[2];
856 *osd75 = osdvalue[3];
857 *osd100 = osdvalue[4];
858 if (rval) {
859 LOGE("PQ_GetNoLineAllSaturationParams Error %d\n", rval);
860 }
861 return rval;
862}
863
864int CPqData::PQ_GetSaturationParams(tvin_port_t source_port, tvin_sig_fmt_t sig_fmt __unused,
865 is_3d_type_t is2dOr3d __unused, tvin_trans_fmt_t trans_fmt __unused,
866 int level, int *params)
867{
868 int val;
869
870 GetNonlinearMapping(TVPQ_DATA_SATURATION, source_port, level, &val);
871 *params = CaculateLevelParam(pq_sat_data, sat_nodes, val);
872 return 0;
873}
874
875int CPqData::PQ_SetSaturationParams(tvin_port_t source_port __unused, tvin_sig_fmt_t sig_fmt __unused,
876 is_3d_type_t is2dOr3d __unused, tvin_trans_fmt_t trans_fmt __unused,
877 int level __unused, int params __unused)
878{
879 return 0;
880}
881
882int CPqData::PQ_SetNoLineAllHueParams(tv_source_input_type_t source_type, int osd0, int osd25,
883 int osd50, int osd75, int osd100)
884{
885 return SetNonlinearMapping(TVPQ_DATA_HUE, source_type, osd0, osd25, osd50, osd75, osd100);
886}
887
888int CPqData::PQ_GetNoLineAllHueParams(tv_source_input_type_t source_type, int *osd0, int *osd25,
889 int *osd50, int *osd75, int *osd100)
890{
891 int osdvalue[5] = { 0 };
892 int rval;
893 rval = GetNonlinearMappingByOSDFac(TVPQ_DATA_HUE, source_type, osdvalue);
894 *osd0 = osdvalue[0];
895 *osd25 = osdvalue[1];
896 *osd50 = osdvalue[2];
897 *osd75 = osdvalue[3];
898 *osd100 = osdvalue[4];
899 if (rval) {
900 LOGE("PQ_GetNoLineAllHueParams Error %d\n", rval);
901 }
902 return rval;
903}
904
905int CPqData::PQ_GetHueParams(tvin_port_t source_port, tvin_sig_fmt_t sig_fmt __unused,
906 is_3d_type_t is2dOr3d __unused, tvin_trans_fmt_t trans_fmt __unused,
907 int level, int *params)
908{
909 int val;
910
911 GetNonlinearMapping(TVPQ_DATA_HUE, source_port, level, &val);
912 *params = CaculateLevelParam(pq_hue_data, hue_nodes, val);
913 return 0;
914}
915
916int CPqData::PQ_SetHueParams(tvin_port_t source_port __unused, tvin_sig_fmt_t sig_fmt __unused,
917 is_3d_type_t is2dOr3d __unused, tvin_trans_fmt_t trans_fmt __unused,
918 int level __unused, int params __unused)
919{
920 return 0;
921}
922
923int CPqData::PQ_SetNoLineAllSharpnessParams(tv_source_input_type_t source_type, int osd0,
924 int osd25, int osd50, int osd75, int osd100)
925{
926 return SetNonlinearMapping(TVPQ_DATA_SHARPNESS, source_type, osd0, osd25, osd50, osd75, osd100);
927}
928
929int CPqData::PQ_GetNoLineAllSharpnessParams(tv_source_input_type_t source_type, int *osd0,
930 int *osd25, int *osd50, int *osd75, int *osd100)
931{
932 int osdvalue[5] = { 0 };
933 int rval;
934 rval = GetNonlinearMappingByOSDFac(TVPQ_DATA_SHARPNESS, source_type, osdvalue);
935 *osd0 = osdvalue[0];
936 *osd25 = osdvalue[1];
937 *osd50 = osdvalue[2];
938 *osd75 = osdvalue[3];
939 *osd100 = osdvalue[4];
940 if (rval) {
941 LOGE("PQ_GetNoLineAllSharpnessParams Error %d\n", rval);
942 }
943 return rval;
944}
945
946int CPqData::PQ_GetSharpnessParams(tvin_port_t source_port, tvin_sig_fmt_t sig_fmt __unused,
947 is_3d_type_t is2dOr3d __unused, tvin_trans_fmt_t trans_fmt __unused,
948 int level, am_regs_t *regs, am_regs_t *regs_l)
949{
950 int val;
951
952 GetNonlinearMapping(TVPQ_DATA_SHARPNESS, source_port, level, &val);
953 LOGD("val = %d\n", val);
954 *regs = CaculateLevelRegsParam(pq_sharpness_reg_data, val, 0);
955 if (sha_diff_flag == 6) {
956 *regs_l = CaculateLevelRegsParam(pq_sharpness_reg_data_1, val, 1);
957 }
958 return 0;
959}
960
961int CPqData::PQ_GetPLLParams(tvin_port_t source_port, tvin_sig_fmt_t sig_fmt, am_regs_t *regs)
962{
963 int ret = -1;
964 int i = 0;
965
966 ret = getRegValuesByValue(ADC_SETTING, PORT, FORMAT, source_port, sig_fmt, regs);
967#ifdef CPQDB_DEBUG
968 if (ret == 0) {
969 for (i = 0; i < regs->length; i++) {
970 LOGD("%s, =================================================", "TV");
971 LOGD("%s, regData.am_reg[%d].type = %d", "TV", i, regs->am_reg[i].type);
972 LOGD("%s, regData.am_reg[%d].addr = %d", "TV", i, regs->am_reg[i].addr);
973 LOGD("%s, regData.am_reg[%d].mask = %d", "TV", i, regs->am_reg[i].mask);
974 LOGD("%s, regData.am_reg[%d].val = %d", "TV", i, regs->am_reg[i].val);
975 }
976 }
977#endif
978 if (regs->am_reg[0].val == 0 && regs->am_reg[1].val == 0 && regs->am_reg[2].val == 0
979 && regs->am_reg[3].val == 0) {
980 LOGE("%s,db's value is all zeros, that's not OK!!!\n", "TV");
981 return -1;
982 }
983 return ret;
984}
985
986int CPqData::PQ_GetCVD2Params(tvin_port_t source_port, tvin_sig_fmt_t sig_fmt, am_regs_t *regs)
987{
988 int ret = -1;
989 int i = 0;
990 ret = getRegValuesByValue(CVD2_SETTING, PORT, FORMAT, source_port, sig_fmt, regs);
991#ifdef CPQDB_DEBUG
992 if (ret == 0) {
993 for (i = 0; i < regs->length; i++) {
994 LOGD("%s, =================================================", "TV");
995 LOGD("%s, regData.am_reg[%d].type = %d", "TV", i, regs->am_reg[i].type);
996 LOGD("%s, regData.am_reg[%d].addr = %d", "TV", i, regs->am_reg[i].addr);
997 LOGD("%s, regData.am_reg[%d].mask = %d", "TV", i, regs->am_reg[i].mask);
998 LOGD("%s, regData.am_reg[%d].val = %d", "TV", i, regs->am_reg[i].val);
999 }
1000 }
1001#endif
1002 if (regs->am_reg[0].val == 0 && regs->am_reg[1].val == 0 && regs->am_reg[2].val == 0
1003 && regs->am_reg[3].val == 0) {
1004 LOGE("%s,db's value is all zeros, that's not OK!!!\n", "TV");
1005 return -1;
1006 }
1007
1008 return ret;
1009}
1010
1011int CPqData::PQ_SetSharpnessParams(tvin_port_t source_port __unused, tvin_sig_fmt_t sig_fmt __unused,
1012 is_3d_type_t is2dOr3d __unused, tvin_trans_fmt_t trans_fmt __unused,
1013 int level __unused, am_regs_t regs __unused)
1014{
1015 return 0;
1016}
1017
1018int CPqData::PQ_SetNoLineAllVolumeParams(tv_source_input_type_t source_type, int osd0, int osd25,
1019 int osd50, int osd75, int osd100)
1020{
1021 return SetNonlinearMapping(TVPQ_DATA_VOLUME, source_type, osd0, osd25, osd50, osd75, osd100);
1022}
1023
1024int CPqData::PQ_GetNoLineAllVolumeParams(tv_source_input_type_t source_type, int *osd0, int *osd25,
1025 int *osd50, int *osd75, int *osd100)
1026{
1027 int osdvalue[5] = { 0 };
1028 int rval;
1029 rval = GetNonlinearMappingByOSDFac(TVPQ_DATA_VOLUME, source_type, osdvalue);
1030 *osd0 = osdvalue[0];
1031 *osd25 = osdvalue[1];
1032 *osd50 = osdvalue[2];
1033 *osd75 = osdvalue[3];
1034 *osd100 = osdvalue[4];
1035 if (rval) {
1036 LOGE("PQ_GetNoLineAllSharpnessParams Error %d\n", rval);
1037 }
1038 return rval;
1039}
1040
1041int CPqData::PQ_SetVolumeParams(tvin_port_t source_port __unused, tvin_sig_fmt_t sig_fmt __unused,
1042 is_3d_type_t is2dOr3d __unused, tvin_trans_fmt_t trans_fmt __unused,
1043 int level __unused, int params __unused)
1044{
1045 return 0;
1046}
1047
1048int CPqData::PQ_ResetAllNoLineParams(void)
1049{
1050 int rval;
1051 char sqlmaster[256];
1052 char *err = NULL;
1053
1054 getSqlParams(
1055 __FUNCTION__,
1056 sqlmaster,
1057 "delete from NonlinearMapping; "
1058 "insert into NonlinearMapping(TVIN_PORT, Item_ID, Level, Value) select TVIN_PORT, Item_ID, Level, Value from NonlinearMapping_Default;");
1059
1060 rval = this->exeSql(sqlmaster);
1061 return rval;
1062}
1063
1064int CPqData::PQ_GetNoiseReductionParams(vpp_noise_reduction_mode_t nr_mode,
1065 tvin_port_t source_port, tvin_sig_fmt_t sig_fmt, is_3d_type_t is2dOr3d,
1066 tvin_trans_fmt_t trans_fmt __unused, int *params)
1067{
1068 CSqlite::Cursor c;
1069 char sqlmaster[256];
1070 int mode = is2dOr3d;//Check2Dor3D(status, trans_fmt);
1071 int rval = -1;
1072
1073 getSqlParams(__FUNCTION__, sqlmaster, "select TableName from GeneralNoiseReductionTable where "
1074 "TVIN_PORT = %d and "
1075 "TVIN_SIG_FMT = %d and "
1076 "TVIN_TRANS_FMT = %d ;", source_port, sig_fmt, mode);
1077
1078 rval = this->select(sqlmaster, c);
1079
1080 if (c.moveToFirst()) {
1081 int index_TableName = 0;//c.getColumnIndex("TableName");
1082 getSqlParams(__FUNCTION__, sqlmaster, "select NRValue from %s where NRLevel = %d;",
1083 c.getString(index_TableName).string(), (int) nr_mode);
1084
1085 rval = this->select(sqlmaster, c);
1086
1087 if (c.moveToFirst()) {
1088 *params = c.getInt(0);
1089 }
1090 }
1091 return rval;
1092}
1093
1094int CPqData::PQ_SetNoiseReductionParams(vpp_noise_reduction_mode_t nr_mode __unused,
1095 tvin_port_t source_port __unused, tvin_sig_fmt_t sig_fmt __unused,
1096 is_3d_type_t is2dOr3d __unused,
1097 tvin_trans_fmt_t trans_fmt __unused, int *params __unused)
1098{
1099 return 0;
1100}
1101
1102int CPqData::PQ_GetOverscanParams(tv_source_input_type_t source_type, tvin_sig_fmt_t fmt,
1103 is_3d_type_t is2dOr3d,
1104 tvin_trans_fmt_t trans_fmt __unused, vpp_display_mode_t dmode __unused,
1105 tvin_cutwin_t *cutwin_t)
1106{
1107 CSqlite::Cursor c;
1108 char sqlmaster[256];
1109 int mode = is2dOr3d;//Check2Dor3D(status, trans_fmt);
1110 int rval = -1;
1111
1112 cutwin_t->hs = 0;
1113 cutwin_t->he = 0;
1114 cutwin_t->vs = 0;
1115 cutwin_t->ve = 0;
1116
1117 getSqlParams(__FUNCTION__, sqlmaster, "select Hs, He, Vs, Ve from OVERSCAN where "
1118 "TVIN_PORT = %d and "
1119 "TVIN_SIG_FMT = %d and "
1120 "TVIN_TRANS_FMT = %d ;", source_type, fmt, mode);
1121
1122 rval = this->select(sqlmaster, c);
1123
1124 if (c.moveToFirst()) {
1125 cutwin_t->hs = c.getInt(0);
1126 cutwin_t->he = c.getInt(1);
1127 cutwin_t->vs = c.getInt(2);
1128 cutwin_t->ve = c.getInt(3);
1129 }
1130 return rval;
1131}
1132int CPqData::PQ_SetOverscanParams(tv_source_input_type_t source_type, tvin_sig_fmt_t fmt,
1133 is_3d_type_t is2dOr3d, tvin_trans_fmt_t trans_fmt __unused, tvin_cutwin_t cutwin_t)
1134{
1135 CSqlite::Cursor c;
1136 char sqlmaster[256];
1137 int mode = is2dOr3d;//Check2Dor3D(status, trans_fmt);
1138 int rval = -1;
1139
1140 getSqlParams(
1141 __FUNCTION__,
1142 sqlmaster,
1143 "select * from OVERSCAN where TVIN_PORT = %d and TVIN_SIG_FMT = %d and TVIN_TRANS_FMT = %d;",
1144 source_type, fmt, mode);
1145
1146 rval = this->select(sqlmaster, c);
1147
1148 if (c.moveToFirst()) {
1149 getSqlParams(
1150 __FUNCTION__,
1151 sqlmaster,
1152 "update OVERSCAN set Hs = %d, He = %d, Vs = %d, Ve = %d where TVIN_PORT = %d and TVIN_SIG_FMT = %d and TVIN_TRANS_FMT = %d;",
1153 cutwin_t.hs, cutwin_t.he, cutwin_t.vs, cutwin_t.ve, source_type, fmt, mode);
1154 } else {
1155 getSqlParams(
1156 __FUNCTION__,
1157 sqlmaster,
1158 "Insert into OVERSCAN(TVIN_PORT, TVIN_SIG_FMT, TVIN_TRANS_FMT, Hs, He, Vs, Ve) values(%d, %d, %d ,%d ,%d, %d, %d);",
1159 source_type, fmt, mode, cutwin_t.hs, cutwin_t.he, cutwin_t.vs, cutwin_t.ve);
1160 }
1161 rval = this->exeSql(sqlmaster);
1162
1163 return rval;
1164}
1165
1166int CPqData::PQ_ResetAllOverscanParams(void)
1167{
1168 int rval;
1169 char sqlmaster[256];
1170
1171 getSqlParams(
1172 __FUNCTION__,
1173 sqlmaster,
1174 "delete from OVERSCAN; insert into OVERSCAN(TVIN_PORT, TVIN_SIG_FMT, TVIN_TRANS_FMT, hs, he, vs, ve) select TVIN_PORT, TVIN_SIG_FMT, TVIN_TRANS_FMT, hs, he, vs, ve from OVERSCAN_default;");
1175 rval = this->exeSql(sqlmaster);
1176
1177 return rval;
1178}
1179
1180int CPqData::PQ_GetPQModeParams(tv_source_input_type_t source_type, vpp_picture_mode_t pq_mode,
1181 vpp_pq_para_t *params)
1182{
1183 CSqlite::Cursor c;
1184 char sqlmaster[256];
1185
1186 int rval = -1;
1187
1188 getSqlParams(__FUNCTION__, sqlmaster,
1189 "select Brightness, Contrast, Saturation, Hue, Sharpness, Backlight, NR from Picture_Mode where "
1190 "TVIN_PORT = %d and "
1191 "Mode = %d ;", source_type, pq_mode);
1192
1193 rval = this->select(sqlmaster, c);
1194
1195 if (c.moveToFirst()) {
1196 params->brightness = c.getInt(0);
1197 params->contrast = c.getInt(1);
1198 params->saturation = c.getInt(2);
1199 params->hue = c.getInt(3);
1200 params->sharpness = c.getInt(4);
1201 params->backlight = c.getInt(5);
1202 params->nr = c.getInt(6);
1203 }
1204 return rval;
1205}
1206
1207int CPqData::PQ_SetPQModeParams(tv_source_input_type_t source_type, vpp_picture_mode_t pq_mode,
1208 vpp_pq_para_t *params)
1209{
1210 int rval;
1211 char sql[256];
1212
1213 getSqlParams(
1214 __FUNCTION__,
1215 sql,
1216 "update Picture_Mode set Brightness = %d, Contrast = %d, Saturation = %d, Hue = %d, Sharpness = %d, Backlight = %d, NR= %d "
1217 " where TVIN_PORT = %d and Mode = %d;", params->brightness, params->contrast,
1218 params->saturation, params->hue, params->sharpness, params->backlight, params->nr,
1219 source_type, pq_mode);
1220 rval = this->exeSql(sql);
1221 return 0;
1222}
1223
1224int CPqData::PQ_SetPQModeParamsByName(const char *name, tv_source_input_type_t source_type,
1225 vpp_picture_mode_t pq_mode, vpp_pq_para_t *params)
1226{
1227 int rval;
1228 char sql[256];
1229
1230 getSqlParams(__FUNCTION__, sql,
1231 "insert into %s(TVIN_PORT, Mode, Brightness, Contrast, Saturation, Hue, Sharpness, Backlight, NR)"
1232 " values(%d,%d,%d,%d,%d,%d,%d,%d,%d);", name, source_type, pq_mode,
1233 params->brightness, params->contrast, params->saturation, params->hue,
1234 params->sharpness, params->backlight, params->nr);
1235
1236 rval = this->exeSql(sql);
1237 return 0;
1238}
1239
1240int CPqData::PQ_ResetAllPQModeParams(void)
1241{
1242 int rval;
1243 char sqlmaster[256];
1244
1245 getSqlParams(
1246 __FUNCTION__,
1247 sqlmaster,
1248 "delete from picture_mode; insert into picture_mode(TVIN_PORT, Mode, Brightness, Contrast, Saturation, Hue, Sharpness, Backlight, NR) select TVIN_PORT, Mode, Brightness, Contrast, Saturation, Hue, Sharpness, Backlight, NR from picture_mode_default;");
1249
1250 rval = this->exeSql(sqlmaster);
1251 return rval;
1252}
1253
1254int CPqData::PQ_GetGammaSpecialTable(int gammaValue, const char *f_name,
1255 tcon_gamma_table_t *gamma_value)
1256{
1257 CSqlite::Cursor c;
1258 char sqlmaster[256];
1259 int rval = -1;
1260
1261 getSqlParams(__FUNCTION__, sqlmaster, "select %s from GAMMA_%d", f_name, gammaValue);
1262
1263 rval = this->select(sqlmaster, c);
1264
1265 if (c.moveToFirst()) {
1266 int index = 0;
1267 do {
1268 gamma_value->data[index] = c.getInt(0);
1269 index++;
1270 } while (c.moveToNext());
1271 }
1272 return rval;
1273}
1274
1275int CPqData::PQ_GetGammaTableR(int panel_id, tvin_port_t source_port, tvin_sig_fmt_t fmt,
1276 tcon_gamma_table_t *gamma_r)
1277{
1278 return PQ_GetGammaTable(panel_id, source_port, fmt, "Red", gamma_r);
1279}
1280
1281int CPqData::PQ_GetGammaTableG(int panel_id, tvin_port_t source_port, tvin_sig_fmt_t fmt,
1282 tcon_gamma_table_t *gamma_g)
1283{
1284 return PQ_GetGammaTable(panel_id, source_port, fmt, "Green", gamma_g);
1285}
1286
1287int CPqData::PQ_GetGammaTableB(int panel_id, tvin_port_t source_port, tvin_sig_fmt_t fmt,
1288 tcon_gamma_table_t *gamma_b)
1289{
1290 return PQ_GetGammaTable(panel_id, source_port, fmt, "Blue", gamma_b);
1291}
1292
1293int CPqData::PQ_GetGammaTable(int panel_id, tvin_port_t source_port, tvin_sig_fmt_t fmt,
1294 const char *f_name, tcon_gamma_table_t *val)
1295{
1296 CSqlite::Cursor c;
1297 char sqlmaster[256];
1298 int rval = -1;
1299
1300 panel_id = panel_id;
1301
1302 getSqlParams(__FUNCTION__, sqlmaster, "select TableName from GeneralGammaTable where "
1303 "TVIN_PORT = %d and "
1304 "TVIN_SIG_FMT = %d;", source_port, fmt);
1305
1306 rval = this->select(sqlmaster, c);
1307 if (c.moveToFirst()) {
1308 int index_TableName = 0;//c.getColumnIndex("TableName");
1309 getSqlParams(__FUNCTION__, sqlmaster, "select %s from %s;", f_name,
1310 c.getString(index_TableName).string());
1311
1312 rval = this->select(sqlmaster, c);
1313 if (c.moveToFirst()) {
1314 int index = 0;
1315 do {
1316 val->data[index] = c.getInt(0);
1317 index++;
1318 } while (c.moveToNext());
1319 }
1320 }
1321 return rval;
1322}
1323
1324int CPqData::PQ_GetVGAAjustPara(tvin_sig_fmt_t vga_fmt, tvafe_vga_parm_t *adjparam)
1325{
1326 CSqlite::Cursor c;
1327 char sqlmaster[256];
1328 int rval = -1;
1329
1330 adjparam->clk_step = 0;
1331 adjparam->phase = 0;
1332 adjparam->hpos_step = 0;
1333 adjparam->vpos_step = 0;
1334 adjparam->vga_in_clean = 0;
1335
1336 getSqlParams(
1337 __FUNCTION__,
1338 sqlmaster,
1339 "select Clk, Phase, HPos, VPos, Vga_in_clean from VGA_AutoParams where TVIN_SIG_FMT = %d",
1340 vga_fmt);
1341
1342 rval = this->select(sqlmaster, c);
1343
1344 if (c.moveToFirst()) {
1345 adjparam->clk_step = c.getInt(0);
1346 adjparam->phase = c.getInt(1);
1347 adjparam->hpos_step = c.getInt(2);
1348 adjparam->vpos_step = c.getInt(3);
1349 adjparam->vga_in_clean = c.getInt(4);
1350 }
1351 return rval;
1352}
1353
1354int CPqData::PQ_SetVGAAjustPara(tvin_sig_fmt_t vga_fmt, tvafe_vga_parm_t adjparam)
1355{
1356 CSqlite::Cursor c;
1357 char sql[256];
1358 int rval = -1;
1359
1360 getSqlParams(__FUNCTION__, sql, "select * from VGA_AutoParams where TVIN_SIG_FMT = %d;",
1361 vga_fmt);
1362
1363 rval = this->select(sql, c);
1364
1365 if (c.moveToFirst()) {
1366 getSqlParams(
1367 __FUNCTION__,
1368 sql,
1369 "Insert into VGA_AutoParams(TVIN_SIG_FMT, Clk, Phase, HPos, VPos, Vga_in_clean) values(%d, %d, %d ,%d ,%d, %d);",
1370 vga_fmt, adjparam.clk_step, adjparam.phase, adjparam.hpos_step, adjparam.vpos_step,
1371 adjparam.vga_in_clean);
1372 } else {
1373 getSqlParams(
1374 __FUNCTION__,
1375 sql,
1376 "update VGA_AutoParams set Clk = %d, Phase = %d, HPos = %d, VPos = %d, Vga_in_clean = %d where TVIN_SIG_FMT = %d;",
1377 adjparam.clk_step, adjparam.phase, adjparam.hpos_step, adjparam.vpos_step,
1378 adjparam.vga_in_clean, vga_fmt);
1379 }
1380 rval = this->exeSql(sql);
1381 return rval;
1382}
1383
1384int CPqData::CaculateLevelParam(tvpq_data_t *pq_data, int nodes, int level)
1385{
1386 int i;
1387
1388 for (i = 0; i < nodes; i++) {
1389 if (level < pq_data[i].IndexValue) {
1390 break;
1391 }
1392 }
1393
1394 if (i == 0) {
1395 return pq_data[i].RegValue;
1396 } else if (i == nodes) {
1397 return pq_data[i - 1].RegValue;
1398 } else {
1399 return pq_data[i - 1].RegValue + (level - pq_data[i - 1].IndexValue) * pq_data[i - 1].step;
1400 }
1401}
1402
1403am_regs_t CPqData::CaculateLevelRegsParam(tvpq_sharpness_regs_t *pq_regs, int level, int flag)
1404{
1405 am_regs_t regs;
1406 int i;
1407 int *pq_nodes = NULL;
1408 if (flag && sha_diff_flag == 6) {
1409 pq_nodes = &sha_nodes_1;
1410 } else {
1411 pq_nodes = &sha_nodes;
1412 }
1413
1414 for (i = 0; i < *pq_nodes; i++) {
1415 if (level < pq_regs[i].reg_data[0].IndexValue) {
1416 break;
1417 }
1418 }
1419
1420 if (i == 0) {
1421 regs.length = pq_regs[i].length;
1422 for (int j = 0; j < pq_regs[i].length; j++) {
1423 regs.am_reg[j].type = pq_regs[i].reg_data[j].Value.type;
1424 regs.am_reg[j].addr = pq_regs[i].reg_data[j].Value.addr;
1425 regs.am_reg[j].mask = pq_regs[i].reg_data[j].Value.mask;
1426 regs.am_reg[j].val = pq_regs[i].reg_data[j].Value.val;
1427 }
1428
1429 } else if (i == *pq_nodes) {
1430 regs.length = pq_regs[i - 1].length;
1431 for (int j = 0; j < pq_regs[i - 1].length; j++) {
1432 regs.am_reg[j].type = pq_regs[i - 1].reg_data[j].Value.type;
1433 regs.am_reg[j].addr = pq_regs[i - 1].reg_data[j].Value.addr;
1434 regs.am_reg[j].mask = pq_regs[i - 1].reg_data[j].Value.mask;
1435 regs.am_reg[j].val = pq_regs[i - 1].reg_data[j].Value.val;
1436 }
1437 } else {
1438 regs.length = pq_regs[i - 1].length;
1439 for (int j = 0; j < pq_regs[i - 1].length; j++) {
1440 regs.am_reg[j].type = pq_regs[i - 1].reg_data[j].Value.type;
1441 regs.am_reg[j].addr = pq_regs[i - 1].reg_data[j].Value.addr;
1442 regs.am_reg[j].mask = pq_regs[i - 1].reg_data[j].Value.mask;
1443 regs.am_reg[j].val = pq_regs[i - 1].reg_data[j].Value.val + (level
1444 - pq_regs[i - 1].reg_data[j].IndexValue) * pq_regs[i - 1].reg_data[j].step;
1445 }
1446 }
1447
1448 return regs;
1449}
1450
1451int CPqData::GetNonlinearMapping(tvpq_data_type_t data_type, tvin_port_t source_port, int level,
1452 int *params)
1453{
1454 CSqlite::Cursor c;
1455 char sqlmaster[256];
1456 int rval = -1;
1457
1458 tv_source_input_type_t type;
1459 //showboz
1460 type = CTvin::Tvin_SourcePortToSourceInputType(source_port);//???
1461
1462 getSqlParams(__FUNCTION__, sqlmaster, "select Value from NonlinearMapping where "
1463 "TVIN_PORT = %d and "
1464 "Item_ID = %d and "
1465 "Level = %d ;", type, data_type, level);
1466
1467 rval = this->select(sqlmaster, c);
1468
1469 if (c.moveToFirst()) {
1470 *params = c.getInt(0);
1471 }
1472 return rval;
1473}
1474
1475int CPqData::GetNonlinearMappingByOSDFac(tvpq_data_type_t data_type,
1476 tv_source_input_type_t source_type, int *params)
1477{
1478 CSqlite::Cursor c;
1479 char sqlmaster[256];
1480 int rval = -1;
1481
1482 getSqlParams(__FUNCTION__, sqlmaster, "select Value from NonlinearMapping where "
1483 "TVIN_PORT = %d and "
1484 "Item_ID = %d and ("
1485 "Level = 0 or Level = 25 or Level = 50 or Level = 75 or Level = 100);", source_type,
1486 data_type);
1487
1488 rval = this->select(sqlmaster, c);
1489
1490 if (c.moveToFirst()) {
1491 params[0] = c.getInt(0);
1492 params[1] = c.getInt(1);
1493 params[2] = c.getInt(2);
1494 params[3] = c.getInt(3);
1495 params[4] = c.getInt(4);
1496 }
1497 return rval;
1498}
1499
1500int CPqData::SetNonlinearMapping(tvpq_data_type_t data_type, tv_source_input_type_t source_type,
1501 int osd0, int osd25, int osd50, int osd75, int osd100)
1502{
1503
1504 int rval;
1505 char *err = NULL;
1506 int osdvalue[101];
1507 double step[4];
1508 char sql[256];
1509
1510 step[0] = (osd25 - osd0) / 25.0;
1511 step[1] = (osd50 - osd25) / 25.0;
1512 step[2] = (osd75 - osd50) / 25.0;
1513 step[3] = (osd100 - osd75) / 25.0;
1514
1515 for (int i = 0; i <= 100; i++) {
1516 if (i == 0) {
1517 osdvalue[i] = osd0;
1518 } else if ((i > 0) && (i <= 25)) {
1519 osdvalue[i] = osd0 + (int) (i * step[0]);
1520 } else if ((i > 25) && (i <= 50)) {
1521 osdvalue[i] = osd25 + (int) ((i - 25) * step[1]);
1522 } else if ((i > 50) && (i <= 75)) {
1523 osdvalue[i] = osd50 + (int) ((i - 50) * step[2]);
1524 } else if ((i > 75) && (i <= 100)) {
1525 osdvalue[i] = osd75 + (int) ((i - 75) * step[3]);
1526 }
1527 getSqlParams(
1528 __FUNCTION__,
1529 sql,
1530 "update NonLinearMapping set Value = %d where TVIN_PORT = %d and Item_ID = %d and Level = %d ;",
1531 osdvalue[i], source_type, data_type, i);
1532 if (!(this->exeSql(sql))) {
1533 return -1;
1534 }
1535 }
1536 return 0;
1537}
1538
1539int CPqData::SetNonlinearMappingByName(const char *name, tvpq_data_type_t data_type,
1540 tv_source_input_type_t source_type, int osd0, int osd25, int osd50, int osd75, int osd100)
1541{
1542 int rval;
1543 char *err = NULL;
1544 int osdvalue[101];
1545 double step[4];
1546 char sql[256];
1547
1548 step[0] = (osd25 - osd0) / 25.0;
1549 step[1] = (osd50 - osd25) / 25.0;
1550 step[2] = (osd75 - osd50) / 25.0;
1551 step[3] = (osd100 - osd75) / 25.0;
1552
1553 for (int i = 0; i <= 100; i++) {
1554 if (i == 0) {
1555 osdvalue[i] = osd0;
1556 } else if ((i > 0) && (i <= 25)) {
1557 osdvalue[i] = osd0 + (int) (i * step[0]);
1558 } else if ((i > 25) && (i <= 50)) {
1559 osdvalue[i] = osd25 + (int) ((i - 25) * step[1]);
1560 } else if ((i > 50) && (i <= 75)) {
1561 osdvalue[i] = osd50 + (int) ((i - 50) * step[2]);
1562 } else if ((i > 75) && (i <= 100)) {
1563 osdvalue[i] = osd75 + (int) ((i - 75) * step[3]);
1564 }
1565 memset(sql, '\0', 256);
1566 getSqlParams(__FUNCTION__, sql,
1567 "insert into %s(TVIN_PORT, Item_ID, Level, Value) values(%d,%d,%d,%d);", name,
1568 source_type, data_type, i, osdvalue[i]);
1569 if (!(this->exeSql(sql))) {
1570 return -1;
1571 }
1572 }
1573 return 0;
1574}
1575
1576int CPqData::getSharpnessFlag()
1577{
1578 return sha_diff_flag;
1579}
1580
1581int CPqData::loadSharpnessData(char *sqlmaster, char *table_name)
1582{
1583 LOGD("%s, table_name: %s, sqlmaster: %s\n", __FUNCTION__, table_name, sqlmaster);
1584 CSqlite::Cursor c;
1585 int rval;
1586 int *pq_nodes = NULL;
1587 int temp_flag = 0;
1588
1589 if (!strncmp("Sharpness_0", table_name, 11)) {//for gxtvbb:Sharpness_0_***
1590 sha_diff_flag = sha_diff_flag | 2;
1591 pq_nodes = &sha_nodes;
1592 temp_flag = 2;
1593 } else if (!strncmp("Sharpness_1", table_name, 11)) {//for gxtvbb:Sharpness_1_***
1594 sha_diff_flag = sha_diff_flag | 4;
1595 pq_nodes = &sha_nodes_1;
1596 temp_flag = 4;
1597 } else {//for g9:Sharpness_G9_***
1598 sha_diff_flag = 1;
1599 pq_nodes = &sha_nodes;
1600 temp_flag = 1;
1601 }
1602 LOGD("%s, sha_diff_flag: %d, temp_flag: %d\n", __FUNCTION__, sha_diff_flag, temp_flag);
1603
1604 rval = this->select(sqlmaster, c);
1605 int length = 0;
1606 int index = 0;
1607 if ((temp_flag == 1) || (temp_flag == 2)) {
1608 if (c.moveToFirst()) {
1609 *pq_nodes = c.getInt(0);//TotalNode?
1610 length = c.getCount() / (*pq_nodes);
1611 for (int i = 0; i < *pq_nodes; i++) {
1612 pq_sharpness_reg_data[i].length = length;
1613 }
1614 do {
1615 pq_sharpness_reg_data[index / length].reg_data[index % length].TotalNode
1616 = c.getInt(0);
1617 pq_sharpness_reg_data[index / length].reg_data[index % length].NodeValue
1618 = c.getInt(1);
1619 pq_sharpness_reg_data[index / length].reg_data[index % length].Value.type
1620 = c.getUInt(2);
1621 pq_sharpness_reg_data[index / length].reg_data[index % length].Value.addr
1622 = c.getUInt(3);
1623 pq_sharpness_reg_data[index / length].reg_data[index % length].Value.mask
1624 = c.getUInt(4);
1625 pq_sharpness_reg_data[index / length].reg_data[index % length].IndexValue
1626 = c.getInt(5);
1627 pq_sharpness_reg_data[index / length].reg_data[index % length].Value.val
1628 = c.getUInt(6);
1629 pq_sharpness_reg_data[index / length].reg_data[index % length].step = c.getF(7);
1630 index++;
1631 } while (c.moveToNext());
1632 }
1633 } else if (temp_flag == 4) {
1634 if (c.moveToFirst()) {
1635 *pq_nodes = c.getInt(0);//TotalNode?
1636 length = c.getCount() / (*pq_nodes);
1637 for (int i = 0; i < *pq_nodes; i++) {
1638 pq_sharpness_reg_data_1[i].length = length;
1639 }
1640 do {
1641 pq_sharpness_reg_data_1[index / length].reg_data[index % length].TotalNode
1642 = c.getInt(0);
1643 pq_sharpness_reg_data_1[index / length].reg_data[index % length].NodeValue
1644 = c.getInt(1);
1645 pq_sharpness_reg_data_1[index / length].reg_data[index % length].Value.type
1646 = c.getUInt(2);
1647 pq_sharpness_reg_data_1[index / length].reg_data[index % length].Value.addr
1648 = c.getUInt(3);
1649 pq_sharpness_reg_data_1[index / length].reg_data[index % length].Value.mask
1650 = c.getUInt(4);
1651 pq_sharpness_reg_data_1[index / length].reg_data[index % length].IndexValue
1652 = c.getInt(5);
1653 pq_sharpness_reg_data_1[index / length].reg_data[index % length].Value.val
1654 = c.getUInt(6);
1655 pq_sharpness_reg_data_1[index / length].reg_data[index % length].step = c.getF(7);
1656 index++;
1657 } while (c.moveToNext());
1658 }
1659 }
1660 return rval;
1661}
1662
1663int CPqData::LoadPQData(tvpq_data_type_t data_type, tvin_port_t source_port,
1664 tvin_sig_fmt_t sig_fmt, is_3d_type_t is2dOr3d, tvin_trans_fmt_t trans_fmt, int flag)
1665{
1666 CSqlite::Cursor c;
1667 int rval;
1668 char sqlmaster[256];
1669 char table_name[128];
1670 int mode = is2dOr3d;
1671 tvpq_data_t *pq_data = NULL;
1672 int *pq_nodes = NULL;
1673
1674 trans_fmt = trans_fmt;
1675 switch (data_type) {
1676 case TVPQ_DATA_BRIGHTNESS:
1677 getSqlParams(__FUNCTION__, sqlmaster,
1678 "select TableName from GeneralContrastBrightnessTable where "
1679 "TVIN_PORT = %d and "
1680 "TVIN_SIG_FMT = %d and "
1681 "TVIN_TRANS_FMT = %d and "
1682 "%s = %d;", source_port, sig_fmt, mode, ID_FIELD, BRIGHTNESS_ID);
1683 pq_data = pq_bri_data;
1684 pq_nodes = &bri_nodes;
1685 break;
1686 case TVPQ_DATA_CONTRAST:
1687 getSqlParams(__FUNCTION__, sqlmaster,
1688 "select TableName from GeneralContrastBrightnessTable where "
1689 "TVIN_PORT = %d and "
1690 "TVIN_SIG_FMT = %d and "
1691 "TVIN_TRANS_FMT = %d and "
1692 "%s = %d;", source_port, sig_fmt, mode, ID_FIELD, CONTRAST_ID);
1693 pq_data = pq_con_data;
1694 pq_nodes = &con_nodes;
1695 break;
1696 case TVPQ_DATA_HUE:
1697 getSqlParams(__FUNCTION__, sqlmaster,
1698 "select TableName from GeneralSaturationHueTable where "
1699 "TVIN_PORT = %d and "
1700 "TVIN_SIG_FMT = %d and "
1701 "TVIN_TRANS_FMT = %d and "
1702 "%s = %d;", source_port, sig_fmt, mode, ID_FIELD, HUE_ID);
1703 pq_data = pq_hue_data;
1704 pq_nodes = &hue_nodes;
1705 break;
1706 case TVPQ_DATA_SATURATION:
1707 getSqlParams(__FUNCTION__, sqlmaster,
1708 "select TableName from GeneralSaturationHueTable where "
1709 "TVIN_PORT = %d and "
1710 "TVIN_SIG_FMT = %d and "
1711 "TVIN_TRANS_FMT = %d and "
1712 "%s = %d;", source_port, sig_fmt, mode, ID_FIELD, SATURATION_ID);
1713 pq_data = pq_sat_data;
1714 pq_nodes = &sat_nodes;
1715 break;
1716 case TVPQ_DATA_SHARPNESS:
1717 //sprintf(sqlmaster, "select TableName from GeneralSharpnessTable where "
1718 getSqlParams(__FUNCTION__, sqlmaster,
1719 "select TableName from GeneralSharpnessG9Table where "
1720 "TVIN_PORT = %d and "
1721 "TVIN_SIG_FMT = %d and "
1722 "TVIN_TRANS_FMT = %d and "
1723 "%s = %d;", source_port, sig_fmt, mode, ID_FIELD, SHARPNESS_ID);
1724 pq_data = NULL;
1725 pq_nodes = &sha_nodes;
1726 break;
1727 default:
1728 break;
1729 }
1730
1731 rval = this->select(sqlmaster, c);
1732
1733 if (c.moveToFirst()) {
1734 switch (data_type) {
1735 case TVPQ_DATA_BRIGHTNESS:
1736 case TVPQ_DATA_CONTRAST:
1737 case TVPQ_DATA_HUE:
1738 case TVPQ_DATA_SATURATION:
1739 getSqlParams(
1740 __FUNCTION__,
1741 sqlmaster,
1742 "select TotalNode, NodeNumber, IndexValue, RegValue, StepUp from %s order by NodeNumber asc;",
1743 c.getString(0).string());
1744 break;
1745 case TVPQ_DATA_SHARPNESS:
1746 do {
1747 getSqlParams(__FUNCTION__, sqlmaster,
1748 "select TotalNode, NodeNumber, RegType, RegAddr, RegMask,"
1749 "IndexValue, RegValue, StepUp from %s order by NodeNumber asc;",
1750 c.getString(0).string());
1751 c.getString(table_name, 0);
1752 rval = loadSharpnessData(sqlmaster, table_name);
1753 } while (c.moveToNext());
1754 return rval;
1755 default:
1756 break;
1757 }
1758 }
1759
1760 rval = this->select(sqlmaster, c);
1761
1762 if (c.moveToFirst()) {
1763 if (data_type != TVPQ_DATA_SHARPNESS) {
1764 int index = 0;
1765 do {
1766 pq_data[index].TotalNode = c.getInt(0);
1767 pq_data[index].NodeValue = c.getInt(1);
1768 pq_data[index].IndexValue = c.getInt(2);
1769 pq_data[index].RegValue = c.getInt(3);
1770 pq_data[index].step = c.getF(4);
1771 if (flag == 1) {
1772 if (data_type == TVPQ_DATA_BRIGHTNESS) {
1773 LOGD("%s, bri pq_data[%d].RegValue = %d\n", "TV", index,
1774 pq_data[index].RegValue);
1775 pq_data[index].RegValue -= 64;
1776 LOGD("%s, bri pq_data[%d].RegValue + 64 = %d\n", "TV", index,
1777 pq_data[index].RegValue);
1778 } else if (data_type == TVPQ_DATA_CONTRAST) {
1779 LOGD("%s, con pq_data[%d].RegValue = %d\n", "TV", index,
1780 pq_data[index].RegValue);
1781 pq_data[index].RegValue += 64;
1782 LOGD("%s, con pq_data[%d].RegValue + 64 = %d\n", "TV", index,
1783 pq_data[index].RegValue);
1784 }
1785 }
1786 index++;
1787 } while (c.moveToNext());
1788 *pq_nodes = index;
1789 }
1790 }
1791
1792 return rval;
1793}
1794
1795int CPqData::LoadAllPQData(tvin_port_t source_port, tvin_sig_fmt_t sig_fmt, is_3d_type_t is2dOr3d,
1796 tvin_trans_fmt_t trans_fmt, int flag)
1797{
1798 int rval = -1;
1799 rval = LoadPQData(TVPQ_DATA_BRIGHTNESS, source_port, sig_fmt, is2dOr3d, trans_fmt, flag);
1800 if (rval) {
1801 return rval;
1802 }
1803 rval = LoadPQData(TVPQ_DATA_CONTRAST, source_port, sig_fmt, is2dOr3d, trans_fmt, flag);
1804 if (rval) {
1805 return rval;
1806 }
1807 rval = LoadPQData(TVPQ_DATA_SATURATION, source_port, sig_fmt, is2dOr3d, trans_fmt, -1);
1808 if (rval) {
1809 return rval;
1810 }
1811 rval = LoadPQData(TVPQ_DATA_HUE, source_port, sig_fmt, is2dOr3d, trans_fmt, -1);
1812 if (rval) {
1813 return rval;
1814 }
1815 rval = LoadPQData(TVPQ_DATA_SHARPNESS, source_port, sig_fmt, is2dOr3d, trans_fmt, -1);
1816 if (rval) {
1817 return rval;
1818 }
1819 return rval;
1820}
1821
1822typedef enum initial_type_e {
1823 TYPE_PMode = 0,
1824 TYPE_PMode_Default,
1825 TYPE_Nonlinear,
1826 TYPE_NonLinear_Default,
1827 TYPE_VGA_AUTO,
1828 TYPE_OVERSCAN,
1829} initial_type_t;
1830
1831const char *Pmode_name[6] = { "Picture_Mode", "Picture_Mode_Default", "NonlinearMapping",
1832 "NonlinearMapping_Default", "VGA_AutoParams", "OVERSCAN"
1833 };
1834
1835void CPqData::initialTable(int type)
1836{
1837 vpp_pq_para_t pmode_default;
1838
1839 pmode_default.backlight = 100;
1840 pmode_default.brightness = 50;
1841 pmode_default.contrast = 50;
1842 pmode_default.hue = 50;
1843 pmode_default.nr = 0;
1844 pmode_default.saturation = 50;
1845 pmode_default.sharpness = 50;
1846
1847 switch (type) {
1848 case TYPE_PMode:
1849 case TYPE_PMode_Default:
1850 for (int i = 0; i < 6; i++) {
1851 for (int j = 0; j < 4; j++) {
1852 PQ_SetPQModeParamsByName(Pmode_name[type], (tv_source_input_type_t) i,
1853 (vpp_picture_mode_t) j, &pmode_default);
1854 }
1855 }
1856 break;
1857 case TYPE_Nonlinear:
1858 case TYPE_NonLinear_Default:
1859 for (int i = 0; i < 6; i++) {
1860 for (int j = 0; j < 5; j++) {
1861 SetNonlinearMappingByName(Pmode_name[type], (tvpq_data_type_t) j,
1862 (tv_source_input_type_t) i, 0, (int) 255 / 4.0, (int) 255 * 2 / 4.0,
1863 (int) 255 * 3 / 4.0, 255);
1864 }
1865 }
1866 break;
1867 case TYPE_VGA_AUTO:
1868 break;
1869 case TYPE_OVERSCAN:
1870 break;
1871 }
1872}
1873
1874/*
1875 void CPqData::transferFixTable()
1876 {
1877 char sql[256];
1878 char *err = NULL;
1879 char **rsltReg = NULL;
1880 int rval, rows, columns;
1881 unsigned int tvin, sig, trans;
1882 char tablename[256];
1883
1884 sprintf(sql, "Select TVIN_PORT, TVIN_SIG_FMT, TVIN_TRANS_FMT, TableName from GeneralSharpnessTable where TableID = 0;");
1885
1886 rval = sqlite3_get_table(DB, sql, &rsltReg, &rows, &columns, &err);
1887
1888 if (rval) {
1889 if (rsltReg != NULL) {
1890 sqlite3_free_table(rsltReg);
1891 rsltReg = NULL;
1892 }
1893 if (err != NULL) {
1894 sqlite3_free(err);
1895 err = NULL;
1896 }
1897 return;
1898 } else {
1899 for (int i = 1; i <= rows; i++) {
1900 memset(sql, '\0', 256);
1901
1902 sscanf(rsltReg[i * columns], "%u", &tvin);
1903 sscanf(rsltReg[i * columns + 1], "%u", &sig);
1904 sscanf(rsltReg[i * columns + 2], "%u", &trans);
1905 sscanf(rsltReg[i * columns + 3], "%s", tablename);
1906
1907 sprintf(sql, "insert into GeneralCommonTable(TVIN_PORT, TVIN_SIG_FMT, TVIN_TRANS_FMT, TableID, TableName) values(%d,%d,%d,0,\"%s\");",
1908 tvin, sig, trans, tablename);
1909 rval = sqlite3_exec(DB, sql, NULL, NULL, &err);
1910 if (rval) {
1911 if (err != NULL) {
1912 sqlite3_free(err);
1913 err = NULL;
1914 }
1915 return;
1916 }
1917 if (err != NULL) {
1918 sqlite3_free(err);
1919 err = NULL;
1920 }
1921 }
1922 memset(sql, '\0', 256);
1923 sprintf(sql, "delete from GeneralSharpnessTable where TableID = 0;");
1924 rval = sqlite3_exec(DB, sql, NULL, NULL, &err);
1925 if (rval) {
1926 if (err != NULL) {
1927 sqlite3_free(err);
1928 err = NULL;
1929 }
1930 return;
1931 }
1932 if (err != NULL) {
1933 sqlite3_free(err);
1934 err = NULL;
1935 }
1936 }
1937 }
1938 */
1939
1940int CPqData::replacePqDb(const char *newFilePath)
1941{
1942
1943 CFile::delFile( PQ_DB_PATH);
1944 if (newFilePath == NULL) {
1945 return 0;
1946 } else {
1947 LOGD("path = %s", newFilePath);
1948 CFile file(newFilePath);
1949 int ret = file.copyTo(PQ_DB_PATH);
1950 system("sync");
1951 return ret;
1952 }
1953}
1954
1955int CPqData::PQ_GetPhaseArray(am_phase_t *am_phase)
1956{
1957 CSqlite::Cursor c;
1958 int iOutRet = 0;
1959 char sqlmaster[256];
1960 getSqlParams(__FUNCTION__, sqlmaster, "select Phase from Phase order by Format ASC; ");
1961
1962 this->select(sqlmaster, c);
1963 int nums = 0;
1964 am_phase->length = c.getCount();
1965 if (c.moveToFirst()) {
1966 do {
1967 am_phase->phase[nums] = c.getInt(0);//col index is 0[Phase]
1968 nums++;
1969 } while (c.moveToNext());
1970 }
1971 //
1972 return nums;
1973}
1974
1975
generated by cgit at 2024-05-10 09:36:00 (GMT)