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