diff options
Diffstat (limited to 'backend/avision.c')
| -rw-r--r-- | backend/avision.c | 555 |
1 files changed, 288 insertions, 267 deletions
diff --git a/backend/avision.c b/backend/avision.c index b81578a..c807d9f 100644 --- a/backend/avision.c +++ b/backend/avision.c @@ -112,7 +112,7 @@ * * . . - sane_cancel() : cancel operation, kill reader_process * - * . - sane_close() : close opened scanner-device, do_cancel, free buffer and handle + * . - sane_close() : do_cancel, close opened scanner-device, free buffer and handle * - sane_exit() : terminate use of backend, free devicename and device-structure */ @@ -159,6 +159,15 @@ static Avision_HWEntry Avision_Device_List [] = { + { NULL, NULL, + 0x0638, 0x2E59, + "Avision", "AD345F", + AV_INT_BUTTON | AV_CANCEL_BUTTON | AV_USE_GRAY_FILTER, + { 0, {0, 0}, {{0, 0}, {0, 0}} } + }, + /* comment="duplex! sheetfed + flatbed scanner" */ + /* status="basic" */ + { "AVISION", "AV100CS", 0, 0, "Avision", "AV100CS", @@ -688,6 +697,15 @@ static Avision_HWEntry Avision_Device_List [] = /* comment="1 pass, 600 dpi, zero-edge" ASIC 7 */ /* status="basic" */ + { NULL, NULL, + 0x0638, 0x2a1f, + "Avision", "FB2280E", + 0, + { 0, {0, 0}, {{0, 0}, {0, 0}} } + }, + /* comment="1 pass, 600 dpi, zero-edge" ASIC 7 */ + /* status="basic" */ + { "AVISION", "AV8000S", 0, 0, "Avision", "AV8000S", @@ -1592,7 +1610,7 @@ Lexmark X4500 MFP }\ }\ -static int num_devices; +static unsigned int num_devices; static Avision_Device* first_dev; static Avision_Scanner* first_handle; static const SANE_Device** devlist = 0; @@ -2149,8 +2167,8 @@ sense_handler (int fd, u_char* sense, void* arg) uint8_t sense_key = sense[2] & 0xf; uint8_t additional_sense = sense[7]; - fd = fd; /* silence gcc */ - arg = arg; /* silence gcc */ + (void) fd; /* silence gcc */ + (void) arg; /* silence gcc */ DBG (3, "sense_handler:\n"); @@ -2690,8 +2708,8 @@ bubble_sort (uint8_t* sort_data, size_t count) for (j = (i + 1); j < count; ++j) { - ti = get_double ((sort_data + i*2)); - tj = get_double ((sort_data + j*2)); + ti = (uint16_t) get_double ((sort_data + i*2)); + tj = (uint16_t) get_double ((sort_data + j*2)); if (ti > tj) { set_double ((sort_data + i*2), tj); @@ -2708,7 +2726,7 @@ bubble_sort (uint8_t* sort_data, size_t count) /* DBG (7, "bubble_sort: %d values for average\n", k); */ if (k > 0) /* if avg to compute */ - return (uint16_t) (sum / k); + return (uint16_t) (sum /(double) k); else return (uint16_t) (sum); /* always zero? */ } @@ -2969,14 +2987,14 @@ compute_parameters (Avision_Scanner* s) SANE_UNFIX (s->val[OPT_BR_X].w), SANE_UNFIX (s->val[OPT_BR_Y].w)); /* window parameter in pixel */ - s->avdimen.tlx = s->avdimen.hw_xres * SANE_UNFIX (s->val[OPT_TL_X].w) - / MM_PER_INCH; - s->avdimen.tly = s->avdimen.hw_yres * SANE_UNFIX (s->val[OPT_TL_Y].w) - / MM_PER_INCH; - s->avdimen.brx = s->avdimen.hw_xres * SANE_UNFIX (s->val[OPT_BR_X].w) - / MM_PER_INCH; - s->avdimen.bry = s->avdimen.hw_yres * SANE_UNFIX (s->val[OPT_BR_Y].w) - / MM_PER_INCH; + s->avdimen.tlx = (long int) (s->avdimen.hw_xres * SANE_UNFIX (s->val[OPT_TL_X].w) + / MM_PER_INCH); + s->avdimen.tly = (long int) (s->avdimen.hw_yres * SANE_UNFIX (s->val[OPT_TL_Y].w) + / MM_PER_INCH); + s->avdimen.brx = (long int) (s->avdimen.hw_xres * SANE_UNFIX (s->val[OPT_BR_X].w) + / MM_PER_INCH); + s->avdimen.bry = (long int) (s->avdimen.hw_yres * SANE_UNFIX (s->val[OPT_BR_Y].w) + / MM_PER_INCH); /* line difference */ if (color_mode_is_color (s->c_mode) && @@ -2990,8 +3008,8 @@ compute_parameters (Avision_Scanner* s) /* limit bry + line_difference to real scan boundary */ { - long y_max = dev->inquiry_y_ranges[s->source_mode_dim] * - s->avdimen.hw_yres / MM_PER_INCH; + long y_max = (long int) (dev->inquiry_y_ranges[s->source_mode_dim] * + s->avdimen.hw_yres / MM_PER_INCH); DBG (3, "sane_compute_parameters: y_max: %ld, bry: %ld, line_difference: %d\n", y_max, s->avdimen.bry, s->avdimen.line_difference); @@ -3009,10 +3027,10 @@ compute_parameters (Avision_Scanner* s) /* add overscan */ if (dev->inquiry_tune_scan_length && is_adf_scan (s)) { /* some extra effort for precise rounding ... */ - int overscan = (s->avdimen.hw_yres * + int overscan = (int) ((s->avdimen.hw_yres * (SANE_UNFIX (s->val[OPT_OVERSCAN_TOP].w) + SANE_UNFIX (s->val[OPT_OVERSCAN_BOTTOM].w)) + (MM_PER_INCH - 1) - ) / MM_PER_INCH; + ) / MM_PER_INCH); DBG (3, "sane_compute_parameters: overscan lines: %d\n", overscan); s->avdimen.bry += overscan; } @@ -3171,10 +3189,10 @@ compute_parameters (Avision_Scanner* s) memset (&s->params, 0, sizeof (s->params)); - s->avdimen.hw_pixels_per_line = (s->avdimen.brx - s->avdimen.tlx); + s->avdimen.hw_pixels_per_line = (int) (s->avdimen.brx - s->avdimen.tlx); s->avdimen.hw_pixels_per_line -= s->avdimen.hw_pixels_per_line % boundary; - s->avdimen.hw_lines = (s->avdimen.bry - s->avdimen.tly - + s->avdimen.hw_lines = (int) (s->avdimen.bry - s->avdimen.tly - 2 * s->avdimen.line_difference); if (s->avdimen.interlaced_duplex && dev->scanner_type != AV_FILM) @@ -3252,7 +3270,7 @@ inquiry (Avision_Connection av_con, uint8_t* data, size_t len) memset (&inquiry, 0, sizeof(inquiry)); inquiry.opc = AVISION_SCSI_INQUIRY; - inquiry.len = len; + inquiry.len = (uint8_t) len; do { size_t size = inquiry.len; @@ -3281,7 +3299,7 @@ wait_ready (Avision_Connection* av_con, int delay) DBG (3, "wait_ready: sending TEST_UNIT_READY\n"); status = avision_cmd (av_con, test_unit_ready, sizeof (test_unit_ready), 0, 0, 0, 0); - sleep (delay); + sleep ((unsigned int) delay); switch (status) { @@ -3338,6 +3356,7 @@ wait_4_light (Avision_Scanner* s) status = avision_cmd (&s->av_con, &rcmd, sizeof (rcmd), 0, 0, &result, &size); if (status != SANE_STATUS_GOOD || size != sizeof (result)) { + status = (status != SANE_STATUS_GOOD)? status: SANE_STATUS_IO_ERROR; DBG (1, "wait_4_light: read failed (%s)\n", sane_strstatus (status)); return status; } @@ -3432,6 +3451,7 @@ get_firmware_status (Avision_Connection* av_con) status = avision_cmd (av_con, &rcmd, sizeof (rcmd), 0, 0, &result, &size); if (status != SANE_STATUS_GOOD || size != sizeof (result)) { + status = (status != SANE_STATUS_GOOD)? status: SANE_STATUS_IO_ERROR; DBG (1, "get_firmware_status: read failed (%s)\n", sane_strstatus (status)); return (status); @@ -3469,6 +3489,7 @@ get_flash_ram_info (Avision_Connection* av_con) status = avision_cmd (av_con, &rcmd, sizeof (rcmd), 0, 0, result, &size); if (status != SANE_STATUS_GOOD || size != sizeof (result)) { + status = (status != SANE_STATUS_GOOD)? status: SANE_STATUS_IO_ERROR; DBG (1, "get_flash_ram_info: read failed (%s)\n", sane_strstatus (status)); return (status); @@ -3550,21 +3571,21 @@ get_nvram_data (Avision_Scanner* s, nvram_data* nvram) } static SANE_Status -get_and_parse_nvram (Avision_Scanner* s, char* str, int n) +get_and_parse_nvram (Avision_Scanner* s, char* str, size_t n) { SANE_Status status; - int i = 0; + size_t i = 0; int x; nvram_data nvram; uint8_t inquiry_result [AVISION_INQUIRY_SIZE_V1]; status = inquiry (s->av_con, inquiry_result, sizeof(inquiry_result)); if (status == SANE_STATUS_GOOD) { - i += snprintf (str+i, n-i, "Vendor: %.8s", + i += (size_t) snprintf (str+i, n-i, "Vendor: %.8s", inquiry_result+8); - i += snprintf (str+i, n-i, "\nModel: %.16s", + i += (size_t) snprintf (str+i, n-i, "\nModel: %.16s", inquiry_result+16); - i += snprintf (str+i, n-i, "\nFirmware: %.4s", + i += (size_t) snprintf (str+i, n-i, "\nFirmware: %.4s", inquiry_result+32); } @@ -3575,32 +3596,32 @@ get_and_parse_nvram (Avision_Scanner* s, char* str, int n) if (status == SANE_STATUS_GOOD) { if (nvram.serial[0]) - i += snprintf (str+i, n-i, "\nSerial: %.24s", + i += (size_t) snprintf (str+i, n-i, "\nSerial: %.24s", nvram.serial); - if (nvram.born_year) - i += snprintf (str+i, n-i, "\nManufacturing date: %d-%d-%d", + if (get_double(nvram.born_year)) + i += (size_t) snprintf (str+i, n-i, "\nManufacturing date: %d-%d-%d", get_double(nvram.born_year), get_double(nvram.born_month), get_double(nvram.born_day)); - if (nvram.first_scan_year) - i += snprintf (str+i, n-i, "\nFirst scan date: %d-%d-%d", + if (get_double(nvram.first_scan_year)) + i += (size_t) snprintf (str+i, n-i, "\nFirst scan date: %d-%d-%d", get_double(nvram.first_scan_year), get_double(nvram.first_scan_month), get_double(nvram.first_scan_day)); x = get_quad (nvram.flatbed_scans); if (x) - i += snprintf (str+i, n-i, "\nFlatbed scans: %d", x); + i += (size_t) snprintf (str+i, n-i, "\nFlatbed scans: %d", x); x = get_quad (nvram.pad_scans); if (x) - i += snprintf (str+i, n-i, "\nPad scans: %d", x); + i += (size_t) snprintf (str+i, n-i, "\nPad scans: %d", x); x = get_quad (nvram.adf_simplex_scans); if (x) - i += snprintf (str+i, n-i, "\nADF simplex scans: %d", x); + i += (size_t) snprintf (str+i, n-i, "\nADF simplex scans: %d", x); x = get_quad (nvram.adf_duplex_scans); if (x) - i += snprintf (str+i, n-i, "\nADF duplex scans: %d", x); + i += (size_t) snprintf (str+i, n-i, "\nADF duplex scans: %d", x); } return status; @@ -3703,12 +3724,12 @@ adf_reset (Avision_Scanner* s) uint8_t payload[4]; size_t size; size_t n; - int i; + ssize_t i; DBG (3, "adf_reset\n"); /* loop twice */ for (i=1; i >= 0; i--) { - n=i; + n= (size_t) i; memset (&scmd, 0, sizeof (scmd)); memset (&payload, 0, sizeof (payload)); scmd.opc = AVISION_SCSI_SEND; @@ -3716,26 +3737,26 @@ adf_reset (Avision_Scanner* s) set_double (scmd.datatypequal, 0); size = 2; set_triple (scmd.transferlen, size); - payload[1] = 0x10 * i; /* write 0x10 the first time, 0x00 the second */ + payload[1] = (uint8_t) (0x10 * i); /* write 0x10 the first time, 0x00 the second */ status = avision_cmd (&s->av_con, &scmd, sizeof (scmd), payload, size, 0, 0); if (status != SANE_STATUS_GOOD) { - DBG (1, "adf_reset: write %d failed (%s)\n", (2-i), + DBG (1, "adf_reset: write %zu failed (%s)\n", (2-i), sane_strstatus (status)); return (status); } - DBG (3, "adf_reset: write %d complete.\n", (2-i)); + DBG (3, "adf_reset: write %zu complete.\n", (2-i)); memset (&rcmd, 0, sizeof (rcmd)); memset (&payload, 0, sizeof (payload)); rcmd.opc = AVISION_SCSI_READ; rcmd.datatypecode = AVISION_DATATYPECODE_READ_NVRAM_DATA; /* Read NVRAM data */ set_double (rcmd.datatypequal, dev->data_dq); - size = 4 - i; /* read 3 bytes the first time, 4 the second */ + size = (size_t) (4 - i); /* read 3 bytes the first time, 4 the second */ set_triple (rcmd.transferlen, size); status = avision_cmd (&s->av_con, &rcmd, sizeof (rcmd), 0, 0, payload, &size); if (status != SANE_STATUS_GOOD || size != (4-n)) { - DBG (1, "adf_reset: read %zu failed (%s)\n", (4-n), - sane_strstatus (status)); + status = (status != SANE_STATUS_GOOD)? status: SANE_STATUS_IO_ERROR; + DBG (1, "adf_reset: read %zu failed (%s)\n", (4-n), sane_strstatus (status)); return (status); } debug_print_raw (3, "adf_reset: raw data:\n", payload, size); @@ -3776,8 +3797,8 @@ get_accessories_info (Avision_Scanner* s) status = avision_cmd (&s->av_con, &rcmd, sizeof (rcmd), 0, 0, result, &size); if (status != SANE_STATUS_GOOD || size != sizeof (result)) { - DBG (1, "get_accessories_info: read failed (%s)\n", - sane_strstatus (status)); + status = (status != SANE_STATUS_GOOD)? status: SANE_STATUS_IO_ERROR; + DBG (1, "get_accessories_info: read failed (%s)\n", sane_strstatus (status)); return (status); } @@ -3839,7 +3860,7 @@ get_accessories_info (Avision_Scanner* s) /* Returns a pointer to static char* strings or NULL for cancel (we do not want to start memcmp'ing for the cancel case). */ static const char* -string_for_button (Avision_Scanner* s, int button) +string_for_button (Avision_Scanner* s, uint8_t button) { static char buffer [16]; Avision_Device* dev = s->hw; @@ -3931,6 +3952,7 @@ get_button_status (Avision_Scanner* s) status = avision_cmd (&s->av_con, &rcmd, sizeof (rcmd), 0, 0, (uint8_t*)&result, &size); if (status != SANE_STATUS_GOOD || size != sizeof (result)) { + status = (status != SANE_STATUS_GOOD)? status: SANE_STATUS_IO_ERROR; DBG (1, "get_button_status: read failed (%s)\n", sane_strstatus (status)); return status; } @@ -3982,7 +4004,7 @@ get_button_status (Avision_Scanner* s) /* simulate button press of the last button ... */ result.press_state = 0x80 | 1; - result.buttons[0] = dev->inquiry_buttons; /* 1 based */ + result.buttons[0] = (uint8_t) dev->inquiry_buttons; /* 1 based */ } } @@ -4001,7 +4023,7 @@ get_button_status (Avision_Scanner* s) char* message = message_begin; #define add_token(format,value) do { \ - int n = snprintf (message, message_end - message, "%s" format, \ + int n = snprintf (message, (size_t) (message_end - message), "%s" format, \ message == message_begin ? "" : ":", value); \ message += n > 0 ? n : 0; \ } while (0) @@ -4041,7 +4063,7 @@ get_button_status (Avision_Scanner* s) } for (i = 0; i < buttons_pressed; ++i) { - const unsigned int button = result.buttons[i] - 1; /* 1 based ... */ + const uint8_t button = result.buttons[i] - 1; /* 1 based ... */ DBG (3, "get_button_status: button %d pressed\n", button); if (button >= dev->inquiry_buttons) { DBG (1, "get_button_status: button %d not allocated as not indicated in inquiry\n", @@ -4089,6 +4111,7 @@ get_frame_info (Avision_Scanner* s) status = avision_cmd (&s->av_con, &rcmd, sizeof (rcmd), 0, 0, result, &size); if (status != SANE_STATUS_GOOD || size != sizeof (result)) { + status = (status != SANE_STATUS_GOOD)? status: SANE_STATUS_IO_ERROR; DBG (1, "get_frame_info: read failed (%s)\n", sane_strstatus (status)); return (status); } @@ -4104,10 +4127,10 @@ get_frame_info (Avision_Scanner* s) DBG (3, "get_frame_info: [2] Frame amount: %d\n", result[2]); DBG (3, "get_frame_info: [3] Mode: %s\n", BIT(result[3],4)?"APS":"Not APS"); DBG (3, "get_frame_info: [3] Exposures (if APS): %s\n", - ((i=(BIT(result[3],3)<<1)+BIT(result[2],2))==0)?"Unknown": + ((i=(size_t) (BIT(result[3],3)<<1)+BIT(result[2],2))==0)?"Unknown": (i==1)?"15":(i==2)?"25":"40"); DBG (3, "get_frame_info: [3] Film Type (if APS): %s\n", - ((i=(BIT(result[1],3)<<1)+BIT(result[0],2))==0)?"Unknown": + ((i=(size_t) (BIT(result[1],3)<<1)+BIT(result[0],2))==0)?"Unknown": (i==1)?"B&W Negative":(i==2)?"Color slide":"Color Negative"); dev->holder_type = result[0]; @@ -4157,6 +4180,7 @@ get_duplex_info (Avision_Scanner* s) status = avision_cmd (&s->av_con, &rcmd, sizeof (rcmd), 0, 0, &result, &size); if (status != SANE_STATUS_GOOD || size != sizeof (result)) { + status = (status != SANE_STATUS_GOOD)? status: SANE_STATUS_IO_ERROR; DBG (1, "get_duplex_info: read failed (%s)\n", sane_strstatus (status)); return (status); } @@ -4220,8 +4244,8 @@ set_frame (Avision_Scanner* s, SANE_Word frame) set_double (scmd.cmd.datatypequal, dev->data_dq); set_triple (scmd.cmd.transferlen, sizeof (scmd.data) ); - scmd.data[0] = dev->holder_type; - scmd.data[1] = frame; + scmd.data[0] = (uint8_t) dev->holder_type; + scmd.data[1] = (uint8_t) frame; status = avision_cmd (&s->av_con, &scmd.cmd, sizeof (scmd.cmd), &scmd.data, sizeof (scmd.data), 0, 0); @@ -4970,7 +4994,7 @@ send_tune_scan_length (Avision_Scanner* s) if (dev->hw->feature_type & AV_OVERSCAN_OPTDPI) dpi = dev->inquiry_optical_res; - top = dpi * SANE_UNFIX (s->val[OPT_OVERSCAN_TOP].w) / MM_PER_INCH; + top = (int) (dpi * SANE_UNFIX (s->val[OPT_OVERSCAN_TOP].w) / MM_PER_INCH); DBG (3, "send_tune_scan_length: top: %d\n", top); /* top offset compensation */ @@ -4986,7 +5010,7 @@ send_tune_scan_length (Avision_Scanner* s) offset += dev->hw->offset.first; /* convert to lines */ - int top_offset = dpi * offset / MM_PER_INCH; + int top_offset = (int) (dpi * offset / MM_PER_INCH); top += top_offset; DBG (3, "send_tune_scan_length: top offset: %d\n", top_offset); } @@ -5007,7 +5031,7 @@ send_tune_scan_length (Avision_Scanner* s) } scmd.datatypecode = AVISION_DATATYPECODE_ATTACH_TRUNCATE_TAIL; /* Attach/Truncate tail(right) of scan length */ - bottom = dpi * SANE_UNFIX (s->val[OPT_OVERSCAN_BOTTOM].w) / MM_PER_INCH; + bottom = (int) (dpi * SANE_UNFIX (s->val[OPT_OVERSCAN_BOTTOM].w) / MM_PER_INCH); DBG (3, "send_tune_scan_length: bottom: %d\n", bottom); /* bottom offset compensation */ @@ -5024,7 +5048,7 @@ send_tune_scan_length (Avision_Scanner* s) offset += fabs(dev->hw->offset.first); /* convert to lines */ - int bottom_offset = dpi * offset / MM_PER_INCH; + int bottom_offset = (int) (dpi * offset / MM_PER_INCH); bottom += bottom_offset; DBG (3, "send_tune_scan_length: bottom offset: %d\n", bottom_offset); } @@ -5161,14 +5185,14 @@ get_calib_format (Avision_Scanner* s, struct calibration_format* format) DBG (3, "get_calib_format: read_data: %lu bytes\n", (u_long) size); status = avision_cmd (&s->av_con, &rcmd, sizeof (rcmd), 0, 0, result, &size); if (status != SANE_STATUS_GOOD || size != sizeof (result) ) { - DBG (1, "get_calib_format: read calib. info failed (%s)\n", - sane_strstatus (status) ); + status = (status != SANE_STATUS_GOOD)? status: SANE_STATUS_IO_ERROR; + DBG (1, "get_calib_format: read calib. info failed (%s)\n", sane_strstatus (status) ); return status; } debug_print_calib_format (3, "get_calib_format", result); - format->pixel_per_line = get_double (&(result[0])); + format->pixel_per_line = (uint16_t) get_double (&(result[0])); format->bytes_per_channel = result[2]; format->lines = result[3]; format->flags = result[4]; @@ -5176,12 +5200,12 @@ get_calib_format (Avision_Scanner* s, struct calibration_format* format) format->r_gain = result[6]; format->g_gain = result[7]; format->b_gain = result[8]; - format->r_shading_target = get_double (&(result[9])); - format->g_shading_target = get_double (&(result[11])); - format->b_shading_target = get_double (&(result[13])); - format->r_dark_shading_target = get_double (&(result[15])); - format->g_dark_shading_target = get_double (&(result[17])); - format->b_dark_shading_target = get_double (&(result[19])); + format->r_shading_target = (uint16_t) get_double (&(result[9])); + format->g_shading_target = (uint16_t) get_double (&(result[11])); + format->b_shading_target = (uint16_t) get_double (&(result[13])); + format->r_dark_shading_target = (uint16_t) get_double (&(result[15])); + format->g_dark_shading_target = (uint16_t) get_double (&(result[17])); + format->b_dark_shading_target = (uint16_t) get_double (&(result[19])); /* now translate to normal! */ /* firmware return R--RG--GB--B with 3 line count */ @@ -5261,7 +5285,7 @@ set_calib_data (Avision_Scanner* s, struct calibration_format* format, { Avision_Device* dev = s->hw; - const int elements_per_line = format->pixel_per_line * format->channels; + const size_t elements_per_line = format->pixel_per_line * format->channels; SANE_Status status; @@ -5270,7 +5294,7 @@ set_calib_data (Avision_Scanner* s, struct calibration_format* format, struct command_send scmd; - int i; + size_t i; DBG (3, "set_calib_data:\n"); @@ -5295,13 +5319,13 @@ set_calib_data (Avision_Scanner* s, struct calibration_format* format, if (BIT (format->ability1, 2) ) { DBG (3, "set_calib_data: merging dark calibration data\n"); for (i = 0; i < elements_per_line; ++i) { - uint16_t value_orig = get_double_le (white_data + i*2); + uint16_t value_orig = (uint16_t) get_double_le (white_data + i*2); uint16_t value_new = value_orig; value_new &= 0xffc0; - value_new |= (get_double_le (dark_data + i*2) >> 10) & 0x3f; + value_new |= (uint16_t) ((get_double_le (dark_data + i*2) >> 10) & 0x3f); - DBG (9, "set_calib_data: element %d, dark difference %d\n", + DBG (9, "set_calib_data: element %zu, dark difference %d\n", i, value_orig - value_new); set_double_le ((white_data + i*2), value_new); @@ -5318,7 +5342,7 @@ set_calib_data (Avision_Scanner* s, struct calibration_format* format, { size_t send_size = elements_per_line * 2; DBG (3, "set_calib_data: all channels in one command\n"); - DBG (3, "set_calib_data: send_size: %lu\n", (u_long) send_size); + DBG (3, "set_calib_data: send_size: %zu\n", send_size); memset (&scmd, 0, sizeof (scmd) ); scmd.opc = AVISION_SCSI_SEND; @@ -5332,7 +5356,7 @@ set_calib_data (Avision_Scanner* s, struct calibration_format* format, } else /* send data channel by channel (some USB ones) */ { - int conv_out_size = format->pixel_per_line * 2; + size_t conv_out_size = format->pixel_per_line * 2; uint16_t* conv_out_data; /* here it is save to use 16bit data since we only move whole words around */ @@ -5356,7 +5380,7 @@ set_calib_data (Avision_Scanner* s, struct calibration_format* format, for (i = 0; i < format->pixel_per_line; ++ i) conv_out_data [i] = casted_avg_data [i * 3 + channel]; - DBG (3, "set_calib_data: sending %i bytes now\n", + DBG (3, "set_calib_data: sending %zu bytes now\n", conv_out_size); memset (&scmd, 0, sizeof (scmd)); @@ -5393,9 +5417,9 @@ set_calib_data (Avision_Scanner* s, struct calibration_format* format, static uint8_t* sort_and_average (struct calibration_format* format, uint8_t* data) { - const int elements_per_line = format->pixel_per_line * format->channels; - const int stride = format->bytes_per_channel * elements_per_line; - int i, line; + const size_t elements_per_line = format->pixel_per_line * format->channels; + const size_t stride = format->bytes_per_channel * elements_per_line; + size_t i, line; uint8_t *sort_data, *avg_data; @@ -5454,7 +5478,7 @@ compute_dark_shading_data (Avision_Scanner* s, DBG (3, "compute_dark_shading_data:\n"); if (s->hw->inquiry_max_shading_target != INVALID_DARK_SHADING) - map_value = s->hw->inquiry_max_shading_target << 8; + map_value = (uint16_t) (s->hw->inquiry_max_shading_target << 8); rgb_map_value[0] = format->r_dark_shading_target; rgb_map_value[1] = format->g_dark_shading_target; @@ -5477,7 +5501,7 @@ compute_dark_shading_data (Avision_Scanner* s, /* Avision SCSI protocol document has bad description. */ for (i = 0; i < elements_per_line; ++i) { - uint16_t tmp_data = get_double_le((data + i*2)); + uint16_t tmp_data = (uint16_t) get_double_le((data + i*2)); if (tmp_data > rgb_map_value[i % 3]) { set_double ((data + i*2), tmp_data - rgb_map_value[i % 3]); } @@ -5504,7 +5528,7 @@ compute_white_shading_data (Avision_Scanner* s, DBG (3, "compute_white_shading_data:\n"); if (s->hw->inquiry_max_shading_target != INVALID_WHITE_SHADING) - inquiry_mst = s->hw->inquiry_max_shading_target << 4; + inquiry_mst = (uint16_t) (s->hw->inquiry_max_shading_target << 4); mst[0] = format->r_shading_target; mst[1] = format->g_shading_target; @@ -5547,14 +5571,14 @@ compute_white_shading_data (Avision_Scanner* s, { int result; /* calculate calibration value for pixel i */ - uint16_t tmp_data = get_double((data + i*2)); + uint16_t tmp_data = (uint16_t) get_double((data + i*2)); if (tmp_data == INVALID_WHITE_SHADING) { tmp_data = DEFAULT_WHITE_SHADING; ++ values_invalid; } - result = ( (int)mst[i % 3] * WHITE_MAP_RANGE / (tmp_data + 0.5)); + result = (int) ( (int)mst[i % 3] * WHITE_MAP_RANGE / (tmp_data + 0.5)); /* sanity check for over-amplification, clipping */ if (result > MAX_WHITE_SHADING) { @@ -5582,7 +5606,8 @@ normal_calibration (Avision_Scanner* s) struct calibration_format calib_format; - int calib_data_size, calib_bytes_per_line; + size_t calib_data_size; + int calib_bytes_per_line; uint8_t read_type; uint8_t *calib_tmp_data; @@ -5604,7 +5629,7 @@ normal_calibration (Avision_Scanner* s) calib_bytes_per_line = calib_format.bytes_per_channel * calib_format.pixel_per_line * calib_format.channels; - calib_data_size = calib_format.lines * calib_bytes_per_line; + calib_data_size = (size_t) calib_format.lines * (size_t) calib_bytes_per_line; calib_tmp_data = malloc (calib_data_size); if (!calib_tmp_data) @@ -5889,7 +5914,7 @@ send_gamma (Avision_Scanner* s) /* interpolate gamma_values to gamma_data */ for (k = 0; k < gamma_values; ++ k, ++ i) { gamma_data [i] = (uint8_t) - (((v1 * (gamma_values - k)) + (v2 * k) ) / (double) gamma_values); + (((v1 * (double) (gamma_values - k)) + (v2 * (double) k) ) / (double) gamma_values); } } @@ -5965,7 +5990,7 @@ send_3x3_matrix (Avision_Scanner* s) a_i = (int) a_f; /* integer */ b_f = a_f - (double) a_i; /* float */ - m |= ((a_i & 0x3) << INT_PART); + m |= (uint16_t) ((a_i & 0x3) << INT_PART); m |= (uint16_t) (b_f * 1024); set_double (((uint8_t*)(&cmd.matrix.v[i])), m); } @@ -6009,6 +6034,7 @@ get_acceleration_info (Avision_Scanner* s, struct acceleration_info* info) DBG (3, "get_acceleration_info: read_data: %lu bytes\n", (u_long) size); status = avision_cmd (&s->av_con, &rcmd, sizeof (rcmd), 0, 0, result, &size); if (status != SANE_STATUS_GOOD || size != sizeof (result) ) { + status = (status != SANE_STATUS_GOOD)? status: SANE_STATUS_IO_ERROR; DBG (1, "get_acceleration_info: read accel. info failed (%s)\n", sane_strstatus (status) ); return status; @@ -6016,12 +6042,12 @@ get_acceleration_info (Avision_Scanner* s, struct acceleration_info* info) debug_print_accel_info (3, "get_acceleration_info", result); - info->total_steps = get_double (&(result[0])); - info->stable_steps = get_double (&(result[2])); - info->table_units = get_quad (&(result[4])); - info->base_units = get_quad (&(result[8])); - info->start_speed = get_double (&(result[12])); - info->target_speed = get_double (&(result[14])); + info->total_steps = (uint16_t) get_double (&(result[0])); + info->stable_steps = (uint16_t) get_double (&(result[2])); + info->table_units = (uint32_t) get_quad (&(result[4])); + info->base_units = (uint32_t) get_quad (&(result[8])); + info->start_speed = (uint16_t) get_double (&(result[12])); + info->target_speed = (uint16_t) get_double (&(result[14])); info->ability = result[16]; info->table_count = result[17]; @@ -6076,10 +6102,10 @@ send_acceleration_table (Avision_Scanner* s) needs such a dumb table and also do not know /why/ it has to be constructed this way. "Works for me" -ReneR */ { - float low_lim = 0.001; + float low_lim = (float) 0.001; float up_lim = 1.0; - uint16_t accel_steps = accel_info.total_steps - accel_info.stable_steps + 1; + uint16_t accel_steps = (uint16_t) (accel_info.total_steps - accel_info.stable_steps + 1); /* acceleration ramp */ while ((up_lim - low_lim) > 0.0001) @@ -6122,7 +6148,7 @@ send_acceleration_table (Avision_Scanner* s) int add_count; /* count total steps in table */ - int table_total = 0; + uint32_t table_total = 0; for (i = 0; i < accel_info.total_steps; i++) table_total += table_data [i]; @@ -6130,9 +6156,9 @@ send_acceleration_table (Avision_Scanner* s) if (((table_total * accel_info.table_units) % accel_info.base_units) == 0) add_count = 0; else - add_count = (accel_info.base_units - - ((table_total*accel_info.table_units) % accel_info.base_units)) - / accel_info.table_units; + add_count = (int) ((accel_info.base_units - + ((table_total*accel_info.table_units) % accel_info.base_units)) + / accel_info.table_units); /* add_count should not be bigger than 255 */ if (add_count > 255) { @@ -6142,7 +6168,7 @@ send_acceleration_table (Avision_Scanner* s) for (i = 0; i < accel_info.total_steps - 1 && add_count > 0; i++) { uint16_t temp_count = 255 - table_data [i]; - temp_count = temp_count > add_count ? add_count : temp_count; + temp_count = (uint16_t) (temp_count > add_count ? add_count : temp_count); table_data [i] += (uint8_t) temp_count; add_count -= temp_count; @@ -6186,8 +6212,8 @@ set_window (Avision_Scanner* s) Avision_Device* dev = s->hw; SANE_Status status; int base_dpi_abs, base_dpi_rel; - int transferlen; - int paralen; + size_t transferlen; + size_t paralen; int bytes_per_line; int line_count; @@ -6225,7 +6251,7 @@ set_window (Avision_Scanner* s) /* optional parameter length to use */ paralen = sizeof (cmd.window.avision) - sizeof (cmd.window.avision.type); - DBG (2, "set_window: base paralen: %d\n", paralen); + DBG (2, "set_window: base paralen: %zu\n", paralen); if (dev->hw->feature_type & AV_FUJITSU) paralen += sizeof (cmd.window.avision.type.fujitsu); @@ -6236,12 +6262,12 @@ set_window (Avision_Scanner* s) else paralen += sizeof (cmd.window.avision.type.normal) - 1; - DBG (2, "set_window: final paralen: %d\n", paralen); + DBG (2, "set_window: final paralen: %zu\n", paralen); transferlen = sizeof (cmd.window) - sizeof (cmd.window.avision) + paralen; - DBG (2, "set_window: transferlen: %d\n", transferlen); + DBG (2, "set_window: transferlen: %zu\n", transferlen); /* command setup */ cmd.cmd.opc = AVISION_SCSI_SET_WINDOW; @@ -6278,20 +6304,20 @@ set_window (Avision_Scanner* s) /* here go the most significant bits if bigger than 16 bit */ if (dev->inquiry_new_protocol && !(dev->hw->feature_type & AV_FUJITSU) ) { DBG (2, "set_window: large data-transfer support (>16bit)!\n"); - cmd.window.avision.type.normal.line_width_msb = - bytes_per_line >> 16; - cmd.window.avision.type.normal.line_count_msb = - line_count >> 16; + cmd.window.avision.type.normal.line_width_msb = (uint8_t) + (bytes_per_line >> 16); + cmd.window.avision.type.normal.line_count_msb = (uint8_t) + (line_count >> 16); } if (dev->inquiry_background_raster) - cmd.window.avision.type.normal.background_lines = s->val[OPT_BACKGROUND].w; + cmd.window.avision.type.normal.background_lines = (uint8_t) s->val[OPT_BACKGROUND].w; /* scanner should use our line-width and count */ SET_BIT (cmd.window.avision.bitset1, 6); /* set speed */ - cmd.window.avision.bitset1 |= s->val[OPT_SPEED].w & 0x07; /* only 3 bit */ + cmd.window.avision.bitset1 |= (uint8_t) (s->val[OPT_SPEED].w & 0x07); /* only 3 bit */ /* ADF scan? */ DBG (3, "set_window: source mode %d source mode dim %d\n", @@ -6371,7 +6397,7 @@ set_window (Avision_Scanner* s) /* fixed values */ cmd.window.descriptor.padding_and_bitset = 3; cmd.window.descriptor.vendor_specific = 0xFF; - cmd.window.descriptor.paralen = paralen; /* R² was: 9, later 14 */ + cmd.window.descriptor.paralen = (uint8_t) paralen; /* R² was: 9, later 14 */ /* This is normally unsupported by Avision scanners, and we do this via the gamma table - which works for all devices ... */ @@ -6443,7 +6469,7 @@ set_window (Avision_Scanner* s) debug_print_window_descriptor (5, "set_window", &(cmd.window)); - DBG (3, "set_window: sending command. Bytes: %d\n", transferlen); + DBG (3, "set_window: sending command. Bytes: %zu\n", transferlen); status = avision_cmd (&s->av_con, &cmd, sizeof (cmd.cmd), &(cmd.window), transferlen, 0, 0); @@ -6482,7 +6508,7 @@ get_background_raster (Avision_Scanner* s) dev->inquiry_background_raster_pixel, bytes_per_line); /* according to spec only 8-bit gray or color, TODO: test for bi-level scans */ - size = bytes_per_line * lines; + size = (size_t) bytes_per_line * (size_t) lines; DBG (3, "get_background_raster: buffer size: %ld\n", (long)size); @@ -6518,7 +6544,7 @@ get_background_raster (Avision_Scanner* s) else { this_lines = s->val[OPT_BACKGROUND].w; } - this_read = bytes_per_line * this_lines; + this_read = (size_t) bytes_per_line * (size_t) this_lines; DBG (3, "get_background_raster: line: %d, lines: %d, %lu bytes\n", i, this_lines, (u_long) this_read); @@ -6528,8 +6554,8 @@ get_background_raster (Avision_Scanner* s) read_size = this_read; status = avision_cmd (&s->av_con, &rcmd, sizeof (rcmd), 0, 0, dst_raster, &read_size); if (status != SANE_STATUS_GOOD || read_size != this_read) { - DBG (1, "get_background_raster: read raster failed (%s)\n", - sane_strstatus (status) ); + status = (status != SANE_STATUS_GOOD)? status: SANE_STATUS_IO_ERROR; + DBG (1, "get_background_raster: read raster failed (%s)\n", sane_strstatus (status) ); return status; } @@ -6545,7 +6571,7 @@ get_background_raster (Avision_Scanner* s) write_pnm_header (f, (color_mode_is_color (s->c_mode) ? AV_TRUECOLOR : AV_GRAYSCALE), 8, bytes_per_line / bpp, lines); - fwrite (background, 1, bytes_per_line * lines, f); + fwrite (background, 1, (size_t) bytes_per_line * (size_t) lines, f); fclose (f); } @@ -6555,7 +6581,7 @@ get_background_raster (Avision_Scanner* s) /* TODO: add 16bit per sample code? */ int l, p; - uint8_t* tmp_data = malloc (bytes_per_line); + uint8_t* tmp_data = malloc ((size_t) bytes_per_line); for (l = 0; l < lines; ++l) { uint8_t* out_data = tmp_data; @@ -6569,7 +6595,7 @@ get_background_raster (Avision_Scanner* s) out_data [p++] = *(b_ptr++); } - memcpy (background + (bytes_per_line * l), tmp_data, bytes_per_line); + memcpy (background + (bytes_per_line * l), tmp_data, (size_t) bytes_per_line); } free (tmp_data); @@ -6596,7 +6622,7 @@ get_background_raster (Avision_Scanner* s) src_raster = background + bytes_per_line * i; DBG(3, "get_background_raster: deinterlaced %d -> %d\n", i, dst_i); - memcpy(dst_raster, src_raster, bytes_per_line); + memcpy(dst_raster, src_raster, (size_t) bytes_per_line); } free (background); @@ -6619,7 +6645,7 @@ get_background_raster (Avision_Scanner* s) write_pnm_header (f, (color_mode_is_color (s->c_mode) ? AV_TRUECOLOR : AV_GRAYSCALE), 8, bytes_per_line / bpp, s->val[OPT_BACKGROUND].w); - fwrite (raster, 1, bytes_per_line * s->val[OPT_BACKGROUND].w, f); + fwrite (raster, 1, (size_t) bytes_per_line * (size_t) s->val[OPT_BACKGROUND].w, f); fclose (f); } @@ -6630,7 +6656,7 @@ get_background_raster (Avision_Scanner* s) src_ptr = background + s->avdimen.tlx * bpp; for (i = 0; i < lines; ++i) { - memmove (dst_ptr, src_ptr, s->avdimen.hw_bytes_per_line); + memmove (dst_ptr, src_ptr, (size_t) s->avdimen.hw_bytes_per_line); dst_ptr += s->avdimen.hw_bytes_per_line; src_ptr += bytes_per_line; } @@ -6659,10 +6685,10 @@ get_background_raster (Avision_Scanner* s) switch (bpp) { case 1: { - uint8_t v = - ( out_data [sy*hwbpl + sx ] * (256-xdist) + + uint8_t v = (uint8_t) + (( out_data [sy*hwbpl + sx ] * (256-xdist) + out_data [sy*hwbpl + sxx] * xdist - ) / (256); + ) / (256)); *dst++ = v; } break; @@ -6672,10 +6698,10 @@ get_background_raster (Avision_Scanner* s) int c; for (c = 0; c < 3; ++c) { - uint8_t v = - ( out_data [sy*hwbpl + sx*3 + c] * (256-xdist) + + uint8_t v = (uint8_t) + (( out_data [sy*hwbpl + sx*3 + c] * (256-xdist) + out_data [sy*hwbpl + sxx*3 + c] * xdist - ) / (256); + ) / (256)); *dst++ = v; } } @@ -6702,7 +6728,7 @@ get_background_raster (Avision_Scanner* s) write_pnm_header (f, (color_mode_is_color (s->c_mode) ? AV_TRUECOLOR : AV_GRAYSCALE), 8, s->params.bytes_per_line / bpp, s->val[OPT_BACKGROUND].w); - fwrite (raster, 1, s->params.bytes_per_line * s->val[OPT_BACKGROUND].w, f); + fwrite (raster, 1, (size_t) s->params.bytes_per_line * (size_t) s->val[OPT_BACKGROUND].w, f); fclose (f); } } @@ -6731,7 +6757,7 @@ release_unit (Avision_Scanner* s, int type) SANE_Status status; DBG (1, "release unit: type: %d\n", type); - cmd[5] = type; /* latest scanners also allow 1: release paper and 2: end job */ + cmd[5] = (char) type; /* latest scanners also allow 1: release paper and 2: end job */ status = avision_cmd (&s->av_con, cmd, sizeof (cmd), 0, 0, 0, 0); return status; } @@ -6944,8 +6970,9 @@ init_options (Avision_Scanner* s) case AV_ASIC_C5: dev->dpi_range.min = 80; break; - case AV_ASIC_C6: /* TODO: AV610 in ADF mode does not scan less than 180 or so */ - dev->dpi_range.min = 50; + case AV_ASIC_C6: /* TODO: AV610 in ADF mode does not scan less than 180 or so; */ + /* Scanjet 8250 does not work with 50 in normal mode */ + dev->dpi_range.min = 60; break; case AV_ASIC_C7: /* AV610C2 empirically tested out */ dev->dpi_range.min = 75; @@ -6983,7 +7010,7 @@ init_options (Avision_Scanner* s) s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE; s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE; s->opt[OPT_MODE].type = SANE_TYPE_STRING; - s->opt[OPT_MODE].size = max_string_size (dev->color_list); + s->opt[OPT_MODE].size = (SANE_Int) max_string_size (dev->color_list); s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; s->opt[OPT_MODE].constraint.string_list = dev->color_list; s->val[OPT_MODE].s = strdup (dev->color_list[dev->color_list_default]); @@ -6994,7 +7021,7 @@ init_options (Avision_Scanner* s) s->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE; s->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE; s->opt[OPT_SOURCE].type = SANE_TYPE_STRING; - s->opt[OPT_SOURCE].size = max_string_size(dev->source_list); + s->opt[OPT_SOURCE].size = (SANE_Int) max_string_size(dev->source_list); s->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST; s->opt[OPT_SOURCE].constraint.string_list = &dev->source_list[0]; s->val[OPT_SOURCE].s = strdup(dev->source_list[0]); @@ -7314,7 +7341,7 @@ init_options (Avision_Scanner* s) s->opt[OPT_MESSAGE].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED; s->opt[OPT_MESSAGE].size = 129; s->opt[OPT_MESSAGE].constraint_type = SANE_CONSTRAINT_NONE; - s->val[OPT_MESSAGE].s = malloc(s->opt[OPT_MESSAGE].size); + s->val[OPT_MESSAGE].s = malloc((size_t) s->opt[OPT_MESSAGE].size); s->val[OPT_MESSAGE].s[0] = 0; /* NVRAM */ @@ -7328,7 +7355,7 @@ init_options (Avision_Scanner* s) s->opt[OPT_NVRAM].unit = SANE_UNIT_NONE; s->opt[OPT_NVRAM].size = 1024; s->opt[OPT_NVRAM].constraint_type = SANE_CONSTRAINT_NONE; - s->val[OPT_NVRAM].s = malloc(s->opt[OPT_NVRAM].size); + s->val[OPT_NVRAM].s = malloc((size_t) s->opt[OPT_NVRAM].size); s->val[OPT_NVRAM].s[0] = 0; /* paper_length */ @@ -7472,11 +7499,27 @@ reader_process (void *data) return SANE_STATUS_NO_MEM; if (dev->adf_offset_compensation) { + char duplex_offtmp_fname [] = "/tmp/avision-offtmp-XXXXXX"; + + int fd = mkstemp(duplex_offtmp_fname); + if (fd == -1) { + DBG (1, "reader_process: failed to generate temporary fname for ADF offset compensation temp file\n"); + return SANE_STATUS_NO_MEM; + } + DBG (1, "reader_process: temporary fname for ADF offset compensation temp file: %s\n", + duplex_offtmp_fname); + + if (unlink(duplex_offtmp_fname) == -1) { + DBG(1, "reader_process: failed to delete temporary file prior to use: %s\n", duplex_offtmp_fname); + // continue though. + } + DBG (3, "reader_process: redirecting output data to temp file for ADF offset compensation.\n"); fp_fd = fp; - fp = fopen (s->duplex_offtmp_fname, "w+"); + fp = fdopen (fd, "w+"); if (!fp) { fclose(fp_fd); + close(fd); return SANE_STATUS_NO_MEM; } } @@ -7525,37 +7568,34 @@ reader_process (void *data) if (!s->duplex_rear_valid) { /* create new file for writing */ DBG (3, "reader_process: opening duplex rear file for writing.\n"); rear_fp = fopen (s->duplex_rear_fname, "w"); - if (! rear_fp) { - fclose (fp); - return SANE_STATUS_NO_MEM; - } } else { /* open saved rear data */ DBG (3, "reader_process: opening duplex rear file for reading.\n"); rear_fp = fopen (s->duplex_rear_fname, "r"); - if (! rear_fp) { - fclose (fp); - return SANE_STATUS_IO_ERROR; - } + } + if (! rear_fp) { + fclose (fp); + fclose (fp_fd); + return SANE_STATUS_IO_ERROR; } } /* it takes quite a few lines to saturate the (USB) bus */ - lines_per_stripe = dev->read_stripe_size; + lines_per_stripe = (unsigned int) dev->read_stripe_size; if (s->avdimen.line_difference) - lines_per_stripe += 2 * s->avdimen.line_difference; + lines_per_stripe += (2 * (unsigned int) s->avdimen.line_difference); - stripe_size = s->avdimen.hw_bytes_per_line * lines_per_stripe; - lines_per_output = lines_per_stripe - 2 * s->avdimen.line_difference; + stripe_size = (unsigned int) s->avdimen.hw_bytes_per_line * lines_per_stripe; + lines_per_output = lines_per_stripe - 2 * (unsigned int) s->avdimen.line_difference; if (s->av_con.connection_type == AV_SCSI) /* maybe better not /2 ... */ - max_bytes_per_read = dev->scsi_buffer_size / 2; + max_bytes_per_read = (unsigned int) dev->scsi_buffer_size / 2; else /* vast buffer size to saturate the bus */ max_bytes_per_read = 0x100000; - out_size = s->avdimen.hw_bytes_per_line * lines_per_output; + out_size = (unsigned int) s->avdimen.hw_bytes_per_line * lines_per_output; DBG (3, "dev->scsi_buffer_size / 2: %d\n", dev->scsi_buffer_size / 2); @@ -7576,18 +7616,18 @@ reader_process (void *data) s->avdimen.hw_yres != s->avdimen.yres) { /* layout out_data so that the interpolation history is exactly in front */ - ip_history = malloc (s->avdimen.hw_bytes_per_line + out_size); + ip_history = malloc ((size_t) s->avdimen.hw_bytes_per_line + out_size); out_data = ip_history + s->avdimen.hw_bytes_per_line; - ip_data = malloc (s->params.bytes_per_line); + ip_data = malloc ((size_t) s->params.bytes_per_line); } else { out_data = malloc (out_size); } /* calculate params for the reading loop */ - total_size = s->avdimen.hw_bytes_per_line * - (s->avdimen.hw_lines + 2 * s->avdimen.line_difference); + total_size = (size_t) s->avdimen.hw_bytes_per_line * + ((size_t) s->avdimen.hw_lines + 2 * (size_t) s->avdimen.line_difference); if (deinterlace != NONE && !s->duplex_rear_valid) total_size *= 2; @@ -7599,7 +7639,7 @@ reader_process (void *data) { raw_fp = fopen ("/tmp/sane-avision.raw", "w"); write_pnm_header (fp, s->c_mode, s->params.depth, - s->avdimen.hw_pixels_per_line, total_size / s->avdimen.hw_bytes_per_line); + s->avdimen.hw_pixels_per_line, (int) (total_size / (size_t) s->avdimen.hw_bytes_per_line)); } processed_bytes = 0; @@ -7613,7 +7653,7 @@ reader_process (void *data) background += s->params.bytes_per_line * s->val[OPT_BACKGROUND].w; DBG (5, "reader_process: dumping background raster\n"); - fwrite (background, s->params.bytes_per_line, s->val[OPT_BACKGROUND].w, fp); + fwrite (background, (size_t) s->params.bytes_per_line, (size_t) s->val[OPT_BACKGROUND].w, fp); } /* Data read; loop until all data has been processed. Might exit @@ -7636,7 +7676,7 @@ reader_process (void *data) byte_per_lines, otherwise some scanners freeze. */ if (this_read > max_bytes_per_read) this_read = (max_bytes_per_read - - max_bytes_per_read % s->avdimen.hw_bytes_per_line); + max_bytes_per_read % (unsigned int) s->avdimen.hw_bytes_per_line); if (processed_bytes + this_read > total_size) this_read = total_size - processed_bytes; @@ -7694,7 +7734,7 @@ reader_process (void *data) exit_status = status; } - stripe_fill += this_read; + stripe_fill += (unsigned int) this_read; processed_bytes += this_read; } @@ -7716,7 +7756,7 @@ reader_process (void *data) DBG (5, "reader_process: virtual this_read: %lu\n", (u_long) this_read); got = fread (stripe_data + stripe_fill, 1, this_read, rear_fp); - stripe_fill += got; + stripe_fill += (unsigned int) got; processed_bytes += got; if (got != this_read) exit_status = SANE_STATUS_EOF; @@ -7727,7 +7767,7 @@ reader_process (void *data) useful_bytes = stripe_fill; if (color_mode_is_color (s->c_mode)) - useful_bytes -= 2 * s->avdimen.line_difference * s->avdimen.hw_bytes_per_line; + useful_bytes -= (unsigned int) (2 * s->avdimen.line_difference * s->avdimen.hw_bytes_per_line); DBG (3, "reader_process: useful_bytes %i\n", useful_bytes); @@ -7737,26 +7777,26 @@ reader_process (void *data) if (deinterlace != NONE && !s->duplex_rear_valid) { /* for all lines we have in the buffer: */ - unsigned int absline = (processed_bytes - stripe_fill) / s->avdimen.hw_bytes_per_line; - unsigned int abslines = absline + useful_bytes / s->avdimen.hw_bytes_per_line; + unsigned int absline = (unsigned int) ((processed_bytes - stripe_fill) / (size_t) s->avdimen.hw_bytes_per_line); + unsigned int abslines = absline + useful_bytes / (unsigned int) s->avdimen.hw_bytes_per_line; uint8_t* ptr = stripe_data; for ( ; absline < abslines; ++absline) { DBG (9, "reader_process: deinterlacing line %d\n", absline); /* interlaced? save the back data to the rear buffer */ if ( (deinterlace == STRIPE && absline % (lines_per_stripe*2) >= lines_per_stripe) || - (deinterlace == HALF && absline >= total_size / s->avdimen.hw_bytes_per_line / 2) || + (deinterlace == HALF && absline >= total_size / (size_t) s->avdimen.hw_bytes_per_line / 2) || (deinterlace == LINE && (absline & 0x1)) ) /* last bit equals % 2 */ { DBG (9, "reader_process: saving rear line %d to temporary file.\n", absline); - fwrite (ptr, s->avdimen.hw_bytes_per_line, 1, rear_fp); + fwrite (ptr, (size_t) s->avdimen.hw_bytes_per_line, 1, rear_fp); if (deinterlace == LINE) memmove (ptr, ptr+s->avdimen.hw_bytes_per_line, - stripe_data + stripe_fill - ptr - s->avdimen.hw_bytes_per_line); + (size_t) (stripe_data + stripe_fill - ptr - s->avdimen.hw_bytes_per_line)); else ptr += s->avdimen.hw_bytes_per_line; - useful_bytes -= s->avdimen.hw_bytes_per_line; - stripe_fill -= s->avdimen.hw_bytes_per_line; + useful_bytes -= (unsigned int) s->avdimen.hw_bytes_per_line; + stripe_fill -= (unsigned int) s->avdimen.hw_bytes_per_line; } else ptr += s->avdimen.hw_bytes_per_line; @@ -7766,14 +7806,14 @@ reader_process (void *data) } if ((dev->hw->feature_type & AV_ADF_FLIPPING_DUPLEX) && s->source_mode == AV_ADF_DUPLEX && !(s->page % 2) && !s->duplex_rear_valid) { /* Here we flip the image by writing the lines from the end of the file to the beginning. */ - unsigned int absline = (processed_bytes - stripe_fill) / s->avdimen.hw_bytes_per_line; - unsigned int abslines = absline + useful_bytes / s->avdimen.hw_bytes_per_line; + unsigned int absline = (unsigned int) ((processed_bytes - stripe_fill) / (size_t) s->avdimen.hw_bytes_per_line); + unsigned int abslines = absline + useful_bytes / (unsigned int) s->avdimen.hw_bytes_per_line; uint8_t* ptr = stripe_data; for ( ; absline < abslines; ++absline) { - fseek (rear_fp, ((0 - s->params.lines) - absline - 2) * s->avdimen.hw_bytes_per_line, SEEK_SET); - fwrite (ptr, s->avdimen.hw_bytes_per_line, 1, rear_fp); - useful_bytes -= s->avdimen.hw_bytes_per_line; - stripe_fill -= s->avdimen.hw_bytes_per_line; + fseek (rear_fp, ((0 - s->params.lines) - (SANE_Int) absline - 2) * s->avdimen.hw_bytes_per_line, SEEK_SET); + fwrite (ptr, (size_t) s->avdimen.hw_bytes_per_line, 1, rear_fp); + useful_bytes -= (unsigned int) s->avdimen.hw_bytes_per_line; + stripe_fill -= (unsigned int) s->avdimen.hw_bytes_per_line; ptr += s->avdimen.hw_bytes_per_line; } DBG (9, "reader_process: after page flip: useful_bytes: %d, stripe_fill: %d\n", @@ -7813,16 +7853,16 @@ reader_process (void *data) else if (dev->inquiry_needs_line_pack) /* line-pack */ { /* TODO: add 16bit per sample code? */ - int i = 0, l, p; - const int lines = useful_bytes / s->avdimen.hw_bytes_per_line; + unsigned int i = 0, l, p; + const unsigned int lines = useful_bytes / (unsigned int) s->avdimen.hw_bytes_per_line; for (l = 0; l < lines; ++l) { - uint8_t* r_ptr = stripe_data + (s->avdimen.hw_bytes_per_line * l); + uint8_t* r_ptr = stripe_data + ((unsigned int) s->avdimen.hw_bytes_per_line * l); uint8_t* g_ptr = r_ptr + s->avdimen.hw_pixels_per_line; uint8_t* b_ptr = g_ptr + s->avdimen.hw_pixels_per_line; - for (p = 0; p < s->avdimen.hw_pixels_per_line; ++p) { + for (p = 0; p < (unsigned int) s->avdimen.hw_pixels_per_line; ++p) { out_data [i++] = *(r_ptr++); out_data [i++] = *(g_ptr++); out_data [i++] = *(b_ptr++); @@ -7846,12 +7886,12 @@ reader_process (void *data) /* Mirroring with bgr -> rgb conversion: Just mirror the * whole line */ - int l; - int lines = useful_bytes / s->avdimen.hw_bytes_per_line; + unsigned int l; + unsigned int lines = useful_bytes / (unsigned int) s->avdimen.hw_bytes_per_line; for (l = 0; l < lines; ++l) { - uint8_t* begin_ptr = out_data + (l * s->avdimen.hw_bytes_per_line); + uint8_t* begin_ptr = out_data + (l * (unsigned int) s->avdimen.hw_bytes_per_line); uint8_t* end_ptr = begin_ptr + s->avdimen.hw_bytes_per_line; while (begin_ptr < end_ptr) { @@ -7866,12 +7906,12 @@ reader_process (void *data) { /* Non-trivial Mirroring with element swapping */ - int l; - int lines = useful_bytes / s->avdimen.hw_bytes_per_line; + unsigned int l; + unsigned int lines = useful_bytes / (unsigned int) s->avdimen.hw_bytes_per_line; for (l = 0; l < lines; ++l) { - uint8_t* begin_ptr = out_data + (l * s->avdimen.hw_bytes_per_line); + uint8_t* begin_ptr = out_data + (l * (unsigned int) s->avdimen.hw_bytes_per_line); uint8_t* end_ptr = begin_ptr + s->avdimen.hw_bytes_per_line - 3; while (begin_ptr < end_ptr) { @@ -7904,8 +7944,8 @@ reader_process (void *data) s->c_mode == AV_TRUECOLOR12 || s->c_mode == AV_TRUECOLOR16) { - int l; - int lines = useful_bytes / s->avdimen.hw_bytes_per_line; + unsigned int l; + unsigned int lines = useful_bytes / (unsigned int) s->avdimen.hw_bytes_per_line; uint8_t* dark_avg_data = s->dark_avg_data; uint8_t* white_avg_data = s->white_avg_data; @@ -7923,9 +7963,9 @@ reader_process (void *data) uint16_t white_avg = WHITE_MAP_RANGE; if (dark_avg_data) - dark_avg = get_double_le (dark_avg_data); + dark_avg = (uint16_t) get_double_le (dark_avg_data); if (white_avg_data) - white_avg = get_double_le (white_avg_data); + white_avg = (uint16_t) get_double_le (white_avg_data); line_ptr = begin_ptr; for (l = 0; l < lines; ++ l) @@ -7935,11 +7975,11 @@ reader_process (void *data) if (0) v = (v - dark_avg) * white_avg / WHITE_MAP_RANGE; - v2 = v < 0xFFFF ? v : 0xFFFF; + v2 = ((uint16_t) v) < 0xFFFF ? ((uint16_t) v) : 0xFFFF; /* SANE Standard 3.2.1 "... bytes of each sample value are transmitted in the machine's native byte order." */ - *line_ptr = v2; + *line_ptr = (uint8_t) v2; line_ptr += s->avdimen.hw_bytes_per_line; } @@ -7954,19 +7994,14 @@ reader_process (void *data) /* SOFTWARE SCALING WITH INTERPOLATION (IF NECESSARY) */ - if (s->avdimen.hw_xres == s->avdimen.xres && - s->avdimen.hw_yres == s->avdimen.yres) /* No scaling */ - { - fwrite (out_data, useful_bytes, 1, fp); - line += useful_bytes / s->avdimen.hw_bytes_per_line; - } - else /* Software scaling - watch out - this code bites back! */ + if (s->avdimen.hw_xres != s->avdimen.xres || + s->avdimen.hw_yres != s->avdimen.yres) /* Software scaling */ { int x; /* for convenience in the 16bit code path */ uint16_t* out_data16 = (uint16_t*) out_data; - const int hw_line_end = hw_line + useful_bytes / s->avdimen.hw_bytes_per_line; + const int hw_line_end = hw_line + (int) useful_bytes / s->avdimen.hw_bytes_per_line; /* on-the-fly bi-linear interpolation */ while (1) { @@ -7993,6 +8028,9 @@ reader_process (void *data) break; } + DBG (8, "reader_process: out line: %d <- from: %d-%d\n", + line, sy, syy); + /* convert to offset in current stripe */ sy -= hw_line; syy -= hw_line; @@ -8002,9 +8040,6 @@ reader_process (void *data) sy = -1; } - DBG (8, "reader_process: out line: %d <- from: %d-%d\n", - line, sy, syy); - for (x = 0; x < s->params.pixels_per_line; ++x) { const double bx = (-1.0 + s->avdimen.hw_pixels_per_line) * x / s->params.pixels_per_line; const int sx = (int)floor(bx); @@ -8022,16 +8057,16 @@ reader_process (void *data) /* Repeating this over and over again is not fast, but as a seldom used code-path we want it readable. x/8 is the byte, and x%8 the bit position. */ - v = + v = (unsigned int) ( ( ((out_data [sy*hwbpl + sx/8 ] >> (7-sx%8 )) & 1) * (256-xdist) * (256-ydist) + ((out_data [sy*hwbpl + sxx/8] >> (7-sxx%8)) & 1) * xdist * (256-ydist) + ((out_data [syy*hwbpl + sx/8 ] >> (7-sx%8 )) & 1) * (256-xdist) * ydist + ((out_data [syy*hwbpl + sxx/8] >> (7-sxx%8)) & 1) * xdist * ydist - ) / (1 + 1 * 256); + ) / (1 + 1 * 256)); /* Shift and or the result together and eventually jump to the next byte. */ - *dst = (*dst << 1) | ((v>>7)&1); + *dst = (uint8_t) ((*dst << 1) | ((v>>7)&1)); if (x % 8 == 7) ++dst; } @@ -8039,13 +8074,13 @@ reader_process (void *data) case AV_GRAYSCALE: { - v = + v = (unsigned int) ( ( out_data [sy*hwbpl + sx ] * (256-xdist) * (256-ydist) + out_data [sy*hwbpl + sxx] * xdist * (256-ydist) + out_data [syy*hwbpl + sx ] * (256-xdist) * ydist + out_data [syy*hwbpl + sxx] * xdist * ydist - ) / (256 * 256); - *dst++ = v; + ) / (256 * 256)); + *dst++ = (uint8_t) v; } break; @@ -8053,13 +8088,13 @@ reader_process (void *data) case AV_GRAYSCALE16: { /* TODO: test! */ - v = + v = (unsigned int) ( ( out_data16 [sy*hwbpl + sx ] * (256-xdist) * (256-ydist) + out_data16 [sy*hwbpl + sxx] * xdist * (256-ydist) + out_data16 [syy*hwbpl + sx ] * (256-xdist) * ydist + out_data16 [syy*hwbpl + sxx] * xdist * ydist - ) / (256 * 256); - *dst16++ = v; + ) / (256 * 256)); + *dst16++ = (uint16_t) v; } break; @@ -8068,13 +8103,13 @@ reader_process (void *data) int c; for (c = 0; c < 3; ++c) { - v = + v = (unsigned int) ( ( out_data [sy*hwbpl + sx*3 + c] * (256-xdist) * (256-ydist) + out_data [sy*hwbpl + sxx*3 + c] * xdist * (256-ydist) + out_data [syy*hwbpl + sx*3 + c] * (256-xdist) * ydist + out_data [syy*hwbpl + sxx*3 + c] * xdist * ydist - ) / (256 * 256); - *dst++ = v; + ) / (256 * 256)); + *dst++ = (uint8_t) v; } } break; @@ -8086,13 +8121,13 @@ reader_process (void *data) int c; for (c = 0; c < 3; ++c) { - v = + v = (unsigned int) ( ( out_data16 [sy*hwbpl + sx*3 + c] * (256-xdist) * (256-ydist) + out_data16 [sy*hwbpl + sxx*3 + c] * xdist * (256-ydist) + out_data16 [syy*hwbpl + sx*3 + c] * (256-xdist) * ydist + out_data16 [syy*hwbpl + sxx*3 + c] * xdist * ydist - ) / (256 * 256); - *dst16++ = v; + ) / (256 * 256)); + *dst16++ = (uint16_t) v; } } break; @@ -8101,13 +8136,18 @@ reader_process (void *data) ; /* silence compiler warning */ } } - fwrite (ip_data, s->params.bytes_per_line, 1, fp); + fwrite (ip_data, (size_t) s->params.bytes_per_line, 1, fp); ++line; } /* copy one line of history for the next pass */ memcpy (ip_history, out_data + useful_bytes - s->avdimen.hw_bytes_per_line, - s->avdimen.hw_bytes_per_line); + (size_t) s->avdimen.hw_bytes_per_line); + } + else /* No scaling */ + { + fwrite (out_data, useful_bytes, 1, fp); + line += (int) useful_bytes / s->avdimen.hw_bytes_per_line; } } @@ -8116,7 +8156,7 @@ reader_process (void *data) if (stripe_fill > 0) memcpy (stripe_data, stripe_data + useful_bytes, stripe_fill); - hw_line += useful_bytes / s->avdimen.hw_bytes_per_line; + hw_line += (int) useful_bytes / s->avdimen.hw_bytes_per_line; DBG (3, "reader_process: end of iteration\n"); } /* end while not all lines or inf. mode */ @@ -8131,12 +8171,12 @@ reader_process (void *data) /* maybe we need to fill in some white data */ if (exit_status == SANE_STATUS_EOF && line < s->params.lines) { DBG (3, "reader_process: padding with white data\n"); - memset (out_data, gray_mode ? 0xff : 0x00, s->params.bytes_per_line); + memset (out_data, gray_mode ? 0xff : 0x00, (size_t) s->params.bytes_per_line); DBG (6, "reader_process: padding line %d - %d\n", line, s->params.lines); while (line < s->params.lines) { - fwrite (out_data, s->params.bytes_per_line, 1, fp); + fwrite (out_data, (size_t) s->params.bytes_per_line, 1, fp); ++line; } } @@ -8147,12 +8187,12 @@ reader_process (void *data) long lines; uint8_t* buffer; - buffer = malloc (s->params.bytes_per_line); + buffer = malloc ((size_t) s->params.bytes_per_line); lines = ftell(fp) / s->params.bytes_per_line; rewind(fp); for (long line = 0; line < lines; line++) { - fread(buffer, s->params.bytes_per_line, 1, fp); + fread(buffer, (size_t) s->params.bytes_per_line, 1, fp); if ( (!s->duplex_rear_valid && (line < s->avdimen.offset.front.top)) || (s->duplex_rear_valid && (line < s->avdimen.offset.rear.top)) ) { @@ -8166,7 +8206,7 @@ reader_process (void *data) break; /* nothing more to write, so break out here */ } - fwrite(buffer, s->params.bytes_per_line, 1, fp_fd); + fwrite(buffer, (size_t) s->params.bytes_per_line, 1, fp_fd); } } @@ -8442,7 +8482,7 @@ sane_reload_devices (void) SANE_Status sane_init (SANE_Int* version_code, SANE_Auth_Callback authorize) { - authorize = authorize; /* silence gcc */ + (void) authorize; /* silence gcc */ DBG_INIT(); @@ -8489,9 +8529,9 @@ SANE_Status sane_get_devices (const SANE_Device*** device_list, SANE_Bool local_only) { Avision_Device* dev; - int i; + unsigned int i; - local_only = local_only; /* silence gcc */ + (void) local_only; /* silence gcc */ DBG (3, "sane_get_devices:\n"); @@ -8581,7 +8621,7 @@ sane_open (SANE_String_Const devicename, SANE_Handle *handle) for (i = 0; i < 4; ++ i) for (j = 0; j < 256; ++ j) - s->gamma_table[i][j] = pow( (double) j / 255, one_over_gamma) * 255; + s->gamma_table[i][j] = (SANE_Int) (pow( (double) j / 255, one_over_gamma) * 255); } /* insert newly opened handle into list of open handles: */ @@ -8640,33 +8680,21 @@ sane_open (SANE_String_Const devicename, SANE_Handle *handle) dev->hw->offset.duplex.rear.bottom != 0) ) dev->adf_offset_compensation = SANE_TRUE; - if (dev->adf_offset_compensation) { - strncpy(s->duplex_offtmp_fname, "/tmp/avision-offtmp-XXXXXX", PATH_MAX); - - if (! mktemp(s->duplex_offtmp_fname) ) { - DBG (1, "sane_open: failed to generate temporary fname for ADF offset compensation temp file\n"); - return SANE_STATUS_NO_MEM; - } - else { - DBG (1, "sane_open: temporary fname for ADF offset compensation temp file: %s\n", - s->duplex_offtmp_fname); - } - } - if (dev->inquiry_duplex_interlaced || dev->scanner_type == AV_FILM || dev->hw->feature_type & AV_ADF_FLIPPING_DUPLEX) { /* Might need at least *DOS (Windows flavour and OS/2) portability fix However, I was told Cygwin (et al.) takes care of it. */ + + /* Create the file but close the fd. It is not used to open the file later. :( */ strncpy(s->duplex_rear_fname, "/tmp/avision-rear-XXXXXX", PATH_MAX); - if (! mkstemp(s->duplex_rear_fname) ) { + int fd = mkstemp(s->duplex_rear_fname); + if (fd == -1) { DBG (1, "sane_open: failed to generate temporary fname for duplex scans\n"); return SANE_STATUS_NO_MEM; } - else { - DBG (1, "sane_open: temporary fname for duplex scans: %s\n", - s->duplex_rear_fname); - } + DBG (1, "sane_open: temporary fname for duplex scans: %s\n", s->duplex_rear_fname); + close(fd); } /* calibrate film scanners, as this must be done without the @@ -8713,22 +8741,14 @@ void sane_close (SANE_Handle handle) { Avision_Scanner* prev; - Avision_Scanner* s = handle; + Avision_Scanner* s; int i; DBG (3, "sane_close:\n"); - /* close the device */ - if (avision_is_open (&s->av_con) ) { - avision_close (&s->av_con); - } - - /* remove handle from list of open handles: */ - prev = 0; - for (s = first_handle; s; s = s->next) { + for (prev = 0, s = first_handle; s; prev = s, s = s->next) { if (s == handle) break; - prev = s; } /* a handle we know about ? */ @@ -8740,6 +8760,12 @@ sane_close (SANE_Handle handle) if (s->scanning) do_cancel (handle); + /* close the device */ + if (avision_is_open(&s->av_con)) { + avision_close(&s->av_con); + } + + /* remove handle from list of open handles */ if (prev) prev->next = s->next; else @@ -8764,11 +8790,6 @@ sane_close (SANE_Handle handle) *(s->duplex_rear_fname) = 0; } - if (*(s->duplex_offtmp_fname)) { - unlink (s->duplex_offtmp_fname); - *(s->duplex_offtmp_fname) = 0; - } - free (handle); } @@ -8863,7 +8884,7 @@ sane_control_option (SANE_Handle handle, SANE_Int option, case OPT_GAMMA_VECTOR_R: case OPT_GAMMA_VECTOR_G: case OPT_GAMMA_VECTOR_B: - memcpy (val, s->val[option].wa, s->opt[option].size); + memcpy (val, s->val[option].wa, (size_t) s->opt[option].size); return SANE_STATUS_GOOD; /* string options: */ @@ -8923,7 +8944,7 @@ sane_control_option (SANE_Handle handle, SANE_Int option, case OPT_GAMMA_VECTOR_R: case OPT_GAMMA_VECTOR_G: case OPT_GAMMA_VECTOR_B: - memcpy (s->val[option].wa, val, s->opt[option].size); + memcpy (s->val[option].wa, val, (size_t) s->opt[option].size); return SANE_STATUS_GOOD; /* options with side-effects: */ @@ -9327,7 +9348,7 @@ sane_read (SANE_Handle handle, SANE_Byte* buf, SANE_Int max_len, SANE_Int* len) DBG (8, "sane_read: max_len: %d\n", max_len); - nread = read (s->read_fds, buf, max_len); + nread = read (s->read_fds, buf, (size_t) max_len); if (nread > 0) { DBG (8, "sane_read: got %ld bytes\n", (long) nread); } @@ -9347,7 +9368,7 @@ sane_read (SANE_Handle handle, SANE_Byte* buf, SANE_Int max_len, SANE_Int* len) } } - *len = nread; + *len = (SANE_Int) nread; /* if all data was passed through */ if (nread == 0) |