diff options
Diffstat (limited to 'backend/canon-sane.c')
| -rw-r--r-- | backend/canon-sane.c | 2229 |
1 files changed, 2229 insertions, 0 deletions
diff --git a/backend/canon-sane.c b/backend/canon-sane.c new file mode 100644 index 0000000..79ce0ba --- /dev/null +++ b/backend/canon-sane.c @@ -0,0 +1,2229 @@ +SANE_Status +sane_init (SANE_Int * version_code, SANE_Auth_Callback UNUSEDARG authorize) +{ + char devnam[PATH_MAX] = "/dev/scanner"; + FILE *fp; + + int i, j; + SANE_Byte primary, secondary, inmask, priMask, secMask; + + DBG_INIT (); + DBG (1, ">> sane_init\n"); + +/****** for lineart mode of FB1200S ******/ + for (i = 0; i < 256; i++) + { + primary = secondary = 0; + inmask = 0x80; + priMask = 0x40; + secMask = 0x80; + for (j = 0; j < 4; j++) + { + if (i & inmask) + { + primary |= priMask; + secondary |= secMask; + } + priMask = priMask >> 2; + secMask = secMask >> 2; + inmask = inmask >> 1; + } + primaryHigh[i] = primary; + secondaryHigh[i] = secondary; + + primary = secondary = 0; + priMask = 0x40; + secMask = 0x80; + for (j = 0; j < 4; j++) + { + if (i & inmask) + { + primary |= priMask; + secondary |= secMask; + } + priMask = priMask >> 2; + secMask = secMask >> 2; + inmask = inmask >> 1; + } + primaryLow[i] = primary; + secondaryLow[i] = secondary; + } +/******************************************/ + +#if defined PACKAGE && defined VERSION + DBG (2, "sane_init: " PACKAGE " " VERSION "\n"); +#endif + + if (version_code) + *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0); + + fp = sanei_config_open (CANON_CONFIG_FILE); + if (fp) + { + char line[PATH_MAX]; + size_t len; + + /* read config file */ + /* while (fgets (line, sizeof (line), fp)) */ + while (sanei_config_read (line, sizeof (line), fp)) + { + if (line[0] == '#') /* ignore line comments */ + continue; + len = strlen (line); + /*if (line[len - 1] == '\n') + line[--len] = '\0'; */ + + if (!len) + continue; /* ignore empty lines */ + strcpy (devnam, line); + } + fclose (fp); + } + sanei_config_attach_matching_devices (devnam, attach_one); + DBG (1, "<< sane_init\n"); + return SANE_STATUS_GOOD; +} + +/**************************************************************************/ + +void +sane_exit (void) +{ + CANON_Device *dev, *next; + DBG (1, ">> sane_exit\n"); + + for (dev = first_dev; dev; dev = next) + { + next = dev->next; + free ((void *) dev->sane.name); + free ((void *) dev->sane.model); + free ((void *) dev); + } + + DBG (1, "<< sane_exit\n"); +} + +/**************************************************************************/ + +SANE_Status +sane_get_devices (const SANE_Device *** device_list, +SANE_Bool UNUSEDARG local_only) +{ + static const SANE_Device **devlist = 0; + CANON_Device *dev; + int i; + DBG (1, ">> sane_get_devices\n"); + + if (devlist) + free (devlist); + devlist = malloc ((num_devices + 1) * sizeof (devlist[0])); + if (!devlist) + return (SANE_STATUS_NO_MEM); + + i = 0; + for (dev = first_dev; dev; dev = dev->next) + devlist[i++] = &dev->sane; + devlist[i++] = 0; + + *device_list = devlist; + + DBG (1, "<< sane_get_devices\n"); + return SANE_STATUS_GOOD; +} + +/**************************************************************************/ + +SANE_Status +sane_open (SANE_String_Const devnam, SANE_Handle * handle) +{ + SANE_Status status; + CANON_Device *dev; + CANON_Scanner *s; + int i, j, c; + + DBG (1, ">> sane_open\n"); + + if (devnam[0] == '\0') + { + for (dev = first_dev; dev; dev = dev->next) + { + if (strcmp (dev->sane.name, devnam) == 0) + break; + } + } + else + dev = first_dev; + + if (!dev) + { + status = attach (devnam, &dev); + if (status != SANE_STATUS_GOOD) + return (status); + } + + + if (!dev) + return (SANE_STATUS_INVAL); + + s = malloc (sizeof (*s)); + if (!s) + return SANE_STATUS_NO_MEM; + memset (s, 0, sizeof (*s)); + + s->fd = -1; + s->hw = dev; + + if (s->hw->info.model == FS2710) + { + for (i = 0; i < 4; i++) + { + s->gamma_map[i][0] = '\0'; + s->gamma_table[i][0] = 0; + } + for (j = 1; j < 4096; ++j) + { /* FS2710 needs inital gamma 2.0 */ + c = (int) (256.0 * pow (((double) j) / 4096.0, 0.5)); + for (i = 0; i < 4; i++) + { + s->gamma_map[i][j] = (u_char) c; + if ((j & 0xf) == 0) + s->gamma_table[i][j >> 4] = c; + } + } + s->colour = 1; + s->auxbuf_len = 0; + } + else + { + for (i = 0; i < 4; ++i) + { + for (j = 0; j < 256; ++j) + s->gamma_table[i][j] = j; + } + } + + init_options (s); + + if (s->hw->info.model == FB1200) + s->inbuffer = malloc (30894); /* modification for FB1200S */ + else + s->inbuffer = malloc (15312); /* modification for FB620S */ + + if (!s->inbuffer) + return SANE_STATUS_NO_MEM; + + if (s->hw->info.model == FB1200) + s->outbuffer = malloc (30894); /* modification for FB1200S */ + else + s->outbuffer = malloc (15312); /* modification for FB620S */ + + if (!s->outbuffer) + { + free (s->inbuffer); + return SANE_STATUS_NO_MEM; + } + + s->next = first_handle; + first_handle = s; + + *handle = s; + + DBG (1, "<< sane_open\n"); + return SANE_STATUS_GOOD; + +} + +/**************************************************************************/ + +void +sane_close (SANE_Handle handle) +{ + CANON_Scanner *s = (CANON_Scanner *) handle; + SANE_Status status; + + DBG (1, ">> sane_close\n"); + + if (s->val[OPT_EJECT_BEFOREEXIT].w) + { + if (s->fd == -1) + sanei_scsi_open (s->hw->sane.name, &s->fd, sense_handler, s->hw); + status = medium_position (s->fd); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "sane_close: MEDIUM POSITION failed\n"); + sanei_scsi_close (s->fd); + s->fd = -1; + } + s->AF_NOW = SANE_TRUE; + DBG (1, "sane_close AF_NOW = '%d'\n", s->AF_NOW); + } + + if (s->fd != -1) + sanei_scsi_close (s->fd); + + if (s->inbuffer) + free (s->inbuffer); /* modification for FB620S */ + if (s->outbuffer) + free (s->outbuffer); /* modification for FB620S */ + if (s->auxbuf_len > 0) + free (s->auxbuf); /* modification for FS2710S */ + + free (s); + + DBG (1, ">> sane_close\n"); +} + +/**************************************************************************/ + +const SANE_Option_Descriptor * +sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) +{ + CANON_Scanner *s = handle; + DBG (21, ">> sane_get_option_descriptor option number %d\n", option); + + if ((unsigned) option >= NUM_OPTIONS) + return (0); + + DBG (21, " sane_get_option_descriptor option name %s\n", + option_name[option]); + + DBG (21, "<< sane_get_option_descriptor option number %d\n", option); + return (s->opt + option); +} + +/**************************************************************************/ +SANE_Status +sane_control_option (SANE_Handle handle, SANE_Int option, + SANE_Action action, void *val, SANE_Int * info) +{ + CANON_Scanner *s = handle; + SANE_Status status; + SANE_Word w, cap; + SANE_Byte gbuf[4096]; + size_t buf_size; + int i, neg, gamma_component, int_t, transfer_data_type; + time_t dtime, rt; + + DBG (21, ">> sane_control_option %s\n", option_name[option]); + + if (info) + *info = 0; + + if (s->scanning == SANE_TRUE) + { + DBG (21, ">> sane_control_option: device is busy scanning\n"); + return (SANE_STATUS_DEVICE_BUSY); + } + if (option >= NUM_OPTIONS) + return (SANE_STATUS_INVAL); + + cap = s->opt[option].cap; + if (!SANE_OPTION_IS_ACTIVE (cap)) + return (SANE_STATUS_INVAL); + + if (action == SANE_ACTION_GET_VALUE) + { + DBG (21, "sane_control_option get value of %s\n", option_name[option]); + switch (option) + { + /* word options: */ + case OPT_FLATBED_ONLY: + case OPT_TPU_ON: + case OPT_TPU_PN: + case OPT_TPU_TRANSPARENCY: + case OPT_RESOLUTION_BIND: + case OPT_HW_RESOLUTION_ONLY: /* 990320, ss */ + case OPT_X_RESOLUTION: + case OPT_Y_RESOLUTION: + case OPT_TL_X: + case OPT_TL_Y: + case OPT_BR_X: + case OPT_BR_Y: + case OPT_NUM_OPTS: + case OPT_BRIGHTNESS: + case OPT_CONTRAST: + case OPT_CUSTOM_GAMMA: + case OPT_CUSTOM_GAMMA_BIND: + case OPT_HNEGATIVE: + /* case OPT_GRC: */ + case OPT_MIRROR: + case OPT_AE: + case OPT_PREVIEW: + case OPT_BIND_HILO: + case OPT_HILITE_R: + case OPT_SHADOW_R: + case OPT_HILITE_G: + case OPT_SHADOW_G: + case OPT_HILITE_B: + case OPT_SHADOW_B: + case OPT_EJECT_AFTERSCAN: + case OPT_EJECT_BEFOREEXIT: + case OPT_THRESHOLD: + case OPT_AF: + case OPT_AF_ONCE: + case OPT_FOCUS: + if ((option >= OPT_NEGATIVE) && (option <= OPT_SHADOW_B)) + { + DBG (21, "GET_VALUE for %s: s->val[%s].w = %d\n", + option_name[option], option_name[option], + s->val[option].w); + } + *(SANE_Word *) val = s->val[option].w; + DBG (21, "value for option %s: %d\n", option_name[option], + s->val[option].w); + return (SANE_STATUS_GOOD); + + case OPT_GAMMA_VECTOR: + case OPT_GAMMA_VECTOR_R: + case OPT_GAMMA_VECTOR_G: + case OPT_GAMMA_VECTOR_B: + + memset (gbuf, 0, sizeof (gbuf)); + buf_size = 256; + transfer_data_type = 0x03; + + DBG (21, "sending GET_DENSITY_CURVE\n"); + if (s->val[OPT_CUSTOM_GAMMA_BIND].w == SANE_TRUE) + /* If using bind analog gamma, option will be OPT_GAMMA_VECTOR. + In this case, use the curve for green */ + gamma_component = 2; + else + /* Else use a different index for each curve */ + gamma_component = option - OPT_GAMMA_VECTOR; + + /* Now get the values from the scanner */ + if (s->hw->info.model != FS2710) + { + sanei_scsi_open (s->hw->sane.name, &s->fd, sense_handler, s->hw); + status = + get_density_curve (s->fd, gamma_component, gbuf, &buf_size, + transfer_data_type); + sanei_scsi_close (s->fd); + s->fd = -1; + if (status != SANE_STATUS_GOOD) + { + DBG (21, "GET_DENSITY_CURVE\n"); + return (SANE_STATUS_INVAL); + } + } + else + status = + get_density_curve_fs2710 (s, gamma_component, gbuf, &buf_size); + + neg = (s->hw->info.is_filmscanner) ? + strcmp (filmtype_list[1], s->val[OPT_NEGATIVE].s) + : s->val[OPT_HNEGATIVE].w; + + for (i = 0; i < 256; i++) + { + if (!neg) + s->gamma_table[option - OPT_GAMMA_VECTOR][i] = + (SANE_Int) gbuf[i]; + else + s->gamma_table[option - OPT_GAMMA_VECTOR][i] = + 255 - (SANE_Int) gbuf[255 - i]; + } + + memcpy (val, s->val[option].wa, s->opt[option].size); + DBG (21, "value for option %s: %d\n", option_name[option], + s->val[option].w); + return (SANE_STATUS_GOOD); + + /* string options: */ + case OPT_TPU_DCM: + case OPT_TPU_FILMTYPE: + case OPT_MODE: + case OPT_NEGATIVE: + case OPT_NEGATIVE_TYPE: + case OPT_SCANNING_SPEED: + strcpy (val, s->val[option].s); + DBG (21, "value for option %s: %s\n", option_name[option], + s->val[option].s); + return (SANE_STATUS_GOOD); + + default: + val = 0; + return (SANE_STATUS_GOOD); + } + } + else if (action == SANE_ACTION_SET_VALUE) + { + DBG (21, "sane_control_option set value for %s\n", option_name[option]); + if (!SANE_OPTION_IS_SETTABLE (cap)) + return (SANE_STATUS_INVAL); + + status = sanei_constrain_value (s->opt + option, val, info); + + if (status != SANE_STATUS_GOOD) + return status; + + switch (option) + { + /* (mostly) side-effect-free word options: */ + case OPT_TPU_PN: + case OPT_TPU_TRANSPARENCY: + case OPT_X_RESOLUTION: + case OPT_Y_RESOLUTION: + case OPT_TL_X: + case OPT_TL_Y: + case OPT_BR_X: + case OPT_BR_Y: + if (info && s->val[option].w != *(SANE_Word *) val) + *info |= SANE_INFO_RELOAD_PARAMS; + /* fall through */ + case OPT_NUM_OPTS: + case OPT_BRIGHTNESS: + case OPT_CONTRAST: + case OPT_THRESHOLD: + case OPT_HNEGATIVE: + /* case OPT_GRC: */ + case OPT_MIRROR: + case OPT_AE: + case OPT_PREVIEW: + case OPT_HILITE_R: + case OPT_SHADOW_R: + case OPT_HILITE_G: + case OPT_SHADOW_G: + case OPT_HILITE_B: + case OPT_SHADOW_B: + case OPT_AF_ONCE: + case OPT_FOCUS: + case OPT_EJECT_AFTERSCAN: + case OPT_EJECT_BEFOREEXIT: + s->val[option].w = *(SANE_Word *) val; + DBG (21, "SET_VALUE for %s: s->val[%s].w = %d\n", + option_name[option], option_name[option], s->val[option].w); + return (SANE_STATUS_GOOD); + + case OPT_RESOLUTION_BIND: + if (s->val[option].w != *(SANE_Word *) val) + { + s->val[option].w = *(SANE_Word *) val; + + if (info) + *info |= SANE_INFO_RELOAD_OPTIONS; + if (!s->val[option].w) + { /* don't bind */ + s->opt[OPT_Y_RESOLUTION].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_X_RESOLUTION].title = + SANE_TITLE_SCAN_X_RESOLUTION; + s->opt[OPT_X_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; + s->opt[OPT_X_RESOLUTION].desc = SANE_DESC_SCAN_X_RESOLUTION; + } + else + { /* bind */ + s->opt[OPT_Y_RESOLUTION].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_X_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; + s->opt[OPT_X_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; + s->opt[OPT_X_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; + } + } + return SANE_STATUS_GOOD; + + /* 990320, ss: switch between slider and option menue for resolution */ + case OPT_HW_RESOLUTION_ONLY: + if (s->val[option].w != *(SANE_Word *) val) + { + int iPos, xres, yres; + + s->val[option].w = *(SANE_Word *) val; + + if (info) + *info |= SANE_INFO_RELOAD_OPTIONS; + if (!s->val[option].w) /* use complete range */ + { + s->opt[OPT_X_RESOLUTION].constraint_type = + SANE_CONSTRAINT_RANGE; + s->opt[OPT_X_RESOLUTION].constraint.range = + &s->hw->info.xres_range; + s->opt[OPT_Y_RESOLUTION].constraint_type = + SANE_CONSTRAINT_RANGE; + s->opt[OPT_Y_RESOLUTION].constraint.range = + &s->hw->info.yres_range; + } + else /* use only hardware resolutions */ + { + s->opt[OPT_X_RESOLUTION].constraint_type = + SANE_CONSTRAINT_WORD_LIST; + s->opt[OPT_X_RESOLUTION].constraint.word_list = + s->xres_word_list; + s->opt[OPT_Y_RESOLUTION].constraint_type = + SANE_CONSTRAINT_WORD_LIST; + s->opt[OPT_Y_RESOLUTION].constraint.word_list = + s->yres_word_list; + + /* adjust resolutions */ + xres = s->xres_word_list[1]; + for (iPos = 0; iPos < s->xres_word_list[0]; iPos++) + { + if (s->val[OPT_X_RESOLUTION].w >= + s->xres_word_list[iPos + 1]) + xres = s->xres_word_list[iPos + 1]; + } + s->val[OPT_X_RESOLUTION].w = xres; + + yres = s->yres_word_list[1]; + for (iPos = 0; iPos < s->yres_word_list[0]; iPos++) + { + if (s->val[OPT_Y_RESOLUTION].w >= + s->yres_word_list[iPos + 1]) + yres = s->yres_word_list[iPos + 1]; + } + s->val[OPT_Y_RESOLUTION].w = yres; + } + } + return (SANE_STATUS_GOOD); + + case OPT_BIND_HILO: + if (s->val[option].w != *(SANE_Word *) val) + { + s->val[option].w = *(SANE_Word *) val; + + if (info) + *info |= SANE_INFO_RELOAD_OPTIONS; + if (!s->val[option].w) + { /* don't bind */ + s->opt[OPT_HILITE_R].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_SHADOW_R].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_HILITE_B].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_SHADOW_B].cap &= ~SANE_CAP_INACTIVE; + + s->opt[OPT_HILITE_G].title = SANE_TITLE_HIGHLIGHT_G; + s->opt[OPT_HILITE_G].name = SANE_NAME_HIGHLIGHT_G; + s->opt[OPT_HILITE_G].desc = SANE_DESC_HIGHLIGHT_G; + + s->opt[OPT_SHADOW_G].title = SANE_TITLE_SHADOW_G; + s->opt[OPT_SHADOW_G].name = SANE_NAME_SHADOW_G; + s->opt[OPT_SHADOW_G].desc = SANE_DESC_SHADOW_G; + } + else + { /* bind */ + s->opt[OPT_HILITE_R].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_SHADOW_R].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_HILITE_B].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_SHADOW_B].cap |= SANE_CAP_INACTIVE; + + s->opt[OPT_HILITE_G].title = SANE_TITLE_HIGHLIGHT; + s->opt[OPT_HILITE_G].name = SANE_NAME_HIGHLIGHT; + s->opt[OPT_HILITE_G].desc = SANE_DESC_HIGHLIGHT; + + s->opt[OPT_SHADOW_G].title = SANE_TITLE_SHADOW; + s->opt[OPT_SHADOW_G].name = SANE_NAME_SHADOW; + s->opt[OPT_SHADOW_G].desc = SANE_DESC_SHADOW; + } + } + return SANE_STATUS_GOOD; + + case OPT_AF: + if (info && s->val[option].w != *(SANE_Word *) val) + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + s->val[option].w = *(SANE_Word *) val; + w = *(SANE_Word *) val; + if (w) + { + s->opt[OPT_AF_ONCE].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_FOCUS].cap |= SANE_CAP_INACTIVE; + } + else + { + s->opt[OPT_AF_ONCE].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_FOCUS].cap &= ~SANE_CAP_INACTIVE; + } + return (SANE_STATUS_GOOD); + + case OPT_FLATBED_ONLY: + s->val[option].w = *(SANE_Word *) val; + if (s->hw->adf.Status != ADF_STAT_NONE && s->val[option].w) + { /* switch on */ + s->hw->adf.Priority |= 0x03; /* flatbed mode */ + s->hw->adf.Feeder &= 0x00; /* autofeed off (default) */ + s->hw->adf.Status = ADF_STAT_DISABLED; + } /* if it isn't connected, don't bother fixing */ + return SANE_STATUS_GOOD; + + case OPT_TPU_ON: + s->val[option].w = *(SANE_Word *) val; + if (s->val[option].w) /* switch on */ + { + s->hw->tpu.Status = TPU_STAT_ACTIVE; + s->opt[OPT_TPU_TRANSPARENCY].cap &= + (s->hw->tpu.ControlMode == 3) ? ~SANE_CAP_INACTIVE : ~0; + s->opt[OPT_TPU_FILMTYPE].cap &= + (s->hw->tpu.ControlMode == 1) ? ~SANE_CAP_INACTIVE : ~0; + } + else /* switch off */ + { + s->hw->tpu.Status = TPU_STAT_INACTIVE; + s->opt[OPT_TPU_TRANSPARENCY].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_TPU_FILMTYPE].cap |= SANE_CAP_INACTIVE; + } + s->opt[OPT_TPU_PN].cap ^= SANE_CAP_INACTIVE; + s->opt[OPT_TPU_DCM].cap ^= SANE_CAP_INACTIVE; + if (info) + *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + return SANE_STATUS_GOOD; + + case OPT_TPU_DCM: + if (s->val[OPT_TPU_DCM].s) + free (s->val[OPT_TPU_DCM].s); + s->val[OPT_TPU_DCM].s = strdup (val); + + s->opt[OPT_TPU_TRANSPARENCY].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_TPU_FILMTYPE].cap |= SANE_CAP_INACTIVE; + if (!strcmp (s->val[OPT_TPU_DCM].s, + SANE_I18N("Correction according to transparency ratio"))) + { + s->hw->tpu.ControlMode = 3; + s->opt[OPT_TPU_TRANSPARENCY].cap &= ~SANE_CAP_INACTIVE; + } + else if (!strcmp (s->val[OPT_TPU_DCM].s, + SANE_I18N("Correction according to film type"))) + { + s->hw->tpu.ControlMode = 1; + s->opt[OPT_TPU_FILMTYPE].cap &= ~SANE_CAP_INACTIVE; + } + else + s->hw->tpu.ControlMode = 0; + if (info) + *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + return SANE_STATUS_GOOD; + + case OPT_TPU_FILMTYPE: + if (s->val[option].s) + free (s->val[option].s); + s->val[option].s = strdup (val); + return SANE_STATUS_GOOD; + + case OPT_MODE: + if (info && strcmp (s->val[option].s, (SANE_String) val)) + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + if (s->val[option].s) + free (s->val[option].s); + s->val[option].s = strdup (val); + if (!strcmp (val, SANE_VALUE_SCAN_MODE_LINEART) + || !strcmp (val, SANE_VALUE_SCAN_MODE_HALFTONE)) + { + /* For Lineart and Halftone: */ + /* Enable "threshold" */ + s->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; + + /* Disable "custom gamma" and "brightness & contrast" */ + s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_CUSTOM_GAMMA_BIND].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + + s->opt[OPT_BRIGHTNESS].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE; + } + else + { + /* For Gray and Color modes: */ + /* Disable "threshold" */ + s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; + + /* Enable "custom gamma" and "brightness & contrast" */ + s->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE; + if (s->val[OPT_CUSTOM_GAMMA].w) + { + if (!strcmp (val, SANE_VALUE_SCAN_MODE_COLOR) + || !strcmp (val, SANE_I18N("Fine color"))) + { + s->opt[OPT_CUSTOM_GAMMA_BIND].cap &= ~SANE_CAP_INACTIVE; + if (s->val[OPT_CUSTOM_GAMMA_BIND].w == SANE_TRUE) + { + s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + } + else + { + s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].cap &= + ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].cap &= + ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].cap &= + ~SANE_CAP_INACTIVE; + } + } + else + { + s->opt[OPT_CUSTOM_GAMMA_BIND].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + } + } + else + { + s->opt[OPT_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_CONTRAST].cap &= ~SANE_CAP_INACTIVE; + } + } + return (SANE_STATUS_GOOD); + + case OPT_NEGATIVE: + if (info && strcmp (s->val[option].s, (SANE_String) val)) + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + if (s->val[option].s) + free (s->val[option].s); + s->val[option].s = strdup (val); + if (!strcmp (val, SANE_I18N("Negatives"))) + { + s->RIF = 0; + s->opt[OPT_NEGATIVE_TYPE].cap &= ~SANE_CAP_INACTIVE; + if (SANE_OPTION_IS_SETTABLE(s->opt[OPT_SCANNING_SPEED].cap)) + s->opt[OPT_SCANNING_SPEED].cap &= ~SANE_CAP_INACTIVE; + } + else + { + s->RIF = 1; + s->opt[OPT_NEGATIVE_TYPE].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_SCANNING_SPEED].cap |= SANE_CAP_INACTIVE; + } + return (SANE_STATUS_GOOD); + + case OPT_NEGATIVE_TYPE: + if (info && strcmp (s->val[option].s, (SANE_String) val)) + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + if (s->val[option].s) + free (s->val[option].s); + s->val[option].s = strdup (val); + for (i = 0; strcmp (val, negative_filmtype_list[i]); i++); + s->negative_filmtype = i; + return (SANE_STATUS_GOOD); + + case OPT_SCANNING_SPEED: + if (info && strcmp (s->val[option].s, (SANE_String) val)) + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + if (s->val[option].s) + free (s->val[option].s); + s->val[option].s = strdup (val); + for (i = 0; strcmp (val, scanning_speed_list[i]); i++); + s->scanning_speed = i; + return (SANE_STATUS_GOOD); + + /* modification for FB620S */ + case OPT_CALIBRATION_NOW: + sanei_scsi_open (s->hw->sane.name, &s->fd, sense_handler, s->hw); + if (status == SANE_STATUS_GOOD) + { + status = execute_calibration (s->fd); + if (status != SANE_STATUS_GOOD) + { + DBG (21, "EXECUTE CALIBRATION failed\n"); + sanei_scsi_close (s->fd); + s->fd = -1; + return (SANE_STATUS_INVAL); + } + DBG (21, "EXECUTE CALIBRATION\n"); + sanei_scsi_close (s->fd); + } + else + DBG (1, "calibration: cannot open device file\n"); + s->fd = -1; + return status; + + case OPT_SCANNER_SELF_DIAGNOSTIC: + sanei_scsi_open (s->hw->sane.name, &s->fd, sense_handler, s->hw); + if (status == SANE_STATUS_GOOD) + { + status = send_diagnostic (s->fd); + { + if (status != SANE_STATUS_GOOD) + { + DBG (21, "SEND DIAGNOSTIC error: %s\n", + sane_strstatus (status)); + sanei_scsi_close (s->fd); + s->fd = -1; + return (status); + } + DBG (21, "SEND DIAGNOSTIC result: %s\n", + sane_strstatus (status)); + sanei_scsi_close (s->fd); + } + } + else + DBG (1, "send diagnostic: cannot open device file\n"); + s->fd = -1; + return status; + + case OPT_RESET_SCANNER: + sanei_scsi_open (s->hw->sane.name, &s->fd, sense_handler, s->hw); + if (status == SANE_STATUS_GOOD) + { + time (&(s->time1)); + DBG (11, "time0 = %ld\n", s->time0); + DBG (11, "time1 = %ld\n", s->time1); + dtime = (s->time1) - (s->time0); + DBG (11, "dtime = %ld\n", dtime); + + DBG (11, "switch_preview = %d\n", s->switch_preview); + if (s->switch_preview == 0) + { + rt = sqrt (15 * 15 * (SANE_UNFIX (s->val[OPT_BR_Y].w)) + / 297) + 0.5; + rt = rt + 2; + } + else + rt = 17; + + DBG (11, "SANE_UNFIX(s->val[OPT_BR_Y].w) = %f\n", + SANE_UNFIX (s->val[OPT_BR_Y].w)); + DBG (11, "rt = %ld\n", rt); + + if (dtime < rt) + { + int_t = (int) (rt - dtime); + DBG (11, "int_t = %d\n", int_t); + + sleep (int_t); + } + status = reset_scanner (s->fd); + { + if (status != SANE_STATUS_GOOD) + { + DBG (21, "RESET SCANNER failed\n"); + sanei_scsi_close (s->fd); + s->fd = -1; + return (status); + } + + DBG (21, "RESET SCANNER\n"); + sanei_scsi_close (s->fd); + } + } + else + DBG (1, "reset scanner: cannot open device file\n"); + s->fd = -1; + return status; + + case OPT_EJECT_NOW: + sanei_scsi_open (s->hw->sane.name, &s->fd, sense_handler, s->hw); + status = medium_position (s->fd); + if (status != SANE_STATUS_GOOD) + { + DBG (21, "MEDIUM POSITION failed\n"); + sanei_scsi_close (s->fd); + s->fd = -1; + return (SANE_STATUS_INVAL); + } + DBG (21, "AF_NOW before = '%d'\n", s->AF_NOW); + s->AF_NOW = SANE_TRUE; + DBG (21, "AF_NOW after = '%d'\n", s->AF_NOW); + sanei_scsi_close (s->fd); + s->fd = -1; + return status; + + case OPT_CUSTOM_GAMMA: + w = *(SANE_Word *) val; + + if (w == s->val[OPT_CUSTOM_GAMMA].w) + return SANE_STATUS_GOOD; /* no change */ + + if (info) + *info |= SANE_INFO_RELOAD_OPTIONS; + + s->val[OPT_CUSTOM_GAMMA].w = w; + if (w) + { + const char *mode = s->val[OPT_MODE].s; + + if (!strcmp (mode, SANE_VALUE_SCAN_MODE_GRAY)) + s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE; + else if (!strcmp (mode, SANE_VALUE_SCAN_MODE_COLOR) + || !strcmp (mode, SANE_I18N("Fine color"))) + { + s->opt[OPT_CUSTOM_GAMMA_BIND].cap &= ~SANE_CAP_INACTIVE; + if (s->val[OPT_CUSTOM_GAMMA_BIND].w) + { + s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + } + else + { + s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE; + } + } + s->opt[OPT_BRIGHTNESS].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE; + } + else + { + s->opt[OPT_CUSTOM_GAMMA_BIND].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + + s->opt[OPT_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_CONTRAST].cap &= ~SANE_CAP_INACTIVE; + } + + return SANE_STATUS_GOOD; + + case OPT_CUSTOM_GAMMA_BIND: + w = *(SANE_Word *) val; + + if (w == s->val[OPT_CUSTOM_GAMMA_BIND].w) + return SANE_STATUS_GOOD; /* no change */ + + if (info) + *info |= SANE_INFO_RELOAD_OPTIONS; + + s->val[OPT_CUSTOM_GAMMA_BIND].w = w; + if (w) + { + s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE; + } + else + { + s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE; + s->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE; + } + + return SANE_STATUS_GOOD; + + case OPT_GAMMA_VECTOR: + 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); + DBG (21, "setting gamma vector\n"); +/* if (info) */ +/* *info |= SANE_INFO_RELOAD_OPTIONS; */ + return (SANE_STATUS_GOOD); + + } + } + + DBG (1, "<< sane_control_option %s\n", option_name[option]); + return (SANE_STATUS_INVAL); + +} + +/**************************************************************************/ + +SANE_Status +sane_get_parameters (SANE_Handle handle, SANE_Parameters *params) +{ + CANON_Scanner *s = handle; + DBG (1, ">> sane_get_parameters\n"); + + if (!s->scanning) + { + int width, length, xres, yres; + const char *mode; + + memset (&s->params, 0, sizeof (s->params)); + + width = SANE_UNFIX (s->val[OPT_BR_X].w - s->val[OPT_TL_X].w) + * s->hw->info.mud / MM_PER_INCH; + length = SANE_UNFIX (s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w) + * s->hw->info.mud / MM_PER_INCH; + + xres = s->val[OPT_X_RESOLUTION].w; + yres = s->val[OPT_Y_RESOLUTION].w; + if (s->val[OPT_RESOLUTION_BIND].w || s->val[OPT_PREVIEW].w) + yres = xres; + + /* make best-effort guess at what parameters will look like once + scanning starts. */ + if (xres > 0 && yres > 0 && width > 0 && length > 0) + { + DBG (11, "sane_get_parameters: width='%d', xres='%d', mud='%d'\n", + width, xres, s->hw->info.mud); + s->params.pixels_per_line = width * xres / s->hw->info.mud; + DBG (11, "sane_get_parameters: length='%d', yres='%d', mud='%d'\n", + length, yres, s->hw->info.mud); + s->params.lines = length * yres / s->hw->info.mud; + DBG (11, "sane_get_parameters: pixels_per_line='%d', lines='%d'\n", + s->params.pixels_per_line, s->params.lines); + } + + mode = s->val[OPT_MODE].s; + if (!strcmp (mode, SANE_VALUE_SCAN_MODE_LINEART) + || !strcmp (mode, SANE_VALUE_SCAN_MODE_HALFTONE)) + { + s->params.format = SANE_FRAME_GRAY; + s->params.bytes_per_line = s->params.pixels_per_line / 8; + /* workaround rounding problems */ + s->params.pixels_per_line = s->params.bytes_per_line * 8; + s->params.depth = 1; + } + else if (!strcmp (mode, SANE_VALUE_SCAN_MODE_GRAY)) + { + s->params.format = SANE_FRAME_GRAY; + s->params.bytes_per_line = s->params.pixels_per_line; + s->params.depth = 8; + } + else if (!strcmp (mode, SANE_VALUE_SCAN_MODE_COLOR) + || !strcmp (mode, SANE_I18N("Fine color"))) + { + s->params.format = SANE_FRAME_RGB; + s->params.bytes_per_line = 3 * s->params.pixels_per_line; + s->params.depth = 8; + } + else + { + s->params.format = SANE_FRAME_RGB; + s->params.bytes_per_line = 6 * s->params.pixels_per_line; + s->params.depth = 16; + } + s->params.last_frame = SANE_TRUE; + } + + DBG (11, "sane_get_parameters: xres='%d', yres='%d', pixels_per_line='%d', " + "bytes_per_line='%d', lines='%d'\n", s->xres, s->yres, + s->params.pixels_per_line, s->params.bytes_per_line, s->params.lines); + + if (params) + *params = s->params; + + DBG (1, "<< sane_get_parameters\n"); + return (SANE_STATUS_GOOD); +} + +/**************************************************************************/ + +SANE_Status +sane_start (SANE_Handle handle) +{ + int mode; + char *mode_str; + CANON_Scanner *s = handle; + SANE_Status status; + u_char wbuf[72], dbuf[28], ebuf[72]; + u_char cbuf[2]; /* modification for FB620S */ + size_t buf_size, i; + + char tmpfilename[] = "/tmp/canon.XXXXXX"; /* for FB1200S */ + char *thistmpfile; /* for FB1200S */ + + DBG (1, ">> sane_start\n"); + + s->tmpfile = -1; /* for FB1200S */ + +/******* making a tempfile for 1200 dpi scanning of FB1200S ******/ + if (s->hw->info.model == FB1200) + { + thistmpfile = strdup(tmpfilename); + + if (thistmpfile != NULL) + { + if (mktemp(thistmpfile) == 0) + { + DBG(1, "mktemp(thistmpfile) is failed\n"); + return (SANE_STATUS_INVAL); + } + } + else + { + DBG(1, "strdup(thistmpfile) is failed\n"); + return (SANE_STATUS_INVAL); + } + + s->tmpfile = open(thistmpfile, O_RDWR | O_CREAT | O_EXCL, 0600); + + if (s->tmpfile == -1) + { + DBG(1, "error opening temp file %s\n", thistmpfile); + DBG(1, "errno: %i; %s\n", errno, strerror(errno)); + errno = 0; + return (SANE_STATUS_INVAL); + } + DBG(1, " ****** tmpfile is opened ****** \n"); + + unlink(thistmpfile); + free (thistmpfile); + DBG(1, "free thistmpfile\n"); + } +/******************************************************************/ + + s->scanning = SANE_FALSE; + + if ((s->hw->adf.Status != ADF_STAT_NONE) + && (s->val[OPT_FLATBED_ONLY].w != SANE_TRUE) + && (s->hw->adf.Problem != 0)) + { + DBG (3, "SCANNER ADF HAS A PROBLEM\n"); + if (s->hw->adf.Problem & 0x08) + { + status = SANE_STATUS_COVER_OPEN; + DBG (3, "ADF Cover Open\n"); + } + else if (s->hw->adf.Problem & 0x04) + { + status = SANE_STATUS_JAMMED; + DBG (3, "ADF Paper Jam\n"); + } + else /* adf.Problem = 0x02 */ + { + status = SANE_STATUS_NO_DOCS; + DBG (3, "ADF No More Documents\n"); + } + return status; + } + else if ((s->hw->adf.Status != ADF_STAT_NONE) + && (s->val[OPT_FLATBED_ONLY].w == SANE_TRUE)) + { + set_adf_mode (s->fd, s->hw->adf.Priority); + /* 2.23 define ADF Mode */ + } + + /* First make sure we have a current parameter set. Some of the + parameters will be overwritten below, but that's OK. */ + status = sane_get_parameters (s, 0); + if (status != SANE_STATUS_GOOD) + return status; + + status = sanei_scsi_open (s->hw->sane.name, &s->fd, sense_handler, s->hw); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "open of %s failed: %s\n", s->hw->sane.name, + sane_strstatus (status)); + return (status); + } + +#if 0 /* code moved after define_scan() calls */ + /* Do focus, but not for the preview */ + if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_FOCUS_GROUP].cap) + && !s->val[OPT_PREVIEW].w && s->AF_NOW) + { + if ((status = do_focus (s)) != SANE_STATUS_GOOD) return (status); + if (s->val[OPT_AF_ONCE].w) s->AF_NOW = SANE_FALSE; + } +#endif + + if (s->val[OPT_CUSTOM_GAMMA].w) + { + if ((status = do_gamma (s)) != SANE_STATUS_GOOD) return (status); + } + + DBG (3, "attach: sending GET SCAN MODE for scan control conditions\n"); + memset (ebuf, 0, sizeof (ebuf)); + buf_size = 20; + status = get_scan_mode (s->fd, (u_char) SCAN_CONTROL_CONDITIONS, + ebuf, &buf_size); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "attach: GET SCAN MODE for scan control conditions failed\n"); + sanei_scsi_close (s->fd); + return (SANE_STATUS_INVAL); + } + for (i = 0; i < buf_size; i++) + DBG (3, "scan mode control byte[%d] = %d\n", (int) i, ebuf[i]); + + if (s->hw->adf.Status != ADF_STAT_NONE) + { + DBG (3, "attach: sending GET SCAN MODE for transparency unit\n"); + memset (ebuf, 0, sizeof (ebuf)); + buf_size = 12; + status = get_scan_mode (s->fd, (u_char) TRANSPARENCY_UNIT, + ebuf, &buf_size); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "attach: GET SCAN MODE for transparency unit failed\n"); + sanei_scsi_close (s->fd); + return (SANE_STATUS_INVAL); + } + for (i = 0; i < buf_size; i++) + DBG (3, "scan mode control byte[%d] = %d\n", (int) i, + ebuf[i]); + } + + mode_str = s->val[OPT_MODE].s; + s->xres = s->val[OPT_X_RESOLUTION].w; + s->yres = s->val[OPT_Y_RESOLUTION].w; + + if (s->val[OPT_RESOLUTION_BIND].w || s->val[OPT_PREVIEW].w) + s->yres = s->xres; + + s->ulx = SANE_UNFIX (s->val[OPT_TL_X].w) * s->hw->info.mud / MM_PER_INCH; + s->uly = SANE_UNFIX (s->val[OPT_TL_Y].w) * s->hw->info.mud / MM_PER_INCH; + + s->width = SANE_UNFIX (s->val[OPT_BR_X].w - s->val[OPT_TL_X].w) + * s->hw->info.mud / MM_PER_INCH; + s->length = SANE_UNFIX (s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w) + * s->hw->info.mud / MM_PER_INCH; + + DBG (11, "s->width='%d', s->length='%d'\n", s->width, s->length); + + if (s->hw->info.model != CS2700 && s->hw->info.model != FS2710) + { + if (!strcmp (mode_str, SANE_VALUE_SCAN_MODE_LINEART) + || !strcmp (mode_str, SANE_VALUE_SCAN_MODE_HALFTONE)) + s->RIF = s->val[OPT_HNEGATIVE].w; + else + s->RIF = !s->val[OPT_HNEGATIVE].w; + } + + s->brightness = s->val[OPT_BRIGHTNESS].w; + s->contrast = s->val[OPT_CONTRAST].w; + s->threshold = s->val[OPT_THRESHOLD].w; + s->bpp = s->params.depth; + + s->GRC = s->val[OPT_CUSTOM_GAMMA].w; + s->Mirror = s->val[OPT_MIRROR].w; + s->AE = s->val[OPT_AE].w; + + s->HiliteG = s->val[OPT_HILITE_G].w; + s->ShadowG = s->val[OPT_SHADOW_G].w; + if (s->val[OPT_BIND_HILO].w) + { + s->HiliteR = s->val[OPT_HILITE_G].w; + s->ShadowR = s->val[OPT_SHADOW_G].w; + s->HiliteB = s->val[OPT_HILITE_G].w; + s->ShadowB = s->val[OPT_SHADOW_G].w; + } + else + { + s->HiliteR = s->val[OPT_HILITE_R].w; + s->ShadowR = s->val[OPT_SHADOW_R].w; + s->HiliteB = s->val[OPT_HILITE_B].w; + s->ShadowB = s->val[OPT_SHADOW_B].w; + } + + if (!strcmp (mode_str, SANE_VALUE_SCAN_MODE_LINEART)) + { + mode = 4; + s->image_composition = 0; + } + else if (!strcmp (mode_str, SANE_VALUE_SCAN_MODE_HALFTONE)) + { + mode = 4; + s->image_composition = 1; + } + else if (!strcmp (mode_str, SANE_VALUE_SCAN_MODE_GRAY)) + { + mode = 5; + s->image_composition = 2; + } + else if (!strcmp (mode_str, SANE_VALUE_SCAN_MODE_COLOR) + || !strcmp (mode_str, SANE_I18N("Fine color"))) + { + mode = 6; + s->image_composition = 5; + } + else if (!strcmp (mode_str, SANE_I18N("Raw"))) + { + mode = 6; + s->image_composition = 5; + } + else + { + mode = 6; + s->image_composition = 5; + } + + memset (wbuf, 0, sizeof (wbuf)); + wbuf[7] = 64; + wbuf[10] = s->xres >> 8; + wbuf[11] = s->xres; + wbuf[12] = s->yres >> 8; + wbuf[13] = s->yres; + wbuf[14] = s->ulx >> 24; + wbuf[15] = s->ulx >> 16; + wbuf[16] = s->ulx >> 8; + wbuf[17] = s->ulx; + wbuf[18] = s->uly >> 24; + wbuf[19] = s->uly >> 16; + wbuf[20] = s->uly >> 8; + wbuf[21] = s->uly; + wbuf[22] = s->width >> 24; + wbuf[23] = s->width >> 16; + wbuf[24] = s->width >> 8; + wbuf[25] = s->width; + wbuf[26] = s->length >> 24; + wbuf[27] = s->length >> 16; + wbuf[28] = s->length >> 8; + wbuf[29] = s->length; + wbuf[30] = s->brightness; + wbuf[31] = s->threshold; + wbuf[32] = s->contrast; + wbuf[33] = s->image_composition; + wbuf[34] = (s->hw->info.model == FS2710) ? 12 : s->bpp; + wbuf[36] = 1; + wbuf[37] = (1 << 7) + 0x03; + wbuf[50] = (s->GRC << 3) | (s->Mirror << 2); +#if 1 + wbuf[50] |= s->AE; /* AE also for preview; needed by frontend controls */ +#else + if (!s->val[OPT_PREVIEW].w) wbuf[50] |= s->AE; /* AE not during preview */ +#endif + wbuf[54] = 2; + wbuf[57] = 1; + wbuf[58] = 1; + wbuf[59] = s->HiliteR; + wbuf[60] = s->ShadowR; + wbuf[62] = s->HiliteG; + wbuf[64] = s->ShadowG; + wbuf[70] = s->HiliteB; + wbuf[71] = s->ShadowB; + + DBG (7, "RIF=%d, GRC=%d, Mirror=%d, AE=%d, Speed=%d\n", s->RIF, s->GRC, + s->Mirror, s->AE, s->scanning_speed); + DBG (7, "HR=%d, SR=%d, HG=%d, SG=%d, HB=%d, SB=%d\n", s->HiliteR, + s->ShadowR, s->HiliteG, s->ShadowG, s->HiliteB, s->ShadowB); + + if (s->hw->info.model == FB620) /* modification for FB620S */ + { + wbuf[36] = 0; + wbuf[37] = (s->RIF << 7) + 0x3; + wbuf[50] = s->GRC << 3; + wbuf[54] = 0; + wbuf[57] = 0; + wbuf[58] = 0; + } + else if (s->hw->info.model == FB1200) /* modification for FB1200S */ + { +#if 0 + wbuf[34] = (((600 < s->val[OPT_X_RESOLUTION].w) + || (600 < s->val[OPT_Y_RESOLUTION].w)) + && (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) != 0)) + ? 12 : s->bpp; +#endif + wbuf[36] = 0; + wbuf[37] = (s->RIF << 7) + 0x3; + wbuf[50] = (1 << 4) | (s->GRC << 3); + wbuf[57] = 1; + wbuf[58] = 1; + } + else if (s->hw->info.model == IX4015) /* modification for IX-4015 */ + { + wbuf[36] = 0; + wbuf[37] = (s->RIF << 7); + wbuf[57] = 0; + wbuf[58] = 0; + /* no highlight and shadow control */ + wbuf[59] = 0; + wbuf[60] = 0; + wbuf[62] = 0; + wbuf[64] = 0; + wbuf[70] = 0; + wbuf[71] = 0; + } + + buf_size = sizeof (wbuf); + status = set_window (s->fd, wbuf); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "SET WINDOW failed: %s\n", sane_strstatus (status)); + return (status); + } + if (s->hw->info.model == FS2710) + status = set_parameters_fs2710 (s); + buf_size = sizeof (wbuf); + memset (wbuf, 0, buf_size); + status = get_window (s->fd, wbuf, &buf_size); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "GET WINDOW failed: %s\n", sane_strstatus (status)); + return (status); + } + DBG (5, "xres=%d\n", (wbuf[10] << 8) + wbuf[11]); + DBG (5, "yres=%d\n", (wbuf[12] << 8) + wbuf[13]); + DBG (5, "ulx=%d\n", (wbuf[14] << 24) + (wbuf[15] << 16) + (wbuf[16] << 8) + + wbuf[17]); + DBG (5, "uly=%d\n", (wbuf[18] << 24) + (wbuf[19] << 16) + (wbuf[20] << 8) + + wbuf[21]); + DBG (5, "width=%d\n", (wbuf[22] << 24) + (wbuf[23] << 16) + (wbuf[24] << 8) + + wbuf[25]); + DBG (5, "length=%d\n", (wbuf[26] << 24) + (wbuf[27] << 16) + (wbuf[28] << 8) + + wbuf[29]); + DBG (5, "Highlight Red=%d\n", wbuf[59]); + DBG (5, "Shadow Red=%d\n", wbuf[60]); + DBG (5, "Highlight (Green)=%d\n", wbuf[62]); + DBG (5, "Shadow (Green)=%d\n", wbuf[64]); + DBG (5, "Highlight Blue=%d\n", wbuf[70]); + DBG (5, "Shadow Blue=%d\n", wbuf[71]); + + if (s->hw->tpu.Status == TPU_STAT_ACTIVE || s->hw->info.is_filmscanner) + { + DBG (3, "sane_start: sending DEFINE SCAN MODE for transparency unit, " + "NP=%d, Negative film type=%d\n", !s->RIF, s->negative_filmtype); + memset (wbuf, 0, sizeof (wbuf)); + wbuf[0] = 0x02; + wbuf[1] = 6; + wbuf[2] = 0x80; + wbuf[3] = 0x05; + wbuf[4] = 39; + wbuf[5] = 16; + wbuf[6] = !s->RIF; + wbuf[7] = s->negative_filmtype; + status = define_scan_mode (s->fd, TRANSPARENCY_UNIT, wbuf); + /* note: If we implement a TPU for the FB1200S, we need + TRANSPARENCY_UNIT_FB1200 here. */ + if (status != SANE_STATUS_GOOD) + { + DBG (1, "define scan mode failed: %s\n", sane_strstatus (status)); + return (status); + } + } + + DBG (3, "sane_start: sending DEFINE SCAN MODE for scan control " + "conditions\n"); + memset (wbuf, 0, sizeof (wbuf)); + wbuf[0] = 0x20; + if (s->hw->info.model == FB1200) + { + wbuf[1] = 17; + wbuf[16] = 3; + wbuf[17] = 8; + wbuf[18] = (1 << 7) | (1 << 3); + + DBG (3, "sane_start: sending DEFINE SCAN MODE for scan control " + "conditions of FB1200\n"); + status = define_scan_mode (s->fd, SCAN_CONTROL_CON_FB1200, wbuf); + } + else + { + wbuf[1] = 14; + /* For preview use always normal speed: */ + if (!s->val[OPT_PREVIEW].w && s->hw->info.is_filmscanner) + wbuf[11] = s->scanning_speed; + wbuf[15] = (s->hw->info.model == FB620 + && !strcmp (mode_str, SANE_I18N("Fine color")) + && !s->val[OPT_PREVIEW].w) ? 1 << 3 : 0; + status = define_scan_mode (s->fd, SCAN_CONTROL_CONDITIONS, wbuf); + } + if (status != SANE_STATUS_GOOD) + { + DBG (1, "define scan mode failed: %s\n", sane_strstatus (status)); + return (status); + } + + DBG (3, "sane_start: sending GET SCAN MODE for scan control conditions\n"); + memset (ebuf, 0, sizeof (ebuf)); + buf_size = sizeof (ebuf); + status = get_scan_mode (s->fd, SCAN_CONTROL_CONDITIONS, ebuf, &buf_size); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "sane_start: GET SCAN MODE for scan control conditions " + "failed\n"); + sanei_scsi_close (s->fd); + return (SANE_STATUS_INVAL); + } + for (i = 0; i < buf_size; i++) + DBG (3, "scan mode byte[%d] = %d\n", (int) i, ebuf[i]); + + /* Focus, but not for previews or negatives with speed control */ + if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_FOCUS_GROUP].cap) + && !s->val[OPT_PREVIEW].w && s->AF_NOW + && (s->RIF || s->AE || s->scanning_speed == 0)) + { + if ((status = do_focus (s)) != SANE_STATUS_GOOD) return (status); + if (s->val[OPT_AF_ONCE].w) s->AF_NOW = SANE_FALSE; + } + + /* ============= modification for FB620S ============= */ + DBG (3, "TEST_UNIT_READY\n"); + status = test_unit_ready (s->fd); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "test unit ready failed (%s)\n", sane_strstatus (status)); + sanei_scsi_close (s->fd); + s->fd = -1; + return (status); + } + + if (s->hw->info.can_calibrate) + { + DBG (3, "sane_start: sending GET_CALIBRATION_STATUS\n"); + buf_size = sizeof (cbuf); + memset (cbuf, 0, buf_size); + status = get_calibration_status (s->fd, cbuf, &buf_size); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "sane_start: GET_CALIBRATION_STATUS failed: %s\n", + sane_strstatus (status)); + sanei_scsi_close (s->fd); + s->fd = -1; + return (status); + } + + DBG (1, "cbuf[0] = %d\n", cbuf[0]); + DBG (1, "cbuf[1] = %d\n", cbuf[1]); + + cbuf[0] &= 3; + if (cbuf[0] == 1 || cbuf[0] == 2 || cbuf[0] == 3) + { + status = execute_calibration (s->fd); + DBG (3, "sane_start: EXECUTE_CALIBRATION\n"); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "sane_start: EXECUTE_CALIBRATION failed\n"); + sanei_scsi_close (s->fd); + s->fd = -1; + return (status); + } + + DBG (3, "after calibration: GET_CALIBRATION_STATUS\n"); + buf_size = sizeof (cbuf); + memset (cbuf, 0, buf_size); + status = get_calibration_status (s->fd, cbuf, &buf_size); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "after calibration: GET_CALIBRATION_STATUS failed: %s\n", + sane_strstatus (status)); + sanei_scsi_close (s->fd); + s->fd = -1; + return (status); + } + DBG (1, "cbuf[0] = %d\n", cbuf[0]); + DBG (1, "cbuf[1] = %d\n", cbuf[1]); + } + } + + status = scan (s->fd); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "start of scan failed: %s\n", sane_strstatus (status)); + return (status); + } + + buf_size = sizeof (dbuf); + memset (dbuf, 0, buf_size); + status = get_data_status (s->fd, dbuf, &buf_size); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "GET DATA STATUS failed: %s\n", sane_strstatus (status)); + return (status); + } + DBG (5, ">> GET DATA STATUS\n"); + DBG (5, "Scan Data Available=%d\n", (dbuf[9] << 16) + (dbuf[10] << 8) + + dbuf[11]); + DBG (5, "Magnified Width=%d\n", (dbuf[12] <<24) + (dbuf[13] << 16) + + (dbuf[14] << 8) + dbuf[15]); + DBG (5, "Magnified Length=%d\n", (dbuf[16] << 24) + (dbuf[17] << 16) + + (dbuf[18] << 8) + dbuf[19]); + DBG (5, "Rest Data=%d bytes\n", (dbuf[20] << 24) + (dbuf[21] << 16) + + (dbuf[22] << 8) + dbuf[23]); + DBG (5, "Filled Data Buffer=%d\n", (dbuf[24] << 24) + (dbuf[25] << 16) + + (dbuf[26] << 8) + dbuf[27]); + DBG (5, "<< GET DATA STATUS\n"); + + s->bytes_to_read = s->params.bytes_per_line * s->params.lines; + + if (s->hw->info.model == FB1200) + { + if (s->bytes_to_read != (((size_t) dbuf[9] << 16) + + ((size_t) dbuf[10] << 8) + (size_t) dbuf[11])) + { + s->params.bytes_per_line = (((size_t) dbuf[12] << 24) + + ((size_t) dbuf[13] << 16) + ((size_t) dbuf[14] << 8) + + (size_t)dbuf[15]); + s->params.lines = (((size_t) dbuf[16] << 24) + + ((size_t) dbuf[17] << 16) + ((size_t) dbuf[18] << 8) + + (size_t) dbuf[19]); + s->bytes_to_read = s->params.bytes_per_line * s->params.lines; + + mode_str = s->val[OPT_MODE].s; + if (!strcmp (mode_str, SANE_VALUE_SCAN_MODE_LINEART)) + { + if (((600 < s->val[OPT_X_RESOLUTION].w) + || (600 < s->val[OPT_Y_RESOLUTION].w))) + { + s->params.bytes_per_line *= 2; + s->params.lines /= 2; + } + s->params.pixels_per_line = s->params.bytes_per_line * 8; + } + else if (!strcmp (mode_str, SANE_VALUE_SCAN_MODE_GRAY)) + s->params.pixels_per_line = s->params.bytes_per_line; + else if (!strcmp (mode_str, SANE_VALUE_SCAN_MODE_COLOR) + || !strcmp (mode_str, SANE_I18N("Fine color"))) + s->params.pixels_per_line = s->params.bytes_per_line / 3; + else + s->params.pixels_per_line = s->params.bytes_per_line / 6; + } + } + + DBG (1, "%d pixels per line, %d bytes, %d lines high, total %lu bytes, " + "dpi=%d\n", s->params.pixels_per_line, s->params.bytes_per_line, + s->params.lines, (u_long) s->bytes_to_read, + s->val[OPT_X_RESOLUTION].w); + +/**************************************************/ +/* modification for FB620S and FB1200S */ + s->buf_used = 0; + s->buf_pos = 0; +/**************************************************/ + + s->scanning = SANE_TRUE; + + DBG (1, "<< sane_start\n"); + return (SANE_STATUS_GOOD); +} + +/**************************************************************************/ + +static SANE_Status +sane_read_direct (SANE_Handle handle, SANE_Byte *buf, SANE_Int max_len, + SANE_Int *len) +{ + CANON_Scanner *s = handle; + SANE_Status status; + size_t nread; + + DBG (21, ">> sane_read\n"); + + *len = 0; + nread = max_len; + + DBG (21, " sane_read: nread=%d, bytes_to_read=%d\n", (int) nread, + (int) s->bytes_to_read); + if (s->bytes_to_read == 0) + { + do_cancel (s); + return (SANE_STATUS_EOF); + } + + if (!s->scanning) return (do_cancel (s)); + + if (nread > s->bytes_to_read) nread = s->bytes_to_read; + status = read_data (s->fd, buf, &nread); + if (status != SANE_STATUS_GOOD) + { + do_cancel (s); + return (SANE_STATUS_IO_ERROR); + } + *len = nread; + s->bytes_to_read -= nread; + + DBG (21, " sane_read: nread=%d, bytes_to_read=%d\n", (int) nread, + (int) s->bytes_to_read); + DBG (21, "<< sane_read\n"); + return (SANE_STATUS_GOOD); +} + +/**************************************************************************/ + +static SANE_Status +read_fs2710 (SANE_Handle handle, SANE_Byte *buf, SANE_Int max_len, + SANE_Int *len) +{ + CANON_Scanner *s = handle; + SANE_Status status; + int c; + size_t i, nread, nread2; + u_char *p; +#if defined(WORDS_BIGENDIAN) + u_char b; +#endif + + DBG (21, ">> sane_read\n"); + + *len = 0; + nread = max_len; + + DBG (21, " sane_read: nread=%d, bytes_to_read=%d\n", (int) nread, + (int) s->bytes_to_read); + + if (nread > s->bytes_to_read) nread = s->bytes_to_read; + if (s->bytes_to_read == 0) + { + do_cancel (s); + return (SANE_STATUS_EOF); + } + + if (!s->scanning) return (do_cancel (s)); + + /* We must receive 2 little-endian bytes per pixel and colour. + In raw mode we must swap the bytes if we are running a big-endian + architecture (SANE standard 3.2.1), and pass them both. + Otherwise the other subroutines expect only 1 byte, so we must + set up an intermediate buffer which is twice as large + as buf, and then map this buffer to buf. */ + + if (!strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR)) + { + if (max_len > s->auxbuf_len) + { /* extend buffer? */ + if (s->auxbuf_len > 0) free (s->auxbuf); + s->auxbuf_len = max_len; + if ((s->auxbuf = (u_char *) malloc (2 * max_len)) == NULL) + { + DBG (1, "sane_read buffer size insufficient\n"); + do_cancel (s); + return SANE_STATUS_NO_MEM; + } + } + + nread2 = 2 * nread; + if ((status = read_data (s->fd, s->auxbuf, &nread2)) != SANE_STATUS_GOOD) + { + do_cancel (s); + return (SANE_STATUS_IO_ERROR); + } + nread = nread2 / 2; + for (i = 0, p = s->auxbuf; i < nread; i++) + { + c = *p++ >> 4; + c |= *p++ << 4; + *buf++ = s->gamma_map[s->colour++][c]; + if (s->colour > 3) s->colour = 1; /* cycle through RGB */ + } + } + else + { + if ((status = read_data (s->fd, buf, &nread)) != SANE_STATUS_GOOD) + { + do_cancel (s); + return (SANE_STATUS_IO_ERROR); + } +#if defined(WORDS_BIGENDIAN) + for (p = buf; p < buf + nread; p++) + { + b = *p; + *p = *(p + 1); + p++; + *p = b; + } +#endif + } + *len = nread; + s->bytes_to_read -= nread; + + DBG (21, " sane_read: nread=%d, bytes_to_read=%d\n", (int) nread, + (int) s->bytes_to_read); + DBG (21, "<< sane_read\n"); + return (SANE_STATUS_GOOD); +} + +/**************************************************************************/ +/* modification for FB620S */ + +static SANE_Status +read_fb620 (SANE_Handle handle, SANE_Byte *buf, SANE_Int max_len, + SANE_Int *len) +{ + CANON_Scanner *s = handle; + SANE_Status status; + SANE_Byte *out, *red, *green, *blue; + SANE_Int ncopy; + size_t nread = 0, i, pixel_per_line; + + DBG (21, ">> read_fb620\n"); + + *len = 0; + + DBG (21, " read_fb620: nread=%d, bytes_to_read=%d\n", (int) nread, + (int) s->bytes_to_read); + + if (s->bytes_to_read == 0 && s->buf_pos == s->buf_used) + { + s->reset_flag = 0; /* no reset */ + + do_cancel (s); + DBG (21, "do_cancel(EOF)\n"); + DBG (21, "reset_flag = %d\n", s->reset_flag); + return (SANE_STATUS_EOF); + } + else + { + s->reset_flag = 1; /* do reset */ + DBG (21, "reset_flag = %d\n", s->reset_flag); + } + DBG (21, " read_fb620: buf_pos=%d, buf_used=%d\n", s->buf_pos, + s->buf_used); + + if (!s->scanning) + return (do_cancel (s)); + + if (s->buf_pos < s->buf_used) + { + ncopy = s->buf_used - s->buf_pos; + if (ncopy > max_len) + ncopy = max_len; + memcpy (buf, &(s->outbuffer[s->buf_pos]), ncopy); + + max_len -= ncopy; + *len += ncopy; + buf = &(buf[ncopy]); + s->buf_pos += ncopy; + } + + if (s->buf_pos >= s->buf_used && s->bytes_to_read) + { + /* buffer is empty: read in scan line and sort color data as shown + above */ + + nread = s->params.bytes_per_line; + + if (nread > s->bytes_to_read) + nread = s->bytes_to_read; + + status = read_data (s->fd, s->inbuffer, &nread); + + if (status != SANE_STATUS_GOOD) + { + do_cancel (s); + return (SANE_STATUS_IO_ERROR); + } + + s->buf_used = s->params.bytes_per_line; + + out = s->outbuffer; + pixel_per_line = s->params.pixels_per_line; + + red = s->inbuffer; + green = &(s->inbuffer[pixel_per_line]); + blue = &(s->inbuffer[2 * pixel_per_line]); + + for (i = 0; i < pixel_per_line; i++) + { + *out++ = *red++; + *out++ = *green++; + *out++ = *blue++; + } + + s->buf_pos = 0; + + s->bytes_to_read -= s->buf_used; + + } + + if (max_len && s->buf_pos < s->buf_used) + { + ncopy = s->buf_used - s->buf_pos; + if (ncopy > max_len) + ncopy = max_len; + memcpy (buf, &(s->outbuffer[s->buf_pos]), ncopy); + *len += ncopy; + s->buf_pos += ncopy; + } + + DBG (21, "<< read_fb620\n"); + return (SANE_STATUS_GOOD); +} + +/**************************************************************************/ +/* modification for FB1200S */ + +static SANE_Status +read_fb1200 (SANE_Handle handle, SANE_Byte *buf, SANE_Int max_len, +SANE_Int *len) +{ + CANON_Scanner *s = handle; + SANE_Status status; + SANE_Byte *firstimage, *secondimage/*, inmask, outmask, outbyte, + primaryHigh[256], primaryLow[256], secondaryHigh[256], + secondaryLow[256] */; + SANE_Int ncopy; + u_char dbuf[28]; + size_t buf_size, nread, remain, nwritten, nremain, pos, pix, pixel_per_line, + byte, byte_per_line/*, bit*/; + ssize_t wres, readres; + int maxpix; + + DBG (21, ">> read_fb1200\n"); + + buf_size = sizeof (dbuf); + memset (dbuf, 0, buf_size); + status = get_data_status (s->fd, dbuf, &buf_size); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "GET DATA STATUS failed: %s\n", sane_strstatus (status)); + return (status); + } + DBG (5, ">> GET DATA STATUS\n"); + DBG (5, "Scan Data Available=%d\n", (dbuf[9] << 16) + (dbuf[10] << 8) + + dbuf[11]); + DBG (5, "Rest Data=%d bytes\n", (dbuf[20] << 24) + (dbuf[21] << 16) + + (dbuf[22] << 8) + dbuf[23]); + DBG (5, "Filled Data Buffer=%d\n", (dbuf[24] << 24) + (dbuf[25] << 16) + + (dbuf[26] << 8) + dbuf[27]); + DBG (5, "temp file position:%u\n", (unsigned int) lseek(s->tmpfile, + 0, SEEK_CUR)); + DBG (5, "<< GET DATA STATUS\n"); + + *len = 0; + + DBG (21, " read_fb1200: bytes_to_read=%d\n", + (int) s->bytes_to_read); + + if (s->bytes_to_read == 0 && s->buf_pos == s->buf_used) + { + do_cancel (s); + DBG (21, "do_cancel(EOF)\n"); + return (SANE_STATUS_EOF); + } + + DBG (21, " read_fb1200: buf_pos=%d, buf_used=%d\n", s->buf_pos, + s->buf_used); + + if (!s->scanning) + return (do_cancel (s)); + + if (s->buf_pos >= s->buf_used && s->bytes_to_read) + { + nread = s->params.bytes_per_line / 2; + + if (nread > s->bytes_to_read) + nread = s->bytes_to_read; + + status = read_data (s->fd, s->inbuffer, &nread); + + if (status != SANE_STATUS_GOOD) + { + do_cancel (s); + return (SANE_STATUS_IO_ERROR); + } + + /**** save the primary scan data to tmpfile ****/ + + if ((SANE_Int) s->bytes_to_read > s->params.bytes_per_line + * s->params.lines / 2) + { + remain = nread; + nwritten = 0; + while (remain) + { + errno = 0; + wres = write (s->tmpfile, &s->inbuffer[nwritten], remain); + if (wres == -1) + { + DBG(1, "error write tmp file: %i, %s\n", errno, + strerror(errno)); + do_cancel(s); + return (SANE_STATUS_NO_MEM); + } + remain -= wres; + nwritten += wres; + } + + s->bytes_to_read -= nread; + + if ((SANE_Int) s->bytes_to_read <= s->params.bytes_per_line + * s->params.lines / 2) + { + if ((SANE_Int) s->bytes_to_read < s->params.bytes_per_line + * s->params.lines / 2) + DBG(1, "warning: read more data for the primary scan " + "than expected\n"); + + lseek (s->tmpfile, 0L, SEEK_SET); + *len = 0; + *buf = 0; + return (SANE_STATUS_GOOD); + } + + DBG(1, "writing: the primary data to tmp file\n"); + *len = 0; + *buf = 0; + return (SANE_STATUS_GOOD); + } + /** the primary scan data from tmpfile and the secondary scan data + are merged **/ + + s->buf_used = s->params.bytes_per_line; + byte_per_line = s->params.bytes_per_line; + pixel_per_line = s->params.pixels_per_line; + + + /** read an entire scan line from the primary scan **/ + + remain = nread; + pos = 0; + firstimage = &(s->inbuffer[byte_per_line/2]); + + while (remain > 0) + { + nremain = (remain < SSIZE_MAX)? remain: SSIZE_MAX; + errno = 0; + readres = read (s->tmpfile, &(firstimage[pos]), nremain); + if (readres == -1) + { + DBG(1, "error reading tmp file: %i %s\n", errno, + strerror(errno)); + do_cancel(s); + return (SANE_STATUS_IO_ERROR); + } + if (readres == 0) + { + DBG(1, "0 byte read from temp file. premature EOF?\n"); + return (SANE_STATUS_INVAL); + /* perhaps an error return? */ + } + DBG(1, "reading: the primary data from tmp file\n"); + remain -= readres; + pos += readres; + } + + secondimage = s->inbuffer; + + if (!strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR)) + { + maxpix = pixel_per_line / 2; + for (pix = 0; (int) pix < maxpix; pix++) + { + s->outbuffer[6 * pix] = secondimage[3 * pix]; + s->outbuffer[6 * pix + 1] = secondimage[3 * pix + 1]; + s->outbuffer[6 * pix + 2] = secondimage[3 * pix + 2]; + s->outbuffer[6 * pix + 3] = firstimage[3 * pix]; + s->outbuffer[6 * pix + 4] = firstimage[3 * pix + 1]; + s->outbuffer[6 * pix + 5] = firstimage[3 * pix + 2]; + } + } + else if (!strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_GRAY)) + { + for (pix = 0; pix < pixel_per_line / 2; pix++) + { + s->outbuffer[2 * pix] = secondimage[pix]; + s->outbuffer[2 * pix + 1] = firstimage[pix]; + } + } + else /* for lineart mode */ + { + maxpix = byte_per_line / 2; + for (byte = 0; (int) byte < maxpix; byte++) + { + s->outbuffer[2 * byte] = primaryHigh[firstimage[byte]] + | secondaryHigh[secondimage[byte]]; + s->outbuffer[2 * byte + 1] = primaryLow[firstimage[byte]] + | secondaryLow[secondimage[byte]]; +#if 0 + inmask = 128; + outmask = 128; + outbyte = 0; + for (bit = 0; bit < 4; bit++) + { + if (inmask == (secondimage[byte] & inmask)) + outbyte = outbyte | outmask; + outmask = outmask >> 1; + if (inmask == (firstimage[byte] & inmask)) + outbyte = outbyte | outmask; + outmask = outmask >> 1; + inmask = inmask >> 1; + } + s->outbuffer[2 * byte] = outbyte; + + outmask = 128; + outbyte = 0; + for (bit = 0; bit < 4; bit++) + { + if (inmask == (secondimage[byte] & inmask)) + outbyte = outbyte | outmask; + outmask = outmask >> 1; + if (inmask == (firstimage[byte] & inmask)) + outbyte = outbyte | outmask; + outmask = outmask >> 1; + inmask = inmask >> 1; + } + s->outbuffer[2 * byte + 1] = outbyte; +#endif + } + } + + s->buf_pos = 0; + s->bytes_to_read -= nread; + } + + if (max_len && s->buf_pos < s->buf_used) + { + ncopy = s->buf_used - s->buf_pos; + if (ncopy > max_len) + ncopy = max_len; + memcpy (buf, &(s->outbuffer[s->buf_pos]), ncopy * 2); + *len += ncopy; + s->buf_pos += ncopy; + } + + DBG (21, "<< read_fb1200\n"); + return (SANE_STATUS_GOOD); +} + +/**************************************************************************/ +SANE_Status +sane_read (SANE_Handle handle, SANE_Byte *buf, SANE_Int max_len, + SANE_Int *len) +{ + CANON_Scanner *s = handle; + SANE_Status status; + if (s->hw->info.model == FB620 && s->params.format == SANE_FRAME_RGB) + status = read_fb620 (handle, buf, max_len, len); + else if (s->hw->info.model == FS2710) + status = read_fs2710 (handle, buf, max_len, len); + else if (s->hw->info.model == FB1200 && ((600 < s->val[OPT_X_RESOLUTION].w) + || (600 < s->val[OPT_Y_RESOLUTION].w))) + status = read_fb1200 (handle, buf, max_len, len); + else + status = sane_read_direct (handle, buf, max_len, len); + if (s->time0 == -1) + s->time0 = 0; + else + time (&(s->time0)); + + DBG (11, "sane_read: time0 = %ld\n", s->time0); + s->switch_preview = s->val[OPT_PREVIEW].w; + return (status); +} + +/**************************************************************************/ + +void +sane_cancel (SANE_Handle handle) +{ + CANON_Scanner *s = handle; + DBG (1, ">> sane_cancel\n"); + +/******** for FB1200S ************/ + if(s->hw->info.model == FB1200) + { + if (s->tmpfile != -1) + { + close (s->tmpfile); + DBG(1, " ****** tmpfile is closed ****** \n"); + } + else + { + DBG(1, "tmpfile is failed\n"); +/* return (SANE_STATUS_INVAL);*/ + } + } +/*********************************/ + + s->scanning = SANE_FALSE; + DBG (1, "<< sane_cancel\n"); +} + +/**************************************************************************/ + +SANE_Status +sane_set_io_mode (SANE_Handle UNUSEDARG handle, +SANE_Bool UNUSEDARG non_blocking) +{ + DBG (1, ">> sane_set_io_mode\n"); + DBG (1, "<< sane_set_io_mode\n"); + return SANE_STATUS_UNSUPPORTED; +} + +/**************************************************************************/ + +SANE_Status +sane_get_select_fd (SANE_Handle UNUSEDARG handle, +SANE_Int UNUSEDARG * fd) +{ + DBG (1, ">> sane_get_select_fd\n"); + DBG (1, "<< sane_get_select_fd\n"); + + return SANE_STATUS_UNSUPPORTED; +} + +/**************************************************************************/ |