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

- changed 'gain' option name to 'brightness' 

- changed 'highlight' option name to 'contrast'
merge-requests/1/head
Stéphane Voltz 2003-02-25 07:04:12 +00:00
rodzic 141a7159d9
commit 5ed8c99cb7
10 zmienionych plików z 451 dodań i 444 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

7
ChangeLog
Wyświetl plik

@ -1,3 +1,10 @@
2003-02-23 Stéphane Voltz <svoltz@wanadoo.fr>
* backend/umax_pp_low.c backend/umax_pp_low.h backend/umax_pp_mid.c
backend/umax_pp_mid.h backend/umax_pp.c backend/umax_pp.h
backend/umax_pp.conf tools/umax_pp.c doc/sane-umax_pp.man: changed
highlight option to contrast, and gain to brightness.
2003-02-24 Henning Meier-Geinitz <henning@meier-geinitz.de>
* backend/Makefile.in backend/dll.conf backend/ma1509.c

609
backend/umax_pp.c
Wyświetl plik

@ -116,13 +116,13 @@ static Umax_PP_Device *first_dev = NULL;
static long int buf_size = 2048 * 1024;
static int red_gain = 0;
static int green_gain = 0;
static int blue_gain = 0;
static int red_brightness = 0;
static int green_brightness = 0;
static int blue_brightness = 0;
static int red_highlight = 0;
static int green_highlight = 0;
static int blue_highlight = 0;
static int red_contrast = 0;
static int green_contrast = 0;
static int blue_contrast = 0;
@ -542,121 +542,121 @@ init_options (Umax_PP_Device * dev)
dev->opt[OPT_GAMMA_VECTOR_B].constraint.range = &u8_range;
dev->val[OPT_GAMMA_VECTOR_B].wa = &dev->gamma_table[3][0];
/* gain group */
dev->opt[OPT_MANUAL_GAIN].name = "manual-channel-gain";
dev->opt[OPT_MANUAL_GAIN].title = SANE_I18N ("Gain");
dev->opt[OPT_MANUAL_GAIN].desc = SANE_I18N ("Color channels gain settings");
dev->opt[OPT_MANUAL_GAIN].type = SANE_TYPE_BOOL;
dev->opt[OPT_MANUAL_GAIN].cap |= SANE_CAP_ADVANCED;
dev->val[OPT_MANUAL_GAIN].w = SANE_FALSE;
/* brightness group */
dev->opt[OPT_MANUAL_BRIGHTNESS].name = "manual-channel-brightness";
dev->opt[OPT_MANUAL_BRIGHTNESS].title = SANE_I18N ("Brightness");
dev->opt[OPT_MANUAL_BRIGHTNESS].desc = SANE_I18N ("Color channels brightness settings");
dev->opt[OPT_MANUAL_BRIGHTNESS].type = SANE_TYPE_BOOL;
dev->opt[OPT_MANUAL_BRIGHTNESS].cap |= SANE_CAP_ADVANCED;
dev->val[OPT_MANUAL_BRIGHTNESS].w = SANE_FALSE;
/* gray gain */
dev->opt[OPT_GRAY_GAIN].name = "gray-gain";
dev->opt[OPT_GRAY_GAIN].title = SANE_I18N ("Gray gain");
dev->opt[OPT_GRAY_GAIN].desc = SANE_I18N ("Sets gray channel gain");
dev->opt[OPT_GRAY_GAIN].type = SANE_TYPE_INT;
dev->opt[OPT_GRAY_GAIN].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_GRAY_GAIN].unit = SANE_UNIT_NONE;
dev->opt[OPT_GRAY_GAIN].size = sizeof (SANE_Int);
dev->opt[OPT_GRAY_GAIN].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_GRAY_GAIN].constraint.range = &u4_range;
dev->val[OPT_GRAY_GAIN].w = dev->gray_gain;
/* gray brightness */
dev->opt[OPT_GRAY_BRIGHTNESS].name = "gray-brightness";
dev->opt[OPT_GRAY_BRIGHTNESS].title = SANE_I18N ("Gray brightness");
dev->opt[OPT_GRAY_BRIGHTNESS].desc = SANE_I18N ("Sets gray channel brightness");
dev->opt[OPT_GRAY_BRIGHTNESS].type = SANE_TYPE_INT;
dev->opt[OPT_GRAY_BRIGHTNESS].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_GRAY_BRIGHTNESS].unit = SANE_UNIT_NONE;
dev->opt[OPT_GRAY_BRIGHTNESS].size = sizeof (SANE_Int);
dev->opt[OPT_GRAY_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_GRAY_BRIGHTNESS].constraint.range = &u4_range;
dev->val[OPT_GRAY_BRIGHTNESS].w = dev->gray_brightness;
/* red gain */
dev->opt[OPT_RED_GAIN].name = "red-gain";
dev->opt[OPT_RED_GAIN].title = SANE_I18N ("Red gain");
dev->opt[OPT_RED_GAIN].desc = SANE_I18N ("Sets red channel gain");
dev->opt[OPT_RED_GAIN].type = SANE_TYPE_INT;
dev->opt[OPT_RED_GAIN].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_RED_GAIN].unit = SANE_UNIT_NONE;
dev->opt[OPT_RED_GAIN].size = sizeof (SANE_Int);
dev->opt[OPT_RED_GAIN].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_RED_GAIN].constraint.range = &u4_range;
dev->val[OPT_RED_GAIN].w = dev->red_gain;
/* red brightness */
dev->opt[OPT_RED_BRIGHTNESS].name = "red-brightness";
dev->opt[OPT_RED_BRIGHTNESS].title = SANE_I18N ("Red brightness");
dev->opt[OPT_RED_BRIGHTNESS].desc = SANE_I18N ("Sets red channel brightness");
dev->opt[OPT_RED_BRIGHTNESS].type = SANE_TYPE_INT;
dev->opt[OPT_RED_BRIGHTNESS].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_RED_BRIGHTNESS].unit = SANE_UNIT_NONE;
dev->opt[OPT_RED_BRIGHTNESS].size = sizeof (SANE_Int);
dev->opt[OPT_RED_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_RED_BRIGHTNESS].constraint.range = &u4_range;
dev->val[OPT_RED_BRIGHTNESS].w = dev->red_brightness;
/* green gain */
dev->opt[OPT_GREEN_GAIN].name = "green-gain";
dev->opt[OPT_GREEN_GAIN].title = SANE_I18N ("Green gain");
dev->opt[OPT_GREEN_GAIN].desc = SANE_I18N ("Sets green channel gain");
dev->opt[OPT_GREEN_GAIN].type = SANE_TYPE_INT;
dev->opt[OPT_GREEN_GAIN].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_GREEN_GAIN].unit = SANE_UNIT_NONE;
dev->opt[OPT_GREEN_GAIN].size = sizeof (SANE_Int);
dev->opt[OPT_GREEN_GAIN].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_GREEN_GAIN].constraint.range = &u4_range;
dev->val[OPT_GREEN_GAIN].w = dev->green_gain;
/* green brightness */
dev->opt[OPT_GREEN_BRIGHTNESS].name = "green-brightness";
dev->opt[OPT_GREEN_BRIGHTNESS].title = SANE_I18N ("Green brightness");
dev->opt[OPT_GREEN_BRIGHTNESS].desc = SANE_I18N ("Sets green channel brightness");
dev->opt[OPT_GREEN_BRIGHTNESS].type = SANE_TYPE_INT;
dev->opt[OPT_GREEN_BRIGHTNESS].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_GREEN_BRIGHTNESS].unit = SANE_UNIT_NONE;
dev->opt[OPT_GREEN_BRIGHTNESS].size = sizeof (SANE_Int);
dev->opt[OPT_GREEN_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_GREEN_BRIGHTNESS].constraint.range = &u4_range;
dev->val[OPT_GREEN_BRIGHTNESS].w = dev->green_brightness;
/* blue gain */
dev->opt[OPT_BLUE_GAIN].name = "blue-gain";
dev->opt[OPT_BLUE_GAIN].title = SANE_I18N ("Blue gain");
dev->opt[OPT_BLUE_GAIN].desc = SANE_I18N ("Sets blue channel gain");
dev->opt[OPT_BLUE_GAIN].type = SANE_TYPE_INT;
dev->opt[OPT_BLUE_GAIN].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_BLUE_GAIN].unit = SANE_UNIT_NONE;
dev->opt[OPT_BLUE_GAIN].size = sizeof (SANE_Int);
dev->opt[OPT_BLUE_GAIN].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_BLUE_GAIN].constraint.range = &u4_range;
dev->val[OPT_BLUE_GAIN].w = dev->blue_gain;
/* blue brightness */
dev->opt[OPT_BLUE_BRIGHTNESS].name = "blue-brightness";
dev->opt[OPT_BLUE_BRIGHTNESS].title = SANE_I18N ("Blue brightness");
dev->opt[OPT_BLUE_BRIGHTNESS].desc = SANE_I18N ("Sets blue channel brightness");
dev->opt[OPT_BLUE_BRIGHTNESS].type = SANE_TYPE_INT;
dev->opt[OPT_BLUE_BRIGHTNESS].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_BLUE_BRIGHTNESS].unit = SANE_UNIT_NONE;
dev->opt[OPT_BLUE_BRIGHTNESS].size = sizeof (SANE_Int);
dev->opt[OPT_BLUE_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_BLUE_BRIGHTNESS].constraint.range = &u4_range;
dev->val[OPT_BLUE_BRIGHTNESS].w = dev->blue_brightness;
/* highlight group */
dev->opt[OPT_MANUAL_HIGHLIGHT].name = "manual-highlight";
dev->opt[OPT_MANUAL_HIGHLIGHT].title = SANE_TITLE_HIGHLIGHT;
dev->opt[OPT_MANUAL_HIGHLIGHT].desc =
SANE_I18N ("Color channels highlight settings");
dev->opt[OPT_MANUAL_HIGHLIGHT].type = SANE_TYPE_BOOL;
dev->opt[OPT_MANUAL_HIGHLIGHT].cap |= SANE_CAP_ADVANCED;
dev->val[OPT_MANUAL_HIGHLIGHT].w = SANE_FALSE;
/* contrast group */
dev->opt[OPT_MANUAL_CONTRAST].name = "manual-contrast";
dev->opt[OPT_MANUAL_CONTRAST].title = SANE_TITLE_CONTRAST;
dev->opt[OPT_MANUAL_CONTRAST].desc =
SANE_I18N ("Color channels contrast settings");
dev->opt[OPT_MANUAL_CONTRAST].type = SANE_TYPE_BOOL;
dev->opt[OPT_MANUAL_CONTRAST].cap |= SANE_CAP_ADVANCED;
dev->val[OPT_MANUAL_CONTRAST].w = SANE_FALSE;
/* gray highlight */
dev->opt[OPT_GRAY_HIGHLIGHT].name = "gray-highlight";
dev->opt[OPT_GRAY_HIGHLIGHT].title = SANE_I18N ("Gray highlight");
dev->opt[OPT_GRAY_HIGHLIGHT].desc =
SANE_I18N ("Sets gray channel highlight");
dev->opt[OPT_GRAY_HIGHLIGHT].type = SANE_TYPE_INT;
dev->opt[OPT_GRAY_HIGHLIGHT].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_GRAY_HIGHLIGHT].unit = SANE_UNIT_NONE;
dev->opt[OPT_GRAY_HIGHLIGHT].size = sizeof (SANE_Int);
dev->opt[OPT_GRAY_HIGHLIGHT].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_GRAY_HIGHLIGHT].constraint.range = &u4_range;
dev->val[OPT_GRAY_HIGHLIGHT].w = dev->gray_highlight;
/* gray contrast */
dev->opt[OPT_GRAY_CONTRAST].name = "gray-contrast";
dev->opt[OPT_GRAY_CONTRAST].title = SANE_I18N ("Gray contrast");
dev->opt[OPT_GRAY_CONTRAST].desc =
SANE_I18N ("Sets gray channel contrast");
dev->opt[OPT_GRAY_CONTRAST].type = SANE_TYPE_INT;
dev->opt[OPT_GRAY_CONTRAST].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_GRAY_CONTRAST].unit = SANE_UNIT_NONE;
dev->opt[OPT_GRAY_CONTRAST].size = sizeof (SANE_Int);
dev->opt[OPT_GRAY_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_GRAY_CONTRAST].constraint.range = &u4_range;
dev->val[OPT_GRAY_CONTRAST].w = dev->gray_contrast;
/* red highlight */
dev->opt[OPT_RED_HIGHLIGHT].name = "red-highlight";
dev->opt[OPT_RED_HIGHLIGHT].title = SANE_TITLE_HIGHLIGHT_R;
dev->opt[OPT_RED_HIGHLIGHT].desc = SANE_I18N ("Sets red channel highlight");
dev->opt[OPT_RED_HIGHLIGHT].type = SANE_TYPE_INT;
dev->opt[OPT_RED_HIGHLIGHT].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_RED_HIGHLIGHT].unit = SANE_UNIT_NONE;
dev->opt[OPT_RED_HIGHLIGHT].size = sizeof (SANE_Int);
dev->opt[OPT_RED_HIGHLIGHT].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_RED_HIGHLIGHT].constraint.range = &u4_range;
dev->val[OPT_RED_HIGHLIGHT].w = dev->red_highlight;
/* red contrast */
dev->opt[OPT_RED_CONTRAST].name = "red-contrast";
dev->opt[OPT_RED_CONTRAST].title = SANE_TITLE_CONTRAST;
dev->opt[OPT_RED_CONTRAST].desc = SANE_I18N ("Sets red channel contrast");
dev->opt[OPT_RED_CONTRAST].type = SANE_TYPE_INT;
dev->opt[OPT_RED_CONTRAST].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_RED_CONTRAST].unit = SANE_UNIT_NONE;
dev->opt[OPT_RED_CONTRAST].size = sizeof (SANE_Int);
dev->opt[OPT_RED_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_RED_CONTRAST].constraint.range = &u4_range;
dev->val[OPT_RED_CONTRAST].w = dev->red_contrast;
/* green highlight */
dev->opt[OPT_GREEN_HIGHLIGHT].name = "green-highlight";
dev->opt[OPT_GREEN_HIGHLIGHT].title = SANE_TITLE_HIGHLIGHT_G;
dev->opt[OPT_GREEN_HIGHLIGHT].desc =
SANE_I18N ("Sets green channel highlight");
dev->opt[OPT_GREEN_HIGHLIGHT].type = SANE_TYPE_INT;
dev->opt[OPT_GREEN_HIGHLIGHT].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_GREEN_HIGHLIGHT].unit = SANE_UNIT_NONE;
dev->opt[OPT_GREEN_HIGHLIGHT].size = sizeof (SANE_Int);
dev->opt[OPT_GREEN_HIGHLIGHT].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_GREEN_HIGHLIGHT].constraint.range = &u4_range;
dev->val[OPT_GREEN_HIGHLIGHT].w = dev->green_highlight;
/* green contrast */
dev->opt[OPT_GREEN_CONTRAST].name = "green-contrast";
dev->opt[OPT_GREEN_CONTRAST].title = SANE_TITLE_CONTRAST;
dev->opt[OPT_GREEN_CONTRAST].desc =
SANE_I18N ("Sets green channel contrast");
dev->opt[OPT_GREEN_CONTRAST].type = SANE_TYPE_INT;
dev->opt[OPT_GREEN_CONTRAST].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_GREEN_CONTRAST].unit = SANE_UNIT_NONE;
dev->opt[OPT_GREEN_CONTRAST].size = sizeof (SANE_Int);
dev->opt[OPT_GREEN_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_GREEN_CONTRAST].constraint.range = &u4_range;
dev->val[OPT_GREEN_CONTRAST].w = dev->green_contrast;
/* blue highlight */
dev->opt[OPT_BLUE_HIGHLIGHT].name = "blue-highlight";
dev->opt[OPT_BLUE_HIGHLIGHT].title = SANE_TITLE_HIGHLIGHT_B;
dev->opt[OPT_BLUE_HIGHLIGHT].desc =
SANE_I18N ("Sets blue channel highlight");
dev->opt[OPT_BLUE_HIGHLIGHT].type = SANE_TYPE_INT;
dev->opt[OPT_BLUE_HIGHLIGHT].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_BLUE_HIGHLIGHT].unit = SANE_UNIT_NONE;
dev->opt[OPT_BLUE_HIGHLIGHT].size = sizeof (SANE_Int);
dev->opt[OPT_BLUE_HIGHLIGHT].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_BLUE_HIGHLIGHT].constraint.range = &u4_range;
dev->val[OPT_BLUE_HIGHLIGHT].w = dev->blue_highlight;
/* blue contrast */
dev->opt[OPT_BLUE_CONTRAST].name = "blue-contrast";
dev->opt[OPT_BLUE_CONTRAST].title = SANE_TITLE_CONTRAST;
dev->opt[OPT_BLUE_CONTRAST].desc =
SANE_I18N ("Sets blue channel contrast");
dev->opt[OPT_BLUE_CONTRAST].type = SANE_TYPE_INT;
dev->opt[OPT_BLUE_CONTRAST].cap |= SANE_CAP_INACTIVE | SANE_CAP_ADVANCED;
dev->opt[OPT_BLUE_CONTRAST].unit = SANE_UNIT_NONE;
dev->opt[OPT_BLUE_CONTRAST].size = sizeof (SANE_Int);
dev->opt[OPT_BLUE_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
dev->opt[OPT_BLUE_CONTRAST].constraint.range = &u4_range;
dev->val[OPT_BLUE_CONTRAST].w = dev->blue_contrast;
return SANE_STATUS_GOOD;
}
@ -775,12 +775,12 @@ sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
sanei_umax_pp_setastra (val);
DBG (3, "init: option astra %ld P\n", val);
}
else if (strncmp (cp, "red-gain", 8) == 0)
else if ( (strncmp (cp, "red-brightness", 14) == 0) && isspace (cp[14]) )
{
char *end;
long int val;
cp += 9;
cp += 15;
errno = 0;
val = strtol (cp, &end, 0);
@ -794,15 +794,15 @@ sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
DBG (3, "init: option buffer %ld\n", val);
DBG (3, "init: setting global option red-gain to %ld\n", val);
red_gain = val;
DBG (3, "init: setting global option red-brightness to %ld\n", val);
red_brightness = val;
}
else if (strncmp (cp, "green-gain", 10) == 0 && isspace (cp[10]))
else if (strncmp (cp, "green-brightness", 16) == 0 && isspace (cp[16]))
{
char *end;
long int val;
cp += 11;
cp += 17;
errno = 0;
val = strtol (cp, &end, 0);
@ -814,16 +814,16 @@ sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
cp, val);
}
DBG (3, "init: option green-gain %ld\n", val);
DBG (3, "init: setting global option green-gain to %ld\n", val);
green_gain = val;
DBG (3, "init: option green-brightness %ld\n", val);
DBG (3, "init: setting global option green-brightness to %ld\n", val);
green_brightness = val;
}
else if (strncmp (cp, "blue-gain", 9) == 0 && isspace (cp[9]))
else if (strncmp (cp, "blue-brightness", 15) == 0 && isspace (cp[15]))
{
char *end;
long int val;
cp += 10;
cp += 16;
errno = 0;
val = strtol (cp, &end, 0);
@ -835,12 +835,58 @@ sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
cp, val);
}
DBG (3, "init: option blue-gain %ld\n", val);
DBG (3, "init: option blue-brightness %ld\n", val);
DBG (3, "init: setting global option blue-gain to %ld\n", val);
blue_gain = val;
DBG (3, "init: setting global option blue-brightness to %ld\n", val);
blue_brightness = val;
}
else if ((strncmp (cp, "red-highlight", 13) == 0)
else if ((strncmp (cp, "red-contrast", 12) == 0) && isspace (cp[12]))
{
char *end;
long int val;
cp += 13;
errno = 0;
val = strtol (cp, &end, 0);
if ((end == cp || errno) || (val < 0) || (val > 15))
{
val = 8; /* safe fallback */
DBG (2, "init: invalid value `%s`, falling back to %ld\n",
cp, val);
}
DBG (3, "init: option buffer %ld\n", val);
DBG (3, "init: setting global option red-contrast to %ld\n",
val);
red_contrast = val;
}
else if (strncmp (cp, "green-contrast", 14) == 0
&& isspace (cp[14]))
{
char *end;
long int val;
cp += 15;
errno = 0;
val = strtol (cp, &end, 0);
if ((end == cp || errno) || (val < 0) || (val > 15))
{
val = 4; /* safe fallback */
DBG (2, "init: invalid value `%s`, falling back to %ld\n",
cp, val);
}
DBG (3, "init: option green-contrast %ld\n", val);
DBG (3, "init: setting global option green-contrast to %ld\n",
val);
green_contrast = val;
}
else if (strncmp (cp, "blue-contrast", 13) == 0
&& isspace (cp[13]))
{
char *end;
@ -858,58 +904,11 @@ sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
cp, val);
}
DBG (3, "init: option buffer %ld\n", val);
DBG (3, "init: option blue-contrast %ld\n", val);
DBG (3, "init: setting global option red-highlight to %ld\n",
DBG (3, "init: setting global option blue-contrast to %ld\n",
val);
red_highlight = val;
}
else if (strncmp (cp, "green-highlight", 15) == 0
&& isspace (cp[15]))
{
char *end;
long int val;
cp += 16;
errno = 0;
val = strtol (cp, &end, 0);
if ((end == cp || errno) || (val < 0) || (val > 15))
{
val = 4; /* safe fallback */
DBG (2, "init: invalid value `%s`, falling back to %ld\n",
cp, val);
}
DBG (3, "init: option green-highlight %ld\n", val);
DBG (3, "init: setting global option green-highlight to %ld\n",
val);
green_highlight = val;
}
else if (strncmp (cp, "blue-highlight", 14) == 0
&& isspace (cp[14]))
{
char *end;
long int val;
cp += 15;
errno = 0;
val = strtol (cp, &end, 0);
if ((end == cp || errno) || (val < 0) || (val > 15))
{
val = 8; /* safe fallback */
DBG (2, "init: invalid value `%s`, falling back to %ld\n",
cp, val);
}
DBG (3, "init: option blue-highlight %ld\n", val);
DBG (3, "init: setting global option blue-highlight to %ld\n",
val);
blue_highlight = val;
blue_contrast = val;
}
}
else if ((strncmp (cp, "port", 4) == 0) && isspace (cp[4]))
@ -1003,28 +1002,28 @@ sane_exit (void)
}
if (devlist != NULL)
{
free (devlist);
devlist = NULL;
}
{
free (devlist);
devlist=NULL;
}
if (devarray != NULL)
{
free (devarray);
devarray = NULL;
}
{
free (devarray);
devarray=NULL;
}
/* reset values */
num_devices = 0;
first_dev = NULL;
red_gain = 0;
green_gain = 0;
blue_gain = 0;
red_brightness = 0;
green_brightness = 0;
blue_brightness = 0;
red_highlight = 0;
green_highlight = 0;
blue_highlight = 0;
red_contrast = 0;
green_contrast = 0;
blue_contrast = 0;
}
@ -1037,10 +1036,10 @@ sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
DBG (129, "unused arg: local_only = %d\n", (int) local_only);
if (devarray != NULL)
{
free (devarray);
devarray = NULL;
}
{
free (devarray);
devarray=NULL;
}
devarray = malloc ((num_devices + 1) * sizeof (devarray[0]));
@ -1119,12 +1118,12 @@ sane_open (SANE_String_Const devicename, SANE_Handle * handle)
return SANE_STATUS_INVAL;
}
DBG (3, "open: trying default device %s, port=%s\n",
devlist[0].sane.name, devlist[0].port);
if (devlist[0].port != NULL)
rc = sanei_umax_pp_open (atoi (devlist[0].port), NULL);
DBG (3, "open: trying default device %s, port=%s,ppdev=%s\n",
devlist[0].sane.name, devlist[0].port, devlist[0].ppdevice);
if(devlist[0].port!=NULL)
rc = sanei_umax_pp_open (atoi (devlist[0].port), NULL);
else
rc = sanei_umax_pp_open (0, devlist[0].sane.name);
rc = sanei_umax_pp_open (0 , devlist[0].ppdevice);
desc = &devlist[0];
}
@ -1200,15 +1199,15 @@ sane_open (SANE_String_Const devicename, SANE_Handle * handle)
dev->y_range.max = dev->desc->max_v_size;
dev->y_range.quant = 0;
dev->gray_gain = 0;
dev->gray_brightness = 0;
/* use pre defined settings read from umax_pp.conf */
dev->red_gain = red_gain;
dev->green_gain = green_gain;
dev->blue_gain = blue_gain;
dev->red_highlight = red_highlight;
dev->green_highlight = green_highlight;
dev->blue_highlight = blue_highlight;
dev->red_brightness = red_brightness;
dev->green_brightness = green_brightness;
dev->blue_brightness = blue_brightness;
dev->red_contrast = red_contrast;
dev->green_contrast = green_contrast;
dev->blue_contrast = blue_contrast;
if (dev->buf == NULL)
@ -1279,13 +1278,13 @@ sane_close (SANE_Handle handle)
}
}
/* then we switch off light if needed */
/* then we switch off brightness if needed */
if (dev->val[OPT_LAMP_CONTROL].w == SANE_TRUE)
{
rc = sanei_umax_pp_lamp (0);
if (rc == UMAX1220P_TRANSPORT_FAILED)
{
DBG (1, "close: switch off light failed (ignored....)\n");
DBG (1, "close: switch off brightness failed (ignored....)\n");
}
}
@ -1381,16 +1380,16 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
case OPT_BR_Y:
case OPT_NUM_OPTS:
case OPT_CUSTOM_GAMMA:
case OPT_MANUAL_GAIN:
case OPT_GRAY_GAIN:
case OPT_GREEN_GAIN:
case OPT_RED_GAIN:
case OPT_BLUE_GAIN:
case OPT_MANUAL_HIGHLIGHT:
case OPT_GRAY_HIGHLIGHT:
case OPT_GREEN_HIGHLIGHT:
case OPT_RED_HIGHLIGHT:
case OPT_BLUE_HIGHLIGHT:
case OPT_MANUAL_BRIGHTNESS:
case OPT_GRAY_BRIGHTNESS:
case OPT_GREEN_BRIGHTNESS:
case OPT_RED_BRIGHTNESS:
case OPT_BLUE_BRIGHTNESS:
case OPT_MANUAL_CONTRAST:
case OPT_GRAY_CONTRAST:
case OPT_GREEN_CONTRAST:
case OPT_RED_CONTRAST:
case OPT_BLUE_CONTRAST:
*(SANE_Word *) val = dev->val[option].w;
return SANE_STATUS_GOOD;
@ -1454,14 +1453,14 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
if (info)
*info |= SANE_INFO_RELOAD_PARAMS;
case OPT_GRAY_GAIN:
case OPT_GREEN_GAIN:
case OPT_RED_GAIN:
case OPT_BLUE_GAIN:
case OPT_GRAY_HIGHLIGHT:
case OPT_GREEN_HIGHLIGHT:
case OPT_RED_HIGHLIGHT:
case OPT_BLUE_HIGHLIGHT:
case OPT_GRAY_BRIGHTNESS:
case OPT_GREEN_BRIGHTNESS:
case OPT_RED_BRIGHTNESS:
case OPT_BLUE_BRIGHTNESS:
case OPT_GRAY_CONTRAST:
case OPT_GREEN_CONTRAST:
case OPT_RED_CONTRAST:
case OPT_BLUE_CONTRAST:
dev->val[option].w = *(SANE_Word *) val;
/* sanity check */
@ -1604,16 +1603,16 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
}
return SANE_STATUS_GOOD;
case OPT_MANUAL_HIGHLIGHT:
case OPT_MANUAL_CONTRAST:
w = *(SANE_Word *) val;
if (w == dev->val[OPT_MANUAL_HIGHLIGHT].w)
if (w == dev->val[OPT_MANUAL_CONTRAST].w)
return SANE_STATUS_GOOD; /* no change */
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS;
dev->val[OPT_MANUAL_HIGHLIGHT].w = w;
dev->val[OPT_MANUAL_CONTRAST].w = w;
if (w == SANE_TRUE)
{
@ -1621,36 +1620,36 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
if ((strcmp (mode, "Grayscale") == 0)
|| (strcmp (mode, "Lineart") == 0))
dev->opt[OPT_GRAY_HIGHLIGHT].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GRAY_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
else if (strcmp (mode, "Color") == 0)
{
dev->opt[OPT_GRAY_HIGHLIGHT].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_RED_HIGHLIGHT].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_HIGHLIGHT].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_HIGHLIGHT].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GRAY_CONTRAST].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_RED_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
}
}
else
{
dev->opt[OPT_GRAY_HIGHLIGHT].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_RED_HIGHLIGHT].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_HIGHLIGHT].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_HIGHLIGHT].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GRAY_CONTRAST].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_RED_CONTRAST].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_CONTRAST].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_CONTRAST].cap |= SANE_CAP_INACTIVE;
}
return SANE_STATUS_GOOD;
case OPT_MANUAL_GAIN:
case OPT_MANUAL_BRIGHTNESS:
w = *(SANE_Word *) val;
if (w == dev->val[OPT_MANUAL_GAIN].w)
if (w == dev->val[OPT_MANUAL_BRIGHTNESS].w)
return SANE_STATUS_GOOD; /* no change */
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS;
dev->val[OPT_MANUAL_GAIN].w = w;
dev->val[OPT_MANUAL_BRIGHTNESS].w = w;
if (w == SANE_TRUE)
{
@ -1658,21 +1657,21 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
if ((strcmp (mode, "Grayscale") == 0)
|| (strcmp (mode, "Lineart") == 0))
dev->opt[OPT_GRAY_GAIN].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GRAY_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE;
else if (strcmp (mode, "Color") == 0)
{
dev->opt[OPT_GRAY_GAIN].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_RED_GAIN].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_GAIN].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_GAIN].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GRAY_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_RED_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE;
}
}
else
{
dev->opt[OPT_GRAY_GAIN].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_RED_GAIN].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_GAIN].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_GAIN].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GRAY_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_RED_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
}
return SANE_STATUS_GOOD;
@ -1782,43 +1781,43 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
}
}
/* rebuild OPT HIGHLIGHT */
dev->opt[OPT_GRAY_HIGHLIGHT].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_RED_HIGHLIGHT].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_HIGHLIGHT].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_HIGHLIGHT].cap |= SANE_CAP_INACTIVE;
/* rebuild OPT CONTRAST */
dev->opt[OPT_GRAY_CONTRAST].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_RED_CONTRAST].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_CONTRAST].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_CONTRAST].cap |= SANE_CAP_INACTIVE;
if (dev->val[OPT_MANUAL_HIGHLIGHT].w == SANE_TRUE)
if (dev->val[OPT_MANUAL_CONTRAST].w == SANE_TRUE)
{
if ((strcmp (val, "Grayscale") == 0)
|| (strcmp (val, "Lineart") == 0))
dev->opt[OPT_GRAY_HIGHLIGHT].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GRAY_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
else if (strcmp (val, "Color") == 0)
{
dev->opt[OPT_RED_HIGHLIGHT].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_HIGHLIGHT].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_HIGHLIGHT].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_RED_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
}
}
/* rebuild OPT GAIN */
dev->opt[OPT_GRAY_GAIN].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_RED_GAIN].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_GAIN].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_GAIN].cap |= SANE_CAP_INACTIVE;
/* rebuild OPT BRIGHTNESS */
dev->opt[OPT_GRAY_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_RED_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
if (dev->val[OPT_MANUAL_GAIN].w == SANE_TRUE)
if (dev->val[OPT_MANUAL_BRIGHTNESS].w == SANE_TRUE)
{
if ((strcmp (val, "Grayscale") == 0)
|| (strcmp (val, "Lineart") == 0))
dev->opt[OPT_GRAY_GAIN].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GRAY_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE;
else if (strcmp (val, "Color") == 0)
{
dev->opt[OPT_RED_GAIN].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_GAIN].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_GAIN].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_RED_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_GREEN_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE;
dev->opt[OPT_BLUE_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE;
}
}
@ -1854,50 +1853,50 @@ sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
else
dev->color = UMAX_PP_MODE_COLOR;
/* highlight control */
if (dev->val[OPT_MANUAL_HIGHLIGHT].w == SANE_TRUE)
/* contrast control */
if (dev->val[OPT_MANUAL_CONTRAST].w == SANE_TRUE)
{
if (dev->color != UMAX_PP_MODE_COLOR)
{
dev->red_highlight = 0;
dev->green_highlight = (int) (dev->val[OPT_GRAY_HIGHLIGHT].w);
dev->blue_highlight = 0;
dev->red_contrast = 0;
dev->green_contrast = (int) (dev->val[OPT_GRAY_CONTRAST].w);
dev->blue_contrast = 0;
}
else
{
dev->red_highlight = (int) (dev->val[OPT_RED_HIGHLIGHT].w);
dev->green_highlight = (int) (dev->val[OPT_GREEN_HIGHLIGHT].w);
dev->blue_highlight = (int) (dev->val[OPT_BLUE_HIGHLIGHT].w);
dev->red_contrast = (int) (dev->val[OPT_RED_CONTRAST].w);
dev->green_contrast = (int) (dev->val[OPT_GREEN_CONTRAST].w);
dev->blue_contrast = (int) (dev->val[OPT_BLUE_CONTRAST].w);
}
}
else
{
dev->red_highlight = 2;
dev->green_highlight = 2;
dev->blue_highlight = 2;
dev->red_contrast = 2;
dev->green_contrast = 2;
dev->blue_contrast = 2;
}
/* gain control */
if (dev->val[OPT_MANUAL_GAIN].w == SANE_TRUE)
/* brightness control */
if (dev->val[OPT_MANUAL_BRIGHTNESS].w == SANE_TRUE)
{
if (dev->color != UMAX_PP_MODE_COLOR)
{
dev->red_gain = 0;
dev->green_gain = (int) (dev->val[OPT_GRAY_GAIN].w);
dev->blue_gain = 0;
dev->red_brightness = 0;
dev->green_brightness = (int) (dev->val[OPT_GRAY_BRIGHTNESS].w);
dev->blue_brightness = 0;
}
else
{
dev->red_gain = (int) (dev->val[OPT_RED_GAIN].w);
dev->green_gain = (int) (dev->val[OPT_GREEN_GAIN].w);
dev->blue_gain = (int) (dev->val[OPT_BLUE_GAIN].w);
dev->red_brightness = (int) (dev->val[OPT_RED_BRIGHTNESS].w);
dev->green_brightness = (int) (dev->val[OPT_GREEN_BRIGHTNESS].w);
dev->blue_brightness = (int) (dev->val[OPT_BLUE_BRIGHTNESS].w);
}
}
else
{
dev->red_gain = red_gain;
dev->green_gain = green_gain;
dev->blue_gain = blue_gain;
dev->red_brightness = red_brightness;
dev->green_brightness = green_brightness;
dev->blue_brightness = blue_brightness;
}
/* geometry */
@ -2034,7 +2033,7 @@ sane_start (SANE_Handle handle)
dev->val[OPT_LAMP_CONTROL].w = SANE_TRUE;
/* tests if we do auto setting */
if (dev->val[OPT_MANUAL_GAIN].w == SANE_TRUE)
if (dev->val[OPT_MANUAL_BRIGHTNESS].w == SANE_TRUE)
autoset = 0;
else
autoset = 1;
@ -2050,9 +2049,9 @@ sane_start (SANE_Handle handle)
dev->BottomX - dev->TopX,
dev->BottomY - dev->TopY,
dev->dpi,
(dev->red_gain << 8) + (dev->green_gain << 4) + dev->blue_gain,
(dev->red_highlight << 8) + (dev->green_highlight << 4) +
dev->blue_highlight);
(dev->red_brightness << 8) + (dev->green_brightness << 4) + dev->blue_brightness,
(dev->red_contrast << 8) + (dev->green_contrast << 4) +
dev->blue_contrast);
rc = sanei_umax_pp_start (dev->TopX,
dev->TopY - 2 * delta,
@ -2061,11 +2060,11 @@ sane_start (SANE_Handle handle)
dev->dpi,
2,
autoset,
(dev->red_gain << 8) +
(dev->green_gain << 4) + dev->blue_gain,
(dev->red_highlight << 8) +
(dev->green_highlight << 4) +
dev->blue_highlight,
(dev->red_brightness << 8) +
(dev->green_brightness << 4) + dev->blue_brightness,
(dev->red_contrast << 8) +
(dev->green_contrast << 4) +
dev->blue_contrast,
&(dev->bpp), &(dev->tw), &(dev->th));
/* we enlarged the scanning zone */
/* to allow reordering, we must */
@ -2079,8 +2078,8 @@ sane_start (SANE_Handle handle)
dev->TopX,
dev->TopY,
dev->BottomX - dev->TopX,
dev->BottomY - dev->TopY, dev->dpi, dev->gray_gain << 4,
dev->gray_highlight << 4);
dev->BottomY - dev->TopY, dev->dpi, dev->gray_brightness << 4,
dev->gray_contrast << 4);
rc = sanei_umax_pp_start (dev->TopX,
dev->TopY,
dev->BottomX - dev->TopX,
@ -2088,7 +2087,7 @@ sane_start (SANE_Handle handle)
dev->dpi,
(dev->color ==
UMAX_PP_MODE_GRAYSCALE) ? 1 : 0, autoset,
dev->gray_gain << 4, dev->gray_highlight << 4,
dev->gray_brightness << 4, dev->gray_contrast << 4,
&(dev->bpp), &(dev->tw), &(dev->th));
}

24
backend/umax_pp.conf
Wyświetl plik

@ -16,29 +16,29 @@ option buffer 2097152
port /dev/parport0
# the following options are local to this scanner
# gain for red channel, if not given, will be automatically computed
# brightness for red channel, if not given, will be automatically computed
# must be between 0 and 15
#option red-gain 8
#option red-brightness 8
# gain for green channel, if not given, will be automatically computed
# brightness for green channel, if not given, will be automatically computed
# must be between 0 and 15
#option green-gain 4
#option green-brightness 4
# gain for blue channel, if not given, will be automatically computed
# brightness for blue channel, if not given, will be automatically computed
# must be between 0 and 15
#option blue-gain 8
#option blue-brightness 8
# highlight for red channel, if not given, will default to 0
# contrast for red channel, if not given, will default to 0
# must be between 0 and 15
#option red-highlight 2
#option red-contrast 2
# highlight for green channel, if not given, will default to 0
# contrast for green channel, if not given, will default to 0
# must be between 0 and 15
#option green-highlight 1
#option green-contrast 1
# highlight for blue channel, if not given, will default to 0
# contrast for blue channel, if not given, will default to 0
# must be between 0 and 15
#option blue-highlight 1
#option blue-contrast 1
#

54
backend/umax_pp.h
Wyświetl plik

@ -77,17 +77,17 @@ enum Umax_PP_Option
OPT_GAMMA_VECTOR_G,
OPT_GAMMA_VECTOR_B,
OPT_MANUAL_GAIN,
OPT_GRAY_GAIN,
OPT_RED_GAIN,
OPT_GREEN_GAIN,
OPT_BLUE_GAIN,
OPT_MANUAL_BRIGHTNESS,
OPT_GRAY_BRIGHTNESS,
OPT_RED_BRIGHTNESS,
OPT_GREEN_BRIGHTNESS,
OPT_BLUE_BRIGHTNESS,
OPT_MANUAL_HIGHLIGHT,
OPT_GRAY_HIGHLIGHT,
OPT_RED_HIGHLIGHT,
OPT_GREEN_HIGHLIGHT,
OPT_BLUE_HIGHLIGHT,
OPT_MANUAL_CONTRAST,
OPT_GRAY_CONTRAST,
OPT_RED_CONTRAST,
OPT_GREEN_CONTRAST,
OPT_BLUE_CONTRAST,
/* must come last: */
NUM_OPTIONS
@ -116,14 +116,14 @@ typedef struct Umax_PP_Descriptor
u_char revision;
/* default values */
SANE_Int gray_gain;
SANE_Int red_gain;
SANE_Int blue_gain;
SANE_Int green_gain;
SANE_Int gray_highlight;
SANE_Int red_highlight;
SANE_Int blue_highlight;
SANE_Int green_highlight;
SANE_Int gray_brightness;
SANE_Int red_brightness;
SANE_Int blue_brightness;
SANE_Int green_brightness;
SANE_Int gray_contrast;
SANE_Int red_contrast;
SANE_Int blue_contrast;
SANE_Int green_contrast;
}
Umax_PP_Descriptor;
@ -147,7 +147,7 @@ typedef struct Umax_PP_Device
int BottomY;
int dpi;
int gain;
int brightness;
int color;
int bpp; /* bytes per pixel */
int tw; /* target width in pixels */
@ -168,15 +168,15 @@ typedef struct Umax_PP_Device
SANE_Range x_range;
SANE_Range y_range;
SANE_Int gray_gain;
SANE_Int red_gain;
SANE_Int blue_gain;
SANE_Int green_gain;
SANE_Int gray_brightness;
SANE_Int red_brightness;
SANE_Int blue_brightness;
SANE_Int green_brightness;
SANE_Int gray_highlight;
SANE_Int red_highlight;
SANE_Int blue_highlight;
SANE_Int green_highlight;
SANE_Int gray_contrast;
SANE_Int red_contrast;
SANE_Int blue_contrast;
SANE_Int green_contrast;
}
Umax_PP_Device;

