diff options
Diffstat (limited to 'backend/xerox_mfp.c')
| -rw-r--r-- | backend/xerox_mfp.c | 2236 |
1 files changed, 1211 insertions, 1025 deletions
diff --git a/backend/xerox_mfp.c b/backend/xerox_mfp.c index 2ef7078..8b8c895 100644 --- a/backend/xerox_mfp.c +++ b/backend/xerox_mfp.c @@ -1,9 +1,12 @@ /* - * SANE backend for Xerox Phaser 3200MFP - * Copyright 2008 ABC <abc@telekom.ru> + * SANE backend for Xerox Phaser 3200MFP et al. + * Copyright 2008-2016 ABC <abc@telekom.ru> * - * Network Scanners Support - * Copyright 2010 Alexander Kuznetsov <acca(at)cpan.org> + * Network Scanners Support + * Copyright 2010 Alexander Kuznetsov <acca(at)cpan.org> + * + * Color scanning on Samsung M2870 model and Xerox Cognac 3215 & 3225 + * models by Laxmeesh Onkar Markod <m.laxmeesh@samsung.com> * * This program is licensed under GPL + SANE exception. * More info at http://www.sane-project.org/license.html @@ -30,6 +33,9 @@ #include "../include/sane/sanei_usb.h" #include "../include/sane/sanei_config.h" #include "../include/sane/sanei_backend.h" +#ifdef HAVE_LIBJPEG +#include <jpeglib.h> +#endif #include "xerox_mfp.h" #define BACKEND_BUILD 13 @@ -46,34 +52,34 @@ transport available_transports[TRANSPORTS_MAX] = { static int resolv_state(int state) { - if (state & STATE_DOCUMENT_JAM) - return SANE_STATUS_JAMMED; - if (state & STATE_NO_DOCUMENT) - return SANE_STATUS_NO_DOCS; - if (state & STATE_COVER_OPEN) - return SANE_STATUS_COVER_OPEN; - if (state & STATE_INVALID_AREA) - return SANE_STATUS_INVAL; /* sane_start: implies SANE_INFO_RELOAD_OPTIONS */ - if (state & STATE_WARMING) + if (state & STATE_DOCUMENT_JAM) + return SANE_STATUS_JAMMED; + if (state & STATE_NO_DOCUMENT) + return SANE_STATUS_NO_DOCS; + if (state & STATE_COVER_OPEN) + return SANE_STATUS_COVER_OPEN; + if (state & STATE_INVALID_AREA) + return SANE_STATUS_INVAL; /* sane_start: implies SANE_INFO_RELOAD_OPTIONS */ + if (state & STATE_WARMING) #ifdef SANE_STATUS_WARMING_UP - return SANE_STATUS_WARMING_UP; + return SANE_STATUS_WARMING_UP; #else - return SANE_STATUS_DEVICE_BUSY; + return SANE_STATUS_DEVICE_BUSY; #endif - if (state & STATE_LOCKING) + if (state & STATE_LOCKING) #ifdef SANE_STATUS_HW_LOCKED - return SANE_STATUS_HW_LOCKED; + return SANE_STATUS_HW_LOCKED; #else - return SANE_STATUS_JAMMED; + return SANE_STATUS_JAMMED; #endif - if (state & ~STATE_NO_ERROR) - return SANE_STATUS_DEVICE_BUSY; - return 0; + if (state & ~STATE_NO_ERROR) + return SANE_STATUS_DEVICE_BUSY; + return 0; } static char *str_cmd(int cmd) { - switch (cmd) { + switch (cmd) { case CMD_ABORT: return "ABORT"; case CMD_INQUIRY: return "INQUIRY"; case CMD_RESERVE_UNIT: return "RESERVE_UNIT"; @@ -82,1262 +88,1442 @@ static char *str_cmd(int cmd) case CMD_READ: return "READ"; case CMD_READ_IMAGE: return "READ_IMAGE"; case CMD_OBJECT_POSITION: return "OBJECT_POSITION"; - } - return "unknown"; + } + return "unknown"; } #define MAX_DUMP 70 +const char *encTmpFileName = "/tmp/stmp_enc.tmp"; + +static int decompress(struct device __sane_unused__ *dev, + const char __sane_unused__ *infilename) +{ +#ifdef HAVE_LIBJPEG + int rc; + int row_stride, width, height, pixel_size; + struct jpeg_decompress_struct cinfo; + struct jpeg_error_mgr jerr; + unsigned long bmp_size = 0; + FILE *pInfile = NULL; + JSAMPARRAY buffer; + + if ((pInfile = fopen(infilename, "rb")) == NULL) { + fprintf(stderr, "can't open %s\n", infilename); + return -1; + } + + cinfo.err = jpeg_std_error(&jerr); + + jpeg_create_decompress(&cinfo); + + jpeg_stdio_src(&cinfo, pInfile); + + rc = jpeg_read_header(&cinfo, TRUE); + if (rc != 1) { + jpeg_destroy_decompress(&cinfo); + fclose(pInfile); + return -1; + } + + jpeg_start_decompress(&cinfo); + + width = cinfo.output_width; + height = cinfo.output_height; + pixel_size = cinfo.output_components; + bmp_size = width * height * pixel_size; + dev->decDataSize = bmp_size; + + row_stride = width * pixel_size; + + buffer = (*cinfo.mem->alloc_sarray) + ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1); + + while (cinfo.output_scanline < cinfo.output_height) { + buffer[0] = dev->decData + \ + (cinfo.output_scanline) * row_stride; + jpeg_read_scanlines(&cinfo, buffer, 1); + } + jpeg_finish_decompress(&cinfo); + jpeg_destroy_decompress(&cinfo); + fclose(pInfile); + return 0; +#else + return -1; +#endif +} + +static int copy_decompress_data(struct device *dev, unsigned char *pDest, int maxlen, int *destLen) +{ + int data_size = 0; + size_t result = 0, retVal = 0; + + + if (0 == dev->decDataSize) { + *destLen = 0; + return retVal; + } + data_size = dev->decDataSize - dev->currentDecDataIndex; + if (data_size > maxlen) { + data_size = maxlen; + } + memcpy(pDest, dev->decData+dev->currentDecDataIndex, data_size); + result = data_size; + *destLen = result; + dev->currentDecDataIndex += result; + retVal = result; + + if (dev->decDataSize == dev->currentDecDataIndex) { + dev->currentDecDataIndex = 0; + dev->decDataSize = 0; + } + + return retVal; +} + +static int decompress_tempfile(struct device *dev) +{ + decompress(dev, encTmpFileName); + remove(encTmpFileName); + return 0; +} + +static int dump_to_tmp_file(struct device *dev) +{ + unsigned char *pSrc = dev->data; + int srcLen = dev->datalen; + FILE *pInfile; + if ((pInfile = fopen(encTmpFileName, "a")) == NULL) { + fprintf(stderr, "can't open %s\n", encTmpFileName); + return 0; + } + + fwrite(pSrc, 1, srcLen, pInfile); + fclose(pInfile); + return srcLen; +} + +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)) + return 1; + else + return 0; +#else + return 0; +#endif +} + static void dbg_dump(struct device *dev) { - int i; - char dbuf[MAX_DUMP * 3 + 1], *dptr = dbuf; - int nzlen = dev->reslen; - int dlen = MIN(dev->reslen, MAX_DUMP); + int i; + char dbuf[MAX_DUMP * 3 + 1], *dptr = dbuf; + int nzlen = dev->reslen; + int dlen = MIN(dev->reslen, MAX_DUMP); - for (i = dev->reslen - 1; i >= 0; i--, nzlen--) - if (dev->res[i] != 0) - break; + for (i = dev->reslen - 1; i >= 0; i--, nzlen--) + if (dev->res[i] != 0) + break; - dlen = MIN(dlen, nzlen + 1); + dlen = MIN(dlen, nzlen + 1); - for (i = 0; i < dlen; i++, dptr += 3) - sprintf(dptr, " %02x", dev->res[i]); + 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, - (dlen < (int)dev->reslen)? "..." : ""); + 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 */ - - if (cmd[2] == CMD_SET_WINDOW) { - /* Set Window have wrong packet length, huh. */ - sendlen = 25; - } - - if (cmd[2] == CMD_READ_IMAGE) { - /* Read Image is raw data, don't need to read response */ - res = NULL; - } - - dev->state = 0; - 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", __FUNCTION__, sane_strstatus (status)); - dev->state = SANE_STATUS_IO_ERROR; - return 0; - } + SANE_Status status; + size_t sendlen = cmd[3] + 4; + SANE_Byte *res = dev->res; - if (!res) { - /* if not need response just return success */ - return 1; - } - /* normal command reply, some sanity checking */ - if (dev->reslen < reqlen) { - DBG (1, "%s: illegal response len %lu, need %lu\n", - __FUNCTION__, (u_long)dev->reslen, (u_long)reqlen); - dev->state = SANE_STATUS_IO_ERROR; - return 0; - } else { - size_t pktlen; /* len specified in packet */ + assert(reqlen <= sizeof(dev->res)); /* requested len */ + dev->reslen = sizeof(dev->res); /* doing full buffer to flush stalled commands */ - if (DBG_LEVEL > 3) - dbg_dump(dev); + if (cmd[2] == CMD_SET_WINDOW) { + /* Set Window have wrong packet length, huh. */ + sendlen = 25; + } - if (dev->res[0] != RES_CODE) { - DBG (2, "%s: illegal data header %02x\n", __FUNCTION__, dev->res[0]); - dev->state = SANE_STATUS_IO_ERROR; - return 0; + if (cmd[2] == CMD_READ_IMAGE) { + /* Read Image is raw data, don't need to read response */ + res = NULL; } - pktlen = dev->res[2] + 3; - if (dev->reslen != pktlen) { - DBG (2, "%s: illegal response len %lu, should be %lu\n", - __FUNCTION__, (u_long)pktlen, (u_long)dev->reslen); - dev->state = SANE_STATUS_IO_ERROR; - return 0; + + dev->state = 0; + 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)); + dev->state = SANE_STATUS_IO_ERROR; + return 0; } - if (dev->reslen > reqlen) - DBG (2, "%s: too big packet len %lu, need %lu\n", - __FUNCTION__, (u_long)dev->reslen, (u_long)reqlen); - } - - dev->state = 0; - if (cmd[2] == CMD_SET_WINDOW || - cmd[2] == CMD_OBJECT_POSITION || - cmd[2] == CMD_READ || - cmd[2] == CMD_RESERVE_UNIT) { - if (dev->res[1] == STATUS_BUSY) - dev->state = SANE_STATUS_DEVICE_BUSY; - else if (dev->res[1] == STATUS_CANCEL) - dev->state = SANE_STATUS_CANCELLED; - else if (dev->res[1] == STATUS_CHECK) - dev->state = resolv_state((cmd[2] == CMD_READ)? - (dev->res[12] << 8 | dev->res[13]) : - (dev->res[4] << 8 | dev->res[5])); - - if (dev->state) - DBG (3, "%s(%s[%#x]): => %d: %s\n", - __FUNCTION__, str_cmd(cmd[2]), cmd[2], - dev->state, sane_strstatus(dev->state)); - } - - return 1; + + if (!res) { + /* if not need response just return success */ + return 1; + } + + /* normal command reply, some sanity checking */ + if (dev->reslen < reqlen) { + 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; + } else { + size_t pktlen; /* len specified in packet */ + + if (DBG_LEVEL > 3) + dbg_dump(dev); + + if (dev->res[0] != RES_CODE) { + 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", + __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", + __func__, (u_long)dev->reslen, (u_long)reqlen); + } + + dev->state = 0; + if (cmd[2] == CMD_SET_WINDOW || + cmd[2] == CMD_OBJECT_POSITION || + cmd[2] == CMD_READ || + cmd[2] == CMD_RESERVE_UNIT) { + if (dev->res[1] == STATUS_BUSY) + dev->state = SANE_STATUS_DEVICE_BUSY; + else if (dev->res[1] == STATUS_CANCEL) + dev->state = SANE_STATUS_CANCELLED; + else if (dev->res[1] == STATUS_CHECK) + dev->state = resolv_state((cmd[2] == CMD_READ)? + (dev->res[12] << 8 | dev->res[13]) : + (dev->res[4] << 8 | dev->res[5])); + + if (dev->state) + DBG(3, "%s(%s[%#x]): => %d: %s\n", + __func__, str_cmd(cmd[2]), cmd[2], + dev->state, sane_strstatus(dev->state)); + } + + return 1; } /* 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); + SANE_Byte cmd[4] = { REQ_CODE_A, REQ_CODE_B }; + cmd[2] = command; + return dev_command(dev, cmd, (command == CMD_INQUIRY)? 70 : 32); } /* stop scanning operation. return previous status */ static SANE_Status dev_stop(struct device *dev) { - int state = dev->state; - - DBG (3, "%s: %p, scanning %d, reserved %d\n", __FUNCTION__, - (void *)dev, dev->scanning, dev->reserved); - dev->scanning = 0; - - /* release */ - if (!dev->reserved) - 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", - dev->para.pixels_per_line, dev->para.lines, - dev->total_img_size, - dev->win_width, dev->win_len, - dev->pixels_per_line, dev->ulines, dev->blocks, - dev->total_data_size, dev->total_out_size); - dev->state = state; - return state; + int state = dev->state; + + DBG(3, "%s: %p, scanning %d, reserved %d\n", __func__, + (void *)dev, dev->scanning, dev->reserved); + dev->scanning = 0; + + /* release */ + if (!dev->reserved) + 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", + dev->para.pixels_per_line, dev->para.lines, + dev->total_img_size, + dev->win_width, dev->win_len, + dev->pixels_per_line, dev->ulines, dev->blocks, + dev->total_data_size, dev->total_out_size); + dev->state = state; + return state; } SANE_Status ret_cancel(struct device *dev, SANE_Status ret) { - dev_cmd(dev, CMD_ABORT); - if (dev->scanning) { - dev_stop(dev); - dev->state = SANE_STATUS_CANCELLED; - } - return ret; + dev_cmd(dev, CMD_ABORT); + if (dev->scanning) { + dev_stop(dev); + dev->state = SANE_STATUS_CANCELLED; + } + return ret; } static int cancelled(struct device *dev) { - if (dev->cancel) - return ret_cancel(dev, 1); - return 0; + if (dev->cancel) + return ret_cancel(dev, 1); + return 0; } /* issue command and wait until scanner is not busy */ /* return 0 on error/blocking, 1 is ok and ready */ static int dev_cmd_wait(struct device *dev, int cmd) { - int sleeptime = 10; - - do { - if (cancelled(dev)) - return 0; - if (!dev_cmd(dev, cmd)) { - dev->state = SANE_STATUS_IO_ERROR; - return 0; - } else if (dev->state) { - if (dev->state != SANE_STATUS_DEVICE_BUSY) - return 0; - else { - if (dev->non_blocking) { - dev->state = SANE_STATUS_GOOD; - return 0; - } else { - if (sleeptime > 1000) - sleeptime = 1000; - 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) - sleeptime *= (sleeptime < 100)? 10 : 2; - } - } /* BUSY */ - } - } while (dev->state == SANE_STATUS_DEVICE_BUSY); + int sleeptime = 10; + + do { + if (cancelled(dev)) + return 0; + if (!dev_cmd(dev, cmd)) { + dev->state = SANE_STATUS_IO_ERROR; + return 0; + } else if (dev->state) { + if (dev->state != SANE_STATUS_DEVICE_BUSY) + return 0; + else { + if (dev->non_blocking) { + dev->state = SANE_STATUS_GOOD; + return 0; + } else { + if (sleeptime > 1000) + sleeptime = 1000; + 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) + sleeptime *= (sleeptime < 100)? 10 : 2; + } + } /* BUSY */ + } + } while (dev->state == SANE_STATUS_DEVICE_BUSY); - return 1; + return 1; } static int inq_dpi_bits[] = { - 75, 150, 0, 0, - 200, 300, 0, 0, - 600, 0, 0, 1200, - 100, 0, 0, 2400, - 0, 4800, 0, 9600 + 75, 150, 0, 0, + 200, 300, 0, 0, + 600, 0, 0, 1200, + 100, 0, 0, 2400, + 0, 4800, 0, 9600 }; static int res_dpi_codes[] = { - 75, 0, 150, 0, - 0, 300, 0, 600, - 1200, 200, 100, 2400, - 4800, 9600 + 75, 0, 150, 0, + 0, 300, 0, 600, + 1200, 200, 100, 2400, + 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; + return *(const SANE_Word *)a - *(const SANE_Word *)b; } /* resolve inquired dpi list to dpi_list array */ static void resolv_inq_dpi(struct device *dev) { - unsigned int i; - int res = dev->resolutions; - - assert(sizeof(inq_dpi_bits) < sizeof(dev->dpi_list)); - for (i = 0; i < sizeof(inq_dpi_bits) / sizeof(int); i++) - if (inq_dpi_bits[i] && (res & (1 << i))) - dev->dpi_list[++dev->dpi_list[0]] = inq_dpi_bits[i]; - qsort(&dev->dpi_list[1], dev->dpi_list[0], sizeof(SANE_Word), SANE_Word_sort); + unsigned int i; + int res = dev->resolutions; + + assert(sizeof(inq_dpi_bits) < sizeof(dev->dpi_list)); + for (i = 0; i < sizeof(inq_dpi_bits) / sizeof(int); i++) + if (inq_dpi_bits[i] && (res & (1 << i))) + dev->dpi_list[++dev->dpi_list[0]] = inq_dpi_bits[i]; + qsort(&dev->dpi_list[1], dev->dpi_list[0], sizeof(SANE_Word), SANE_Word_sort); } static unsigned int dpi_to_code(int dpi) { - unsigned int i; + unsigned int i; - for (i = 0; i < sizeof(res_dpi_codes) / sizeof(int); i++) { - if (dpi == res_dpi_codes[i]) - return i; - } - return 0; + for (i = 0; i < sizeof(res_dpi_codes) / sizeof(int); i++) { + if (dpi == res_dpi_codes[i]) + return i; + } + return 0; } static int string_match_index(const SANE_String_Const s[], SANE_String m) { - int i; - - for (i = 0; *s; i++) { - SANE_String_Const x = *s++; - if (strcasecmp(x, m) == 0) - return i; - } - return 0; + int i; + + for (i = 0; *s; i++) { + SANE_String_Const x = *s++; + if (strcasecmp(x, m) == 0) + return i; + } + return 0; } static SANE_String string_match(const SANE_String_Const s[], SANE_String m) { - return UNCONST(s[string_match_index(s, 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; - - while (*s) { - size_t size = strlen(*s++) + 1; - if (size > max) - max = size; - } - return max; + size_t max = 0; + + while (*s) { + size_t size = strlen(*s++) + 1; + if (size > max) + max = size; + } + return max; } static SANE_String_Const doc_sources[] = { - "Flatbed", "ADF", "Auto", NULL + "Flatbed", "ADF", "Auto", NULL }; static int doc_source_to_code[] = { - 0x40, 0x20, 0x80 + 0x40, 0x20, 0x80 }; static SANE_String_Const scan_modes[] = { - SANE_VALUE_SCAN_MODE_LINEART, - SANE_VALUE_SCAN_MODE_HALFTONE, - SANE_VALUE_SCAN_MODE_GRAY, - SANE_VALUE_SCAN_MODE_COLOR, - NULL + SANE_VALUE_SCAN_MODE_LINEART, + SANE_VALUE_SCAN_MODE_HALFTONE, + SANE_VALUE_SCAN_MODE_GRAY, + SANE_VALUE_SCAN_MODE_COLOR, + NULL }; static int scan_mode_to_code[] = { - 0x00, 0x01, 0x03, 0x05 + 0x00, 0x01, 0x03, 0x05 }; static SANE_Range threshold = { - SANE_FIX(30), SANE_FIX(70), SANE_FIX(10) + SANE_FIX(30), SANE_FIX(70), SANE_FIX(10) }; static void reset_options(struct device *dev) { - dev->val[OPT_RESOLUTION].w = 150; - dev->val[OPT_MODE].s = string_match(scan_modes, SANE_VALUE_SCAN_MODE_COLOR); - - /* if docs loaded in adf use it as default source, flatbed oterwise */ - dev->val[OPT_SOURCE].s = UNCONST(doc_sources[(dev->doc_loaded)? 1 : 0]); - - dev->val[OPT_THRESHOLD].w = SANE_FIX(50); - - /* this is reported maximum window size, will be fixed later */ - dev->win_x_range.min = SANE_FIX(0); - dev->win_x_range.max = SANE_FIX((double)dev->max_win_width / PNT_PER_MM); - dev->win_x_range.quant = SANE_FIX(1); - dev->win_y_range.min = SANE_FIX(0); - dev->win_y_range.max = SANE_FIX((double)dev->max_win_len / PNT_PER_MM); - dev->win_y_range.quant = SANE_FIX(1); - dev->val[OPT_SCAN_TL_X].w = dev->win_x_range.min; - dev->val[OPT_SCAN_TL_Y].w = dev->win_y_range.min; - dev->val[OPT_SCAN_BR_X].w = dev->win_x_range.max; - dev->val[OPT_SCAN_BR_Y].w = dev->win_y_range.max; + dev->val[OPT_RESOLUTION].w = 150; + dev->val[OPT_MODE].s = string_match(scan_modes, SANE_VALUE_SCAN_MODE_COLOR); + + /* if docs loaded in adf use it as default source, flatbed oterwise */ + dev->val[OPT_SOURCE].s = UNCONST(doc_sources[(dev->doc_loaded)? 1 : 0]); + + dev->val[OPT_THRESHOLD].w = SANE_FIX(50); + + /* this is reported maximum window size, will be fixed later */ + dev->win_x_range.min = SANE_FIX(0); + dev->win_x_range.max = SANE_FIX((double)dev->max_win_width / PNT_PER_MM); + dev->win_x_range.quant = SANE_FIX(1); + dev->win_y_range.min = SANE_FIX(0); + dev->win_y_range.max = SANE_FIX((double)dev->max_win_len / PNT_PER_MM); + dev->win_y_range.quant = SANE_FIX(1); + dev->val[OPT_SCAN_TL_X].w = dev->win_x_range.min; + dev->val[OPT_SCAN_TL_Y].w = dev->win_y_range.min; + dev->val[OPT_SCAN_BR_X].w = dev->win_x_range.max; + dev->val[OPT_SCAN_BR_Y].w = dev->win_y_range.max; } static void init_options(struct device *dev) { - int i; - - for (i = 0; i < NUM_OPTIONS; i++) { - dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; - dev->opt[i].size = sizeof(SANE_Word); - dev->opt[i].type = SANE_TYPE_FIXED; - dev->val[i].s = NULL; - } - - dev->opt[OPT_NUMOPTIONS].name = SANE_NAME_NUM_OPTIONS; - dev->opt[OPT_NUMOPTIONS].title = SANE_TITLE_NUM_OPTIONS; - dev->opt[OPT_NUMOPTIONS].desc = SANE_DESC_NUM_OPTIONS; - dev->opt[OPT_NUMOPTIONS].type = SANE_TYPE_INT; - dev->opt[OPT_NUMOPTIONS].cap = SANE_CAP_SOFT_DETECT; - dev->val[OPT_NUMOPTIONS].w = NUM_OPTIONS; - - dev->opt[OPT_GROUP_STD].name = SANE_NAME_STANDARD; - dev->opt[OPT_GROUP_STD].title = SANE_TITLE_STANDARD; - dev->opt[OPT_GROUP_STD].desc = SANE_DESC_STANDARD; - dev->opt[OPT_GROUP_STD].type = SANE_TYPE_GROUP; - dev->opt[OPT_GROUP_STD].cap = 0; - - dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; - dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; - dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; - dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT; - dev->opt[OPT_RESOLUTION].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT; - dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; - dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST; - dev->opt[OPT_RESOLUTION].constraint.word_list = dev->dpi_list; - - dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE; - dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE; - dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE; - dev->opt[OPT_MODE].type = SANE_TYPE_STRING; - dev->opt[OPT_MODE].size = max_string_size(scan_modes); - dev->opt[OPT_MODE].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT; - dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; - dev->opt[OPT_MODE].constraint.string_list = scan_modes; - - dev->opt[OPT_THRESHOLD].name = SANE_NAME_HIGHLIGHT; - dev->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD; - dev->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD; - dev->opt[OPT_THRESHOLD].unit = SANE_UNIT_PERCENT; - dev->opt[OPT_THRESHOLD].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT; - dev->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_THRESHOLD].constraint.range = &threshold; - - dev->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE; - dev->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE; - dev->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE; - dev->opt[OPT_SOURCE].type = SANE_TYPE_STRING; - dev->opt[OPT_SOURCE].size = max_string_size(doc_sources); - dev->opt[OPT_SOURCE].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT; - dev->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST; - dev->opt[OPT_SOURCE].constraint.string_list = doc_sources; - - dev->opt[OPT_GROUP_GEO].name = SANE_NAME_GEOMETRY; - dev->opt[OPT_GROUP_GEO].title = SANE_TITLE_GEOMETRY; - dev->opt[OPT_GROUP_GEO].desc = SANE_DESC_GEOMETRY; - dev->opt[OPT_GROUP_GEO].type = SANE_TYPE_GROUP; - dev->opt[OPT_GROUP_GEO].cap = 0; - - dev->opt[OPT_SCAN_TL_X].name = SANE_NAME_SCAN_TL_X; - dev->opt[OPT_SCAN_TL_X].title = SANE_TITLE_SCAN_TL_X; - dev->opt[OPT_SCAN_TL_X].desc = SANE_DESC_SCAN_TL_X; - dev->opt[OPT_SCAN_TL_X].unit = SANE_UNIT_MM; - dev->opt[OPT_SCAN_TL_X].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_SCAN_TL_X].constraint.range = &dev->win_x_range; - - dev->opt[OPT_SCAN_TL_Y].name = SANE_NAME_SCAN_TL_Y; - dev->opt[OPT_SCAN_TL_Y].title = SANE_TITLE_SCAN_TL_Y; - dev->opt[OPT_SCAN_TL_Y].desc = SANE_DESC_SCAN_TL_Y; - dev->opt[OPT_SCAN_TL_Y].unit = SANE_UNIT_MM; - dev->opt[OPT_SCAN_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_SCAN_TL_Y].constraint.range = &dev->win_y_range; - - dev->opt[OPT_SCAN_BR_X].name = SANE_NAME_SCAN_BR_X; - dev->opt[OPT_SCAN_BR_X].title = SANE_TITLE_SCAN_BR_X; - dev->opt[OPT_SCAN_BR_X].desc = SANE_DESC_SCAN_BR_X; - dev->opt[OPT_SCAN_BR_X].unit = SANE_UNIT_MM; - dev->opt[OPT_SCAN_BR_X].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_SCAN_BR_X].constraint.range = &dev->win_x_range; - - dev->opt[OPT_SCAN_BR_Y].name = SANE_NAME_SCAN_BR_Y; - dev->opt[OPT_SCAN_BR_Y].title = SANE_TITLE_SCAN_BR_Y; - dev->opt[OPT_SCAN_BR_Y].desc = SANE_DESC_SCAN_BR_Y; - dev->opt[OPT_SCAN_BR_Y].unit = SANE_UNIT_MM; - dev->opt[OPT_SCAN_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE; - dev->opt[OPT_SCAN_BR_Y].constraint.range = &dev->win_y_range; + int i; + + for (i = 0; i < NUM_OPTIONS; i++) { + dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + dev->opt[i].size = sizeof(SANE_Word); + dev->opt[i].type = SANE_TYPE_FIXED; + dev->val[i].s = NULL; + } + + dev->opt[OPT_NUMOPTIONS].name = SANE_NAME_NUM_OPTIONS; + dev->opt[OPT_NUMOPTIONS].title = SANE_TITLE_NUM_OPTIONS; + dev->opt[OPT_NUMOPTIONS].desc = SANE_DESC_NUM_OPTIONS; + dev->opt[OPT_NUMOPTIONS].type = SANE_TYPE_INT; + dev->opt[OPT_NUMOPTIONS].cap = SANE_CAP_SOFT_DETECT; + dev->val[OPT_NUMOPTIONS].w = NUM_OPTIONS; + + dev->opt[OPT_GROUP_STD].name = SANE_NAME_STANDARD; + dev->opt[OPT_GROUP_STD].title = SANE_TITLE_STANDARD; + dev->opt[OPT_GROUP_STD].desc = SANE_DESC_STANDARD; + dev->opt[OPT_GROUP_STD].type = SANE_TYPE_GROUP; + dev->opt[OPT_GROUP_STD].cap = 0; + + dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; + dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; + dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; + dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT; + dev->opt[OPT_RESOLUTION].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT; + dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; + dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST; + dev->opt[OPT_RESOLUTION].constraint.word_list = dev->dpi_list; + + dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE; + dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE; + dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE; + dev->opt[OPT_MODE].type = SANE_TYPE_STRING; + dev->opt[OPT_MODE].size = max_string_size(scan_modes); + dev->opt[OPT_MODE].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT; + dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_MODE].constraint.string_list = scan_modes; + + dev->opt[OPT_THRESHOLD].name = SANE_NAME_HIGHLIGHT; + dev->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD; + dev->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD; + dev->opt[OPT_THRESHOLD].unit = SANE_UNIT_PERCENT; + dev->opt[OPT_THRESHOLD].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT; + dev->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_THRESHOLD].constraint.range = &threshold; + + dev->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE; + dev->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE; + dev->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE; + dev->opt[OPT_SOURCE].type = SANE_TYPE_STRING; + dev->opt[OPT_SOURCE].size = max_string_size(doc_sources); + dev->opt[OPT_SOURCE].cap = SANE_CAP_SOFT_SELECT|SANE_CAP_SOFT_DETECT; + dev->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + dev->opt[OPT_SOURCE].constraint.string_list = doc_sources; + + dev->opt[OPT_GROUP_GEO].name = SANE_NAME_GEOMETRY; + dev->opt[OPT_GROUP_GEO].title = SANE_TITLE_GEOMETRY; + dev->opt[OPT_GROUP_GEO].desc = SANE_DESC_GEOMETRY; + dev->opt[OPT_GROUP_GEO].type = SANE_TYPE_GROUP; + dev->opt[OPT_GROUP_GEO].cap = 0; + + dev->opt[OPT_SCAN_TL_X].name = SANE_NAME_SCAN_TL_X; + dev->opt[OPT_SCAN_TL_X].title = SANE_TITLE_SCAN_TL_X; + dev->opt[OPT_SCAN_TL_X].desc = SANE_DESC_SCAN_TL_X; + dev->opt[OPT_SCAN_TL_X].unit = SANE_UNIT_MM; + dev->opt[OPT_SCAN_TL_X].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_SCAN_TL_X].constraint.range = &dev->win_x_range; + + dev->opt[OPT_SCAN_TL_Y].name = SANE_NAME_SCAN_TL_Y; + dev->opt[OPT_SCAN_TL_Y].title = SANE_TITLE_SCAN_TL_Y; + dev->opt[OPT_SCAN_TL_Y].desc = SANE_DESC_SCAN_TL_Y; + dev->opt[OPT_SCAN_TL_Y].unit = SANE_UNIT_MM; + dev->opt[OPT_SCAN_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_SCAN_TL_Y].constraint.range = &dev->win_y_range; + + dev->opt[OPT_SCAN_BR_X].name = SANE_NAME_SCAN_BR_X; + dev->opt[OPT_SCAN_BR_X].title = SANE_TITLE_SCAN_BR_X; + dev->opt[OPT_SCAN_BR_X].desc = SANE_DESC_SCAN_BR_X; + dev->opt[OPT_SCAN_BR_X].unit = SANE_UNIT_MM; + dev->opt[OPT_SCAN_BR_X].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_SCAN_BR_X].constraint.range = &dev->win_x_range; + + dev->opt[OPT_SCAN_BR_Y].name = SANE_NAME_SCAN_BR_Y; + dev->opt[OPT_SCAN_BR_Y].title = SANE_TITLE_SCAN_BR_Y; + dev->opt[OPT_SCAN_BR_Y].desc = SANE_DESC_SCAN_BR_Y; + dev->opt[OPT_SCAN_BR_Y].unit = SANE_UNIT_MM; + dev->opt[OPT_SCAN_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_SCAN_BR_Y].constraint.range = &dev->win_y_range; } /* fill parameters from options */ static void set_parameters(struct device *dev) { - double px_to_len; + double px_to_len; - dev->para.last_frame = SANE_TRUE; - dev->para.lines = -1; - px_to_len = 1200.0 / dev->val[OPT_RESOLUTION].w; + dev->para.last_frame = SANE_TRUE; + dev->para.lines = -1; + px_to_len = 1200.0 / dev->val[OPT_RESOLUTION].w; #define BETTER_BASEDPI 1 - /* tests prove that 1200dpi base is very inexact - * so I calculated better values for each axis */ -#if BETTER_BASEDPI - px_to_len = 1180.0 / dev->val[OPT_RESOLUTION].w; -#endif - dev->para.pixels_per_line = dev->win_width / px_to_len; - dev->para.bytes_per_line = dev->para.pixels_per_line; + /* tests prove that 1200dpi base is very inexact + * so I calculated better values for each axis */ #if BETTER_BASEDPI - px_to_len = 1213.9 / dev->val[OPT_RESOLUTION].w; + px_to_len = 1180.0 / dev->val[OPT_RESOLUTION].w; #endif - dev->para.lines = dev->win_len / px_to_len; - if (dev->composition == MODE_LINEART || - dev->composition == MODE_HALFTONE) { - dev->para.format = SANE_FRAME_GRAY; - dev->para.depth = 1; - dev->para.bytes_per_line = (dev->para.pixels_per_line + 7) / 8; - } else if (dev->composition == MODE_GRAY8) { - dev->para.format = SANE_FRAME_GRAY; - dev->para.depth = 8; + dev->para.pixels_per_line = dev->win_width / px_to_len; dev->para.bytes_per_line = dev->para.pixels_per_line; - } else if (dev->composition == MODE_RGB24) { - dev->para.format = SANE_FRAME_RGB; - dev->para.depth = 8; - dev->para.bytes_per_line *= 3; - } else { - /* this will never happen */ - DBG (1, "%s: impossible image composition %d\n", - __FUNCTION__, dev->composition); - dev->para.format = SANE_FRAME_GRAY; - dev->para.depth = 8; - } + + if (!isSupportedDevice(dev)) { +#if BETTER_BASEDPI + px_to_len = 1213.9 / dev->val[OPT_RESOLUTION].w; +#endif + } + dev->para.lines = dev->win_len / px_to_len; + if (dev->composition == MODE_LINEART || + dev->composition == MODE_HALFTONE) { + dev->para.format = SANE_FRAME_GRAY; + dev->para.depth = 1; + dev->para.bytes_per_line = (dev->para.pixels_per_line + 7) / 8; + } else if (dev->composition == MODE_GRAY8) { + dev->para.format = SANE_FRAME_GRAY; + dev->para.depth = 8; + dev->para.bytes_per_line = dev->para.pixels_per_line; + } else if (dev->composition == MODE_RGB24) { + dev->para.format = SANE_FRAME_RGB; + dev->para.depth = 8; + dev->para.bytes_per_line *= 3; + } else { + /* this will never happen */ + DBG(1, "%s: impossible image composition %d\n", + __func__, dev->composition); + dev->para.format = SANE_FRAME_GRAY; + dev->para.depth = 8; + } } /* resolve all options related to scan window */ /* called after option changed and in set_window */ static int fix_window(struct device *dev) { - double win_width_mm, win_len_mm; - int i; - int threshold = SANE_UNFIX(dev->val[OPT_THRESHOLD].w); - - dev->resolution = dpi_to_code(dev->val[OPT_RESOLUTION].w); - dev->composition = scan_mode_to_code[string_match_index(scan_modes, dev->val[OPT_MODE].s)]; - - if (dev->composition == MODE_LINEART || - dev->composition == MODE_HALFTONE) { - dev->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; - } else { - dev->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; - } - if (threshold < 30) { - dev->val[OPT_THRESHOLD].w = SANE_FIX(30); - } else if (threshold > 70) { - dev->val[OPT_THRESHOLD].w = SANE_FIX(70); - } - threshold = SANE_UNFIX(dev->val[OPT_THRESHOLD].w); - dev->threshold = (threshold - 30) / 10; - dev->val[OPT_THRESHOLD].w = SANE_FIX(dev->threshold * 10 + 30); - - dev->doc_source = doc_source_to_code[string_match_index(doc_sources, dev->val[OPT_SOURCE].s)]; - - /* max window len is dependent of document source */ - if (dev->doc_source == DOC_FLATBED || - (dev->doc_source == DOC_AUTO && !dev->doc_loaded)) - dev->max_len = dev->max_len_fb; - else - dev->max_len = dev->max_len_adf; - - /* parameters */ - dev->win_y_range.max = SANE_FIX((double)dev->max_len / PNT_PER_MM); - - /* window sanity checking */ - for (i = OPT_SCAN_TL_X; i <= OPT_SCAN_BR_Y; i++) { - if (dev->val[i].w < dev->opt[i].constraint.range->min) - dev->val[i].w = dev->opt[i].constraint.range->min; - if (dev->val[i].w > dev->opt[i].constraint.range->max) - dev->val[i].w = dev->opt[i].constraint.range->max; - } - - if (dev->val[OPT_SCAN_TL_X].w > dev->val[OPT_SCAN_BR_X].w) - SWAP_Word(dev->val[OPT_SCAN_TL_X].w, dev->val[OPT_SCAN_BR_X].w); - if (dev->val[OPT_SCAN_TL_Y].w > dev->val[OPT_SCAN_BR_Y].w) - SWAP_Word(dev->val[OPT_SCAN_TL_Y].w, dev->val[OPT_SCAN_BR_Y].w); - - /* recalculate millimeters to inches */ - dev->win_off_x = SANE_UNFIX(dev->val[OPT_SCAN_TL_X].w) / MM_PER_INCH; - dev->win_off_y = SANE_UNFIX(dev->val[OPT_SCAN_TL_Y].w) / MM_PER_INCH; - - /* calc win size in mm */ - win_width_mm = SANE_UNFIX(dev->val[OPT_SCAN_BR_X].w) - - SANE_UNFIX(dev->val[OPT_SCAN_TL_X].w); - win_len_mm = SANE_UNFIX(dev->val[OPT_SCAN_BR_Y].w) - - SANE_UNFIX(dev->val[OPT_SCAN_TL_Y].w); - /* convert mm to 1200 dpi points */ - dev->win_width = (int)(win_width_mm * PNT_PER_MM); - dev->win_len = (int)(win_len_mm * PNT_PER_MM); - - /* don't scan if window is zero size */ - if (!dev->win_width || !dev->win_len) { - /* "The scan cannot be started with the current set of options." */ - dev->state = SANE_STATUS_INVAL; - return 0; - } + double win_width_mm, win_len_mm; + int i; + int threshold = SANE_UNFIX(dev->val[OPT_THRESHOLD].w); - return 1; -} + dev->resolution = dpi_to_code(dev->val[OPT_RESOLUTION].w); + dev->composition = scan_mode_to_code[string_match_index(scan_modes, dev->val[OPT_MODE].s)]; -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 - }; + if (dev->composition == MODE_LINEART || + dev->composition == MODE_HALFTONE) { + dev->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; + } else { + dev->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; + } + if (threshold < 30) { + dev->val[OPT_THRESHOLD].w = SANE_FIX(30); + } else if (threshold > 70) { + dev->val[OPT_THRESHOLD].w = SANE_FIX(70); + } + threshold = SANE_UNFIX(dev->val[OPT_THRESHOLD].w); + dev->threshold = (threshold - 30) / 10; + dev->val[OPT_THRESHOLD].w = SANE_FIX(dev->threshold * 10 + 30); - if (!fix_window(dev)) - return 0; + dev->doc_source = doc_source_to_code[string_match_index(doc_sources, dev->val[OPT_SOURCE].s)]; + + /* max window len is dependent of document source */ + if (dev->doc_source == DOC_FLATBED || + (dev->doc_source == DOC_AUTO && !dev->doc_loaded)) + dev->max_len = dev->max_len_fb; + else + dev->max_len = dev->max_len_adf; + + /* parameters */ + dev->win_y_range.max = SANE_FIX((double)dev->max_len / PNT_PER_MM); + + /* window sanity checking */ + for (i = OPT_SCAN_TL_X; i <= OPT_SCAN_BR_Y; i++) { + if (dev->val[i].w < dev->opt[i].constraint.range->min) + dev->val[i].w = dev->opt[i].constraint.range->min; + if (dev->val[i].w > dev->opt[i].constraint.range->max) + dev->val[i].w = dev->opt[i].constraint.range->max; + } + + if (dev->val[OPT_SCAN_TL_X].w > dev->val[OPT_SCAN_BR_X].w) + SWAP_Word(dev->val[OPT_SCAN_TL_X].w, dev->val[OPT_SCAN_BR_X].w); + if (dev->val[OPT_SCAN_TL_Y].w > dev->val[OPT_SCAN_BR_Y].w) + SWAP_Word(dev->val[OPT_SCAN_TL_Y].w, dev->val[OPT_SCAN_BR_Y].w); + + /* recalculate millimeters to inches */ + dev->win_off_x = SANE_UNFIX(dev->val[OPT_SCAN_TL_X].w) / MM_PER_INCH; + dev->win_off_y = SANE_UNFIX(dev->val[OPT_SCAN_TL_Y].w) / MM_PER_INCH; + + /* calc win size in mm */ + win_width_mm = SANE_UNFIX(dev->val[OPT_SCAN_BR_X].w) - + SANE_UNFIX(dev->val[OPT_SCAN_TL_X].w); + win_len_mm = SANE_UNFIX(dev->val[OPT_SCAN_BR_Y].w) - + SANE_UNFIX(dev->val[OPT_SCAN_TL_Y].w); + /* convert mm to 1200 dpi points */ + dev->win_width = (int)(win_width_mm * PNT_PER_MM); + dev->win_len = (int)(win_len_mm * PNT_PER_MM); + + /* don't scan if window is zero size */ + if (!dev->win_width || !dev->win_len) { + /* "The scan cannot be started with the current set of options." */ + dev->state = SANE_STATUS_INVAL; + return 0; + } - cmd[0x05] = dev->win_width >> 24; - cmd[0x06] = dev->win_width >> 16; - cmd[0x07] = dev->win_width >> 8; - cmd[0x08] = dev->win_width; - cmd[0x09] = dev->win_len >> 24; - cmd[0x0a] = dev->win_len >> 16; - cmd[0x0b] = dev->win_len >> 8; - cmd[0x0c] = dev->win_len; - cmd[0x0d] = dev->resolution; /* x */ - cmd[0x0e] = dev->resolution; /* y */ - cmd[0x0f] = (SANE_Byte)floor(dev->win_off_x); - cmd[0x10] = (SANE_Byte)((dev->win_off_x - floor(dev->win_off_x)) * 100); - cmd[0x11] = (SANE_Byte)floor(dev->win_off_y); - cmd[0x12] = (SANE_Byte)((dev->win_off_y - floor(dev->win_off_y)) * 100); - cmd[0x13] = dev->composition; - cmd[0x16] = dev->threshold; - cmd[0x17] = dev->doc_source; - - 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], - cmd[0x05], cmd[0x06], cmd[0x07], cmd[0x08], - cmd[0x09], cmd[0x0a], cmd[0x0b], cmd[0x0c], - dev->max_win_width, dev->max_win_len); - - return dev_command (dev, cmd, 32); + return 1; +} + +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 + }; + + if (!fix_window(dev)) + return 0; + + cmd[0x05] = dev->win_width >> 24; + cmd[0x06] = dev->win_width >> 16; + cmd[0x07] = dev->win_width >> 8; + cmd[0x08] = dev->win_width; + cmd[0x09] = dev->win_len >> 24; + cmd[0x0a] = dev->win_len >> 16; + cmd[0x0b] = dev->win_len >> 8; + cmd[0x0c] = dev->win_len; + cmd[0x0d] = dev->resolution; /* x */ + cmd[0x0e] = dev->resolution; /* y */ + cmd[0x0f] = (SANE_Byte)floor(dev->win_off_x); + cmd[0x10] = (SANE_Byte)((dev->win_off_x - floor(dev->win_off_x)) * 100); + cmd[0x11] = (SANE_Byte)floor(dev->win_off_y); + cmd[0x12] = (SANE_Byte)((dev->win_off_y - floor(dev->win_off_y)) * 100); + cmd[0x13] = dev->composition; + /* 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)) { + cmd[0x14] = 0x6; + } + } + cmd[0x16] = dev->threshold; + cmd[0x17] = dev->doc_source; + + 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], + cmd[0x05], cmd[0x06], cmd[0x07], cmd[0x08], + cmd[0x09], cmd[0x0a], cmd[0x0b], cmd[0x0c], + dev->max_win_width, dev->max_win_len); + + 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)) - return SANE_STATUS_IO_ERROR; - ptr = dev->res; - if (ptr[3] != MSG_PRODUCT_INFO) { - DBG (1, "%s: illegal INQUIRY response %02x\n", __FUNCTION__, ptr[3]); - return SANE_STATUS_IO_ERROR; - } - - /* parse reported manufacturer/product names */ - dev->sane.vendor = optr = (SANE_Char *) malloc (33); - for (ptr += 4; ptr < &dev->res[0x24] && *ptr && *ptr != ' ';) - *optr++ = *ptr++; - *optr++ = 0; - - for (; ptr < &dev->res[0x24] && (!*ptr || *ptr == ' '); ptr++) - /* skip spaces */; - - dev->sane.model = optr = (SANE_Char *) malloc (33); - xptr = optr; /* is last non space character + 1 */ - for (; ptr < &dev->res[0x24] && *ptr;) { - if (*ptr != ' ') - xptr = optr + 1; - *optr++ = *ptr++; - } - *optr++ = 0; - *xptr = 0; - - DBG (1, "%s: found %s/%s\n", __FUNCTION__, dev->sane.vendor, dev->sane.model); - dev->sane.type = strdup ("multi-function peripheral"); - - dev->resolutions = dev->res[0x37] << 16 | - dev->res[0x24] << 8 | - dev->res[0x25]; - dev->compositions = dev->res[0x27]; - dev->max_win_width = dev->res[0x28] << 24 | - dev->res[0x29] << 16 | - dev->res[0x2a] << 8 | - dev->res[0x2b]; - dev->max_win_len = dev->res[0x2c] << 24 | - dev->res[0x2d] << 16 | - dev->res[0x2e] << 8 | - dev->res[0x2f]; - dev->max_len_adf = dev->res[0x38] << 24 | - dev->res[0x39] << 16 | - dev->res[0x3a] << 8 | - dev->res[0x3b]; - dev->max_len_fb = dev->res[0x3c] << 24 | - dev->res[0x3d] << 16 | - dev->res[0x3e] << 8 | - dev->res[0x3f]; - dev->line_order = dev->res[0x31]; - dev->doc_loaded = (dev->res[0x35] == 0x02) && - (dev->res[0x26] & 0x03); - - init_options(dev); - reset_options(dev); - fix_window(dev); - set_parameters(dev); - resolv_inq_dpi(dev); - - return SANE_STATUS_GOOD; + SANE_Byte *ptr; + SANE_Char *optr, *xptr; + + 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]); + return SANE_STATUS_IO_ERROR; + } + + /* parse reported manufacturer/product names */ + dev->sane.vendor = optr = (SANE_Char *) malloc(33); + for (ptr += 4; ptr < &dev->res[0x24] && *ptr && *ptr != ' ';) + *optr++ = *ptr++; + *optr++ = 0; + + for (; ptr < &dev->res[0x24] && (!*ptr || *ptr == ' '); ptr++) + /* skip spaces */; + + dev->sane.model = optr = (SANE_Char *) malloc(33); + xptr = optr; /* is last non space character + 1 */ + for (; ptr < &dev->res[0x24] && *ptr;) { + if (*ptr != ' ') + xptr = optr + 1; + *optr++ = *ptr++; + } + *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"); + + dev->resolutions = dev->res[0x37] << 16 | + dev->res[0x24] << 8 | + dev->res[0x25]; + dev->compositions = dev->res[0x27]; + dev->max_win_width = dev->res[0x28] << 24 | + dev->res[0x29] << 16 | + dev->res[0x2a] << 8 | + dev->res[0x2b]; + dev->max_win_len = dev->res[0x2c] << 24 | + dev->res[0x2d] << 16 | + dev->res[0x2e] << 8 | + dev->res[0x2f]; + dev->max_len_adf = dev->res[0x38] << 24 | + dev->res[0x39] << 16 | + dev->res[0x3a] << 8 | + dev->res[0x3b]; + dev->max_len_fb = dev->res[0x3c] << 24 | + dev->res[0x3d] << 16 | + dev->res[0x3e] << 8 | + dev->res[0x3f]; + dev->line_order = dev->res[0x31]; + dev->compressionTypes = dev->res[0x32]; + dev->doc_loaded = (dev->res[0x35] == 0x02) && + (dev->res[0x26] & 0x03); + + init_options(dev); + reset_options(dev); + fix_window(dev); + set_parameters(dev); + resolv_inq_dpi(dev); + + return SANE_STATUS_GOOD; } 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; + struct device *dev = h; - DBG (3, "%s: %p, %d\n", __FUNCTION__, h, opt); - if (opt >= NUM_OPTIONS || opt < 0) - return NULL; - return &dev->opt[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", __FUNCTION__, h, opt, act, val, (void *)info); - if (!dev || opt >= NUM_OPTIONS || opt < 0) - return SANE_STATUS_INVAL; - - if (info) - *info = 0; - - if (act == SANE_ACTION_GET_VALUE) { /* GET */ - if (dev->opt[opt].type == SANE_TYPE_STRING) - strcpy(val, dev->val[opt].s); - else - *(SANE_Word *)val = dev->val[opt].w; - } else if (act == SANE_ACTION_SET_VALUE) { /* SET */ - SANE_Parameters xpara = dev->para; - SANE_Option_Descriptor xopt[NUM_OPTIONS]; - Option_Value xval[NUM_OPTIONS]; - int i; - - if (dev->opt[opt].constraint_type == SANE_CONSTRAINT_STRING_LIST) { - dev->val[opt].s = string_match(dev->opt[opt].constraint.string_list, val); - if (info && strcasecmp(dev->val[opt].s, val)) - *info |= SANE_INFO_INEXACT; - } else if (opt == OPT_RESOLUTION) - dev->val[opt].w = res_dpi_codes[dpi_to_code(*(SANE_Word *)val)]; - else - dev->val[opt].w = *(SANE_Word *)val; - - memcpy(&xopt, &dev->opt, sizeof(xopt)); - memcpy(&xval, &dev->val, sizeof(xval)); - fix_window(dev); - set_parameters(dev); - - /* check for side effects */ - if (info) { - if (memcmp(&xpara, &dev->para, sizeof(xpara))) - *info |= SANE_INFO_RELOAD_PARAMS; - if (memcmp(&xopt, &dev->opt, sizeof(xopt))) - *info |= SANE_INFO_RELOAD_OPTIONS; - for (i = 0; i < NUM_OPTIONS; i++) - if (xval[i].w != dev->val[i].w) { - if (i == opt) - *info |= SANE_INFO_INEXACT; - else - *info |= SANE_INFO_RELOAD_OPTIONS; - } + struct device *dev = h; + + 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; + + if (info) + *info = 0; + + if (act == SANE_ACTION_GET_VALUE) { /* GET */ + if (dev->opt[opt].type == SANE_TYPE_STRING) + strcpy(val, dev->val[opt].s); + else + *(SANE_Word *)val = dev->val[opt].w; + } else if (act == SANE_ACTION_SET_VALUE) { /* SET */ + SANE_Parameters xpara = dev->para; + SANE_Option_Descriptor xopt[NUM_OPTIONS]; + Option_Value xval[NUM_OPTIONS]; + int i; + + if (dev->opt[opt].constraint_type == SANE_CONSTRAINT_STRING_LIST) { + dev->val[opt].s = string_match(dev->opt[opt].constraint.string_list, val); + if (info && strcasecmp(dev->val[opt].s, val)) + *info |= SANE_INFO_INEXACT; + } else if (opt == OPT_RESOLUTION) + dev->val[opt].w = res_dpi_codes[dpi_to_code(*(SANE_Word *)val)]; + else + dev->val[opt].w = *(SANE_Word *)val; + + memcpy(&xopt, &dev->opt, sizeof(xopt)); + memcpy(&xval, &dev->val, sizeof(xval)); + fix_window(dev); + set_parameters(dev); + + /* check for side effects */ + if (info) { + if (memcmp(&xpara, &dev->para, sizeof(xpara))) + *info |= SANE_INFO_RELOAD_PARAMS; + if (memcmp(&xopt, &dev->opt, sizeof(xopt))) + *info |= SANE_INFO_RELOAD_OPTIONS; + for (i = 0; i < NUM_OPTIONS; i++) + if (xval[i].w != dev->val[i].w) { + if (i == opt) + *info |= SANE_INFO_INEXACT; + else + *info |= SANE_INFO_RELOAD_OPTIONS; + } + } } - } - DBG (4, "%s: %d, <%d> => %08x, %x\n", __FUNCTION__, opt, act, - val? *(SANE_Word *)val : 0, info? *info : 0); - return SANE_STATUS_GOOD; + 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)); - if (dev->sane.vendor) - free (UNCONST(dev->sane.vendor)); - if (dev->sane.model) - free (UNCONST(dev->sane.model)); - if (dev->sane.type) - free (UNCONST(dev->sane.type)); - if (dev->data) - free(dev->data); - memset (dev, 0, sizeof (*dev)); - free (dev); + if (!dev) + return; + + if (dev->sane.name) + free(UNCONST(dev->sane.name)); + if (dev->sane.vendor) + free(UNCONST(dev->sane.vendor)); + if (dev->sane.model) + free(UNCONST(dev->sane.model)); + if (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); } static void -free_devices (void) +free_devices(void) { - int i; - struct device *next; - struct device *dev; - - if (devlist) { - free (devlist); - devlist = NULL; - } - for (i = 0, dev = devices_head; dev; dev = next) { - next = dev->next; - dev_free (dev); - } - devices_head = NULL; + struct device *next; + struct device *dev; + + if (devlist) { + free(devlist); + devlist = NULL; + } + for (dev = devices_head; dev; dev = next) { + next = dev->next; + dev_free(dev); + } + devices_head = NULL; } static transport *tr_from_devname(SANE_String_Const devname) { - if (strncmp("tcp", devname, 3) == 0) - return &available_transports[TRANSPORT_TCP]; - return &available_transports[TRANSPORT_USB]; + if (strncmp("tcp", devname, 3) == 0) + return &available_transports[TRANSPORT_TCP]; + return &available_transports[TRANSPORT_USB]; } 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", __FUNCTION__, devname); - - for (dev = devices_head; dev; dev = dev->next) { - if (strcmp (dev->sane.name, devname) == 0) - return SANE_STATUS_GOOD; - } - - tr = tr_from_devname(devname); - - dev = calloc (1, sizeof (struct device)); - if (dev == NULL) - return SANE_STATUS_NO_MEM; - - dev->sane.name = strdup (devname); - dev->io = tr; - status = tr->dev_open (dev); - if (status != SANE_STATUS_GOOD) { - dev_free (dev); - return status; - } - -/* 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", __FUNCTION__, - dev->sane.name, sane_strstatus (status)); - dev_free (dev); - return status; - } - - /* good device, add it to list */ - dev->next = devices_head; - devices_head = dev; - return SANE_STATUS_GOOD; + struct device *dev; + SANE_Status status; + transport *tr; + + DBG(4, "%s: %s\n", __func__, devname); + + for (dev = devices_head; dev; dev = dev->next) { + if (strcmp(dev->sane.name, devname) == 0) + return SANE_STATUS_GOOD; + } + + tr = tr_from_devname(devname); + + dev = calloc(1, sizeof(struct device)); + if (dev == NULL) + return SANE_STATUS_NO_MEM; + + dev->sane.name = strdup(devname); + dev->io = tr; + status = tr->dev_open(dev); + if (status != SANE_STATUS_GOOD) { + dev_free(dev); + return status; + } + + /* 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); + return status; + } + + /* good device, add it to list */ + dev->next = devices_head; + devices_head = dev; + return SANE_STATUS_GOOD; } /* 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); + 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, - (version_code) ? "!=" : "==", (cb) ? "!=" : "=="); + 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); + if (version_code) + *version_code = SANE_VERSION_CODE(V_MAJOR, V_MINOR, BACKEND_BUILD); - sanei_usb_init (); - return SANE_STATUS_GOOD; + sanei_usb_init(); + return SANE_STATUS_GOOD; } void -sane_exit (void) +sane_exit(void) { - struct device *dev; + struct device *dev; + + for (dev = devices_head; dev; dev = dev->next) + if (dev->dn != -1) + sane_close(dev); /* implies flush */ - for (dev = devices_head; dev; dev = dev->next) - 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; + SANEI_Config config; + struct device *dev; + int dev_count; + int i; - DBG (3, "%s: %p, %d\n", __FUNCTION__, (const void *)device_list, local); + DBG(3, "%s: %p, %d\n", __func__, (const void *)device_list, local); - if (devlist) { - if (device_list) - *device_list = devlist; - return SANE_STATUS_GOOD; - } + if (devlist) { + if (device_list) + *device_list = devlist; + 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); + config.count = 0; + config.descriptors = NULL; + config.values = NULL; + sanei_configure_attach(XEROX_CONFIG_FILE, &config, list_conf_devices); - for (dev_count = 0, dev = devices_head; dev; dev = dev->next) - dev_count++; + 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", __FUNCTION__); - return SANE_STATUS_NO_MEM; + devlist = malloc((dev_count + 1) * sizeof(*devlist)); + if (!devlist) { + DBG(1, "%s: malloc: no memory\n", __func__); + return SANE_STATUS_NO_MEM; } - for (i = 0, dev = devices_head; dev; dev = dev->next) - devlist[i++] = &dev->sane; - devlist[i++] = NULL; + for (i = 0, dev = devices_head; dev; dev = dev->next) + devlist[i++] = &dev->sane; + devlist[i++] = NULL; - if (device_list) - *device_list = devlist; - return SANE_STATUS_GOOD; + if (device_list) + *device_list = devlist; + return SANE_STATUS_GOOD; } void -sane_close (SANE_Handle h) +sane_close(SANE_Handle h) { - struct device *dev = h; + struct device *dev = h; - if (!dev) - return; + if (!dev) + return; - DBG (3, "%s: %p (%s)\n", __FUNCTION__, (void *)dev, dev->sane.name); - dev->io->dev_close(dev); + 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", __FUNCTION__, name); - - if (!devlist) - 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) - return SANE_STATUS_GOOD; - } + struct device *dev; + + DBG(3, "%s: '%s'\n", __func__, name); + + if (!devlist) + 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) + return SANE_STATUS_GOOD; + } + } + } else { + for (dev = devices_head; dev; dev = dev->next) { + if (strcmp(name, dev->sane.name) == 0) { + *h = dev; + return dev->io->dev_open(dev); + } + } } - } else { - for (dev = devices_head; dev; dev = dev->next) { - if (strcmp(name, dev->sane.name) == 0) { - *h = dev; - return dev->io->dev_open(dev); - } - } - } - return SANE_STATUS_INVAL; + return SANE_STATUS_INVAL; } SANE_Status -sane_get_parameters (SANE_Handle h, SANE_Parameters * para) +sane_get_parameters(SANE_Handle h, SANE_Parameters *para) { - struct device *dev = h; + struct device *dev = h; - DBG (3, "%s: %p, %p\n", __FUNCTION__, h, (void *)para); - if (!para) - return SANE_STATUS_INVAL; + DBG(3, "%s: %p, %p\n", __func__, h, (void *)para); + if (!para) + return SANE_STATUS_INVAL; - *para = dev->para; - return SANE_STATUS_GOOD; + *para = dev->para; + return SANE_STATUS_GOOD; } /* check if image data is ready, and wait if not */ /* 1: image is acquired, 0: error or non_blocking mode */ static int dev_acquire(struct device *dev) { - if (!dev_cmd_wait(dev, CMD_READ)) - return dev->state; - - dev->state = SANE_STATUS_GOOD; - dev->vertical = dev->res[0x08] << 8 | dev->res[0x09]; - dev->horizontal = dev->res[0x0a] << 8 | dev->res[0x0b]; - dev->blocklen = dev->res[4] << 24 | - dev->res[5] << 16 | - dev->res[6] << 8 | - dev->res[7]; - dev->final_block = (dev->res[3] == MSG_END_BLOCK)? 1 : 0; - - dev->pixels_per_line = dev->horizontal; - dev->bytes_per_line = dev->horizontal; - - if (dev->composition == MODE_RGB24) - dev->bytes_per_line *= 3; - else if (dev->composition == MODE_LINEART || - dev->composition == MODE_HALFTONE) - dev->pixels_per_line *= 8; - - 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", - __FUNCTION__, dev->bytes_per_line, DATASIZE); - return ret_cancel(dev, SANE_STATUS_NO_MEM); - } - - dev->reading = 0; /* need to issue READ_IMAGE */ - - dev->dataindex = 0; - dev->datalen = 0; - dev->dataoff = 0; - - return 1; + if (!dev_cmd_wait(dev, CMD_READ)) + return dev->state; + + dev->state = SANE_STATUS_GOOD; + dev->vertical = dev->res[0x08] << 8 | dev->res[0x09]; + dev->horizontal = dev->res[0x0a] << 8 | dev->res[0x0b]; + dev->blocklen = dev->res[4] << 24 | + dev->res[5] << 16 | + dev->res[6] << 8 | + dev->res[7]; + dev->final_block = (dev->res[3] == MSG_END_BLOCK)? 1 : 0; + + dev->pixels_per_line = dev->horizontal; + dev->bytes_per_line = dev->horizontal; + + if (dev->composition == MODE_RGB24) + dev->bytes_per_line *= 3; + else if (dev->composition == MODE_LINEART || + dev->composition == MODE_HALFTONE) + dev->pixels_per_line *= 8; + + 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", + __func__, dev->bytes_per_line, DATASIZE); + return ret_cancel(dev, SANE_STATUS_NO_MEM); + } + + dev->reading = 0; /* need to issue READ_IMAGE */ + + dev->dataindex = 0; + dev->datalen = 0; + dev->dataoff = 0; + + return 1; } static int fill_slack(struct device *dev, SANE_Byte *buf, int maxlen) { - const int slack = dev->total_img_size - dev->total_out_size; - const int havelen = MIN(slack, maxlen); - int j; - - if (havelen <= 0) - return 0; - for (j = 0; j < havelen; j++) - buf[j] = 255; - return havelen; + const int slack = dev->total_img_size - dev->total_out_size; + const int havelen = MIN(slack, maxlen); + int j; + + if (havelen <= 0) + return 0; + for (j = 0; j < havelen; j++) + buf[j] = 255; + return havelen; } static int copy_plain_trim(struct device *dev, SANE_Byte *buf, int maxlen, int *olenp) { - int j; - const int linesize = dev->bytes_per_line; - int k = dev->dataindex; - *olenp = 0; - for (j = 0; j < dev->datalen && *olenp < maxlen; j++, k++) { - const int x = k % linesize; - const int y = k / linesize; - if (y >= dev->vertical) - break; /* slack */ - if (x < dev->para.bytes_per_line && - (y + dev->y_off) < dev->para.lines) { - *buf++ = dev->data[(dev->dataoff + j) & DATAMASK]; - (*olenp)++; + int j; + const int linesize = dev->bytes_per_line; + int k = dev->dataindex; + *olenp = 0; + for (j = 0; j < dev->datalen && *olenp < maxlen; j++, k++) { + const int x = k % linesize; + const int y = k / linesize; + if (y >= dev->vertical) + break; /* slack */ + if (x < dev->para.bytes_per_line && + (y + dev->y_off) < dev->para.lines) { + *buf++ = dev->data[(dev->dataoff + j) & DATAMASK]; + (*olenp)++; + } } - } - dev->dataindex = k; - return j; + dev->dataindex = k; + return j; } /* 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) { - int j; +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 */ + const int linesize = dev->bytes_per_line; /* caching real line size */ - /* line number of the head of input buffer, - * input buffer is always aligned to whole line */ - const int y_off = dev->dataindex / linesize; + /* line number of the head of input buffer, + * input buffer is always aligned to whole line */ + const int y_off = dev->dataindex / linesize; - int k = dev->dataindex; /* caching current index of input buffer */ + int k = dev->dataindex; /* caching current index of input buffer */ - /* can only copy as much as full lines we have */ - int havelen = dev->datalen / linesize * linesize - k % linesize; + /* can only copy as much as full lines we have */ + int havelen = dev->datalen / linesize * linesize - k % linesize; - const int bands = 3; - *olenp = 0; + const int bands = 3; + *olenp = 0; - /* while we have data && they can receive */ - for (j = 0; j < havelen && *olenp < maxlen; j++, k++) { - const int band = (k % bands) * dev->horizontal; - const int x = k % linesize / bands; - const int y = k / linesize - y_off; /* y relative to buffer head */ - const int y_rly = y + y_off + dev->y_off; /* global y */ + /* while we have data && they can receive */ + for (j = 0; j < havelen && *olenp < maxlen; j++, k++) { + const int band = (k % bands) * dev->horizontal; + const int x = k % linesize / bands; + const int y = k / linesize - y_off; /* y relative to buffer head */ + const int y_rly = y + y_off + dev->y_off; /* global y */ - if (x < dev->para.pixels_per_line && - y_rly < dev->para.lines) { - *buf++ = dev->data[(dev->dataoff + band + x + y * linesize) & DATAMASK]; - (*olenp)++; + if (x < dev->para.pixels_per_line && + y_rly < dev->para.lines) { + *buf++ = dev->data[(dev->dataoff + band + x + y * linesize) & DATAMASK]; + (*olenp)++; + } } - } - dev->dataindex = k; + dev->dataindex = k; - /* how much full lines are finished */ - return (k / linesize - y_off) * linesize; + /* how much full lines are finished */ + return (k / linesize - y_off) * linesize; } 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; + SANE_Status status; + struct device *dev = h; + + DBG(3, "%s: %p, %p, %d, %p\n", __func__, h, buf, maxlen, (void *)lenp); + + if (lenp) + *lenp = 0; + if (!dev) + return SANE_STATUS_INVAL; + + if (!dev->scanning) + return SANE_STATUS_EOF; + + /* if there is no data to read or output from buffer */ + if (!dev->blocklen && dev->datalen <= PADDING_SIZE) { + + /* copying uncompressed data */ + 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)) { + dev->total_out_size += *lenp; + return SANE_STATUS_GOOD; + } + } + + /* and we don't need to acquire next block */ + if (dev->final_block) { + int slack = dev->total_img_size - dev->total_out_size; + + /* but we may need to fill slack */ + 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", + 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) { + remove(encTmpFileName); + } + /* that's all */ + dev_stop(dev); + return SANE_STATUS_EOF; + } + + /* queue next image block */ + if (!dev_acquire(dev)) + return dev->state; + } + + if (!dev->reading) { + if (cancelled(dev)) + return dev->state; + DBG(5, "READ_IMAGE\n"); + if (!dev_cmd(dev, CMD_READ_IMAGE)) + return SANE_STATUS_IO_ERROR; + dev->reading++; + dev->ulines += dev->vertical; + dev->y_off = dev->ulines - dev->vertical; + dev->total_data_size += dev->blocklen; + dev->blocks++; + } - DBG (3, "%s: %p, %p, %d, %p\n", __FUNCTION__, h, buf, maxlen, (void *)lenp); + do { + size_t datalen; + int clrlen; /* cleared lines len */ + int olen; /* output len */ + + /* read as much data into the buffer */ + datalen = DATAROOM(dev) & USB_BLOCK_MASK; + while (datalen && dev->blocklen) { + SANE_Byte *rbuf = dev->data + DATATAIL(dev); + + 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", + (u_long)datalen, dev->dataoff, DATATAIL(dev), dev->datalen); + if (dev->blocklen < 0) + return ret_cancel(dev, SANE_STATUS_IO_ERROR); + + datalen = DATAROOM(dev) & USB_BLOCK_MASK; + } + + if (buf && lenp) { /* read mode */ + /* copy will do minimal of valid data */ + if (dev->para.format == SANE_FRAME_RGB && dev->line_order) { + if (isSupportedDevice(dev)) { + clrlen = dump_to_tmp_file(dev); + /* decompress after reading entire block data*/ + if (0 == dev->blocklen) { + decompress_tempfile(dev); + } + copy_decompress_data(dev, buf, maxlen, &olen); + } else { + clrlen = copy_mix_bands_trim(dev, buf, maxlen, &olen); + } + } else + clrlen = copy_plain_trim(dev, buf, maxlen, &olen); + + dev->datalen -= clrlen; + dev->dataoff = (dev->dataoff + clrlen) & DATAMASK; + buf += olen; + maxlen -= olen; + *lenp += olen; + dev->total_out_size += olen; + + 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); + + /* slack beyond last line */ + if (dev->dataindex / dev->bytes_per_line + dev->y_off >= dev->para.lines) { + dev->datalen = 0; + dev->dataoff = 0; + } + + if (!clrlen || maxlen <= 0) + break; + } else { /* flush mode */ + dev->datalen = 0; + dev->dataoff = 0; + } + + } while (dev->blocklen); + + if (lenp) + DBG(9, " ==> %d\n", *lenp); - if (lenp) - *lenp = 0; - if (!dev) - return SANE_STATUS_INVAL; + return SANE_STATUS_GOOD; +} - if (!dev->scanning) - return SANE_STATUS_EOF; - - /* if there is no data to read or output from buffer */ - if (!dev->blocklen && dev->datalen <= PADDING_SIZE) { - - /* and we don't need to acquire next block */ - if (dev->final_block) { - int slack = dev->total_img_size - dev->total_out_size; - - /* but we may need to fill slack */ - 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", - 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); - } - - /* that's all */ - dev_stop(dev); - return SANE_STATUS_EOF; +SANE_Status +sane_start(SANE_Handle h) +{ + struct device *dev = h; + + DBG(3, "%s: %p\n", __func__, h); + + dev->cancel = 0; + dev->scanning = 0; + dev->total_img_size = 0; + dev->total_out_size = 0; + dev->total_data_size = 0; + dev->blocks = 0; + + if (!dev->reserved) { + if (!dev_cmd_wait(dev, CMD_RESERVE_UNIT)) + return dev->state; + dev->reserved++; } - /* queue next image block */ + if (!dev_set_window(dev) || + (dev->state && dev->state != SANE_STATUS_DEVICE_BUSY)) + return dev_stop(dev); + + if (!dev_cmd_wait(dev, CMD_OBJECT_POSITION)) + return dev_stop(dev); + + if (!dev_cmd(dev, CMD_READ) || + (dev->state && dev->state != SANE_STATUS_DEVICE_BUSY)) + return dev_stop(dev); + + dev->scanning = 1; + dev->final_block = 0; + dev->blocklen = 0; + dev->pixels_per_line = 0; + dev->bytes_per_line = 0; + dev->ulines = 0; + + set_parameters(dev); + + if (!dev->data && !(dev->data = malloc(DATASIZE))) + return ret_cancel(dev, SANE_STATUS_NO_MEM); + + if (!dev->decData && !(dev->decData = malloc(POST_DATASIZE))) + return ret_cancel(dev, SANE_STATUS_NO_MEM); + if (!dev_acquire(dev)) - return dev->state; - } - - if (!dev->reading) { - if (cancelled(dev)) - return dev->state; - DBG (5, "READ_IMAGE\n"); - if (!dev_cmd(dev, CMD_READ_IMAGE)) - return SANE_STATUS_IO_ERROR; - dev->reading++; - dev->ulines += dev->vertical; - dev->y_off = dev->ulines - dev->vertical; - dev->total_data_size += dev->blocklen; - dev->blocks++; - } - - do { - size_t datalen; - int clrlen; /* cleared lines len */ - int olen; /* output len */ - - /* read as much data into the buffer */ - datalen = DATAROOM(dev) & USB_BLOCK_MASK; - while (datalen && dev->blocklen) { - SANE_Byte *rbuf = dev->data + DATATAIL(dev); - - 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", - (u_long)datalen, dev->dataoff, DATATAIL(dev), dev->datalen); - if (dev->blocklen < 0) - return ret_cancel(dev, SANE_STATUS_IO_ERROR); - - datalen = DATAROOM(dev) & USB_BLOCK_MASK; - } + return dev->state; - if (buf && lenp) { /* read mode */ - /* copy will do minimal of valid data */ - if (dev->para.format == SANE_FRAME_RGB && dev->line_order) - clrlen = copy_mix_bands_trim(dev, buf, maxlen, &olen); - else - clrlen = copy_plain_trim(dev, buf, maxlen, &olen); - - dev->datalen -= clrlen; - dev->dataoff = (dev->dataoff + clrlen) & DATAMASK; - buf += olen; - maxlen -= olen; - *lenp += olen; - dev->total_out_size += olen; - - 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); - - /* slack beyond last line */ - if (dev->dataindex / dev->bytes_per_line + dev->y_off >= dev->para.lines) { - dev->datalen = 0; - dev->dataoff = 0; - } - - if (!clrlen || maxlen <= 0) - break; - } else { /* flush mode */ - dev->datalen = 0; - dev->dataoff = 0; + /* make sure to have dev->para <= of real size */ + if (dev->para.pixels_per_line > dev->pixels_per_line) { + dev->para.pixels_per_line = dev->pixels_per_line; + dev->para.bytes_per_line = dev->pixels_per_line; } - } while (dev->blocklen); - - if (lenp) - DBG (9, " ==> %d\n", *lenp); + if (dev->composition == MODE_RGB24) + dev->para.bytes_per_line = dev->para.pixels_per_line * 3; + else if (dev->composition == MODE_LINEART || + dev->composition == MODE_HALFTONE) { + dev->para.bytes_per_line = (dev->para.pixels_per_line + 7) / 8; + dev->para.pixels_per_line = dev->para.bytes_per_line * 8; + } else { + dev->para.bytes_per_line = dev->para.pixels_per_line; + } - return SANE_STATUS_GOOD; -} + dev->total_img_size = dev->para.bytes_per_line * dev->para.lines; -SANE_Status -sane_start (SANE_Handle h) -{ - struct device *dev = h; - - DBG (3, "%s: %p\n", __FUNCTION__, h); - - dev->cancel = 0; - dev->scanning = 0; - dev->total_img_size = 0; - dev->total_out_size = 0; - dev->total_data_size = 0; - dev->blocks = 0; - - if (!dev->reserved) { - if (!dev_cmd_wait(dev, CMD_RESERVE_UNIT)) - return dev->state; - dev->reserved++; - } - - if (!dev_set_window(dev) || - (dev->state && dev->state != SANE_STATUS_DEVICE_BUSY)) - return dev_stop(dev); - - if (!dev_cmd_wait(dev, CMD_OBJECT_POSITION)) - return dev_stop(dev); - - if (!dev_cmd(dev, CMD_READ) || - (dev->state && dev->state != SANE_STATUS_DEVICE_BUSY)) - return dev_stop(dev); - - dev->scanning = 1; - dev->final_block = 0; - dev->blocklen = 0; - dev->pixels_per_line = 0; - dev->bytes_per_line = 0; - dev->ulines = 0; - - set_parameters(dev); - - if (!dev->data && !(dev->data = malloc(DATASIZE))) - return ret_cancel(dev, SANE_STATUS_NO_MEM); - - if (!dev_acquire(dev)) - return dev->state; - - /* make sure to have dev->para <= of real size */ - if (dev->para.pixels_per_line > dev->pixels_per_line) { - dev->para.pixels_per_line = dev->pixels_per_line; - dev->para.bytes_per_line = dev->pixels_per_line; - } - - if (dev->composition == MODE_RGB24) - dev->para.bytes_per_line = dev->para.pixels_per_line * 3; - else if (dev->composition == MODE_LINEART || - dev->composition == MODE_HALFTONE) { - dev->para.bytes_per_line = (dev->para.pixels_per_line + 7) / 8; - dev->para.pixels_per_line = dev->para.bytes_per_line * 8; - } else { - dev->para.bytes_per_line = dev->para.pixels_per_line; - } + if (isSupportedDevice(dev) && + dev->composition == MODE_RGB24) { + int fd; + remove(encTmpFileName); - dev->total_img_size = dev->para.bytes_per_line * dev->para.lines; + /* Precreate temporary file in exclusive mode. */ + fd = open(encTmpFileName, O_CREAT|O_EXCL, 0600); + if (fd == -1) { + DBG(3, "%s: %p, can't create temporary file %s: %s\n", __func__, + (void *)dev, encTmpFileName, strerror(errno)); + return ret_cancel(dev, SANE_STATUS_ACCESS_DENIED); + } + close(fd); + } + dev->currentDecDataIndex = 0; - return SANE_STATUS_GOOD; + 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; + struct device *dev = h; - DBG (3, "%s: %p, %d\n", __FUNCTION__, h, non_blocking); + DBG(3, "%s: %p, %d\n", __func__, h, non_blocking); - if (non_blocking) - return SANE_STATUS_UNSUPPORTED; + if (non_blocking) + return SANE_STATUS_UNSUPPORTED; - dev->non_blocking = non_blocking; - return SANE_STATUS_GOOD; + dev->non_blocking = 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", __FUNCTION__, h, (void *)fdp); - /* supporting of this will require thread creation */ - return SANE_STATUS_UNSUPPORTED; + 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; + struct device *dev = h; - DBG (3, "%s: %p\n", __FUNCTION__, h); - dev->cancel = 1; + DBG(3, "%s: %p\n", __func__, h); + dev->cancel = 1; } /* xerox_mfp.c */ |