kopia lustrzana https://gitlab.com/sane-project/backends
Run indent: astyle -A8 -U -H -k3 -W3 -o xerox_mfp.[ch]
This is purely indent commit w/o any code changes. To prove run `git diff -w`.merge-requests/1/head
Alex Belkin
rodzic
e4aed53a1e
commit
83bbcfe7d5
|
|
@ -155,12 +155,12 @@ static int copy_decompress_data(struct device *dev, unsigned char *pDest, int ma
|
|||
size_t result = 0, retVal = 0;
|
||||
|
||||
|
||||
if ( 0 == dev->decDataSize ) {
|
||||
if (0 == dev->decDataSize) {
|
||||
*destLen = 0;
|
||||
return retVal;
|
||||
}
|
||||
data_size = dev->decDataSize - dev->currentDecDataIndex;
|
||||
if ( data_size > maxlen ) {
|
||||
if (data_size > maxlen) {
|
||||
data_size = maxlen;
|
||||
}
|
||||
memcpy(pDest, dev->decData+dev->currentDecDataIndex, data_size);
|
||||
|
|
@ -169,7 +169,7 @@ static int copy_decompress_data(struct device *dev, unsigned char *pDest, int ma
|
|||
dev->currentDecDataIndex += result;
|
||||
retVal = result;
|
||||
|
||||
if ( dev->decDataSize == dev->currentDecDataIndex ) {
|
||||
if (dev->decDataSize == dev->currentDecDataIndex) {
|
||||
dev->currentDecDataIndex = 0;
|
||||
dev->decDataSize = 0;
|
||||
}
|
||||
|
|
@ -186,9 +186,9 @@ static int decompress_tempfile(struct device *dev)
|
|||
|
||||
static int dump_to_tmp_file(struct device *dev)
|
||||
{
|
||||
unsigned char * pSrc = dev->data;
|
||||
unsigned char *pSrc = dev->data;
|
||||
int srcLen = dev->datalen;
|
||||
FILE * pInfile;
|
||||
FILE *pInfile;
|
||||
if ((pInfile = fopen(encTmpFileName, "a")) == NULL) {
|
||||
fprintf(stderr, "can't open %s\n", encTmpFileName);
|
||||
return 0;
|
||||
|
|
@ -203,7 +203,7 @@ static int isSupportedDevice(struct device __sane_unused__ *dev)
|
|||
{
|
||||
#ifdef HAVE_LIBJPEG
|
||||
/* Checking device which supports JPEG Lossy compression for color scanning*/
|
||||
if ( dev->compressionTypes & (1 << 6) )
|
||||
if (dev->compressionTypes & (1 << 6))
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
|
|
@ -228,21 +228,21 @@ static void dbg_dump(struct device *dev)
|
|||
for (i = 0; i < dlen; i++, dptr += 3)
|
||||
sprintf(dptr, " %02x", dev->res[i]);
|
||||
|
||||
DBG (5, "[%lu]%s%s\n", (u_long)dev->reslen, dbuf,
|
||||
DBG(5, "[%lu]%s%s\n", (u_long)dev->reslen, dbuf,
|
||||
(dlen < (int)dev->reslen)? "..." : "");
|
||||
}
|
||||
|
||||
/* one command to device */
|
||||
/* return 0: on error, 1: success */
|
||||
static int dev_command (struct device *dev, SANE_Byte * cmd, size_t reqlen)
|
||||
static int dev_command(struct device *dev, SANE_Byte *cmd, size_t reqlen)
|
||||
{
|
||||
SANE_Status status;
|
||||
size_t sendlen = cmd[3] + 4;
|
||||
SANE_Byte *res = dev->res;
|
||||
|
||||
|
||||
assert (reqlen <= sizeof (dev->res)); /* requested len */
|
||||
dev->reslen = sizeof (dev->res); /* doing full buffer to flush stalled commands */
|
||||
assert(reqlen <= sizeof(dev->res)); /* requested len */
|
||||
dev->reslen = sizeof(dev->res); /* doing full buffer to flush stalled commands */
|
||||
|
||||
if (cmd[2] == CMD_SET_WINDOW) {
|
||||
/* Set Window have wrong packet length, huh. */
|
||||
|
|
@ -255,11 +255,11 @@ static int dev_command (struct device *dev, SANE_Byte * cmd, size_t reqlen)
|
|||
}
|
||||
|
||||
dev->state = 0;
|
||||
DBG (4, ":: dev_command(%s[%#x], %lu)\n", str_cmd(cmd[2]), cmd[2],
|
||||
DBG(4, ":: dev_command(%s[%#x], %lu)\n", str_cmd(cmd[2]), cmd[2],
|
||||
(u_long)reqlen);
|
||||
status = dev->io->dev_request(dev, cmd, sendlen, res, &dev->reslen);
|
||||
if (status != SANE_STATUS_GOOD) {
|
||||
DBG (1, "%s: dev_request: %s\n", __func__, sane_strstatus (status));
|
||||
DBG(1, "%s: dev_request: %s\n", __func__, sane_strstatus(status));
|
||||
dev->state = SANE_STATUS_IO_ERROR;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -271,7 +271,7 @@ static int dev_command (struct device *dev, SANE_Byte * cmd, size_t reqlen)
|
|||
|
||||
/* normal command reply, some sanity checking */
|
||||
if (dev->reslen < reqlen) {
|
||||
DBG (1, "%s: illegal response len %lu, need %lu\n",
|
||||
DBG(1, "%s: illegal response len %lu, need %lu\n",
|
||||
__func__, (u_long)dev->reslen, (u_long)reqlen);
|
||||
dev->state = SANE_STATUS_IO_ERROR;
|
||||
return 0;
|
||||
|
|
@ -282,19 +282,19 @@ static int dev_command (struct device *dev, SANE_Byte * cmd, size_t reqlen)
|
|||
dbg_dump(dev);
|
||||
|
||||
if (dev->res[0] != RES_CODE) {
|
||||
DBG (2, "%s: illegal data header %02x\n", __func__, dev->res[0]);
|
||||
DBG(2, "%s: illegal data header %02x\n", __func__, dev->res[0]);
|
||||
dev->state = SANE_STATUS_IO_ERROR;
|
||||
return 0;
|
||||
}
|
||||
pktlen = dev->res[2] + 3;
|
||||
if (dev->reslen != pktlen) {
|
||||
DBG (2, "%s: illegal response len %lu, should be %lu\n",
|
||||
DBG(2, "%s: illegal response len %lu, should be %lu\n",
|
||||
__func__, (u_long)pktlen, (u_long)dev->reslen);
|
||||
dev->state = SANE_STATUS_IO_ERROR;
|
||||
return 0;
|
||||
}
|
||||
if (dev->reslen > reqlen)
|
||||
DBG (2, "%s: too big packet len %lu, need %lu\n",
|
||||
DBG(2, "%s: too big packet len %lu, need %lu\n",
|
||||
__func__, (u_long)dev->reslen, (u_long)reqlen);
|
||||
}
|
||||
|
||||
|
|
@ -313,7 +313,7 @@ static int dev_command (struct device *dev, SANE_Byte * cmd, size_t reqlen)
|
|||
(dev->res[4] << 8 | dev->res[5]));
|
||||
|
||||
if (dev->state)
|
||||
DBG (3, "%s(%s[%#x]): => %d: %s\n",
|
||||
DBG(3, "%s(%s[%#x]): => %d: %s\n",
|
||||
__func__, str_cmd(cmd[2]), cmd[2],
|
||||
dev->state, sane_strstatus(dev->state));
|
||||
}
|
||||
|
|
@ -322,11 +322,11 @@ static int dev_command (struct device *dev, SANE_Byte * cmd, size_t reqlen)
|
|||
}
|
||||
|
||||
/* one short command to device */
|
||||
static int dev_cmd (struct device *dev, SANE_Byte command)
|
||||
static int dev_cmd(struct device *dev, SANE_Byte command)
|
||||
{
|
||||
SANE_Byte cmd[4] = { REQ_CODE_A, REQ_CODE_B };
|
||||
cmd[2] = command;
|
||||
return dev_command (dev, cmd, (command == CMD_INQUIRY)? 70 : 32);
|
||||
return dev_command(dev, cmd, (command == CMD_INQUIRY)? 70 : 32);
|
||||
}
|
||||
|
||||
/* stop scanning operation. return previous status */
|
||||
|
|
@ -334,7 +334,7 @@ static SANE_Status dev_stop(struct device *dev)
|
|||
{
|
||||
int state = dev->state;
|
||||
|
||||
DBG (3, "%s: %p, scanning %d, reserved %d\n", __func__,
|
||||
DBG(3, "%s: %p, scanning %d, reserved %d\n", __func__,
|
||||
(void *)dev, dev->scanning, dev->reserved);
|
||||
dev->scanning = 0;
|
||||
|
||||
|
|
@ -343,7 +343,7 @@ static SANE_Status dev_stop(struct device *dev)
|
|||
return state;
|
||||
dev->reserved = 0;
|
||||
dev_cmd(dev, CMD_RELEASE_UNIT);
|
||||
DBG (3, "total image %d*%d size %d (win %d*%d), %d*%d %d data: %d, out %d bytes\n",
|
||||
DBG(3, "total image %d*%d size %d (win %d*%d), %d*%d %d data: %d, out %d bytes\n",
|
||||
dev->para.pixels_per_line, dev->para.lines,
|
||||
dev->total_img_size,
|
||||
dev->win_width, dev->win_len,
|
||||
|
|
@ -392,7 +392,7 @@ static int dev_cmd_wait(struct device *dev, int cmd)
|
|||
} else {
|
||||
if (sleeptime > 1000)
|
||||
sleeptime = 1000;
|
||||
DBG (4, "(%s) sleeping(%d ms).. [%x %x]\n",
|
||||
DBG(4, "(%s) sleeping(%d ms).. [%x %x]\n",
|
||||
str_cmd(cmd), sleeptime, dev->res[4], dev->res[5]);
|
||||
usleep(sleeptime * 1000);
|
||||
if (sleeptime < 1000)
|
||||
|
|
@ -420,7 +420,7 @@ static int res_dpi_codes[] = {
|
|||
4800, 9600
|
||||
};
|
||||
|
||||
static int SANE_Word_sort(const void * a, const void * b)
|
||||
static int SANE_Word_sort(const void *a, const void *b)
|
||||
{
|
||||
return *(const SANE_Word *)a - *(const SANE_Word *)b;
|
||||
}
|
||||
|
|
@ -466,7 +466,7 @@ static SANE_String string_match(const SANE_String_Const s[], SANE_String m)
|
|||
return UNCONST(s[string_match_index(s, m)]);
|
||||
}
|
||||
|
||||
static size_t max_string_size (SANE_String_Const s[])
|
||||
static size_t max_string_size(SANE_String_Const s[])
|
||||
{
|
||||
size_t max = 0;
|
||||
|
||||
|
|
@ -636,7 +636,7 @@ static void set_parameters(struct device *dev)
|
|||
dev->para.pixels_per_line = dev->win_width / px_to_len;
|
||||
dev->para.bytes_per_line = dev->para.pixels_per_line;
|
||||
|
||||
if ( !isSupportedDevice(dev) ) {
|
||||
if (!isSupportedDevice(dev)) {
|
||||
#if BETTER_BASEDPI
|
||||
px_to_len = 1213.9 / dev->val[OPT_RESOLUTION].w;
|
||||
#endif
|
||||
|
|
@ -657,7 +657,7 @@ static void set_parameters(struct device *dev)
|
|||
dev->para.bytes_per_line *= 3;
|
||||
} else {
|
||||
/* this will never happen */
|
||||
DBG (1, "%s: impossible image composition %d\n",
|
||||
DBG(1, "%s: impossible image composition %d\n",
|
||||
__func__, dev->composition);
|
||||
dev->para.format = SANE_FRAME_GRAY;
|
||||
dev->para.depth = 8;
|
||||
|
|
@ -738,7 +738,7 @@ static int fix_window(struct device *dev)
|
|||
return 1;
|
||||
}
|
||||
|
||||
static int dev_set_window (struct device *dev)
|
||||
static int dev_set_window(struct device *dev)
|
||||
{
|
||||
SANE_Byte cmd[0x19] = {
|
||||
REQ_CODE_A, REQ_CODE_B, CMD_SET_WINDOW, 0x13, MSG_SCANNING_PARAM
|
||||
|
|
@ -765,14 +765,14 @@ static int dev_set_window (struct device *dev)
|
|||
/* Set to JPEG Lossy Compression, if mode is color (only for supported model)...
|
||||
* else go with Uncompressed (For backard compatibility with old models )*/
|
||||
if (dev->composition == MODE_RGB24) {
|
||||
if ( isSupportedDevice(dev) ) {
|
||||
if (isSupportedDevice(dev)) {
|
||||
cmd[0x14] = 0x6;
|
||||
}
|
||||
}
|
||||
cmd[0x16] = dev->threshold;
|
||||
cmd[0x17] = dev->doc_source;
|
||||
|
||||
DBG (5, "OFF xi: %02x%02x yi: %02x%02x,"
|
||||
DBG(5, "OFF xi: %02x%02x yi: %02x%02x,"
|
||||
" WIN xp: %02x%02x%02x%02x yp %02x%02x%02x%02x,"
|
||||
" MAX %08x %08x\n",
|
||||
cmd[0x0f], cmd[0x10], cmd[0x11], cmd[0x12],
|
||||
|
|
@ -780,25 +780,25 @@ static int dev_set_window (struct device *dev)
|
|||
cmd[0x09], cmd[0x0a], cmd[0x0b], cmd[0x0c],
|
||||
dev->max_win_width, dev->max_win_len);
|
||||
|
||||
return dev_command (dev, cmd, 32);
|
||||
return dev_command(dev, cmd, 32);
|
||||
}
|
||||
|
||||
static SANE_Status
|
||||
dev_inquiry (struct device *dev)
|
||||
dev_inquiry(struct device *dev)
|
||||
{
|
||||
SANE_Byte *ptr;
|
||||
SANE_Char *optr, *xptr;
|
||||
|
||||
if (!dev_cmd (dev, CMD_INQUIRY))
|
||||
if (!dev_cmd(dev, CMD_INQUIRY))
|
||||
return SANE_STATUS_IO_ERROR;
|
||||
ptr = dev->res;
|
||||
if (ptr[3] != MSG_PRODUCT_INFO) {
|
||||
DBG (1, "%s: illegal INQUIRY response %02x\n", __func__, ptr[3]);
|
||||
DBG(1, "%s: illegal INQUIRY response %02x\n", __func__, ptr[3]);
|
||||
return SANE_STATUS_IO_ERROR;
|
||||
}
|
||||
|
||||
/* parse reported manufacturer/product names */
|
||||
dev->sane.vendor = optr = (SANE_Char *) malloc (33);
|
||||
dev->sane.vendor = optr = (SANE_Char *) malloc(33);
|
||||
for (ptr += 4; ptr < &dev->res[0x24] && *ptr && *ptr != ' ';)
|
||||
*optr++ = *ptr++;
|
||||
*optr++ = 0;
|
||||
|
|
@ -806,7 +806,7 @@ dev_inquiry (struct device *dev)
|
|||
for (; ptr < &dev->res[0x24] && (!*ptr || *ptr == ' '); ptr++)
|
||||
/* skip spaces */;
|
||||
|
||||
dev->sane.model = optr = (SANE_Char *) malloc (33);
|
||||
dev->sane.model = optr = (SANE_Char *) malloc(33);
|
||||
xptr = optr; /* is last non space character + 1 */
|
||||
for (; ptr < &dev->res[0x24] && *ptr;) {
|
||||
if (*ptr != ' ')
|
||||
|
|
@ -816,8 +816,8 @@ dev_inquiry (struct device *dev)
|
|||
*optr++ = 0;
|
||||
*xptr = 0;
|
||||
|
||||
DBG (1, "%s: found %s/%s\n", __func__, dev->sane.vendor, dev->sane.model);
|
||||
dev->sane.type = strdup ("multi-function peripheral");
|
||||
DBG(1, "%s: found %s/%s\n", __func__, dev->sane.vendor, dev->sane.model);
|
||||
dev->sane.type = strdup("multi-function peripheral");
|
||||
|
||||
dev->resolutions = dev->res[0x37] << 16 |
|
||||
dev->res[0x24] << 8 |
|
||||
|
|
@ -854,23 +854,23 @@ dev_inquiry (struct device *dev)
|
|||
}
|
||||
|
||||
const SANE_Option_Descriptor *
|
||||
sane_get_option_descriptor (SANE_Handle h, SANE_Int opt)
|
||||
sane_get_option_descriptor(SANE_Handle h, SANE_Int opt)
|
||||
{
|
||||
struct device *dev = h;
|
||||
|
||||
DBG (3, "%s: %p, %d\n", __func__, h, opt);
|
||||
DBG(3, "%s: %p, %d\n", __func__, h, opt);
|
||||
if (opt >= NUM_OPTIONS || opt < 0)
|
||||
return NULL;
|
||||
return &dev->opt[opt];
|
||||
}
|
||||
|
||||
SANE_Status
|
||||
sane_control_option (SANE_Handle h, SANE_Int opt, SANE_Action act,
|
||||
void *val, SANE_Word * info)
|
||||
sane_control_option(SANE_Handle h, SANE_Int opt, SANE_Action act,
|
||||
void *val, SANE_Word *info)
|
||||
{
|
||||
struct device *dev = h;
|
||||
|
||||
DBG (3, "%s: %p, %d, <%d>, %p, %p\n", __func__, h, opt, act, val, (void *)info);
|
||||
DBG(3, "%s: %p, %d, <%d>, %p, %p\n", __func__, h, opt, act, val, (void *)info);
|
||||
if (!dev || opt >= NUM_OPTIONS || opt < 0)
|
||||
return SANE_STATUS_INVAL;
|
||||
|
||||
|
|
@ -918,48 +918,48 @@ sane_control_option (SANE_Handle h, SANE_Int opt, SANE_Action act,
|
|||
}
|
||||
}
|
||||
|
||||
DBG (4, "%s: %d, <%d> => %08x, %x\n", __func__, opt, act,
|
||||
DBG(4, "%s: %d, <%d> => %08x, %x\n", __func__, opt, act,
|
||||
val? *(SANE_Word *)val : 0, info? *info : 0);
|
||||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
static void
|
||||
dev_free (struct device *dev)
|
||||
dev_free(struct device *dev)
|
||||
{
|
||||
if (!dev)
|
||||
return;
|
||||
|
||||
if (dev->sane.name)
|
||||
free (UNCONST(dev->sane.name));
|
||||
free(UNCONST(dev->sane.name));
|
||||
if (dev->sane.vendor)
|
||||
free (UNCONST(dev->sane.vendor));
|
||||
free(UNCONST(dev->sane.vendor));
|
||||
if (dev->sane.model)
|
||||
free (UNCONST(dev->sane.model));
|
||||
free(UNCONST(dev->sane.model));
|
||||
if (dev->sane.type)
|
||||
free (UNCONST(dev->sane.type));
|
||||
free(UNCONST(dev->sane.type));
|
||||
if (dev->data)
|
||||
free(dev->data);
|
||||
if (dev->decData) {
|
||||
free(dev->decData);
|
||||
dev->decData = NULL;
|
||||
}
|
||||
memset (dev, 0, sizeof (*dev));
|
||||
free (dev);
|
||||
memset(dev, 0, sizeof(*dev));
|
||||
free(dev);
|
||||
}
|
||||
|
||||
static void
|
||||
free_devices (void)
|
||||
free_devices(void)
|
||||
{
|
||||
struct device *next;
|
||||
struct device *dev;
|
||||
|
||||
if (devlist) {
|
||||
free (devlist);
|
||||
free(devlist);
|
||||
devlist = NULL;
|
||||
}
|
||||
for (dev = devices_head; dev; dev = next) {
|
||||
next = dev->next;
|
||||
dev_free (dev);
|
||||
dev_free(dev);
|
||||
}
|
||||
devices_head = NULL;
|
||||
}
|
||||
|
|
@ -972,40 +972,40 @@ static transport *tr_from_devname(SANE_String_Const devname)
|
|||
}
|
||||
|
||||
static SANE_Status
|
||||
list_one_device (SANE_String_Const devname)
|
||||
list_one_device(SANE_String_Const devname)
|
||||
{
|
||||
struct device *dev;
|
||||
SANE_Status status;
|
||||
transport *tr;
|
||||
|
||||
DBG (4, "%s: %s\n", __func__, devname);
|
||||
DBG(4, "%s: %s\n", __func__, devname);
|
||||
|
||||
for (dev = devices_head; dev; dev = dev->next) {
|
||||
if (strcmp (dev->sane.name, devname) == 0)
|
||||
if (strcmp(dev->sane.name, devname) == 0)
|
||||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
tr = tr_from_devname(devname);
|
||||
|
||||
dev = calloc (1, sizeof (struct device));
|
||||
dev = calloc(1, sizeof(struct device));
|
||||
if (dev == NULL)
|
||||
return SANE_STATUS_NO_MEM;
|
||||
|
||||
dev->sane.name = strdup (devname);
|
||||
dev->sane.name = strdup(devname);
|
||||
dev->io = tr;
|
||||
status = tr->dev_open (dev);
|
||||
status = tr->dev_open(dev);
|
||||
if (status != SANE_STATUS_GOOD) {
|
||||
dev_free (dev);
|
||||
dev_free(dev);
|
||||
return status;
|
||||
}
|
||||
|
||||
/* status = dev_cmd (dev, CMD_ABORT);*/
|
||||
status = dev_inquiry (dev);
|
||||
tr->dev_close (dev);
|
||||
/* status = dev_cmd (dev, CMD_ABORT);*/
|
||||
status = dev_inquiry(dev);
|
||||
tr->dev_close(dev);
|
||||
if (status != SANE_STATUS_GOOD) {
|
||||
DBG (1, "%s: dev_inquiry(%s): %s\n", __func__,
|
||||
dev->sane.name, sane_strstatus (status));
|
||||
dev_free (dev);
|
||||
DBG(1, "%s: dev_inquiry(%s): %s\n", __func__,
|
||||
dev->sane.name, sane_strstatus(status));
|
||||
dev_free(dev);
|
||||
return status;
|
||||
}
|
||||
|
||||
|
|
@ -1017,27 +1017,27 @@ list_one_device (SANE_String_Const devname)
|
|||
|
||||
/* SANE API ignores return code of this callback */
|
||||
static SANE_Status
|
||||
list_conf_devices (UNUSED (SANEI_Config * config), const char *devname)
|
||||
list_conf_devices(UNUSED(SANEI_Config *config), const char *devname)
|
||||
{
|
||||
return tr_from_devname(devname)->configure_device(devname, list_one_device);
|
||||
}
|
||||
|
||||
SANE_Status
|
||||
sane_init (SANE_Int * version_code, SANE_Auth_Callback cb)
|
||||
sane_init(SANE_Int *version_code, SANE_Auth_Callback cb)
|
||||
{
|
||||
DBG_INIT ();
|
||||
DBG (2, "sane_init: Xerox backend (build %d), version %s null, authorize %s null\n", BACKEND_BUILD,
|
||||
DBG_INIT();
|
||||
DBG(2, "sane_init: Xerox backend (build %d), version %s null, authorize %s null\n", BACKEND_BUILD,
|
||||
(version_code) ? "!=" : "==", (cb) ? "!=" : "==");
|
||||
|
||||
if (version_code)
|
||||
*version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, BACKEND_BUILD);
|
||||
*version_code = SANE_VERSION_CODE(V_MAJOR, V_MINOR, BACKEND_BUILD);
|
||||
|
||||
sanei_usb_init ();
|
||||
sanei_usb_init();
|
||||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
void
|
||||
sane_exit (void)
|
||||
sane_exit(void)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
|
|
@ -1045,18 +1045,18 @@ sane_exit (void)
|
|||
if (dev->dn != -1)
|
||||
sane_close(dev); /* implies flush */
|
||||
|
||||
free_devices ();
|
||||
free_devices();
|
||||
}
|
||||
|
||||
SANE_Status
|
||||
sane_get_devices (const SANE_Device *** device_list, SANE_Bool local)
|
||||
sane_get_devices(const SANE_Device *** device_list, SANE_Bool local)
|
||||
{
|
||||
SANEI_Config config;
|
||||
struct device *dev;
|
||||
int dev_count;
|
||||
int i;
|
||||
|
||||
DBG (3, "%s: %p, %d\n", __func__, (const void *)device_list, local);
|
||||
DBG(3, "%s: %p, %d\n", __func__, (const void *)device_list, local);
|
||||
|
||||
if (devlist) {
|
||||
if (device_list)
|
||||
|
|
@ -1064,20 +1064,19 @@ sane_get_devices (const SANE_Device *** device_list, SANE_Bool local)
|
|||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
free_devices ();
|
||||
free_devices();
|
||||
|
||||
config.count = 0;
|
||||
config.descriptors = NULL;
|
||||
config.values = NULL;
|
||||
sanei_configure_attach (XEROX_CONFIG_FILE, &config, list_conf_devices);
|
||||
sanei_configure_attach(XEROX_CONFIG_FILE, &config, list_conf_devices);
|
||||
|
||||
for (dev_count = 0, dev = devices_head; dev; dev = dev->next)
|
||||
dev_count++;
|
||||
|
||||
devlist = malloc ((dev_count + 1) * sizeof (*devlist));
|
||||
if (!devlist)
|
||||
{
|
||||
DBG (1, "%s: malloc: no memory\n", __func__);
|
||||
devlist = malloc((dev_count + 1) * sizeof(*devlist));
|
||||
if (!devlist) {
|
||||
DBG(1, "%s: malloc: no memory\n", __func__);
|
||||
return SANE_STATUS_NO_MEM;
|
||||
}
|
||||
|
||||
|
|
@ -1091,32 +1090,32 @@ sane_get_devices (const SANE_Device *** device_list, SANE_Bool local)
|
|||
}
|
||||
|
||||
void
|
||||
sane_close (SANE_Handle h)
|
||||
sane_close(SANE_Handle h)
|
||||
{
|
||||
struct device *dev = h;
|
||||
|
||||
if (!dev)
|
||||
return;
|
||||
|
||||
DBG (3, "%s: %p (%s)\n", __func__, (void *)dev, dev->sane.name);
|
||||
DBG(3, "%s: %p (%s)\n", __func__, (void *)dev, dev->sane.name);
|
||||
dev->io->dev_close(dev);
|
||||
}
|
||||
|
||||
SANE_Status
|
||||
sane_open (SANE_String_Const name, SANE_Handle * h)
|
||||
sane_open(SANE_String_Const name, SANE_Handle *h)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
DBG (3, "%s: '%s'\n", __func__, name);
|
||||
DBG(3, "%s: '%s'\n", __func__, name);
|
||||
|
||||
if (!devlist)
|
||||
sane_get_devices (NULL, SANE_TRUE);
|
||||
sane_get_devices(NULL, SANE_TRUE);
|
||||
|
||||
if (!name || !*name) {
|
||||
/* special case of empty name: open first available device */
|
||||
for (dev = devices_head; dev; dev = dev->next) {
|
||||
if (dev->dn != -1) {
|
||||
if (sane_open (dev->sane.name, h) == SANE_STATUS_GOOD)
|
||||
if (sane_open(dev->sane.name, h) == SANE_STATUS_GOOD)
|
||||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
}
|
||||
|
|
@ -1133,11 +1132,11 @@ sane_open (SANE_String_Const name, SANE_Handle * h)
|
|||
}
|
||||
|
||||
SANE_Status
|
||||
sane_get_parameters (SANE_Handle h, SANE_Parameters * para)
|
||||
sane_get_parameters(SANE_Handle h, SANE_Parameters *para)
|
||||
{
|
||||
struct device *dev = h;
|
||||
|
||||
DBG (3, "%s: %p, %p\n", __func__, h, (void *)para);
|
||||
DBG(3, "%s: %p, %p\n", __func__, h, (void *)para);
|
||||
if (!para)
|
||||
return SANE_STATUS_INVAL;
|
||||
|
||||
|
|
@ -1170,12 +1169,12 @@ static int dev_acquire(struct device *dev)
|
|||
dev->composition == MODE_HALFTONE)
|
||||
dev->pixels_per_line *= 8;
|
||||
|
||||
DBG (4, "acquiring, size per band v: %d, h: %d, %sblock: %d, slack: %d\n",
|
||||
DBG(4, "acquiring, size per band v: %d, h: %d, %sblock: %d, slack: %d\n",
|
||||
dev->vertical, dev->horizontal, dev->final_block? "last " : "",
|
||||
dev->blocklen, dev->blocklen - (dev->vertical * dev->bytes_per_line));
|
||||
|
||||
if (dev->bytes_per_line > DATASIZE) {
|
||||
DBG (1, "%s: unsupported line size: %d bytes > %d\n",
|
||||
DBG(1, "%s: unsupported line size: %d bytes > %d\n",
|
||||
__func__, dev->bytes_per_line, DATASIZE);
|
||||
return ret_cancel(dev, SANE_STATUS_NO_MEM);
|
||||
}
|
||||
|
|
@ -1225,7 +1224,8 @@ static int copy_plain_trim(struct device *dev, SANE_Byte *buf, int maxlen, int *
|
|||
|
||||
/* return: how much data could be freed from cyclic buffer */
|
||||
/* convert from RRGGBB to RGBRGB */
|
||||
static int copy_mix_bands_trim(struct device *dev, SANE_Byte *buf, int maxlen, int *olenp) {
|
||||
static int copy_mix_bands_trim(struct device *dev, SANE_Byte *buf, int maxlen, int *olenp)
|
||||
{
|
||||
int j;
|
||||
|
||||
const int linesize = dev->bytes_per_line; /* caching real line size */
|
||||
|
|
@ -1262,12 +1262,12 @@ static int copy_mix_bands_trim(struct device *dev, SANE_Byte *buf, int maxlen, i
|
|||
}
|
||||
|
||||
SANE_Status
|
||||
sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, SANE_Int * lenp)
|
||||
sane_read(SANE_Handle h, SANE_Byte *buf, SANE_Int maxlen, SANE_Int *lenp)
|
||||
{
|
||||
SANE_Status status;
|
||||
struct device *dev = h;
|
||||
|
||||
DBG (3, "%s: %p, %p, %d, %p\n", __func__, h, buf, maxlen, (void *)lenp);
|
||||
DBG(3, "%s: %p, %p, %d, %p\n", __func__, h, buf, maxlen, (void *)lenp);
|
||||
|
||||
if (lenp)
|
||||
*lenp = 0;
|
||||
|
|
@ -1281,13 +1281,13 @@ sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, SANE_Int * lenp)
|
|||
if (!dev->blocklen && dev->datalen <= PADDING_SIZE) {
|
||||
|
||||
/* copying uncompressed data */
|
||||
if ( dev->composition == MODE_RGB24 &&
|
||||
if (dev->composition == MODE_RGB24 &&
|
||||
isSupportedDevice(dev) &&
|
||||
dev->decDataSize > 0) {
|
||||
int diff = dev->total_img_size - dev->total_out_size;
|
||||
int bufLen = (diff < maxlen) ? diff : maxlen;
|
||||
if ( 0 < diff &&
|
||||
0 < copy_decompress_data(dev, buf, bufLen, lenp) ) {
|
||||
if (0 < diff &&
|
||||
0 < copy_decompress_data(dev, buf, bufLen, lenp)) {
|
||||
dev->total_out_size += *lenp;
|
||||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
|
@ -1301,15 +1301,15 @@ sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, SANE_Int * lenp)
|
|||
if (buf && lenp && slack > 0) {
|
||||
*lenp = fill_slack(dev, buf, maxlen);
|
||||
dev->total_out_size += *lenp;
|
||||
DBG (9, "<> slack: %d, filled: %d, maxlen %d\n",
|
||||
DBG(9, "<> slack: %d, filled: %d, maxlen %d\n",
|
||||
slack, *lenp, maxlen);
|
||||
return SANE_STATUS_GOOD;
|
||||
} else if (slack < 0) {
|
||||
/* this will never happen */
|
||||
DBG(1, "image overflow %d bytes\n", dev->total_img_size - dev->total_out_size);
|
||||
}
|
||||
if ( isSupportedDevice(dev) &&
|
||||
dev->composition == MODE_RGB24 ) {
|
||||
if (isSupportedDevice(dev) &&
|
||||
dev->composition == MODE_RGB24) {
|
||||
remove(encTmpFileName);
|
||||
}
|
||||
/* that's all */
|
||||
|
|
@ -1325,7 +1325,7 @@ sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, SANE_Int * lenp)
|
|||
if (!dev->reading) {
|
||||
if (cancelled(dev))
|
||||
return dev->state;
|
||||
DBG (5, "READ_IMAGE\n");
|
||||
DBG(5, "READ_IMAGE\n");
|
||||
if (!dev_cmd(dev, CMD_READ_IMAGE))
|
||||
return SANE_STATUS_IO_ERROR;
|
||||
dev->reading++;
|
||||
|
|
@ -1345,14 +1345,14 @@ sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, SANE_Int * lenp)
|
|||
while (datalen && dev->blocklen) {
|
||||
SANE_Byte *rbuf = dev->data + DATATAIL(dev);
|
||||
|
||||
DBG (9, "<> request len: %lu, [%d, %d; %d]\n",
|
||||
DBG(9, "<> request len: %lu, [%d, %d; %d]\n",
|
||||
(u_long)datalen, dev->dataoff, DATATAIL(dev), dev->datalen);
|
||||
if ((status = dev->io->dev_request(dev, NULL, 0, rbuf, &datalen)) !=
|
||||
SANE_STATUS_GOOD)
|
||||
return status;
|
||||
dev->datalen += datalen;
|
||||
dev->blocklen -= datalen;
|
||||
DBG (9, "<> got %lu, [%d, %d; %d]\n",
|
||||
DBG(9, "<> got %lu, [%d, %d; %d]\n",
|
||||
(u_long)datalen, dev->dataoff, DATATAIL(dev), dev->datalen);
|
||||
if (dev->blocklen < 0)
|
||||
return ret_cancel(dev, SANE_STATUS_IO_ERROR);
|
||||
|
|
@ -1366,7 +1366,7 @@ sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, SANE_Int * lenp)
|
|||
if (isSupportedDevice(dev)) {
|
||||
clrlen = dump_to_tmp_file(dev);
|
||||
/* decompress after reading entire block data*/
|
||||
if ( 0 == dev->blocklen ) {
|
||||
if (0 == dev->blocklen) {
|
||||
decompress_tempfile(dev);
|
||||
}
|
||||
copy_decompress_data(dev, buf, maxlen, &olen);
|
||||
|
|
@ -1383,7 +1383,7 @@ sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, SANE_Int * lenp)
|
|||
*lenp += olen;
|
||||
dev->total_out_size += olen;
|
||||
|
||||
DBG (9, "<> olen: %d, clrlen: %d, blocklen: %d/%d, maxlen %d (%d %d %d)\n",
|
||||
DBG(9, "<> olen: %d, clrlen: %d, blocklen: %d/%d, maxlen %d (%d %d %d)\n",
|
||||
olen, clrlen, dev->blocklen, dev->datalen, maxlen,
|
||||
dev->dataindex / dev->bytes_per_line + dev->y_off,
|
||||
dev->y_off, dev->para.lines);
|
||||
|
|
@ -1404,17 +1404,17 @@ sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, SANE_Int * lenp)
|
|||
} while (dev->blocklen);
|
||||
|
||||
if (lenp)
|
||||
DBG (9, " ==> %d\n", *lenp);
|
||||
DBG(9, " ==> %d\n", *lenp);
|
||||
|
||||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
SANE_Status
|
||||
sane_start (SANE_Handle h)
|
||||
sane_start(SANE_Handle h)
|
||||
{
|
||||
struct device *dev = h;
|
||||
|
||||
DBG (3, "%s: %p\n", __func__, h);
|
||||
DBG(3, "%s: %p\n", __func__, h);
|
||||
|
||||
dev->cancel = 0;
|
||||
dev->scanning = 0;
|
||||
|
|
@ -1476,8 +1476,8 @@ sane_start (SANE_Handle h)
|
|||
|
||||
dev->total_img_size = dev->para.bytes_per_line * dev->para.lines;
|
||||
|
||||
if ( isSupportedDevice(dev) &&
|
||||
dev->composition == MODE_RGB24 ) {
|
||||
if (isSupportedDevice(dev) &&
|
||||
dev->composition == MODE_RGB24) {
|
||||
remove(encTmpFileName);
|
||||
}
|
||||
dev->currentDecDataIndex = 0;
|
||||
|
|
@ -1485,11 +1485,11 @@ sane_start (SANE_Handle h)
|
|||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
SANE_Status sane_set_io_mode (SANE_Handle h, SANE_Bool non_blocking)
|
||||
SANE_Status sane_set_io_mode(SANE_Handle h, SANE_Bool non_blocking)
|
||||
{
|
||||
struct device *dev = h;
|
||||
|
||||
DBG (3, "%s: %p, %d\n", __func__, h, non_blocking);
|
||||
DBG(3, "%s: %p, %d\n", __func__, h, non_blocking);
|
||||
|
||||
if (non_blocking)
|
||||
return SANE_STATUS_UNSUPPORTED;
|
||||
|
|
@ -1498,18 +1498,18 @@ SANE_Status sane_set_io_mode (SANE_Handle h, SANE_Bool non_blocking)
|
|||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
SANE_Status sane_get_select_fd (SANE_Handle h, SANE_Int * fdp)
|
||||
SANE_Status sane_get_select_fd(SANE_Handle h, SANE_Int *fdp)
|
||||
{
|
||||
DBG (3, "%s: %p, %p\n", __func__, h, (void *)fdp);
|
||||
DBG(3, "%s: %p, %p\n", __func__, h, (void *)fdp);
|
||||
/* supporting of this will require thread creation */
|
||||
return SANE_STATUS_UNSUPPORTED;
|
||||
}
|
||||
|
||||
void sane_cancel (SANE_Handle h)
|
||||
void sane_cancel(SANE_Handle h)
|
||||
{
|
||||
struct device *dev = h;
|
||||
|
||||
DBG (3, "%s: %p\n", __func__, h);
|
||||
DBG(3, "%s: %p\n", __func__, h);
|
||||
dev->cancel = 1;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -124,33 +124,34 @@ struct device {
|
|||
|
||||
/* Transport abstract layer */
|
||||
struct transport {
|
||||
char* ttype;
|
||||
char *ttype;
|
||||
|
||||
int (*dev_request) (struct device *dev,
|
||||
int (*dev_request)(struct device *dev,
|
||||
SANE_Byte *cmd, size_t cmdlen,
|
||||
SANE_Byte *resp, size_t *resplen);
|
||||
SANE_Status (*dev_open) (struct device *dev);
|
||||
void (*dev_close) (struct device *dev);
|
||||
SANE_Status (*configure_device) (const char *devname, SANE_Status (*cb)(SANE_String_Const devname));
|
||||
SANE_Status(*dev_open)(struct device *dev);
|
||||
void (*dev_close)(struct device *dev);
|
||||
SANE_Status(*configure_device)(const char *devname, SANE_Status(*cb)(SANE_String_Const devname));
|
||||
};
|
||||
|
||||
/* USB transport */
|
||||
int usb_dev_request (struct device *dev, SANE_Byte *cmd, size_t cmdlen, SANE_Byte *resp, size_t *resplen);
|
||||
SANE_Status usb_dev_open (struct device *dev);
|
||||
void usb_dev_close (struct device *dev);
|
||||
SANE_Status usb_configure_device (const char *devname, SANE_Status (*cb)(SANE_String_Const devname));
|
||||
int usb_dev_request(struct device *dev, SANE_Byte *cmd, size_t cmdlen, SANE_Byte *resp, size_t *resplen);
|
||||
SANE_Status usb_dev_open(struct device *dev);
|
||||
void usb_dev_close(struct device *dev);
|
||||
SANE_Status usb_configure_device(const char *devname, SANE_Status(*cb)(SANE_String_Const devname));
|
||||
|
||||
/* TCP unicast */
|
||||
int tcp_dev_request (struct device *dev, SANE_Byte *cmd, size_t cmdlen, SANE_Byte *resp, size_t *resplen);
|
||||
SANE_Status tcp_dev_open (struct device *dev);
|
||||
void tcp_dev_close (struct device *dev);
|
||||
SANE_Status tcp_configure_device (const char *devname, SANE_Status (*cb)(SANE_String_Const devname));
|
||||
int tcp_dev_request(struct device *dev, SANE_Byte *cmd, size_t cmdlen, SANE_Byte *resp, size_t *resplen);
|
||||
SANE_Status tcp_dev_open(struct device *dev);
|
||||
void tcp_dev_close(struct device *dev);
|
||||
SANE_Status tcp_configure_device(const char *devname, SANE_Status(*cb)(SANE_String_Const devname));
|
||||
|
||||
/* device wants transfer buffer to be multiple of 512 */
|
||||
#define USB_BLOCK_SIZE 512
|
||||
#define USB_BLOCK_MASK ~(USB_BLOCK_SIZE - 1)
|
||||
|
||||
static inline int dataroom(struct device *dev) {
|
||||
static inline int dataroom(struct device *dev)
|
||||
{
|
||||
int tail = DATATAIL(dev);
|
||||
if (tail < dev->dataoff)
|
||||
return dev->dataoff - tail;
|
||||
|
|
|
|||
Ładowanie…
Reference in New Issue