90
backend/umax_pp_low.c
Wyświetl plik

@ -461,8 +461,8 @@ sanei_umax_pp_InitPort (int port, char *name)
/* since this function must be called before */
/* any other, we put debug init here */
DBG_INIT ();
/* sets global vars */
/* sets global vars */
ggGreen = ggamma;
ggBlue = ggamma;
ggRed = ggamma;
@ -3821,7 +3821,7 @@ sanei_umax_pp_InitScanner (int recover)
sentcmd[j] = 0x80;
j++;
sentcmd[j] = 0xF0;
j++; /* F0 means light on, 90 light off */
j++; /* F0 means brightness on, 90 brightness off */
if (GetModel () == 0x07)
{
sentcmd[j] = 0x00;
@ -6334,10 +6334,10 @@ Bloc2Decode (int *op)
DBG (0, "\t->scan height =0x%04X (%d)\n", scanh, scanh);
DBG (0, "\t->skip height =0x%04X (%d)\n", skiph, skiph);
DBG (0, "\t->y dpi =0x%04X (%d)\n", dpi, dpi);
DBG (0, "\t->channel 1 gain=0x%02X (%d)\n", op[10] & 0x0F, op[10] & 0x0F);
DBG (0, "\t->channel 2 gain=0x%02X (%d)\n", (op[10] & 0xF0) / 16,
DBG (0, "\t->channel 1 brightness=0x%02X (%d)\n", op[10] & 0x0F, op[10] & 0x0F);
DBG (0, "\t->channel 2 brightness=0x%02X (%d)\n", (op[10] & 0xF0) / 16,
(op[10] & 0xF0) / 16);
DBG (0, "\t->channel 3 gain=0x%02X (%d)\n", op[11] & 0x0F, op[11] & 0x0F);
DBG (0, "\t->channel 3 brightness=0x%02X (%d)\n", op[11] & 0x0F, op[11] & 0x0F);
DBG (0, "\t->channel 1 high=0x%02X (%d)\n", (op[11] / 16) & 0x0F,
(op[11] / 16) & 0x0F);
DBG (0, "\t->channel 2 high=0x%02X (%d)\n", (op[12] & 0xF0) / 16,
@ -7026,7 +7026,7 @@ MoveToOrigin (void)
*/
static int
WarmUp (int color, int *gain)
WarmUp (int color, int *brightness)
{
unsigned char buffer[5300];
int i, val, min, max;
@ -7221,16 +7221,16 @@ WarmUp (int color, int *gain)
/***********************/
/* auto gain computing */
/* auto brightness computing */
/***********************/
/* color correction set to 53 05 */
/* for a start */
*gain = 0x535;
*brightness = 0x535;
CMDSETGET (2, 0x10, opsc18);
CMDSETGET (8, 0x24, opsc39);
opsc04[7] = opsc04[7] & 0x20;
opsc04[6] = 0x06; /* one channel gain value */
opsc04[6] = 0x06; /* one channel brightness value */
CMDSETGET (1, 0x08, opsc10); /* was opsc04, extraneaous string */
/* that prevents using Move .... */
CMDSYNC (0xC2);
@ -7242,10 +7242,10 @@ WarmUp (int color, int *gain)
Dump (0x200, buffer, NULL);
/* auto correction of gain levels */
/* auto correction of brightness levels */
/* first color component X */
opsc51[10] = (*gain) / 16; /* channel 1 & 2 gain */
opsc51[11] = (*gain) % 16; /* channel 3 gain */
opsc51[10] = (*brightness) / 16; /* channel 1 & 2 brightness */
opsc51[11] = (*brightness) % 16; /* channel 3 brightness */
if (color >= RGB_MODE)
{
if (sanei_umax_pp_getastra () == 1600)
@ -7263,7 +7263,7 @@ WarmUp (int color, int *gain)
Bloc2Decode (opsc51);
Bloc8Decode (opsc40);
}
opsc04[6] = (*gain) / 256;
opsc04[6] = (*brightness) / 256;
CMDSETGET (1, 0x08, opsc04);
CMDSYNC (0xC2);
CMDSYNC (0x00);
@ -7301,9 +7301,9 @@ WarmUp (int color, int *gain)
}
}
*gain = (*gain & 0xFF) + 256 * (opsc04[6] - 1);
opsc51[10] = *gain / 16; /* channel 1 & 2 gain */
opsc51[11] = *gain % 16; /* channel 3 gain */
*brightness = (*brightness & 0xFF) + 256 * (opsc04[6] - 1);
opsc51[10] = *brightness / 16; /* channel 1 & 2 brightness */
opsc51[11] = *brightness % 16; /* channel 3 brightness */
opsc51[0] = 0x01;
opsc51[13] = 0x80;
if (sanei_umax_pp_getastra () == 1600)
@ -7316,7 +7316,7 @@ WarmUp (int color, int *gain)
}
CMDSETGET (2, 0x10, opsc51);
CMDSETGET (8, 0x24, opsc40);
opsc04[6] = (*gain & 0x00F);
opsc04[6] = (*brightness & 0x00F);
CMDSETGET (1, 0x08, opsc04);
CMDSYNC (0xC2);
CMDSYNC (0x00);
@ -7354,7 +7354,7 @@ WarmUp (int color, int *gain)
max = buffer[i];
}
}
*gain = (*gain & 0xFF0) + (opsc04[6] - 1);
*brightness = (*brightness & 0xFF0) + (opsc04[6] - 1);
}
@ -7362,8 +7362,8 @@ WarmUp (int color, int *gain)
/* component Z: B&W component */
opsc51[10] = *gain / 16; /* channel 1 & 2 gain */
opsc51[11] = *gain % 16; /* channel 3 gain */
opsc51[10] = *brightness / 16; /* channel 1 & 2 brightness */
opsc51[11] = *brightness % 16; /* channel 3 brightness */
if (color < RGB_MODE)
opsc51[0] = 0x01; /* in BW, scan zone doesn't have an extra 4 points */
else
@ -7383,7 +7383,7 @@ WarmUp (int color, int *gain)
Bloc2Decode (opsc51);
}
CMDSETGET (8, 0x24, opsc40);
opsc04[6] = (*gain & 0x0F0) / 16;
opsc04[6] = (*brightness & 0x0F0) / 16;
CMDSETGET (1, 0x08, opsc04);
CMDSYNC (0xC2);
CMDSYNC (0x00);
@ -7420,7 +7420,7 @@ WarmUp (int color, int *gain)
max = buffer[i];
}
}
*gain = (*gain & 0xF0F) + (opsc04[6] - 1) * 16;
*brightness = (*brightness & 0xF0F) + (opsc04[6] - 1) * 16;
DBG (1, "Warm-up done ...\n");
return (1);
}
@ -7459,7 +7459,7 @@ sanei_umax_pp_Park (void)
/* calibrates CCD: returns 1 on success, 0 on failure */
static int
ColorCalibration (int color, int dpi, int gain, int highlight, int width,
ColorCalibration (int color, int dpi, int brightness, int contrast, int width,
int *calibration)
{
int opsc32[17] =
@ -7507,18 +7507,18 @@ ColorCalibration (int color, int dpi, int gain, int highlight, int width,
/* get calibration data */
if (sanei_umax_pp_getauto ())
{ /* auto settings doesn't use highlight */
highlight = 0x000;
{ /* auto settings doesn't use contrast */
contrast = 0x000;
}
else
{ /* manual settings */
gain = 0x777;
highlight = 0x000;
brightness = 0x777;
contrast = 0x000;
}
opsc32[10] = gain / 16;
opsc32[11] = gain % 16 | ((highlight / 16) & 0xF0);
opsc32[12] = highlight % 256;
DBG (8, "USING 0x%03X gain, 0x%03X highlight\n", gain, highlight);
opsc32[10] = brightness / 16;
opsc32[11] = brightness % 16 | ((contrast / 16) & 0xF0);
opsc32[12] = contrast % 256;
DBG (8, "USING 0x%03X brightness, 0x%03X contrast\n", brightness, contrast);
if (sanei_umax_pp_getastra () == 1600)
{
opsc32[13] = 0x03;
@ -7649,7 +7649,7 @@ sanei_umax_pp_ReadBlock (long len, int window, int dpi, int last,
int
sanei_umax_pp_Scan (int x, int y, int width, int height, int dpi, int color,
int gain, int highlight)
int brightness, int contrast)
{
#ifdef HAVE_SYS_TIME_H
struct timeval td, tf;
@ -7665,7 +7665,7 @@ sanei_umax_pp_Scan (int x, int y, int width, int height, int dpi, int color,
int bx, by;
if (sanei_umax_pp_StartScan
(x, y, width, height, dpi, color, gain, highlight, &bpp, &tw, &th) == 1)
(x, y, width, height, dpi, color, brightness, contrast, &bpp, &tw, &th) == 1)
{
COMPLETIONWAIT;
@ -7852,7 +7852,7 @@ sanei_umax_pp_ParkWait (void)
/* starts scan: return 1 on success */
int
sanei_umax_pp_StartScan (int x, int y, int width, int height, int dpi,
int color, int gain, int highlight, int *rbpp,
int color, int brightness, int contrast, int *rbpp,
int *rtw, int *rth)
{
unsigned char *buffer;
@ -7893,7 +7893,7 @@ sanei_umax_pp_StartScan (int x, int y, int width, int height, int dpi,
DBG (8, "StartScan(%d,%d,%d,%d,%d,%d,%X);\n", x, y, width, height, dpi,
color, gain);
color, brightness);
buffer = (unsigned char *) malloc (2096100);
if (buffer == NULL)
{
@ -8042,11 +8042,11 @@ sanei_umax_pp_StartScan (int x, int y, int width, int height, int dpi,
}
/* adjust gain and color offset */
/* adjust brightness and color offset */
/* red*256+green*16+blue */
if (sanei_umax_pp_getauto ())
{
if (WarmUp (color, &gain) == 0)
if (WarmUp (color, &brightness) == 0)
{
DBG (0, "Warm-up failed !!! (%s:%d)\n", __FILE__, __LINE__);
return (0);
@ -8078,7 +8078,7 @@ sanei_umax_pp_StartScan (int x, int y, int width, int height, int dpi,
tw = (width * xdpi) / 600;
/* do gamma calibration */
if (ColorCalibration (color, dpi, gain, highlight, width, calibration) == 0)
if (ColorCalibration (color, dpi, brightness, contrast, width, calibration) == 0)
{
DBG (0, "Gamma calibration failed !!! (%s:%d)\n", __FILE__, __LINE__);
return (0);
@ -8173,10 +8173,10 @@ sanei_umax_pp_StartScan (int x, int y, int width, int height, int dpi,
break;
}
/* channels gain */
opsc53[10] = gain / 16;
opsc53[11] = ((highlight / 16) & 0xF0) | (gain % 16);
opsc53[12] = highlight % 256;
/* channels brightness */
opsc53[10] = brightness / 16;
opsc53[11] = ((contrast / 16) & 0xF0) | (brightness % 16);
opsc53[12] = contrast % 256;
/* scan height */
opsc53[0] = h % 256;
@ -8218,7 +8218,7 @@ sanei_umax_pp_StartScan (int x, int y, int width, int height, int dpi,
{
opsc53[7] = 0x2F;
/* 00 seems to give better results ? */
/* 80 some more gain, lamp power level ? */
/* 80 some more brightness, lamp power level ? */
/* 8x does not make much difference */
opsc04[6] = 0x8F;
if (sanei_umax_pp_getastra () == 1600)
@ -8236,7 +8236,7 @@ sanei_umax_pp_StartScan (int x, int y, int width, int height, int dpi,
{
opsc53[7] = 0x40;
opsc53[13] = 0xC0;
opsc04[6] = 0x80 | ((gain / 16) & 0x0F);
opsc04[6] = 0x80 | ((brightness / 16) & 0x0F);
if (sanei_umax_pp_getastra () == 1600)
{
opsc04[7] = 0x20;

4
backend/umax_pp_low.h
Wyświetl plik

@ -91,7 +91,7 @@ extern void sanei_umax_pp_setauto (int mode);
#endif
extern int sanei_umax_pp_Scan (int x, int y, int width, int height, int dpi,
int color, int gain, int highlight);
int color, int brightness, int contrast);
extern int sanei_umax_pp_Move (int distance, int precision,
unsigned char *buffer);
extern int sanei_umax_pp_SetLamp (int on);
@ -102,7 +102,7 @@ extern int sanei_umax_pp_ParkWait (void);
extern int sanei_umax_pp_ReadBlock (long len, int window, int dpi, int last,
unsigned char *buffer);
extern int sanei_umax_pp_StartScan (int x, int y, int width, int height,
int dpi, int color, int gain,
int dpi, int color, int brightness,
int contrast, int *rbpp, int *rtw,
int *rth);

4
backend/umax_pp_mid.c
Wyświetl plik

@ -330,7 +330,7 @@ sanei_umax_pp_cancel (void)
int
sanei_umax_pp_start (int x, int y, int width, int height, int dpi, int color,
int autoset,
int gain, int highlight, int *rbpp, int *rtw, int *rth)
int brightness, int contrast, int *rbpp, int *rtw, int *rth)
{
int col = BW_MODE;
@ -359,7 +359,7 @@ sanei_umax_pp_start (int x, int y, int width, int height, int dpi, int color,
}
if (sanei_umax_pp_StartScan
(x + 144, y, width, height, dpi, col, gain, highlight, rbpp, rtw,
(x + 144, y, width, height, dpi, col, brightness, contrast, rbpp, rtw,
rth) != 1)
{
sanei_umax_pp_EndSession ();

10
backend/umax_pp_mid.h
Wyświetl plik

@ -132,7 +132,7 @@ extern int sanei_umax_pp_cancel (void);
/* starts scanning:
- find scanner origin
- does channel gain calibration if needed
- does channel brightness calibration if needed
- does calibration
- initialize scan operation
@ -142,8 +142,8 @@ extern int sanei_umax_pp_cancel (void);
color is true for color scan, false for gray-levels
gain value is 256*red_gain+16*green_gain+blue_gain
if gain is given (ie <> 0), auto gain will not be performed
brightness value is 256*red_brightness+16*green_brightness+blue_brightness
if brightness is given (ie <> 0), auto brightness will not be performed
@ -152,8 +152,8 @@ extern int sanei_umax_pp_cancel (void);
the width of scanned area expressed in pixels
*/
extern int sanei_umax_pp_start (int x, int y, int width, int height, int dpi,
int color, int autoset, int gain,
int highlight, int *rbpp, int *rtw, int *rth);
int color, int autoset, int brightness,
int contrast, int *rbpp, int *rtw, int *rth);
/* reads one block of data from scanner

33
doc/sane-umax_pp.man
Wyświetl plik

@ -112,35 +112,36 @@ scanners. Empty lines and lines starting with a hash mark (#) are
ignored.
.PP
The height options supported are
.BR red-gain ,
.BR green-gain ,
.BR blue-gain ,
.BR red-highlight ,
.BR green-highlight ,
.BR blue-highlight ,
.BR red-brightness ,
.BR green-brightness ,
.BR blue-brightness ,
.BR red-contrast ,
.BR green-contrast ,
.BR blue-contrast ,
.BR astra ,
and
.BR buffer .
Options
.B red-gain
.B red-brightness
,
.B green-gain
.B green-brightness
and
.B blue-gain
.B blue-brightness
allow you to adjust the sensitivy of your scanner for the given color. Values
range from 0 (lowest gain) to 15 (highest). When all three gains are set to
0, the backend does auto gain tuning.
range from 0 (lowest brightness) to 15 (highest). The "Brightness" option isn't
checked in the frontend, the backend does automatic brightness calibration.
.PP
Options
.B red-highlight
.B red-contrast
,
.B green-highlight
.B green-contrast
and
.B blue-highlight
allow you to adjust the highlight of your scanner for the given color. Values
range from 0 (lowest highlight) to 15 (highest).
.B blue-contrast
allow you to adjust the contrast of your scanner for the given color. Values
range from 0 (lowest contrast) to 15 (highest).
.PP
Option

60
tools/umax_pp.c
Wyświetl plik

@ -19,7 +19,7 @@ static void
Usage (char *name)
{
fprintf (stderr,
"%s [-c color_mode] [-x coord] [-y coord] [-w width] [-h height] [-g gain] [-z highlight] [-d dpi] [-t level] [-s] [-p] [-l 0|1] [-a ioport_addr] [-r]\n",
"%s [-c color_mode] [-x coord] [-y coord] [-w width] [-h height] [-g brightness] [-z contrast] [-d dpi] [-t level] [-s] [-p] [-l 0|1] [-a ioport_addr] [-r]\n",
name);
}
@ -39,8 +39,8 @@ main (int argc, char **argv)
int trace = 0;
/* scanning parameters : defaults to preview (75 dpi color, full scan area) */
int gain = 0x0;
int highlight = 0x2C0;
int brightness = 0x0;
int contrast = 0x2C0;
int dpi = 75;
int x = 0, y = 0;
int width = 5100, height = 7000;
@ -50,23 +50,23 @@ main (int argc, char **argv)
/* option parsing */
/*
-c --color : color mode: RGB, BW, BW12, RGB12
-x : x coordinate
-y : y coordinate
-w --witdh : scan width
-h --height : scan height
-f --file : session file
-p --probe : probe scanner
-s --scan : scan
-t --trace : execution trace
-l --lamp : turn lamp on/off 1/0
-d --dpi : set scan resolution
-g --gain : set RVB gain
-z --highlight: set highlight
-a --addr : io port address
-n --name : ppdev device name
-r : recover from previous failed scan
-m --model : model revision
-c --color : color mode: RGB, BW, BW12, RGB12
-x : x coordinate
-y : y coordinate
-w --witdh : scan width
-h --height : scan height
-f --file : session file
-p --probe : probe scanner
-s --scan : scan
-t --trace : execution trace
-l --lamp : turn lamp on/off 1/0
-d --dpi : set scan resolution
-g --brightness : set RVB brightness
-z --contrast: set contrast
-a --addr : io port address
-n --name : ppdev device name
-r : recover from previous failed scan
-m --model : model revision
*/
@ -249,12 +249,12 @@ main (int argc, char **argv)
found = 1;
}
if ((strcmp (argv[i], "-g") == 0) || (strcmp (argv[i], "--gain") == 0))
if ((strcmp (argv[i], "-g") == 0) || (strcmp (argv[i], "--brightness") == 0))
{
if (i == (argc - 1))
{
Usage (argv[0]);
fprintf (stderr, "expected hex gain value ( ex: A59 )\n");
fprintf (stderr, "expected hex brightness value ( ex: A59 )\n");
return (0);
}
i++;
@ -262,20 +262,20 @@ main (int argc, char **argv)
if (strlen (argv[i]) != 3)
{
Usage (argv[0]);
fprintf (stderr, "expected hex gain value ( ex: A59 )\n");
fprintf (stderr, "expected hex brightness value ( ex: A59 )\n");
return (0);
}
gain = strtol (argv[i], NULL, 16);
brightness = strtol (argv[i], NULL, 16);
sanei_umax_pp_setauto (0);
}
if ((strcmp (argv[i], "-z") == 0)
|| (strcmp (argv[i], "--highlight") == 0))
|| (strcmp (argv[i], "--contrast") == 0))
{
if (i == (argc - 1))
{
Usage (argv[0]);
fprintf (stderr, "expected hex highlight value ( ex: A59 )\n");
fprintf (stderr, "expected hex contrast value ( ex: A59 )\n");
return (0);
}
i++;
@ -283,10 +283,10 @@ main (int argc, char **argv)
if (strlen (argv[i]) != 3)
{
Usage (argv[0]);
fprintf (stderr, "expected hex highlight value ( ex: A59 )\n");
fprintf (stderr, "expected hex contrast value ( ex: A59 )\n");
return (0);
}
highlight = strtol (argv[i], NULL, 16);
contrast = strtol (argv[i], NULL, 16);
}
if ((strcmp (argv[i], "-n") == 0) || (strcmp (argv[i], "--name") == 0))
@ -367,7 +367,7 @@ main (int argc, char **argv)
}
if (trace)
{
printf ("UMAX 1220P scanning program version 3.0 starting ...\n");
printf ("UMAX 1220P scanning program version 3.1 starting ...\n");
#ifdef HAVE_LINUX_PPDEV_H
printf ("ppdev character device built-in.\n");
#endif
@ -477,7 +477,7 @@ main (int argc, char **argv)
}
/* scan */
if (sanei_umax_pp_Scan
(x, y, width, height, dpi, color, gain, highlight) != 1)
(x, y, width, height, dpi, color, brightness, contrast) != 1)
{
sanei_umax_pp_ReleaseScanner ();
sanei_umax_pp_EndSession ();