mirror
/
sane-project-backends
kopia lustrzana https://gitlab.com/sane-project/backends
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

genesys: Make per-sensor register override list generic

merge-requests/81/head
Povilas Kanapickas 2019-06-02 11:47:30 +03:00
rodzic 7f22e35e2c
commit e9419d5e33
9 zmienionych plików z 1196 dodań i 404 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

4
backend/genesys.cc
Wyświetl plik

@ -2970,7 +2970,9 @@ genesys_restore_calibration (Genesys_Device * dev)
{
memcpy (&dev->frontend, &cache.frontend, sizeof (dev->frontend));
/* we don't restore the gamma fields */
memcpy (dev->sensor.regs_0x10_0x1d.data(), cache.sensor.regs_0x10_0x1d.data(), 6);
for (uint16_t addr = 0x10; addr < 0x16; ++addr) {
dev->sensor.custom_regs.set_value(addr, cache.sensor.custom_regs.get_value(addr));
}
dev->average_size = cache.average_size;
dev->calib_pixels = cache.calib_pixels;

1240
backend/genesys_devices.cc
Wyświetl plik

Plik diff jest za duży Load Diff

28
backend/genesys_gl124.cc
Wyświetl plik

@ -902,14 +902,14 @@ gl124_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi,
DBGSTART;
// we start at 6, 0-5 is a 16 bits cache for exposure
for (int i = 0x06; i < 0x0e; i++) {
regs->set8(0x10 + i, dev->sensor.regs_0x10_0x1d[i]);
for (uint16_t addr = 0x16; addr < 0x1e; addr++) {
regs->set8(addr, dev->sensor.custom_regs.get_value(addr));
}
// skip writing 5d,5e which is AFE address because
// they are not deifned in register set */
for (int i = 0; i < 11; i++) {
regs->set8(0x52 + i, dev->sensor.regs_0x52_0x5e[i]);
// they are not defined in register set */
for (uint16_t addr = 0x52; addr < 0x52 + 11; addr++) {
regs->set8(addr, dev->sensor.custom_regs.get_value(addr));
}
/* set EXPDUMMY and CKxMAP */
@ -933,21 +933,21 @@ gl124_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi,
sanei_genesys_set_double(regs,REG_EXPDMY,sensor->expdummy);
/* if no calibration has been done, set default values for exposures */
exp=dev->sensor.regs_0x10_0x1d[0]*256+dev->sensor.regs_0x10_0x1d[1];
exp = dev->sensor.custom_regs.get_value(0x10)*256 + dev->sensor.custom_regs.get_value(0x11);
if(exp==0)
{
exp=sensor->expr;
}
sanei_genesys_set_triple(regs,REG_EXPR,exp);
exp=dev->sensor.regs_0x10_0x1d[2]*256+dev->sensor.regs_0x10_0x1d[3];
exp = dev->sensor.custom_regs.get_value(0x12)*256 + dev->sensor.custom_regs.get_value(0x13);
if(exp==0)
{
exp=sensor->expg;
}
sanei_genesys_set_triple(regs,REG_EXPG,exp);
exp=dev->sensor.regs_0x10_0x1d[4]*256+dev->sensor.regs_0x10_0x1d[5];
exp = dev->sensor.custom_regs.get_value(0x14)*256 + dev->sensor.custom_regs.get_value(0x15);
if(exp==0)
{
exp=sensor->expb;
@ -2942,12 +2942,12 @@ gl124_led_calibration (Genesys_Device * dev)
sanei_genesys_set_triple(&dev->reg,REG_EXPB,exp[2]);
/* store in this struct since it is the one used by cache calibration */
dev->sensor.regs_0x10_0x1d[0] = (exp[0] >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[1] = exp[0] & 0xff;
dev->sensor.regs_0x10_0x1d[2] = (exp[1] >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[3] = exp[1] & 0xff;
dev->sensor.regs_0x10_0x1d[4] = (exp[2] >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[5] = exp[2] & 0xff;
dev->sensor.custom_regs.set_value(0x10, (exp[0] >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x11, exp[0] & 0xff);
dev->sensor.custom_regs.set_value(0x12, (exp[1] >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x13, exp[1] & 0xff);
dev->sensor.custom_regs.set_value(0x14, (exp[2] >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x15, exp[2] & 0xff);
DBGCOMPLETED;
return status;

44
backend/genesys_gl646.cc
Wyświetl plik

@ -995,29 +995,13 @@ gl646_setup_registers (Genesys_Device * dev,
static void
gl646_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs)
{
GenesysRegister *r;
int i;
DBG(DBG_proc, "%s: start\n", __func__);
DBG(DBG_proc, "%s: start\n", __func__);
for (i = 0; i < 4; i++)
{
r = sanei_genesys_get_address (regs, 0x08 + i);
r->value = dev->sensor.regs_0x08_0x0b[i];
for (const auto& reg_setting : dev->sensor.custom_regs) {
regs->set8(reg_setting.address, reg_setting.value);
}
for (i = 0; i < 14; i++)
{
r = sanei_genesys_get_address (regs, 0x10 + i);
r->value = dev->sensor.regs_0x10_0x1d[i];
}
for (i = 0; i < 13; i++)
{
r = sanei_genesys_get_address (regs, 0x52 + i);
r->value = dev->sensor.regs_0x52_0x5e[i];
}
DBG(DBG_proc, "%s: end\n", __func__);
DBG(DBG_proc, "%s: end\n", __func__);
}
/** Test if the ASIC works
@ -3197,22 +3181,20 @@ gl646_led_calibration (Genesys_Device * dev)
Sensor_Master uint8_t regs_0x10_0x15[6];
*/
expr = (dev->sensor.regs_0x10_0x1d[0] << 8) | dev->sensor.regs_0x10_0x1d[1];
expg = (dev->sensor.regs_0x10_0x1d[2] << 8) | dev->sensor.regs_0x10_0x1d[3];
expb = (dev->sensor.regs_0x10_0x1d[4] << 8) | dev->sensor.regs_0x10_0x1d[5];
expr = (dev->sensor.custom_regs.get_value(0x10) << 8) | dev->sensor.custom_regs.get_value(0x11);
expg = (dev->sensor.custom_regs.get_value(0x12) << 8) | dev->sensor.custom_regs.get_value(0x13);
expb = (dev->sensor.custom_regs.get_value(0x14) << 8) | dev->sensor.custom_regs.get_value(0x15);
turn = 0;
do
{
dev->sensor.regs_0x10_0x1d[0] = (expr >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[1] = expr & 0xff;
dev->sensor.regs_0x10_0x1d[2] = (expg >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[3] = expg & 0xff;
dev->sensor.regs_0x10_0x1d[4] = (expb >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[5] = expb & 0xff;
dev->sensor.custom_regs.set_value(0x10, (expr >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x11, expr & 0xff);
dev->sensor.custom_regs.set_value(0x12, (expg >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x13, expg & 0xff);
dev->sensor.custom_regs.set_value(0x14, (expb >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x15, expb & 0xff);
DBG(DBG_info, "%s: starting first line reading\n", __func__);

92
backend/genesys_gl841.cc
Wyświetl plik

@ -207,27 +207,22 @@ sanei_gl841_setup_sensor (Genesys_Device * dev,
Genesys_Register_Set * regs,
SANE_Bool extended, SANE_Bool half_ccd)
{
GenesysRegister *r;
int i;
DBG(DBG_proc, "%s\n", __func__);
DBG(DBG_proc, "%s\n", __func__);
// that one is tricky at least
for (uint16_t addr = 0x08; addr <= 0x0b; ++addr) {
regs->set8(0x70 + addr - 0x08, dev->sensor.custom_regs.get_value(addr));
}
/* that one is tricky at least ....*/
r = sanei_genesys_get_address (regs, 0x70);
for (i = 0; i < 4; i++, r++)
r->value = dev->sensor.regs_0x08_0x0b[i];
// ignore registers in range [0x10..0x16)
for (uint16_t addr = 0x16; addr < 0x1e; ++addr) {
regs->set8(addr, dev->sensor.custom_regs.get_value(addr));
}
r = sanei_genesys_get_address (regs, 0x16);
for (i = 0x06; i < 0x0a; i++, r++)
r->value = dev->sensor.regs_0x10_0x1d[i];
r = sanei_genesys_get_address (regs, 0x1a);
for (i = 0x0a; i < 0x0e; i++, r++)
r->value = dev->sensor.regs_0x10_0x1d[i];
r = sanei_genesys_get_address (regs, 0x52);
for (i = 0; i < 9; i++, r++)
r->value = dev->sensor.regs_0x52_0x5e[i];
// ignore registers in range [0x5b..0x5e]
for (uint16_t addr = 0x52; addr < 0x52 + 9; ++addr) {
regs->set8(addr, dev->sensor.custom_regs.get_value(addr));
}
/* don't go any further if no extended setup */
if (!extended)
@ -240,6 +235,7 @@ sanei_gl841_setup_sensor (Genesys_Device * dev,
{
if (half_ccd)
{
GenesysRegister* r;
/* settings for CCD used at half is max resolution */
r = sanei_genesys_get_address (regs, 0x70);
r->value = 0x00;
@ -256,12 +252,16 @@ sanei_gl841_setup_sensor (Genesys_Device * dev,
}
else
{
GenesysRegister* r;
/* swap latch times */
r = sanei_genesys_get_address (regs, 0x18);
r->value = 0x30;
r = sanei_genesys_get_address (regs, 0x52);
for (i = 0; i < 6; i++, r++)
r->value = dev->sensor.regs_0x52_0x5e[(i + 3) % 6];
regs->set8(0x52, dev->sensor.custom_regs.get_value(0x55));
regs->set8(0x53, dev->sensor.custom_regs.get_value(0x56));
regs->set8(0x54, dev->sensor.custom_regs.get_value(0x57));
regs->set8(0x55, dev->sensor.custom_regs.get_value(0x52));
regs->set8(0x56, dev->sensor.custom_regs.get_value(0x53));
regs->set8(0x57, dev->sensor.custom_regs.get_value(0x54));
r = sanei_genesys_get_address (regs, 0x58);
r->value = 0x20 | (r->value & 0x03); /* VSMP=4 */
}
@ -271,6 +271,7 @@ sanei_gl841_setup_sensor (Genesys_Device * dev,
if (dev->model->ccd_type == CCD_HP2300)
{
/* settings for CCD used at half is max resolution */
GenesysRegister* r;
if (half_ccd)
{
r = sanei_genesys_get_address (regs, 0x70);
@ -1910,10 +1911,12 @@ gl841_init_optical_regs_scan(Genesys_Device * dev,
r->value = 0x01;/* 0x0101 is as off as possible */
else
{ /* EXP[R,G,B] only matter for CIS scanners */
if (dev->sensor.regs_0x10_0x1d[i] == 0x00)
r->value = 0x01; /*0x00 will not be accepted*/
else
r->value = dev->sensor.regs_0x10_0x1d[i];
uint8_t value = dev->sensor.custom_regs.get_value(0x10 + i);
if (value == 0x00) {
r->value = 0x01; /*0x00 will not be accepted*/
} else {
r->value = value;
}
}
}
@ -2059,9 +2062,10 @@ gl841_get_led_exposure(Genesys_Device * dev)
if (!dev->model->is_cis)
return 0;
d = dev->reg.find_reg(0x19).value;
r = dev->sensor.regs_0x10_0x1d[1] | (dev->sensor.regs_0x10_0x1d[0] << 8);
g = dev->sensor.regs_0x10_0x1d[3] | (dev->sensor.regs_0x10_0x1d[2] << 8);
b = dev->sensor.regs_0x10_0x1d[5] | (dev->sensor.regs_0x10_0x1d[4] << 8);
r = (dev->sensor.custom_regs.get_value(0x10) << 8) | dev->sensor.custom_regs.get_value(0x11);
g = (dev->sensor.custom_regs.get_value(0x12) << 8) | dev->sensor.custom_regs.get_value(0x13);
b = (dev->sensor.custom_regs.get_value(0x14) << 8) | dev->sensor.custom_regs.get_value(0x15);
m = r;
if (m < g)
@ -2782,10 +2786,12 @@ gl841_set_lamp_power (Genesys_Device * dev,
r = sanei_genesys_get_address (regs, 0x10);
for (i = 0; i < 6; i++, r++) {
if (dev->sensor.regs_0x10_0x1d[i] == 0x00)
r->value = 0x01;/*0x00 will not be accepted*/
else
r->value = dev->sensor.regs_0x10_0x1d[i];
uint8_t value = dev->sensor.custom_regs.get_value(0x10 + i);
if (value == 0x00) {
r->value = 0x01; /*0x00 will not be accepted*/
} else {
r->value = value;
}
}
r = sanei_genesys_get_address (regs, 0x19);
r->value = 0x50;
@ -4103,9 +4109,9 @@ gl841_led_calibration (Genesys_Device * dev)
adjust exposure times
*/
exp[0] = (dev->sensor.regs_0x10_0x1d[0] << 8) | dev->sensor.regs_0x10_0x1d[1];
exp[1] = (dev->sensor.regs_0x10_0x1d[2] << 8) | dev->sensor.regs_0x10_0x1d[3];
exp[2] = (dev->sensor.regs_0x10_0x1d[4] << 8) | dev->sensor.regs_0x10_0x1d[5];
exp[0] = (dev->sensor.custom_regs.get_value(0x10) << 8) | dev->sensor.custom_regs.get_value(0x11);
exp[1] = (dev->sensor.custom_regs.get_value(0x12) << 8) | dev->sensor.custom_regs.get_value(0x13);
exp[2] = (dev->sensor.custom_regs.get_value(0x14) << 8) | dev->sensor.custom_regs.get_value(0x15);
turn = 0;
/* max exposure is set to ~2 time initial average
@ -4115,17 +4121,17 @@ gl841_led_calibration (Genesys_Device * dev)
do {
dev->sensor.regs_0x10_0x1d[0] = (exp[0] >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[1] = exp[0] & 0xff;
dev->sensor.regs_0x10_0x1d[2] = (exp[1] >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[3] = exp[1] & 0xff;
dev->sensor.regs_0x10_0x1d[4] = (exp[2] >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[5] = exp[2] & 0xff;
dev->sensor.custom_regs.set_value(0x10, (exp[0] >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x11, exp[0] & 0xff);
dev->sensor.custom_regs.set_value(0x12, (exp[1] >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x13, exp[1] & 0xff);
dev->sensor.custom_regs.set_value(0x14, (exp[2] >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x15, exp[2] & 0xff);
r = &(dev->calib_reg.find_reg(0x10));
for (i = 0; i < 6; i++, r++) {
r->value = dev->sensor.regs_0x10_0x1d[i];
RIE (sanei_genesys_write_register (dev, 0x10+i, dev->sensor.regs_0x10_0x1d[i]));
r->value = dev->sensor.custom_regs.get_value(0x10 + i);
RIE(sanei_genesys_write_register(dev, 0x10+i, r->value));
}
RIE(sanei_genesys_bulk_write_register(dev, dev->calib_reg));

36
backend/genesys_gl843.cc
Wyświetl plik

@ -1932,11 +1932,10 @@ gl843_set_lamp_power (Genesys_Device * dev,
{
val |= REG03_LAMPPWR;
sanei_genesys_set_reg_from_set (regs, REG03, val);
for (i = 0; i < 6; i++)
{
r = sanei_genesys_get_address (regs, 0x10 + i);
r->value = dev->sensor.regs_0x10_0x1d[i];
}
for (uint16_t addr = 0x10; addr < 0x16; addr++) {
regs->set8(addr, dev->sensor.custom_regs.get_value(addr));
}
}
else
{
@ -3219,7 +3218,6 @@ gl843_led_calibration (Genesys_Device * dev)
int avg[3], avga, avge;
int turn;
uint16_t expr, expg, expb;
GenesysRegister *r;
SANE_Bool acceptable = SANE_FALSE;
@ -3272,27 +3270,25 @@ gl843_led_calibration (Genesys_Device * dev)
adjust exposure times
*/
expr = (dev->sensor.regs_0x10_0x1d[0] << 8) | dev->sensor.regs_0x10_0x1d[1];
expg = (dev->sensor.regs_0x10_0x1d[2] << 8) | dev->sensor.regs_0x10_0x1d[3];
expb = (dev->sensor.regs_0x10_0x1d[4] << 8) | dev->sensor.regs_0x10_0x1d[5];
expr = (dev->sensor.custom_regs.get_value(0x10) << 8) | dev->sensor.custom_regs.get_value(0x11);
expg = (dev->sensor.custom_regs.get_value(0x12) << 8) | dev->sensor.custom_regs.get_value(0x13);
expb = (dev->sensor.custom_regs.get_value(0x14) << 8) | dev->sensor.custom_regs.get_value(0x15);
turn = 0;
do
{
dev->sensor.regs_0x10_0x1d[0] = (expr >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[1] = expr & 0xff;
dev->sensor.regs_0x10_0x1d[2] = (expg >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[3] = expg & 0xff;
dev->sensor.regs_0x10_0x1d[4] = (expb >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[5] = expb & 0xff;
dev->sensor.custom_regs.set_value(0x10, (expr >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x11, expr & 0xff);
dev->sensor.custom_regs.set_value(0x12, (expg >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x13, expg & 0xff);
dev->sensor.custom_regs.set_value(0x14, (expb >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x15, expb & 0xff);
for (i = 0; i < 6; i++)
{
r = sanei_genesys_get_address(&dev->calib_reg, 0x10 + i);
r->value = dev->sensor.regs_0x10_0x1d[i];
}
for (uint16_t addr = 0x10; addr < 0x16; addr++) {
dev->calib_reg.set8(addr, dev->sensor.custom_regs.get_value(addr));
}
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));

32
backend/genesys_gl846.cc
Wyświetl plik

@ -223,18 +223,12 @@ gl846_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi)
DBGSTART;
dpihw=sanei_genesys_compute_dpihw(dev,dpi);
for (i = 0x06; i < 0x0e; i++)
{
r = sanei_genesys_get_address (regs, 0x10 + i);
if (r)
r->value = dev->sensor.regs_0x10_0x1d[i];
for (uint16_t addr = 0x16; addr < 0x1e; addr++) {
regs->set8(addr, dev->sensor.custom_regs.get_value(addr));
}
for (i = 0; i < 9; i++)
{
r = sanei_genesys_get_address (regs, 0x52 + i);
if (r)
r->value = dev->sensor.regs_0x52_0x5e[i];
for (uint16_t addr = 0x52; addr < 0x52 + 9; addr++) {
regs->set8(addr, dev->sensor.custom_regs.get_value(addr));
}
/* set EXPDUMMY and CKxMAP */
@ -244,21 +238,21 @@ gl846_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi)
sanei_genesys_set_reg_from_set(regs,REG_EXPDMY,(uint8_t)((sensor->expdummy) & 0xff));
/* if no calibration has been done, set default values for exposures */
exp=dev->sensor.regs_0x10_0x1d[0]*256+dev->sensor.regs_0x10_0x1d[1];
exp = (dev->sensor.custom_regs.get_value(0x10) << 8) | dev->sensor.custom_regs.get_value(0x11);
if(exp==0)
{
exp=sensor->expr;
}
sanei_genesys_set_double(regs,REG_EXPR,exp);
exp=dev->sensor.regs_0x10_0x1d[2]*256+dev->sensor.regs_0x10_0x1d[3];
exp = (dev->sensor.custom_regs.get_value(0x12) << 8) | dev->sensor.custom_regs.get_value(0x13);
if(exp==0)
{
exp=sensor->expg;
}
sanei_genesys_set_double(regs,REG_EXPG,exp);
exp=dev->sensor.regs_0x10_0x1d[4]*256+dev->sensor.regs_0x10_0x1d[5];
exp = (dev->sensor.custom_regs.get_value(0x14) << 8) | dev->sensor.custom_regs.get_value(0x15);
if(exp==0)
{
exp=sensor->expb;
@ -2531,12 +2525,12 @@ gl846_led_calibration (Genesys_Device * dev)
sanei_genesys_set_double(&dev->reg,REG_EXPB,exp[2]);
/* store in this struct since it is the one used by cache calibration */
dev->sensor.regs_0x10_0x1d[0] = (exp[0] >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[1] = exp[0] & 0xff;
dev->sensor.regs_0x10_0x1d[2] = (exp[1] >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[3] = exp[1] & 0xff;
dev->sensor.regs_0x10_0x1d[4] = (exp[2] >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[5] = exp[2] & 0xff;
dev->sensor.custom_regs.set_value(0x10, (exp[0] >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x11, exp[0] & 0xff);
dev->sensor.custom_regs.set_value(0x12, (exp[1] >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x13, exp[1] & 0xff);
dev->sensor.custom_regs.set_value(0x14, (exp[2] >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x15, exp[2] & 0xff);
/* go back home */
if(move>20)

32
backend/genesys_gl847.cc
Wyświetl plik

@ -218,18 +218,12 @@ gl847_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi)
DBGSTART;
dpihw=sanei_genesys_compute_dpihw(dev,dpi);
for (i = 0x06; i < 0x0e; i++)
{
r = sanei_genesys_get_address (regs, 0x10 + i);
if (r)
r->value = dev->sensor.regs_0x10_0x1d[i];
for (uint16_t addr = 0x16; addr < 0x1e; addr++) {
regs->set8(addr, dev->sensor.custom_regs.get_value(addr));
}
for (i = 0; i < 9; i++)
{
r = sanei_genesys_get_address (regs, 0x52 + i);
if (r)
r->value = dev->sensor.regs_0x52_0x5e[i];
for (uint16_t addr = 0x52; addr < 0x52 + 9; addr++) {
regs->set8(addr, dev->sensor.custom_regs.get_value(addr));
}
/* set EXPDUMMY and CKxMAP */
@ -239,21 +233,21 @@ gl847_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi)
sanei_genesys_set_reg_from_set(regs,REG_EXPDMY,(uint8_t)((sensor->expdummy) & 0xff));
/* if no calibration has been done, set default values for exposures */
exp=dev->sensor.regs_0x10_0x1d[0]*256+dev->sensor.regs_0x10_0x1d[1];
exp = (dev->sensor.custom_regs.get_value(0x10) << 8) | dev->sensor.custom_regs.get_value(0x11);
if(exp==0)
{
exp=sensor->expr;
}
sanei_genesys_set_double(regs,REG_EXPR,exp);
exp=dev->sensor.regs_0x10_0x1d[2]*256+dev->sensor.regs_0x10_0x1d[3];
exp = (dev->sensor.custom_regs.get_value(0x12) << 8) | dev->sensor.custom_regs.get_value(0x13);
if(exp==0)
{
exp=sensor->expg;
}
sanei_genesys_set_double(regs,REG_EXPG,exp);
exp=dev->sensor.regs_0x10_0x1d[4]*256+dev->sensor.regs_0x10_0x1d[5];
exp = (dev->sensor.custom_regs.get_value(0x14) << 8) | dev->sensor.custom_regs.get_value(0x15);
if(exp==0)
{
exp=sensor->expb;
@ -2594,12 +2588,12 @@ gl847_led_calibration (Genesys_Device * dev)
sanei_genesys_set_double(&dev->reg,REG_EXPB,exp[2]);
/* store in this struct since it is the one used by cache calibration */
dev->sensor.regs_0x10_0x1d[0] = (exp[0] >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[1] = exp[0] & 0xff;
dev->sensor.regs_0x10_0x1d[2] = (exp[1] >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[3] = exp[1] & 0xff;
dev->sensor.regs_0x10_0x1d[4] = (exp[2] >> 8) & 0xff;
dev->sensor.regs_0x10_0x1d[5] = exp[2] & 0xff;
dev->sensor.custom_regs.set_value(0x10, (exp[0] >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x11, exp[0] & 0xff);
dev->sensor.custom_regs.set_value(0x12, (exp[1] >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x13, exp[1] & 0xff);
dev->sensor.custom_regs.set_value(0x14, (exp[2] >> 8) & 0xff);
dev->sensor.custom_regs.set_value(0x15, exp[2] & 0xff);
/* go back home */
if(move>20)

92
backend/genesys_low.h
Wyświetl plik

@ -415,6 +415,69 @@ struct AssignableArray : public std::array<T, Size> {
}
};
struct GenesysRegisterSetting {
GenesysRegisterSetting() = default;
GenesysRegisterSetting(uint16_t p_address, uint8_t p_value) :
address(p_address), value(p_value)
{}
GenesysRegisterSetting(uint16_t p_address, uint8_t p_value, uint8_t p_mask) :
address(p_address), value(p_value), mask(p_mask)
{}
uint16_t address = 0;
uint8_t value = 0;
uint8_t mask = 0xff;
};
class GenesysRegisterSettingSet {
public:
using container = std::vector<GenesysRegisterSetting>;
using iterator = typename container::iterator;
using const_iterator = typename container::const_iterator;
GenesysRegisterSettingSet() = default;
GenesysRegisterSettingSet(std::initializer_list<GenesysRegisterSetting> ilist) : regs_(ilist) {}
iterator begin() { return regs_.begin(); }
const_iterator begin() const { return regs_.begin(); }
iterator end() { return regs_.end(); }
const_iterator end() const { return regs_.end(); }
GenesysRegisterSetting& operator[](size_t i) { return regs_[i]; }
const GenesysRegisterSetting& operator[](size_t i) const { return regs_[i]; }
size_t size() const { return regs_.size(); }
bool empty() const { return regs_.empty(); }
void clear() { regs_.clear(); }
void push_back(GenesysRegisterSetting reg) { regs_.push_back(reg); }
uint8_t get_value(uint16_t address) const
{
for (const auto& reg : regs_) {
if (reg.address == address)
return reg.value;
}
throw std::runtime_error("Unknown register");
}
void set_value(uint16_t address, uint8_t value)
{
for (auto& reg : regs_) {
if (reg.address == address) {
reg.value = value;
return;
}
}
throw std::runtime_error("Unknown register");
}
private:
std::vector<GenesysRegisterSetting> regs_;
};
struct Genesys_Sensor {
Genesys_Sensor() = default;
@ -438,10 +501,9 @@ struct Genesys_Sensor {
// CCD target code (reference gain)
int gain_white_ref = 0;
AssignableArray<uint8_t, 4> regs_0x08_0x0b;
// Initial exposure values, EXPR, EXPG and EXPB are contained in 0x10-0x15
AssignableArray<uint8_t, 14> regs_0x10_0x1d;
AssignableArray<uint8_t, 13> regs_0x52_0x5e;
// FIXME: move exposure to separate variable
GenesysRegisterSettingSet custom_regs;
// red, green and blue gamma coefficient for default gamma tables
AssignableArray<float, 3> gamma;
@ -460,9 +522,17 @@ struct Genesys_Sensor {
success &= 1 == ::fread(&sensor_pixels, sizeof(sensor_pixels), 1, fp);
success &= 1 == ::fread(&fau_gain_white_ref, sizeof(fau_gain_white_ref), 1, fp);
success &= 1 == ::fread(&gain_white_ref, sizeof(gain_white_ref), 1, fp);
success &= 1 == ::fread(&regs_0x08_0x0b, sizeof(regs_0x08_0x0b), 1, fp);
success &= 1 == ::fread(&regs_0x10_0x1d, sizeof(regs_0x10_0x1d), 1, fp);
success &= 1 == ::fread(&regs_0x52_0x5e, sizeof(regs_0x52_0x5e), 1, fp);
custom_regs.clear();
uint32_t custom_regs_count = 0;
success &= 1 == ::fread(&custom_regs_count, sizeof(custom_regs_count), 1, fp);
for (uint32_t i = 0; i < custom_regs_count && success; ++i) {
GenesysRegisterSetting reg;
success &= 1 == ::fread(&reg.address, sizeof(reg.address), 1, fp);
success &= 1 == ::fread(&reg.value, sizeof(reg.value), 1, fp);
success &= 1 == ::fread(&reg.mask, sizeof(reg.mask), 1, fp);
custom_regs.push_back(reg);
}
return success ? 1 : 0;
}
@ -476,9 +546,13 @@ struct Genesys_Sensor {
::fwrite(&sensor_pixels, sizeof(sensor_pixels), 1, fp);
::fwrite(&fau_gain_white_ref, sizeof(fau_gain_white_ref), 1, fp);
::fwrite(&gain_white_ref, sizeof(gain_white_ref), 1, fp);
::fwrite(&regs_0x08_0x0b, sizeof(regs_0x08_0x0b), 1, fp);
::fwrite(&regs_0x10_0x1d, sizeof(regs_0x10_0x1d), 1, fp);
::fwrite(&regs_0x52_0x5e, sizeof(regs_0x52_0x5e), 1, fp);
uint32_t custom_regs_count = custom_regs.size();
::fwrite(&custom_regs_count, sizeof(custom_regs_count), 1, fp);
for (uint32_t i = 0; i < custom_regs_count; ++i) {
::fwrite(&custom_regs[i].address, sizeof(custom_regs[i].address), 1, fp);
::fwrite(&custom_regs[i].value, sizeof(custom_regs[i].value), 1, fp);
::fwrite(&custom_regs[i].mask, sizeof(custom_regs[i].mask), 1, fp);
}
}
};