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

896 wiersze
27 KiB
C
Czysty Wina Historia

/***************************************************************************
as6e.c - description
-------------------
begin : Mon Feb 21 20:27:05 EST 2000
copyright : (C) 2000 by Eugene Weiss
email : eweiss@sas.upenn.edu
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include "../include/sane/config.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <limits.h>
#include <stdarg.h>
#include <string.h>
#include <signal.h>
#include <sys/stat.h>
#include "as6e.h"
#include "../include/sane/sane.h"
#include "../include/sane/saneopts.h"
#define BACKENDNAME as6e
#include "../include/sane/sanei_backend.h"
#include "../include/sane/sanei_config.h"
static int num_devices;
static AS6E_Device *first_dev;
static AS6E_Scan *first_handle;
static SANE_Status attach (const char *devname, AS6E_Device ** devp);
/* static SANE_Status attach_one (const char *dev); */
static const SANE_String_Const mode_list[] = {
"Lineart", "Gray", "Color",
0
};
static const SANE_Word resolution_list[] = {
4, 300, 200, 100, 50
};
static const SANE_Range x_range = {
SANE_FIX (0),
SANE_FIX (215.91),
SANE_FIX (0)
};
static const SANE_Range y_range = {
SANE_FIX (0),
SANE_FIX (297.19),
SANE_FIX (0)
};
static const SANE_Range brightness_range = {
-100,
100,
1
};
static const SANE_Range contrast_range = {
-100,
100,
1
};
/*--------------------------------------------------------------------------*/
static SANE_Int as6e_unit_convert (SANE_Fixed value)
{
double precise;
SANE_Int return_value;
precise = SANE_UNFIX (value);
precise = (precise * 300) / MM_PER_INCH;
return_value = precise;
return return_value;
}
/*--------------------------------------------------------------------------*/
SANE_Status
sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
SANE_Int * len)
{
AS6E_Scan *s = handle;
SANE_Word buffer_offset = 0;
int written = 0, bytes_read = 0, maxbytes;
SANE_Word bytecounter, linebufcounter, ctlbytes;
SANE_Byte *linebuffer;
DBG (3, "\nreading %d bytes, %d bytes in carryover buffer", max_len,
s->scan_buffer_count);
if (s->image_counter >= s->bytes_to_read)
{
*len = 0;
if (s->scanning)
{
read (s->as6e_params.ctlinpipe, &written, sizeof (written));
if (written != -1)
printf ("\npipe error");
DBG (3, "\ntrying to read -1 ...written = %d", written);
}
s->scanning = SANE_FALSE;
DBG (1, "\nimage data complete, sending EOF...");
return SANE_STATUS_EOF;
} /*image complete */
linebuffer = s->line_buffer;
if (s->scan_buffer_count > 0)
{ /*there are leftover bytes from the last call */
if (s->scan_buffer_count <= max_len)
{
for (*len = 0; *len < s->scan_buffer_count; (*len)++)
{
buf[*len] = s->scan_buffer[*len];
buffer_offset++;
}
s->scan_buffer_count = 0;
if (s->scan_buffer_count == max_len)
{
s->scan_buffer_count = 0;
s->image_counter += max_len;
DBG (3, "\nreturning %d bytes from the carryover buffer", *len);
return SANE_STATUS_GOOD;
}
}
else
{
for (*len = 0; *len < max_len; (*len)++)
buf[*len] = s->scan_buffer[*len];
for (bytecounter = max_len;
bytecounter < s->scan_buffer_count; bytecounter++)
s->scan_buffer[bytecounter - max_len]
= s->scan_buffer[bytecounter];
s->scan_buffer_count -= max_len;
s->image_counter += max_len;
DBG (3, "\nreturning %d bytes from the carryover buffer", *len);
return SANE_STATUS_GOOD;
}
}
else
{
*len = 0; /*no bytes in the buffer */
if (!s->scanning)
{
DBG (1, "\nscan over returning %d", *len);
if (s->scan_buffer_count)
return SANE_STATUS_GOOD;
else
return SANE_STATUS_EOF;
}
}
while (*len < max_len)
{
DBG (3, "\ntrying to read number of bytes...");
ctlbytes = read (s->as6e_params.ctlinpipe, &written, sizeof (written));
DBG (3, "\nbytes written = %d, ctlbytes =%d", written, ctlbytes);
fflush (stdout);
if ((s->cancelled) && (written == 0))
{ /*first clear -1 from pipe */
DBG (1, "\nsending SANE_STATUS_CANCELLED");
read (s->as6e_params.ctlinpipe, &written, sizeof (written));
s->scanning = SANE_FALSE;
return SANE_STATUS_CANCELLED;
}
if (written == -1)
{
DBG (1, "\n-1READ Scanner through. returning %d bytes", *len);
s->image_counter += *len;
s->scanning = SANE_FALSE;
return SANE_STATUS_GOOD;
}
linebufcounter = 0;
DBG (3,
"\nlinebufctr reset, len =%d written =%d bytes_read =%d, max = %d",
*len, written, bytes_read, max_len);
maxbytes = written;
while (linebufcounter < written)
{
DBG (4, "\ntrying to read data pipe");
bytes_read =
read (s->as6e_params.datapipe, linebuffer + linebufcounter,
maxbytes);
linebufcounter += bytes_read;
maxbytes -= bytes_read;
DBG (3, "\nbytes_read = %d linebufcounter = %d", bytes_read,
linebufcounter);}
DBG (3, "\nwritten =%d max_len =%d len =%d", written, max_len, *len);
if (written <= (max_len - *len))
{
for (bytecounter = 0; bytecounter < written; bytecounter++)
{
buf[bytecounter + buffer_offset] = linebuffer[bytecounter];
(*len)++;
}
buffer_offset += written;
DBG (3, "\nbuffer offset = %d", buffer_offset);
}
else if (max_len > *len)
{ /*there's still room to send data */
for (bytecounter = 0; bytecounter < (max_len - *len); bytecounter++)
buf[bytecounter + buffer_offset] = linebuffer[bytecounter];
DBG (3, "\ntopping off buffer");
for (bytecounter = (max_len - *len); bytecounter < written;
bytecounter++)
{
s->scan_buffer[s->scan_buffer_count + bytecounter -
(max_len - *len)] = linebuffer[bytecounter];
}
s->scan_buffer_count += (written - (max_len - *len));
*len = max_len;
}
else
{ /*everything goes into the carryover buffer */
for (bytecounter = 0; bytecounter < written; bytecounter++)
s->scan_buffer[s->scan_buffer_count + bytecounter]
= linebuffer[bytecounter]; s->scan_buffer_count += written;
}
} /*while there's space in the buffer */
s->image_counter += *len;
DBG (3, "\nimage ctr = %d bytes_to_read = %d returning %d",
s->image_counter, s->bytes_to_read, *len);
return SANE_STATUS_GOOD;
}
/*--------------------------------------------------------------------------*/
void
sane_cancel (SANE_Handle h)
{
AS6E_Scan *s = h;
SANE_Word test;
DBG (2, "\ntrying to cancel...");
if (s->scanning)
{
test = kill (s->child_pid, SIGUSR1);
if (test == 0)
s->cancelled = SANE_TRUE;
}
}
/*--------------------------------------------------------------------------*/
SANE_Status
sane_start (SANE_Handle handle)
{
AS6E_Scan *s = handle;
SANE_Status status;
int repeat = 1;
SANE_Word numbytes;
int scan_params[8];
/* First make sure we have a current parameter set. Some of the
* parameters will be overwritten below, but that's OK. */
DBG (2, "\nsane_start");
status = sane_get_parameters (s, 0);
if (status != SANE_STATUS_GOOD)
return status;
DBG (1, "\nGot params again...");
numbytes = write (s->as6e_params.ctloutpipe, &repeat, sizeof (repeat));
if (numbytes != sizeof (repeat))
return (SANE_STATUS_IO_ERROR);
DBG (1, "\nsending start_scan signal");
scan_params[0] = s->as6e_params.resolution;
if (strcmp (s->value[OPT_MODE].s, "Color") == 0)
scan_params[1] = 0;
else if (strcmp (s->value[OPT_MODE].s, "Gray") == 0)
scan_params[1] = 1;
else if (strcmp (s->value[OPT_MODE].s, "Lineart") == 0)
scan_params[1] = 2;
else
return (SANE_STATUS_JAMMED); /*this should never happen */
scan_params[2] = s->as6e_params.startpos;
scan_params[3] = s->as6e_params.stoppos;
scan_params[4] = s->as6e_params.startline;
scan_params[5] = s->as6e_params.stopline;
scan_params[6] = s->value[OPT_BRIGHTNESS].w;
scan_params[7] = s->value[OPT_CONTRAST].w;
DBG (1, "\nscan params = %d %d %d %d %d %d %d %d", scan_params[0],
scan_params[1], scan_params[2], scan_params[3],
scan_params[4], scan_params[5], scan_params[6], scan_params[7]);
numbytes =
write (s->as6e_params.ctloutpipe, scan_params, sizeof (scan_params));
if (numbytes != sizeof (scan_params))
return (SANE_STATUS_IO_ERROR);
s->scanning = SANE_TRUE;
s->scan_buffer_count = 0;
s->image_counter = 0;
s->cancelled = 0;
return (SANE_STATUS_GOOD);
}
/*--------------------------------------------------------------------------*/
SANE_Status
sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
{
AS6E_Scan *s = handle;
SANE_String mode;
SANE_Word divisor = 1;
DBG (2, "\nsane_get_parameters");
if (!s->scanning)
{
memset (&s->sane_params, 0, sizeof (s->sane_params));
s->as6e_params.resolution = s->value[OPT_RESOLUTION].w;
s->as6e_params.startpos = as6e_unit_convert (s->value[OPT_TL_X].w);
s->as6e_params.stoppos = as6e_unit_convert (s->value[OPT_BR_X].w);
s->as6e_params.startline = as6e_unit_convert (s->value[OPT_TL_Y].w);
s->as6e_params.stopline = as6e_unit_convert (s->value[OPT_BR_Y].w);
if ((s->as6e_params.resolution == 200)
|| (s->as6e_params.resolution == 100)) divisor = 3;
else if (s->as6e_params.resolution == 50)
divisor = 6; /*get legal values for 200 dpi */
s->as6e_params.startpos = (s->as6e_params.startpos / divisor) * divisor;
s->as6e_params.stoppos = (s->as6e_params.stoppos / divisor) * divisor;
s->as6e_params.startline =
(s->as6e_params.startline / divisor) * divisor;
s->as6e_params.stopline = (s->as6e_params.stopline / divisor) * divisor;
s->sane_params.pixels_per_line =
(s->as6e_params.stoppos -
s->as6e_params.startpos) * s->as6e_params.resolution / 300;
s->sane_params.lines =
(s->as6e_params.stopline -
s->as6e_params.startline) * s->as6e_params.resolution / 300;
mode = s->value[OPT_MODE].s;
/* if ((strcmp (s->mode, "Lineart") == 0) ||
(strcmp (s->mode, "Halftone") == 0))
{
s->sane_params.format = SANE_FRAME_GRAY;
s->sane_params.bytes_per_line = (s->sane_params.pixels_per_line + 7) / 8;
s->sane_params.depth = 1;
} */
/*else*/ if ((strcmp (mode, "Gray") == 0)
|| (strcmp (mode, "Lineart") == 0))
{
s->sane_params.format = SANE_FRAME_GRAY;
s->sane_params.bytes_per_line = s->sane_params.pixels_per_line;
s->sane_params.depth = 8;
} /*grey frame */
else
{
s->sane_params.format = SANE_FRAME_RGB;
s->sane_params.bytes_per_line = 3 * s->sane_params.pixels_per_line;
s->sane_params.depth = 8;
} /*color frame */
s->bytes_to_read = s->sane_params.lines * s->sane_params.bytes_per_line;
s->sane_params.last_frame = SANE_TRUE;
} /*!scanning */
if (params)
*params = s->sane_params;
return (SANE_STATUS_GOOD);
}
/*--------------------------------------------------------------------------*/
SANE_Status
sane_control_option (SANE_Handle handle, SANE_Int option,
SANE_Action action, void *val, SANE_Int * info)
{
AS6E_Scan *s = handle;
SANE_Status status = 0;
SANE_Word cap;
DBG (2, "\nsane_control_option");
if (info)
*info = 0;
if (s->scanning)
return SANE_STATUS_DEVICE_BUSY;
if (option >= NUM_OPTIONS)
return SANE_STATUS_INVAL;
cap = s->options_list[option].cap;
if (!SANE_OPTION_IS_ACTIVE (cap))
return SANE_STATUS_INVAL;
if (action == SANE_ACTION_GET_VALUE)
{
DBG (1, "sane_control_option %d, get value\n", option);
switch (option)
{
/* word options: */
case OPT_RESOLUTION:
case OPT_TL_X:
case OPT_TL_Y:
case OPT_BR_X:
case OPT_BR_Y:
case OPT_NUM_OPTS:
case OPT_CONTRAST:
case OPT_BRIGHTNESS:
*(SANE_Word *) val = s->value[option].w;
return (SANE_STATUS_GOOD);
/* string options: */
case OPT_MODE:
strcpy (val, s->value[option].s);
return (SANE_STATUS_GOOD);
}
}
else if (action == SANE_ACTION_SET_VALUE)
{
DBG (1, "sane_control_option %d, set value\n", option);
if (!SANE_OPTION_IS_SETTABLE (cap))
return (SANE_STATUS_INVAL);
/* status = sanei_constrain_value (s->options_list[option], val, info);*/
if (status != SANE_STATUS_GOOD)
return (status);
switch (option)
{
/* (mostly) side-effect-free word options: */
case OPT_RESOLUTION:
case OPT_BR_X:
case OPT_BR_Y:
case OPT_TL_X:
case OPT_TL_Y:
if (info && s->value[option].w != *(SANE_Word *) val)
*info |= SANE_INFO_RELOAD_PARAMS;
/* fall through */
case OPT_NUM_OPTS:
case OPT_CONTRAST:
case OPT_BRIGHTNESS:
s->value[option].w = *(SANE_Word *) val;
DBG (1, "\nset brightness to");
return (SANE_STATUS_GOOD);
case OPT_MODE:
if (s->value[option].s)
free (s->value[option].s);
s->value[option].s = strdup (val);
return (SANE_STATUS_GOOD);
}
}
return (SANE_STATUS_INVAL);
}
/*--------------------------------------------------------------------------*/
const SANE_Option_Descriptor *
sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
{
AS6E_Scan *s = handle;
DBG (2, "\nsane_get_option_descriptor");
if ((unsigned) option >= NUM_OPTIONS)
return (0);
return (&s->options_list[option]);
}
/*--------------------------------------------------------------------------*/
void
sane_close (SANE_Handle handle)
{
AS6E_Scan *prev, *s;
SANE_Word repeat = 0;
DBG (2, "\nsane_close");
/* remove handle from list of open handles: */
prev = 0;
for (s = first_handle; s; s = s->next)
{
if (s == handle)
break;
prev = s;
}
if (!s)
{
DBG (1, "close: invalid handle %p\n", handle);
return; /* oops, not a handle we know about */
}
if (s->scanning)
sane_cancel (handle);
write (s->as6e_params.ctloutpipe, &repeat, sizeof (repeat));
close (s->as6e_params.ctloutpipe);
free (s->scan_buffer);
free (s->line_buffer);
if (prev)
prev->next = s->next;
else
first_handle = s;
free (handle);
}
/*--------------------------------------------------------------------------*/
void
sane_exit (void)
{
AS6E_Device *next;
DBG (2, "\nsane_exit");
while (first_dev != NULL)
{
next = first_dev->next;
/* free((void *) first_dev->sane.name);*/
/* free((void *) first_dev->sane.model);*/
free (first_dev);
first_dev = next;
}
}
/*--------------------------------------------------------------------------*/
static SANE_Status
as6e_open (AS6E_Scan * s)
{
int data_processed, exec_result, as6e_status;
int ctloutpipe[2], ctlinpipe[2], datapipe[2];
char inpipe_desc[32], outpipe_desc[32], datapipe_desc[32];
pid_t fork_result;
DBG (1, "\nas6e_open");
memset (inpipe_desc, '\0', sizeof (inpipe_desc));
memset (outpipe_desc, '\0', sizeof (outpipe_desc));
memset (datapipe_desc, '\0', sizeof (datapipe_desc));
if ((pipe (ctloutpipe) == 0) && (pipe (ctlinpipe) == 0)
&& (pipe (datapipe) == 0))
{
fork_result = fork ();
if (fork_result == (pid_t) - 1)
{
fprintf (stderr, "Fork failure");
return (SANE_STATUS_IO_ERROR);
}
if (fork_result == 0)
{ /*in child */
sprintf (inpipe_desc, "%d", ctlinpipe[WRITEPIPE]);
sprintf (outpipe_desc, "%d", ctloutpipe[READPIPE]);
sprintf (datapipe_desc, "%d", datapipe[WRITEPIPE]);
exec_result =
execlp ("as6edriver", "as6edriver", "-s", inpipe_desc,
outpipe_desc, datapipe_desc, (char *) 0);
printf ("\nThe SANE backend was unable to start \"as6edriver\".");
printf ("\nThis must be installed in a driectory in your PATH.\n");
printf ("\nTo aquire the as6edriver program,");
printf ("\ngo to http://as6edriver.sourceforge.net.");
write (ctlinpipe[WRITEPIPE], &exec_result, sizeof (exec_result));
exit (-1);
}
else
{ /*parent process */
data_processed =
read (ctlinpipe[READPIPE], &as6e_status, sizeof (as6e_status));
DBG (1, "%d - read %d status = %d\n", getpid (), data_processed,
as6e_status); if (as6e_status == -2)
{
printf ("\nPort access denied.");
return (SANE_STATUS_IO_ERROR);
}
if (as6e_status == -1)
{
printf ("\nCould not contact scanner.");
return (SANE_STATUS_IO_ERROR);
}
if (as6e_status == 1)
printf ("\nUsing nibble mode.");
if (as6e_status == 2)
printf ("\nUsing byte mode.");
if (as6e_status == 3)
printf ("\nUsing EPP mode.");
s->as6e_params.ctlinpipe = ctlinpipe[READPIPE];
s->as6e_params.ctloutpipe = ctloutpipe[WRITEPIPE];
s->as6e_params.datapipe = datapipe[READPIPE];
s->child_pid = fork_result;
return (SANE_STATUS_GOOD);
} /*else */
}
else
return (SANE_STATUS_IO_ERROR);
}
/*--------------------------------------------------------------------------*/
SANE_Status
sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
{
char dev_name[PATH_MAX];
size_t len;
FILE *fp = NULL;
DBG_INIT();
DBG (2, "\nsane_init");
if (version_code)
*version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, 0);
/* fp = sanei_config_open (AS6E_CONFIG_FILE);*/
if (!fp)
{
/* attach ("as6edriver", 0);*/
return (attach ("as6edriver", 0));
}
while (fgets (dev_name, sizeof (dev_name), fp))
{
if (dev_name[0] == '#') /* ignore line comments */
continue;
len = strlen (dev_name);
if (dev_name[len - 1] == '\n')
dev_name[--len] = '\0';
if (!len)
continue; /* ignore empty lines */
/* sanei_config_attach_matching_devices (dev_name, attach_one);*/
}
fclose (fp);
return (SANE_STATUS_GOOD);
}
/*--------------------------------------------------------------------------*/
/*
static SANE_Status
attach_one (const char *dev)
{
DBG (2, "attach_one\n");
attach (dev, 0);
return (SANE_STATUS_GOOD);
}
*/
/*--------------------------------------------------------------------------*/
SANE_Status
sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
{
static const SANE_Device **devlist = 0;
AS6E_Device *dev;
int i;
DBG (3, "\nsane_get_devices");
if (devlist)
free (devlist);
devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
if (!devlist)
return SANE_STATUS_NO_MEM;
i = 0;
for (dev = first_dev; i < num_devices; dev = dev->next)
devlist[i++] = &dev->sane;
devlist[i++] = 0;
*device_list = devlist;
return (SANE_STATUS_GOOD);
}
/*--------------------------------------------------------------------------*/
static size_t
max_string_size (const SANE_String_Const strings[])
{
size_t size, max_size = 0;
int i;
for (i = 0; strings[i]; ++i)
{
size = strlen (strings[i]) + 1;
if (size > max_size)
max_size = size;
}
return (max_size);
}
/*--------------------------------------------------------------------------*/
static void
initialize_options_list (AS6E_Scan * s)
{
SANE_Int option;
DBG (2, "\ninitialize_options_list");
for (option = 0; option < NUM_OPTIONS; ++option)
{
s->options_list[option].size = sizeof (SANE_Word);
s->options_list[option].cap =
SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;}
s->options_list[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
s->options_list[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
s->options_list[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
s->options_list[OPT_NUM_OPTS].type = SANE_TYPE_INT;
s->options_list[OPT_NUM_OPTS].unit = SANE_UNIT_NONE;
s->options_list[OPT_NUM_OPTS].size = sizeof (SANE_Word);
s->options_list[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
s->options_list[OPT_NUM_OPTS].constraint_type = SANE_CONSTRAINT_NONE;
s->value[OPT_NUM_OPTS].w = NUM_OPTIONS;
s->options_list[OPT_MODE].name = SANE_NAME_SCAN_MODE;
s->options_list[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
s->options_list[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
s->options_list[OPT_MODE].type = SANE_TYPE_STRING;
s->options_list[OPT_MODE].size = max_string_size (mode_list);
s->options_list[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
s->options_list[OPT_MODE].constraint.string_list = mode_list;
s->value[OPT_MODE].s = strdup (mode_list[2]);
s->options_list[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
s->options_list[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
s->options_list[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
s->options_list[OPT_RESOLUTION].type = SANE_TYPE_INT;
s->options_list[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
s->options_list[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
s->options_list[OPT_RESOLUTION].constraint.word_list = resolution_list;
s->value[OPT_RESOLUTION].w = 200;
s->options_list[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
s->options_list[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
s->options_list[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
s->options_list[OPT_TL_X].type = SANE_TYPE_FIXED;
s->options_list[OPT_TL_X].unit = SANE_UNIT_MM;
s->options_list[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
s->options_list[OPT_TL_X].constraint.range = &x_range;
s->value[OPT_TL_X].w = s->options_list[OPT_TL_X].constraint.range->min;
s->options_list[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
s->options_list[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
s->options_list[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
s->options_list[OPT_TL_Y].type = SANE_TYPE_FIXED;
s->options_list[OPT_TL_Y].unit = SANE_UNIT_MM;
s->options_list[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
s->options_list[OPT_TL_Y].constraint.range = &y_range;
s->value[OPT_TL_Y].w = s->options_list[OPT_TL_Y].constraint.range->min;
s->options_list[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
s->options_list[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
s->options_list[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
s->options_list[OPT_BR_X].type = SANE_TYPE_FIXED;
s->options_list[OPT_BR_X].unit = SANE_UNIT_MM;
s->options_list[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
s->options_list[OPT_BR_X].constraint.range = &x_range;
s->value[OPT_BR_X].w = s->options_list[OPT_BR_X].constraint.range->max;
s->options_list[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
s->options_list[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
s->options_list[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
s->options_list[OPT_BR_Y].type = SANE_TYPE_FIXED;
s->options_list[OPT_BR_Y].unit = SANE_UNIT_MM;
s->options_list[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
s->options_list[OPT_BR_Y].constraint.range = &y_range;
s->value[OPT_BR_Y].w = s->options_list[OPT_BR_Y].constraint.range->max;
s->options_list[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
s->options_list[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
s->options_list[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
s->options_list[OPT_CONTRAST].type = SANE_TYPE_INT;
s->options_list[OPT_CONTRAST].unit = SANE_UNIT_NONE;
s->options_list[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
s->options_list[OPT_CONTRAST].constraint.range = &brightness_range;
s->value[OPT_BRIGHTNESS].w = 10;
s->options_list[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
s->options_list[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
s->options_list[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
s->options_list[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
s->options_list[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
s->options_list[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
s->options_list[OPT_BRIGHTNESS].constraint.range = &contrast_range;
s->value[OPT_CONTRAST].w = -32;
}
/*--------------------------------------------------------------------------*/
static int
check_for_driver (const char *devname)
{
#define NAMESIZE 128
struct stat statbuf;
mode_t modes;
char *path;
char fullname[NAMESIZE];
char dir[NAMESIZE];
int count = 0, offset = 0;
path = getenv ("PATH");
while (path[count] != '\0')
{
memset (fullname, '\0', sizeof (fullname));
memset (dir, '\0', sizeof (dir));
while ((path[count] != ':') && (path[count] != '\0'))
{
dir[count - offset] = path[count];
count++;
}
strncpy (fullname, dir, NAMESIZE);
strncat (fullname, "/", NAMESIZE);
strncat (fullname, devname, NAMESIZE);
stat (fullname, &statbuf);
modes = statbuf.st_mode;
if (S_ISREG (modes))
return (1); /* found as6edriver */
if (path[count] == '\0')
return (0); /* end of path --no driver found */
count++;
offset = count;
}
return (0);
}
/*--------------------------------------------------------------------------*/
static SANE_Status
attach (const char *devname, AS6E_Device ** devp)
{
AS6E_Device *dev;
/* SANE_Status status; */
DBG (2, "\nattach");
for (dev = first_dev; dev; dev = dev->next)
{
if (strcmp (dev->sane.name, devname) == 0)
{
if (devp)
*devp = dev;
return (SANE_STATUS_GOOD);
}
}
dev = malloc (sizeof (*dev));
if (!dev)
return (SANE_STATUS_NO_MEM);
memset (dev, 0, sizeof (*dev));
dev->sane.name = strdup (devname);
if (!check_for_driver (devname))
return (SANE_STATUS_INVAL);
dev->sane.model = "AS6E";
dev->sane.vendor = "Artec";
dev->sane.type = "flatbed scanner";
++num_devices;
dev->next = first_dev;
first_dev = dev;
if (devp)
*devp = dev;
return (SANE_STATUS_GOOD);
}
/*--------------------------------------------------------------------------*/
SANE_Status
sane_open (SANE_String_Const devicename, SANE_Handle * handle)
{
SANE_Status status;
AS6E_Device *dev;
AS6E_Scan *s;
DBG (2, "\nsane_open");
if (devicename[0])
{
for (dev = first_dev; dev; dev = dev->next)
if (strcmp (dev->sane.name, devicename) == 0)
break;
if (!dev)
{
status = attach (devicename, &dev);
if (status != SANE_STATUS_GOOD)
return (status);
}
}
else
{
/* empty devicname -> use first device */
dev = first_dev;
}
if (!dev)
return SANE_STATUS_INVAL;
s = malloc (sizeof (*s));
if (!s)
return SANE_STATUS_NO_MEM;
memset (s, 0, sizeof (*s));
s->scan_buffer = malloc (SCAN_BUF_SIZE);
if (!s->scan_buffer)
return SANE_STATUS_NO_MEM;
memset (s->scan_buffer, 0, SCAN_BUF_SIZE);
s->line_buffer = malloc (SCAN_BUF_SIZE);
if (!s->line_buffer)
return SANE_STATUS_NO_MEM;
memset (s->line_buffer, 0, SCAN_BUF_SIZE);
status = as6e_open (s);
if (status != SANE_STATUS_GOOD)
return status;
initialize_options_list (s);
s->scanning = 0;
/* insert newly opened handle into list of open handles: */
s->next = first_handle;
first_handle = s;
*handle = s;
return (status);
}
/*--------------------------------------------------------------------------*/
SANE_Status
sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
{
DBG (2, "sane_set_io_mode( %p, %d )\n", handle, non_blocking);
return (SANE_STATUS_UNSUPPORTED);
}
/*---------------------------------------------------------------------------*/
SANE_Status
sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
{
return SANE_STATUS_UNSUPPORTED;
}
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik