Lines Matching refs:scanner
58 . - sane_get_devices() : query list of scanner-devices
59 . - sane_open() : open a particular scanner-device and attach_scanner(devicename,&dev)
61 . . - sane_get_select_fd : get scanner-fd
75 . - sane_close() : close opened scanner-device, do_cancel, free buffer and handle
141 #include "umax-scanner.c"
490 DBG(DBG_inquiry,"scanner capability (%02x, %02x, %02x):\n",
1082 static void umax_set_rgb_bind(Umax_Scanner *scanner)
1084 if ( (scanner->val[OPT_RGB_BIND].w == SANE_FALSE) &&
1085 (strcmp(scanner->val[OPT_MODE].s, COLOR_STR) == 0) ) /* enable rgb options */
1087 if (scanner->device->inquiry_analog_gamma)
1089 scanner->opt[OPT_ANALOG_GAMMA].cap |= SANE_CAP_INACTIVE;
1090 scanner->opt[OPT_ANALOG_GAMMA_R].cap &= ~SANE_CAP_INACTIVE;
1091 scanner->opt[OPT_ANALOG_GAMMA_G].cap &= ~SANE_CAP_INACTIVE;
1092 scanner->opt[OPT_ANALOG_GAMMA_B].cap &= ~SANE_CAP_INACTIVE;
1094 if (scanner->device->inquiry_highlight)
1096 scanner->opt[OPT_HIGHLIGHT].cap |= SANE_CAP_INACTIVE;
1097 scanner->opt[OPT_HIGHLIGHT_R].cap &= ~SANE_CAP_INACTIVE;
1098 scanner->opt[OPT_HIGHLIGHT_G].cap &= ~SANE_CAP_INACTIVE;
1099 scanner->opt[OPT_HIGHLIGHT_B].cap &= ~SANE_CAP_INACTIVE;
1101 if (scanner->device->inquiry_shadow)
1103 scanner->opt[OPT_SHADOW].cap |= SANE_CAP_INACTIVE;
1104 scanner->opt[OPT_SHADOW_R].cap &= ~SANE_CAP_INACTIVE;
1105 scanner->opt[OPT_SHADOW_G].cap &= ~SANE_CAP_INACTIVE;
1106 scanner->opt[OPT_SHADOW_B].cap &= ~SANE_CAP_INACTIVE;
1111 if (scanner->device->inquiry_analog_gamma)
1113 scanner->opt[OPT_ANALOG_GAMMA].cap &= ~SANE_CAP_INACTIVE;
1114 scanner->opt[OPT_ANALOG_GAMMA_R].cap |= SANE_CAP_INACTIVE;
1115 scanner->opt[OPT_ANALOG_GAMMA_G].cap |= SANE_CAP_INACTIVE;
1116 scanner->opt[OPT_ANALOG_GAMMA_B].cap |= SANE_CAP_INACTIVE;
1118 if (scanner->device->inquiry_highlight)
1120 scanner->opt[OPT_HIGHLIGHT].cap &= ~SANE_CAP_INACTIVE;
1121 scanner->opt[OPT_HIGHLIGHT_R].cap |= SANE_CAP_INACTIVE;
1122 scanner->opt[OPT_HIGHLIGHT_G].cap |= SANE_CAP_INACTIVE;
1123 scanner->opt[OPT_HIGHLIGHT_B].cap |= SANE_CAP_INACTIVE;
1125 if (scanner->device->inquiry_shadow)
1127 scanner->opt[OPT_SHADOW].cap &= ~SANE_CAP_INACTIVE;
1128 scanner->opt[OPT_SHADOW_R].cap |= SANE_CAP_INACTIVE;
1129 scanner->opt[OPT_SHADOW_G].cap |= SANE_CAP_INACTIVE;
1130 scanner->opt[OPT_SHADOW_B].cap |= SANE_CAP_INACTIVE;
1134 if ( (scanner->device->inquiry_exposure_adj) && (scanner->val[OPT_SELECT_EXPOSURE_TIME].w) )
1136 if ( (scanner->val[OPT_RGB_BIND].w == SANE_FALSE) &&
1137 (!scanner->device->exposure_time_rgb_bind) &&
1138 (strcmp(scanner->val[OPT_MODE].s, COLOR_STR) == 0) ) /* enable rgb exposure time options */
1140 if (scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w) /* exposure time setting for calibration enabled */
1142 scanner->opt[OPT_CAL_EXPOS_TIME].cap |= SANE_CAP_INACTIVE;
1143 scanner->opt[OPT_CAL_EXPOS_TIME_R].cap &= ~SANE_CAP_INACTIVE;
1144 scanner->opt[OPT_CAL_EXPOS_TIME_G].cap &= ~SANE_CAP_INACTIVE;
1145 scanner->opt[OPT_CAL_EXPOS_TIME_B].cap &= ~SANE_CAP_INACTIVE;
1149 scanner->opt[OPT_CAL_EXPOS_TIME].cap |= SANE_CAP_INACTIVE;
1150 scanner->opt[OPT_CAL_EXPOS_TIME_R].cap |= SANE_CAP_INACTIVE;
1151 scanner->opt[OPT_CAL_EXPOS_TIME_G].cap |= SANE_CAP_INACTIVE;
1152 scanner->opt[OPT_CAL_EXPOS_TIME_B].cap |= SANE_CAP_INACTIVE;
1155 scanner->opt[OPT_SCAN_EXPOS_TIME].cap |= SANE_CAP_INACTIVE;
1156 scanner->opt[OPT_SCAN_EXPOS_TIME_R].cap &= ~SANE_CAP_INACTIVE;
1157 scanner->opt[OPT_SCAN_EXPOS_TIME_G].cap &= ~SANE_CAP_INACTIVE;
1158 scanner->opt[OPT_SCAN_EXPOS_TIME_B].cap &= ~SANE_CAP_INACTIVE;
1162 if (scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w) /* exposure time setting for calibration enabled */
1164 scanner->opt[OPT_CAL_EXPOS_TIME].cap &= ~SANE_CAP_INACTIVE;
1168 scanner->opt[OPT_CAL_EXPOS_TIME].cap |= SANE_CAP_INACTIVE;
1170 scanner->opt[OPT_CAL_EXPOS_TIME_R].cap |= SANE_CAP_INACTIVE;
1171 scanner->opt[OPT_CAL_EXPOS_TIME_G].cap |= SANE_CAP_INACTIVE;
1172 scanner->opt[OPT_CAL_EXPOS_TIME_B].cap |= SANE_CAP_INACTIVE;
1174 scanner->opt[OPT_SCAN_EXPOS_TIME].cap &= ~SANE_CAP_INACTIVE;
1175 scanner->opt[OPT_SCAN_EXPOS_TIME_R].cap |= SANE_CAP_INACTIVE;
1176 scanner->opt[OPT_SCAN_EXPOS_TIME_G].cap |= SANE_CAP_INACTIVE;
1177 scanner->opt[OPT_SCAN_EXPOS_TIME_B].cap |= SANE_CAP_INACTIVE;
1545 Umax_Scanner *scanner = handle;
1551 if (umax_scsi_open(scanner->device->sane.name, scanner->device, sense_handler,
1552 scanner->device) != SANE_STATUS_GOOD )
1554 DBG(DBG_error, "ERROR: umax_set_lamp_status: open of %s failed:\n", scanner->device->sane.name);
1558 status = umax_scsi_get_lamp_status(scanner->device, &lamp_status);
1562 status = umax_scsi_set_lamp_status(scanner->device, lamp_on);
1565 umax_scsi_close(scanner->device);
1623 DBG(DBG_warning, "scanner does not get ready\n");
1634 DBG(DBG_info2, "scanner reports %s, waiting ...\n", sane_strstatus(status));
1641 DBG(DBG_info, "scanner ready\n");
1658 WAIT_SCANNER; /* wait for scanner ready */
1667 DBG(DBG_info, "scanner reserved\n");
1685 DBG(DBG_info2, "trying to reposition scanner ...\n");
1702 DBG(DBG_info, "scanner repositioned\n");
1706 DBG(DBG_info, "not waiting for finishing reposition scanner\n");
1720 DBG(DBG_info2, "trying to release scanner ...\n");
1728 DBG(DBG_info, "scanner released\n");
1737 usleep(200000); /* 200 ms pause to make sure program does not exit before scanner is ready */
1914 DBG(DBG_error, "ERROR: unknown gamma download curve type for this scanner\n");
2152 set_WD_line_arrangement(buffer_r, WD_line_arrengement_by_fw); /* line arrangement by scanner */
2558 DBG(DBG_info,"scanner sends %d lines with %d pixels and %d bytes/pixel\n", lines, width, bytespp);
2568 /* (although 0 is not black) my scanner sends values around 220 */
2796 dev->calibration_bytespp = 1; /* scanner says 2 bytespp for calibration but 1 bytepp is correct */
2833 dev->pause_after_reposition = 3000; /* pause after repostion scanner in ms */
2977 /* the scanner uses the same exposure times for red, green and blue exposure_time_rgb_bind = 1 */
3138 if (get_inquiry_periph_devtype(dev->buffer[0]) != IN_periph_devtype_scanner) { return 1; } /* no scanner */
3162 DBG(DBG_info, "Found %s scanner %sversion %s on device %s\n", vendor, product, version, dev->devicename);
3185 DBG(DBG_error0, "WARNING: %s scanner %s version %s on device %s\n"
3211 if (!strncmp(product, inq_data.scanner, strlen(inq_data.scanner)))
3214 DBG(DBG_warning, "using driver-internal inquiry-data for this scanner!\n");
3229 DBG(DBG_error0, "ERROR: %s scanner %s version %s on device %s\n"
3240 return 1; /* NO SUPPORTED SCANNER: short inquiry-block and unknown scanner */
3312 DBG(DBG_error, "ERROR: transparency mode not supported by scanner\n");
3323 DBG(DBG_error,"ERROR: adf mode not supported by scanner\n");
3334 DBG(DBG_error, "ERROR: double optical resolution not supported by scanner\n");
3425 /* limit the size to what the scanner can scan. */
3570 DBG(DBG_warning, "WARNING: fast preview function not supported by scanner\n");
3575 /* always set calibration lines because we also need this value if the scanner
3587 DBG(DBG_warning, "WARNING: quality calibration not supported by scanner\n");
3606 DBG(DBG_warning, "WARNING: scanner doesn't support lamp intensity control\n");
3651 DBG(DBG_warning,"WARNING: analog gamma correction not supported by scanner!\n");
3718 DBG(DBG_error,"ERROR: lineart mode not supported by scanner\n");
3737 DBG(DBG_error,"ERROR: halftone mode not supported by scanner\n");
3756 DBG(DBG_error, "ERROR: grayscale mode not supported by scanner\n");
3778 DBG(DBG_error,"ERROR: color mode not supported by scanner\n");
3788 DBG(DBG_info,"scanner uses color-pixel-ordering\n");
3794 DBG(DBG_info,"scanner uses color-line-ordering without CCD-distance\n");
3913 DBG(DBG_info,"scanner uses color-line-ordering with CCD-distance of %d lines\n", dev->CCD_distance);
4345 DBG(DBG_error,"ERROR: umax_reader_process: unable to get image data from scanner!\n");
4616 dev->pause_after_reposition = -1; /* pause after repostion scanner in ms, -1 = do not wait */
4662 static SANE_Status do_cancel(Umax_Scanner *scanner)
4669 scanner->scanning = SANE_FALSE;
4671 if (sanei_thread_is_valid (scanner->reader_pid))
4675 sanei_thread_kill(scanner->reader_pid);
4676 pid = sanei_thread_waitpid(scanner->reader_pid, &status);
4687 sanei_thread_invalidate (scanner->reader_pid);
4689 if (scanner->device->pixelbuffer != NULL) /* pixelbuffer exists? */
4691 free(scanner->device->pixelbuffer); /* free pixelbuffer */
4692 scanner->device->pixelbuffer = NULL;
4698 if (scanner->device->sfd != -1) /* make sure we have a working filedescriptor */
4700 umax_give_scanner(scanner->device); /* reposition and release scanner */
4702 umax_scsi_close(scanner->device);
4705 scanner->device->three_pass_color = 1; /* reset color in color scanning */
4721 for (dev = first_dev; dev; dev = dev->next) /* search is scanner already is listed in devicelist */
4723 if (strcmp(dev->sane.name, devicename) == 0) /* scanner is already listed */
4733 /* scanner has not been attached yet */
4818 DBG(DBG_error, "ERROR: attach scanner: could not allocate buffer[0]\n");
4833 DBG(DBG_error, "ERROR: attach_scanner: scanner-identification failed\n");
4871 dev->sane.type = "flatbed scanner";
4875 dev->sane.type = "page scanner";
4944 Umax_Scanner *scanner = (Umax_Scanner *)data;
4954 close(scanner->pipe_read_fd);
4955 scanner->pipe_read_fd = -1;
4968 scanner->device->scsi_maxqueue = scanner->device->request_scsi_maxqueue;
4970 if (scanner->device->request_scsi_maxqueue > 1)
4974 if (scanner->device->buffer[i])
4977 free(scanner->device->buffer[i]); /* free buffer */
4978 scanner->device->buffer[i] = NULL;
4982 for (i = 1; i<scanner->device->request_scsi_maxqueue; i++)
4985 scanner->device->buffer[i] = malloc(scanner->device->bufsize); /* allocate buffer */
4987 if (!scanner->device->buffer[i]) /* malloc failed */
4989 DBG(DBG_warning, "WARNING: reader_process: only allocated %d/%d scsi buffers\n", i, scanner->device->request_scsi_maxqueue);
4990 scanner->device->scsi_maxqueue = i;
4996 data_length = scanner->params.lines * scanner->params.bytes_per_line;
4998 fp = fdopen(scanner->pipe_write_fd, "w");
5006 status = umax_reader_process(scanner->device, fp, data_length);
5009 for (i = 1; i<scanner->device->request_scsi_maxqueue; i++)
5011 if (scanner->device->buffer[i])
5014 free(scanner->device->buffer[i]); /* free buffer */
5015 scanner->device->buffer[i] = NULL;
5027 static SANE_Status init_options(Umax_Scanner *scanner)
5035 memset(scanner->opt, 0, sizeof (scanner->opt));
5036 memset(scanner->val, 0, sizeof (scanner->val));
5040 scanner->opt[i].size = sizeof (SANE_Word);
5041 scanner->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
5044 scanner->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS; /* empty string */
5045 scanner->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
5046 scanner->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
5047 scanner->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
5048 scanner->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
5049 scanner->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
5052 scanner->opt[OPT_MODE_GROUP].title = SANE_I18N("Scan Mode");
5053 scanner->opt[OPT_MODE_GROUP].desc = "";
5054 scanner->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
5055 scanner->opt[OPT_MODE_GROUP].cap = 0;
5056 scanner->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
5060 if (scanner->device->inquiry_lineart)
5065 if (scanner->device->inquiry_halftone)
5070 if (scanner->device->inquiry_gray)
5075 if (scanner->device->inquiry_color)
5078 if (scanner->device->inquiry_lineart)
5081 if (scanner->device->inquiry_halftone)
5093 if (scanner->device->inquiry_adfmode)
5098 if (scanner->device->inquiry_transavail)
5107 scanner->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
5108 scanner->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
5109 scanner->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
5110 scanner->opt[OPT_MODE].type = SANE_TYPE_STRING;
5111 scanner->opt[OPT_MODE].size = max_string_size((SANE_String_Const *) scan_mode_list);
5112 scanner->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
5113 scanner->opt[OPT_MODE].constraint.string_list = (SANE_String_Const *) scan_mode_list;
5114 scanner->val[OPT_MODE].s = (SANE_Char*)strdup(scan_mode_list[0]);
5117 scanner->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE;
5118 scanner->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE;
5119 scanner->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE;
5120 scanner->opt[OPT_SOURCE].type = SANE_TYPE_STRING;
5121 scanner->opt[OPT_SOURCE].size = max_string_size(source_list);
5122 scanner->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
5123 scanner->opt[OPT_SOURCE].constraint.string_list = source_list;
5124 scanner->val[OPT_SOURCE].s = (SANE_Char*)strdup(source_list[0]);
5127 scanner->opt[OPT_X_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
5128 scanner->opt[OPT_X_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
5129 scanner->opt[OPT_X_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
5130 scanner->opt[OPT_X_RESOLUTION].type = SANE_TYPE_FIXED;
5131 scanner->opt[OPT_X_RESOLUTION].unit = SANE_UNIT_DPI;
5132 scanner->opt[OPT_X_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
5133 scanner->opt[OPT_X_RESOLUTION].constraint.range = &scanner->device->x_dpi_range;
5134 scanner->val[OPT_X_RESOLUTION].w = 100 << SANE_FIXED_SCALE_SHIFT;
5137 scanner->opt[OPT_Y_RESOLUTION].name = SANE_NAME_SCAN_Y_RESOLUTION;
5138 scanner->opt[OPT_Y_RESOLUTION].title = SANE_TITLE_SCAN_Y_RESOLUTION;
5139 scanner->opt[OPT_Y_RESOLUTION].desc = SANE_DESC_SCAN_Y_RESOLUTION;
5140 scanner->opt[OPT_Y_RESOLUTION].type = SANE_TYPE_FIXED;
5141 scanner->opt[OPT_Y_RESOLUTION].unit = SANE_UNIT_DPI;
5142 scanner->opt[OPT_Y_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
5143 scanner->opt[OPT_Y_RESOLUTION].constraint.range = &scanner->device->y_dpi_range;
5144 scanner->val[OPT_Y_RESOLUTION].w = 100 << SANE_FIXED_SCALE_SHIFT;
5145 scanner->opt[OPT_Y_RESOLUTION].cap |= SANE_CAP_INACTIVE;
5148 scanner->opt[OPT_RESOLUTION_BIND].name = SANE_NAME_RESOLUTION_BIND;
5149 scanner->opt[OPT_RESOLUTION_BIND].title = SANE_TITLE_RESOLUTION_BIND;
5150 scanner->opt[OPT_RESOLUTION_BIND].desc = SANE_DESC_RESOLUTION_BIND;
5151 scanner->opt[OPT_RESOLUTION_BIND].type = SANE_TYPE_BOOL;
5152 scanner->val[OPT_RESOLUTION_BIND].w = SANE_TRUE;
5153 if (scanner->device->common_xy_resolutions) /* disable bind if x and y res have to be the same */
5155 scanner->opt[OPT_RESOLUTION_BIND].cap |= SANE_CAP_INACTIVE;
5160 scanner->opt[OPT_NEGATIVE].name = SANE_NAME_NEGATIVE;
5161 scanner->opt[OPT_NEGATIVE].title = SANE_TITLE_NEGATIVE;
5162 scanner->opt[OPT_NEGATIVE].desc = SANE_DESC_NEGATIVE;
5163 scanner->opt[OPT_NEGATIVE].type = SANE_TYPE_BOOL;
5164 scanner->val[OPT_NEGATIVE].w = SANE_FALSE;
5166 if (scanner->device->inquiry_reverse_multi == 0)
5168 scanner->opt[OPT_NEGATIVE].cap |= SANE_CAP_INACTIVE;
5174 scanner->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N("Geometry");
5175 scanner->opt[OPT_GEOMETRY_GROUP].desc = "";
5176 scanner->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
5177 scanner->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
5178 scanner->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
5181 scanner->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
5182 scanner->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
5183 scanner->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
5184 scanner->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
5185 scanner->opt[OPT_TL_X].unit = SANE_UNIT_MM;
5186 scanner->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
5187 scanner->opt[OPT_TL_X].constraint.range = &(scanner->device->x_range);
5188 scanner->val[OPT_TL_X].w = 0;
5191 scanner->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
5192 scanner->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
5193 scanner->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
5194 scanner->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
5195 scanner->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
5196 scanner->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
5197 scanner->opt[OPT_TL_Y].constraint.range = &(scanner->device->y_range);
5198 scanner->val[OPT_TL_Y].w = 0;
5201 scanner->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
5202 scanner->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
5203 scanner->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
5204 scanner->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
5205 scanner->opt[OPT_BR_X].unit = SANE_UNIT_MM;
5206 scanner->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
5207 scanner->opt[OPT_BR_X].constraint.range = &(scanner->device->x_range);
5208 scanner->val[OPT_BR_X].w = scanner->device->x_range.max;
5211 scanner->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
5212 scanner->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
5213 scanner->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
5214 scanner->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
5215 scanner->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
5216 scanner->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
5217 scanner->opt[OPT_BR_Y].constraint.range = &(scanner->device->y_range);
5218 scanner->val[OPT_BR_Y].w = scanner->device->y_range.max;
5224 scanner->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N("Enhancement");
5225 scanner->opt[OPT_ENHANCEMENT_GROUP].desc = "";
5226 scanner->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
5227 scanner->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
5228 scanner->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
5234 if (scanner->device->inquiry_GOB & 1)
5239 if (scanner->device->inquiry_GOB & 2)
5244 if (scanner->device->inquiry_GOB & 4)
5249 if (scanner->device->inquiry_GOB & 8)
5254 if (scanner->device->inquiry_GOB & 16)
5259 if (scanner->device->inquiry_GOB & 32)
5266 scanner->opt[OPT_BIT_DEPTH].name = SANE_NAME_BIT_DEPTH;
5267 scanner->opt[OPT_BIT_DEPTH].title = SANE_TITLE_BIT_DEPTH;
5268 scanner->opt[OPT_BIT_DEPTH].desc = SANE_DESC_BIT_DEPTH;
5269 scanner->opt[OPT_BIT_DEPTH].type = SANE_TYPE_INT;
5270 scanner->opt[OPT_BIT_DEPTH].unit = SANE_UNIT_BIT;
5271 scanner->opt[OPT_BIT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST;
5272 scanner->opt[OPT_BIT_DEPTH].constraint.word_list = bit_depth_list;
5273 scanner->val[OPT_BIT_DEPTH].w = bit_depth_list[1];
5277 scanner->opt[OPT_QUALITY].name = SANE_NAME_QUALITY_CAL;
5278 scanner->opt[OPT_QUALITY].title = SANE_TITLE_QUALITY_CAL;
5279 scanner->opt[OPT_QUALITY].desc = SANE_DESC_QUALITY_CAL;
5280 scanner->opt[OPT_QUALITY].type = SANE_TYPE_BOOL;
5281 scanner->val[OPT_QUALITY].w = SANE_FALSE;
5283 if ((scanner->device->inquiry_quality_ctrl == 0) || (scanner->device->force_quality_calibration) )
5285 scanner->opt[OPT_QUALITY].cap |= SANE_CAP_INACTIVE;
5289 scanner->val[OPT_QUALITY].w = SANE_TRUE;
5294 scanner->opt[OPT_DOR].name = SANE_NAME_DOR;
5295 scanner->opt[OPT_DOR].title = SANE_TITLE_DOR;
5296 scanner->opt[OPT_DOR].desc = SANE_DESC_DOR;
5297 scanner->opt[OPT_DOR].type = SANE_TYPE_BOOL;
5298 scanner->val[OPT_DOR].w = SANE_FALSE;
5300 if (scanner->device->inquiry_dor == 0)
5302 scanner->opt[OPT_DOR].cap |= SANE_CAP_INACTIVE;
5307 scanner->opt[OPT_WARMUP].name = SANE_NAME_WARMUP;
5308 scanner->opt[OPT_WARMUP].title = SANE_TITLE_WARMUP;
5309 scanner->opt[OPT_WARMUP].desc = SANE_DESC_WARMUP;
5310 scanner->opt[OPT_WARMUP].type = SANE_TYPE_BOOL;
5311 scanner->val[OPT_WARMUP].w = SANE_FALSE;
5313 if (scanner->device->inquiry_max_warmup_time == 0)
5315 scanner->opt[OPT_WARMUP].cap |= SANE_CAP_INACTIVE;
5318 scanner->opt[OPT_RGB_BIND].name = SANE_NAME_RGB_BIND;
5319 scanner->opt[OPT_RGB_BIND].title = SANE_TITLE_RGB_BIND;
5320 scanner->opt[OPT_RGB_BIND].desc = SANE_DESC_RGB_BIND;
5321 scanner->opt[OPT_RGB_BIND].type = SANE_TYPE_BOOL;
5322 scanner->val[OPT_RGB_BIND].w = SANE_FALSE;
5325 scanner->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
5326 scanner->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
5327 scanner->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
5328 scanner->opt[OPT_BRIGHTNESS].type = SANE_TYPE_FIXED;
5329 scanner->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_PERCENT;
5330 scanner->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
5331 scanner->opt[OPT_BRIGHTNESS].constraint.range = &percentage_range;
5332 scanner->val[OPT_BRIGHTNESS].w = 0;
5335 scanner->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
5336 scanner->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
5337 scanner->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
5338 scanner->opt[OPT_CONTRAST].type = SANE_TYPE_FIXED;
5339 scanner->opt[OPT_CONTRAST].unit = SANE_UNIT_PERCENT;
5340 scanner->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
5341 scanner->opt[OPT_CONTRAST].constraint.range = &percentage_range;
5342 scanner->val[OPT_CONTRAST].w = 0;
5346 scanner->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD;
5347 scanner->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
5348 scanner->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
5349 scanner->opt[OPT_THRESHOLD].type = SANE_TYPE_FIXED;
5350 scanner->opt[OPT_THRESHOLD].unit = SANE_UNIT_PERCENT;
5351 scanner->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
5352 scanner->opt[OPT_THRESHOLD].constraint.range = &percentage_range_100;
5353 scanner->val[OPT_THRESHOLD].w = SANE_FIX(50);
5360 scanner->opt[OPT_HIGHLIGHT].name = SANE_NAME_HIGHLIGHT;
5361 scanner->opt[OPT_HIGHLIGHT].title = SANE_TITLE_HIGHLIGHT;
5362 scanner->opt[OPT_HIGHLIGHT].desc = SANE_DESC_HIGHLIGHT;
5363 scanner->opt[OPT_HIGHLIGHT].type = SANE_TYPE_FIXED;
5364 scanner->opt[OPT_HIGHLIGHT].unit = SANE_UNIT_PERCENT;
5365 scanner->opt[OPT_HIGHLIGHT].constraint_type = SANE_CONSTRAINT_RANGE;
5366 scanner->opt[OPT_HIGHLIGHT].constraint.range = &percentage_range_100;
5367 scanner->val[OPT_HIGHLIGHT].w = SANE_FIX(100);
5369 scanner->opt[OPT_HIGHLIGHT_R].name = SANE_NAME_HIGHLIGHT_R;
5370 scanner->opt[OPT_HIGHLIGHT_R].title = SANE_TITLE_HIGHLIGHT_R;
5371 scanner->opt[OPT_HIGHLIGHT_R].desc = SANE_DESC_HIGHLIGHT_R;
5372 scanner->opt[OPT_HIGHLIGHT_R].type = SANE_TYPE_FIXED;
5373 scanner->opt[OPT_HIGHLIGHT_R].unit = SANE_UNIT_PERCENT;
5374 scanner->opt[OPT_HIGHLIGHT_R].constraint_type = SANE_CONSTRAINT_RANGE;
5375 scanner->opt[OPT_HIGHLIGHT_R].constraint.range = &percentage_range_100;
5376 scanner->val[OPT_HIGHLIGHT_R].w = SANE_FIX(100);
5378 scanner->opt[OPT_HIGHLIGHT_G].name = SANE_NAME_HIGHLIGHT_G;
5379 scanner->opt[OPT_HIGHLIGHT_G].title = SANE_TITLE_HIGHLIGHT_G;
5380 scanner->opt[OPT_HIGHLIGHT_G].desc = SANE_DESC_HIGHLIGHT_G;
5381 scanner->opt[OPT_HIGHLIGHT_G].type = SANE_TYPE_FIXED;
5382 scanner->opt[OPT_HIGHLIGHT_G].unit = SANE_UNIT_PERCENT;
5383 scanner->opt[OPT_HIGHLIGHT_G].constraint_type = SANE_CONSTRAINT_RANGE;
5384 scanner->opt[OPT_HIGHLIGHT_G].constraint.range = &percentage_range_100;
5385 scanner->val[OPT_HIGHLIGHT_G].w = SANE_FIX(100);
5387 scanner->opt[OPT_HIGHLIGHT_B].name = SANE_NAME_HIGHLIGHT_B;
5388 scanner->opt[OPT_HIGHLIGHT_B].title = SANE_TITLE_HIGHLIGHT_B;
5389 scanner->opt[OPT_HIGHLIGHT_B].desc = SANE_DESC_HIGHLIGHT_B;
5390 scanner->opt[OPT_HIGHLIGHT_B].type = SANE_TYPE_FIXED;
5391 scanner->opt[OPT_HIGHLIGHT_B].unit = SANE_UNIT_PERCENT;
5392 scanner->opt[OPT_HIGHLIGHT_B].constraint_type = SANE_CONSTRAINT_RANGE;
5393 scanner->opt[OPT_HIGHLIGHT_B].constraint.range = &percentage_range_100;
5394 scanner->val[OPT_HIGHLIGHT_B].w = SANE_FIX(100);
5398 scanner->opt[OPT_SHADOW].name = SANE_NAME_SHADOW;
5399 scanner->opt[OPT_SHADOW].title = SANE_TITLE_SHADOW;
5400 scanner->opt[OPT_SHADOW].desc = SANE_DESC_SHADOW;
5401 scanner->opt[OPT_SHADOW].type = SANE_TYPE_FIXED;
5402 scanner->opt[OPT_SHADOW].unit = SANE_UNIT_PERCENT;
5403 scanner->opt[OPT_SHADOW].constraint_type = SANE_CONSTRAINT_RANGE;
5404 scanner->opt[OPT_SHADOW].constraint.range = &percentage_range_100;
5405 scanner->val[OPT_SHADOW].w = 0;
5407 scanner->opt[OPT_SHADOW_R].name = SANE_NAME_SHADOW_R;
5408 scanner->opt[OPT_SHADOW_R].title = SANE_TITLE_SHADOW_R;
5409 scanner->opt[OPT_SHADOW_R].desc = SANE_DESC_SHADOW_R;
5410 scanner->opt[OPT_SHADOW_R].type = SANE_TYPE_FIXED;
5411 scanner->opt[OPT_SHADOW_R].unit = SANE_UNIT_PERCENT;
5412 scanner->opt[OPT_SHADOW_R].constraint_type = SANE_CONSTRAINT_RANGE;
5413 scanner->opt[OPT_SHADOW_R].constraint.range = &percentage_range_100;
5414 scanner->val[OPT_SHADOW_R].w = 0;
5416 scanner->opt[OPT_SHADOW_G].name = SANE_NAME_SHADOW_G;
5417 scanner->opt[OPT_SHADOW_G].title = SANE_TITLE_SHADOW_G;
5418 scanner->opt[OPT_SHADOW_G].desc = SANE_DESC_SHADOW_G;
5419 scanner->opt[OPT_SHADOW_G].type = SANE_TYPE_FIXED;
5420 scanner->opt[OPT_SHADOW_G].unit = SANE_UNIT_PERCENT;
5421 scanner->opt[OPT_SHADOW_G].constraint_type = SANE_CONSTRAINT_RANGE;
5422 scanner->opt[OPT_SHADOW_G].constraint.range = &percentage_range_100;
5423 scanner->val[OPT_SHADOW_G].w = 0;
5425 scanner->opt[OPT_SHADOW_B].name = SANE_NAME_SHADOW_B;
5426 scanner->opt[OPT_SHADOW_B].title = SANE_TITLE_SHADOW_B;
5427 scanner->opt[OPT_SHADOW_B].desc = SANE_DESC_SHADOW_B;
5428 scanner->opt[OPT_SHADOW_B].type = SANE_TYPE_FIXED;
5429 scanner->opt[OPT_SHADOW_B].unit = SANE_UNIT_PERCENT;
5430 scanner->opt[OPT_SHADOW_B].constraint_type = SANE_CONSTRAINT_RANGE;
5431 scanner->opt[OPT_SHADOW_B].constraint.range = &percentage_range_100;
5432 scanner->val[OPT_SHADOW_B].w = 0;
5437 scanner->opt[OPT_ANALOG_GAMMA].name = SANE_NAME_ANALOG_GAMMA;
5438 scanner->opt[OPT_ANALOG_GAMMA].title = SANE_TITLE_ANALOG_GAMMA;
5439 scanner->opt[OPT_ANALOG_GAMMA].desc = SANE_DESC_ANALOG_GAMMA;
5440 scanner->opt[OPT_ANALOG_GAMMA].type = SANE_TYPE_FIXED;
5441 scanner->opt[OPT_ANALOG_GAMMA].unit = SANE_UNIT_NONE;
5442 scanner->opt[OPT_ANALOG_GAMMA].constraint_type = SANE_CONSTRAINT_RANGE;
5443 scanner->opt[OPT_ANALOG_GAMMA].constraint.range = &(scanner->device->analog_gamma_range);
5444 scanner->val[OPT_ANALOG_GAMMA].w = 1 << SANE_FIXED_SCALE_SHIFT;
5446 scanner->opt[OPT_ANALOG_GAMMA_R].name = SANE_NAME_ANALOG_GAMMA_R;
5447 scanner->opt[OPT_ANALOG_GAMMA_R].title = SANE_TITLE_ANALOG_GAMMA_R;
5448 scanner->opt[OPT_ANALOG_GAMMA_R].desc = SANE_DESC_ANALOG_GAMMA_R;
5449 scanner->opt[OPT_ANALOG_GAMMA_R].type = SANE_TYPE_FIXED;
5450 scanner->opt[OPT_ANALOG_GAMMA_R].unit = SANE_UNIT_NONE;
5451 scanner->opt[OPT_ANALOG_GAMMA_R].constraint_type = SANE_CONSTRAINT_RANGE;
5452 scanner->opt[OPT_ANALOG_GAMMA_R].constraint.range = &(scanner->device->analog_gamma_range);
5453 scanner->val[OPT_ANALOG_GAMMA_R].w = 1 << SANE_FIXED_SCALE_SHIFT;
5455 scanner->opt[OPT_ANALOG_GAMMA_G].name = SANE_NAME_ANALOG_GAMMA_G;
5456 scanner->opt[OPT_ANALOG_GAMMA_G].title = SANE_TITLE_ANALOG_GAMMA_G;
5457 scanner->opt[OPT_ANALOG_GAMMA_G].desc = SANE_DESC_ANALOG_GAMMA_G;
5458 scanner->opt[OPT_ANALOG_GAMMA_G].type = SANE_TYPE_FIXED;
5459 scanner->opt[OPT_ANALOG_GAMMA_G].unit = SANE_UNIT_NONE;
5460 scanner->opt[OPT_ANALOG_GAMMA_G].constraint_type = SANE_CONSTRAINT_RANGE;
5461 scanner->opt[OPT_ANALOG_GAMMA_G].constraint.range = &(scanner->device->analog_gamma_range);
5462 scanner->val[OPT_ANALOG_GAMMA_G].w = 1 << SANE_FIXED_SCALE_SHIFT;
5464 scanner->opt[OPT_ANALOG_GAMMA_B].name = SANE_NAME_ANALOG_GAMMA_B;
5465 scanner->opt[OPT_ANALOG_GAMMA_B].title = SANE_TITLE_ANALOG_GAMMA_B;
5466 scanner->opt[OPT_ANALOG_GAMMA_B].desc = SANE_DESC_ANALOG_GAMMA_B;
5467 scanner->opt[OPT_ANALOG_GAMMA_B].type = SANE_TYPE_FIXED;
5468 scanner->opt[OPT_ANALOG_GAMMA_B].unit = SANE_UNIT_NONE;
5469 scanner->opt[OPT_ANALOG_GAMMA_B].constraint_type = SANE_CONSTRAINT_RANGE;
5470 scanner->opt[OPT_ANALOG_GAMMA_B].constraint.range = &(scanner->device->analog_gamma_range);
5471 scanner->val[OPT_ANALOG_GAMMA_B].w = 1 << SANE_FIXED_SCALE_SHIFT;
5475 scanner->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
5476 scanner->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
5477 scanner->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
5478 scanner->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
5479 scanner->val[OPT_CUSTOM_GAMMA].w = SANE_TRUE;
5482 scanner->opt[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR;
5483 scanner->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR;
5484 scanner->opt[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR;
5485 scanner->opt[OPT_GAMMA_VECTOR].type = SANE_TYPE_INT;
5486 scanner->opt[OPT_GAMMA_VECTOR].unit = SANE_UNIT_NONE;
5487 scanner->opt[OPT_GAMMA_VECTOR].constraint_type = SANE_CONSTRAINT_RANGE;
5488 scanner->val[OPT_GAMMA_VECTOR].wa = scanner->gamma_table[0];
5489 scanner->opt[OPT_GAMMA_VECTOR].constraint.range = &scanner->output_range;
5490 scanner->opt[OPT_GAMMA_VECTOR].size = scanner->gamma_length * sizeof(SANE_Word);
5492 scanner->output_range.min = 0;
5496 scanner->output_range.max = 255; /* 8 bits/pixel */
5500 scanner->output_range.max = 65535; /* 9-16 bits/pixel */
5503 scanner->output_range.quant = 0;
5506 scanner->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
5507 scanner->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
5508 scanner->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
5509 scanner->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
5510 scanner->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
5511 scanner->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
5512 scanner->val[OPT_GAMMA_VECTOR_R].wa = scanner->gamma_table[1];
5513 scanner->opt[OPT_GAMMA_VECTOR_R].constraint.range = &(scanner->gamma_range);
5514 scanner->opt[OPT_GAMMA_VECTOR_R].size = scanner->gamma_length * sizeof(SANE_Word);
5517 scanner->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
5518 scanner->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
5519 scanner->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
5520 scanner->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
5521 scanner->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
5522 scanner->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
5523 scanner->val[OPT_GAMMA_VECTOR_G].wa = scanner->gamma_table[2];
5524 scanner->opt[OPT_GAMMA_VECTOR_G].constraint.range = &(scanner->gamma_range);
5525 scanner->opt[OPT_GAMMA_VECTOR_G].size = scanner->gamma_length * sizeof(SANE_Word);
5528 scanner->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
5529 scanner->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
5530 scanner->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
5531 scanner->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
5532 scanner->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
5533 scanner->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
5534 scanner->val[OPT_GAMMA_VECTOR_B].wa = scanner->gamma_table[3];
5535 scanner->opt[OPT_GAMMA_VECTOR_B].constraint.range = &(scanner->gamma_range);
5536 scanner->opt[OPT_GAMMA_VECTOR_B].size = scanner->gamma_length * sizeof(SANE_Word);
5539 scanner->opt[OPT_HALFTONE_DIMENSION].name = SANE_NAME_HALFTONE_DIMENSION;
5540 scanner->opt[OPT_HALFTONE_DIMENSION].title = SANE_TITLE_HALFTONE_DIMENSION;
5541 scanner->opt[OPT_HALFTONE_DIMENSION].desc = SANE_DESC_HALFTONE_DIMENSION;
5542 scanner->opt[OPT_HALFTONE_DIMENSION].type = SANE_TYPE_INT;
5543 scanner->opt[OPT_HALFTONE_DIMENSION].unit = SANE_UNIT_PIXEL;
5544 scanner->opt[OPT_HALFTONE_DIMENSION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
5545 scanner->opt[OPT_HALFTONE_DIMENSION].constraint.word_list = pattern_dim_list;
5546 scanner->val[OPT_HALFTONE_DIMENSION].w = pattern_dim_list[1];
5549 scanner->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN;
5550 scanner->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN;
5551 scanner->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN;
5552 scanner->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_INT;
5553 scanner->opt[OPT_HALFTONE_PATTERN].size = 0;
5554 scanner->opt[OPT_HALFTONE_PATTERN].constraint_type = SANE_CONSTRAINT_RANGE;
5555 scanner->opt[OPT_HALFTONE_PATTERN].constraint.range = &u8_range;
5556 scanner->val[OPT_HALFTONE_PATTERN].wa = scanner->halftone_pattern;
5563 scanner->opt[OPT_ADVANCED_GROUP].title = SANE_I18N("Advanced");
5564 scanner->opt[OPT_ADVANCED_GROUP].desc = "";
5565 scanner->opt[OPT_ADVANCED_GROUP].type = SANE_TYPE_GROUP;
5566 scanner->opt[OPT_ADVANCED_GROUP].cap = SANE_CAP_ADVANCED;
5567 scanner->opt[OPT_ADVANCED_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
5574 scanner->opt[OPT_SELECT_EXPOSURE_TIME].name = SANE_NAME_SELECT_EXPOSURE_TIME;
5575 scanner->opt[OPT_SELECT_EXPOSURE_TIME].title = SANE_TITLE_SELECT_EXPOSURE_TIME;
5576 scanner->opt[OPT_SELECT_EXPOSURE_TIME].desc = SANE_DESC_SELECT_EXPOSURE_TIME;
5577 scanner->opt[OPT_SELECT_EXPOSURE_TIME].type = SANE_TYPE_BOOL;
5578 scanner->val[OPT_SELECT_EXPOSURE_TIME].w = SANE_FALSE;
5581 scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].name = SANE_UMAX_NAME_SELECT_CALIBRATON_EXPOSURE_TIME;
5582 scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].title = SANE_UMAX_TITLE_SELECT_CALIBRATION_EXPOSURE_TIME;
5583 scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].desc = SANE_UMAX_DESC_SELECT_CALIBRATION_EXPOSURE_TIME;
5584 scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].type = SANE_TYPE_BOOL;
5585 scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w = SANE_FALSE;
5586 scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].cap |= SANE_CAP_INACTIVE;
5589 scanner->opt[OPT_CAL_EXPOS_TIME].name = SANE_NAME_CAL_EXPOS_TIME;
5590 scanner->opt[OPT_CAL_EXPOS_TIME].title = SANE_TITLE_CAL_EXPOS_TIME;
5591 scanner->opt[OPT_CAL_EXPOS_TIME].desc = SANE_DESC_CAL_EXPOS_TIME;
5592 scanner->opt[OPT_CAL_EXPOS_TIME].type = SANE_TYPE_INT;
5593 scanner->opt[OPT_CAL_EXPOS_TIME].unit = SANE_UNIT_MICROSECOND;
5594 scanner->opt[OPT_CAL_EXPOS_TIME].constraint_type = SANE_CONSTRAINT_RANGE;
5595 scanner->opt[OPT_CAL_EXPOS_TIME].constraint.range = &(scanner->exposure_time_range);
5596 scanner->val[OPT_CAL_EXPOS_TIME].w = scanner->device->inquiry_exposure_time_g_fb_def *
5597 scanner->device->inquiry_exposure_time_step_unit;
5598 scanner->opt[OPT_CAL_EXPOS_TIME].cap |= SANE_CAP_INACTIVE;
5601 scanner->opt[OPT_CAL_EXPOS_TIME_R].name = SANE_NAME_CAL_EXPOS_TIME_R;
5602 scanner->opt[OPT_CAL_EXPOS_TIME_R].title = SANE_TITLE_CAL_EXPOS_TIME_R;
5603 scanner->opt[OPT_CAL_EXPOS_TIME_R].desc = SANE_DESC_CAL_EXPOS_TIME_R;
5604 scanner->opt[OPT_CAL_EXPOS_TIME_R].type = SANE_TYPE_INT;
5605 scanner->opt[OPT_CAL_EXPOS_TIME_R].unit = SANE_UNIT_MICROSECOND;
5606 scanner->opt[OPT_CAL_EXPOS_TIME_R].constraint_type = SANE_CONSTRAINT_RANGE;
5607 scanner->opt[OPT_CAL_EXPOS_TIME_R].constraint.range = &(scanner->exposure_time_range);
5608 scanner->val[OPT_CAL_EXPOS_TIME_R].w = scanner->device->inquiry_exposure_time_c_fb_def_r *
5609 scanner->device->inquiry_exposure_time_step_unit;
5610 scanner->opt[OPT_CAL_EXPOS_TIME_R].cap |= SANE_CAP_INACTIVE;
5613 scanner->opt[OPT_CAL_EXPOS_TIME_G].name = SANE_NAME_CAL_EXPOS_TIME_G;
5614 scanner->opt[OPT_CAL_EXPOS_TIME_G].title = SANE_TITLE_CAL_EXPOS_TIME_G;
5615 scanner->opt[OPT_CAL_EXPOS_TIME_G].desc = SANE_DESC_CAL_EXPOS_TIME_G;
5616 scanner->opt[OPT_CAL_EXPOS_TIME_G].type = SANE_TYPE_INT;
5617 scanner->opt[OPT_CAL_EXPOS_TIME_G].unit = SANE_UNIT_MICROSECOND;
5618 scanner->opt[OPT_CAL_EXPOS_TIME_G].constraint_type = SANE_CONSTRAINT_RANGE;
5619 scanner->opt[OPT_CAL_EXPOS_TIME_G].constraint.range = &(scanner->exposure_time_range);
5620 scanner->val[OPT_CAL_EXPOS_TIME_G].w = scanner->device->inquiry_exposure_time_c_fb_def_g *
5621 scanner->device->inquiry_exposure_time_step_unit;
5622 scanner->opt[OPT_CAL_EXPOS_TIME_G].cap |= SANE_CAP_INACTIVE;
5625 scanner->opt[OPT_CAL_EXPOS_TIME_B].name = SANE_NAME_CAL_EXPOS_TIME_B;
5626 scanner->opt[OPT_CAL_EXPOS_TIME_B].title = SANE_TITLE_CAL_EXPOS_TIME_B;
5627 scanner->opt[OPT_CAL_EXPOS_TIME_B].desc = SANE_DESC_CAL_EXPOS_TIME_B;
5628 scanner->opt[OPT_CAL_EXPOS_TIME_B].type = SANE_TYPE_INT;
5629 scanner->opt[OPT_CAL_EXPOS_TIME_B].unit = SANE_UNIT_MICROSECOND;
5630 scanner->opt[OPT_CAL_EXPOS_TIME_B].constraint_type = SANE_CONSTRAINT_RANGE;
5631 scanner->opt[OPT_CAL_EXPOS_TIME_B].constraint.range = &(scanner->exposure_time_range);
5632 scanner->val[OPT_CAL_EXPOS_TIME_B].w = scanner->device->inquiry_exposure_time_c_fb_def_b *
5633 scanner->device->inquiry_exposure_time_step_unit;
5634 scanner->opt[OPT_CAL_EXPOS_TIME_B].cap |= SANE_CAP_INACTIVE;
5637 scanner->opt[OPT_SCAN_EXPOS_TIME].name = SANE_NAME_SCAN_EXPOS_TIME;
5638 scanner->opt[OPT_SCAN_EXPOS_TIME].title = SANE_TITLE_SCAN_EXPOS_TIME;
5639 scanner->opt[OPT_SCAN_EXPOS_TIME].desc = SANE_DESC_SCAN_EXPOS_TIME;
5640 scanner->opt[OPT_SCAN_EXPOS_TIME].type = SANE_TYPE_INT;
5641 scanner->opt[OPT_SCAN_EXPOS_TIME].unit = SANE_UNIT_MICROSECOND;
5642 scanner->opt[OPT_SCAN_EXPOS_TIME].constraint_type = SANE_CONSTRAINT_RANGE;
5643 scanner->opt[OPT_SCAN_EXPOS_TIME].constraint.range = &(scanner->exposure_time_range);
5644 scanner->val[OPT_SCAN_EXPOS_TIME].w = scanner->device->inquiry_exposure_time_g_fb_def *
5645 scanner->device->inquiry_exposure_time_step_unit;
5646 scanner->opt[OPT_SCAN_EXPOS_TIME].cap |= SANE_CAP_INACTIVE;
5649 scanner->opt[OPT_SCAN_EXPOS_TIME_R].name = SANE_NAME_SCAN_EXPOS_TIME_R;
5650 scanner->opt[OPT_SCAN_EXPOS_TIME_R].title = SANE_TITLE_SCAN_EXPOS_TIME_R;
5651 scanner->opt[OPT_SCAN_EXPOS_TIME_R].desc = SANE_DESC_SCAN_EXPOS_TIME_R;
5652 scanner->opt[OPT_SCAN_EXPOS_TIME_R].type = SANE_TYPE_INT;
5653 scanner->opt[OPT_SCAN_EXPOS_TIME_R].unit = SANE_UNIT_MICROSECOND;
5654 scanner->opt[OPT_SCAN_EXPOS_TIME_R].constraint_type = SANE_CONSTRAINT_RANGE;
5655 scanner->opt[OPT_SCAN_EXPOS_TIME_R].constraint.range = &(scanner->exposure_time_range);
5656 scanner->val[OPT_SCAN_EXPOS_TIME_R].w = scanner->device->inquiry_exposure_time_c_fb_def_r *
5657 scanner->device->inquiry_exposure_time_step_unit;
5658 scanner->opt[OPT_SCAN_EXPOS_TIME_R].cap |= SANE_CAP_INACTIVE;
5661 scanner->opt[OPT_SCAN_EXPOS_TIME_G].name = SANE_NAME_SCAN_EXPOS_TIME_G;
5662 scanner->opt[OPT_SCAN_EXPOS_TIME_G].title = SANE_TITLE_SCAN_EXPOS_TIME_G;
5663 scanner->opt[OPT_SCAN_EXPOS_TIME_G].desc = SANE_DESC_SCAN_EXPOS_TIME_G;
5664 scanner->opt[OPT_SCAN_EXPOS_TIME_G].type = SANE_TYPE_INT;
5665 scanner->opt[OPT_SCAN_EXPOS_TIME_G].unit = SANE_UNIT_MICROSECOND;
5666 scanner->opt[OPT_SCAN_EXPOS_TIME_G].constraint_type = SANE_CONSTRAINT_RANGE;
5667 scanner->opt[OPT_SCAN_EXPOS_TIME_G].constraint.range = &(scanner->exposure_time_range);
5668 scanner->val[OPT_SCAN_EXPOS_TIME_G].w = scanner->device->inquiry_exposure_time_c_fb_def_g *
5669 scanner->device->inquiry_exposure_time_step_unit;
5670 scanner->opt[OPT_SCAN_EXPOS_TIME_G].cap |= SANE_CAP_INACTIVE;
5673 scanner->opt[OPT_SCAN_EXPOS_TIME_B].name = SANE_NAME_SCAN_EXPOS_TIME_B;
5674 scanner->opt[OPT_SCAN_EXPOS_TIME_B].title = SANE_TITLE_SCAN_EXPOS_TIME_B;
5675 scanner->opt[OPT_SCAN_EXPOS_TIME_B].desc = SANE_DESC_SCAN_EXPOS_TIME_B;
5676 scanner->opt[OPT_SCAN_EXPOS_TIME_B].type = SANE_TYPE_INT;
5677 scanner->opt[OPT_SCAN_EXPOS_TIME_B].unit = SANE_UNIT_MICROSECOND;
5678 scanner->opt[OPT_SCAN_EXPOS_TIME_B].constraint_type = SANE_CONSTRAINT_RANGE;
5679 scanner->opt[OPT_SCAN_EXPOS_TIME_B].constraint.range = &(scanner->exposure_time_range);
5680 scanner->val[OPT_SCAN_EXPOS_TIME_B].w = scanner->device->inquiry_exposure_time_c_fb_def_b *
5681 scanner->device->inquiry_exposure_time_step_unit;
5682 scanner->opt[OPT_SCAN_EXPOS_TIME_B].cap |= SANE_CAP_INACTIVE;
5684 if (scanner->device->inquiry_exposure_adj == 0)
5686 scanner->opt[OPT_SELECT_EXPOSURE_TIME].cap |= SANE_CAP_INACTIVE;
5694 scanner->opt[OPT_SELECT_LAMP_DENSITY].name = SANE_NAME_SELECT_LAMP_DENSITY;
5695 scanner->opt[OPT_SELECT_LAMP_DENSITY].title = SANE_TITLE_SELECT_LAMP_DENSITY;
5696 scanner->opt[OPT_SELECT_LAMP_DENSITY].desc = SANE_DESC_SELECT_LAMP_DENSITY;
5697 scanner->opt[OPT_SELECT_LAMP_DENSITY].type = SANE_TYPE_BOOL;
5698 scanner->val[OPT_SELECT_LAMP_DENSITY].w = SANE_FALSE;
5701 scanner->opt[OPT_CAL_LAMP_DEN].name = SANE_NAME_CAL_LAMP_DEN;
5702 scanner->opt[OPT_CAL_LAMP_DEN].title = SANE_TITLE_CAL_LAMP_DEN;
5703 scanner->opt[OPT_CAL_LAMP_DEN].desc = SANE_DESC_CAL_LAMP_DEN;
5704 scanner->opt[OPT_CAL_LAMP_DEN].type = SANE_TYPE_FIXED;
5705 scanner->opt[OPT_CAL_LAMP_DEN].unit = SANE_UNIT_PERCENT;
5706 scanner->opt[OPT_CAL_LAMP_DEN].constraint_type = SANE_CONSTRAINT_RANGE;
5707 scanner->opt[OPT_CAL_LAMP_DEN].constraint.range = &percentage_range_100;
5708 scanner->val[OPT_CAL_LAMP_DEN].w = SANE_FIX(50);
5709 scanner->opt[OPT_CAL_LAMP_DEN].cap |= SANE_CAP_INACTIVE;
5712 scanner->opt[OPT_SCAN_LAMP_DEN].name = SANE_NAME_SCAN_LAMP_DEN;
5713 scanner->opt[OPT_SCAN_LAMP_DEN].title = SANE_TITLE_SCAN_LAMP_DEN;
5714 scanner->opt[OPT_SCAN_LAMP_DEN].desc = SANE_DESC_SCAN_LAMP_DEN;
5715 scanner->opt[OPT_SCAN_LAMP_DEN].type = SANE_TYPE_FIXED;
5716 scanner->opt[OPT_SCAN_LAMP_DEN].unit = SANE_UNIT_PERCENT;
5717 scanner->opt[OPT_SCAN_LAMP_DEN].constraint_type = SANE_CONSTRAINT_RANGE;
5718 scanner->opt[OPT_SCAN_LAMP_DEN].constraint.range = &percentage_range_100;
5719 scanner->val[OPT_SCAN_LAMP_DEN].w = SANE_FIX(50);
5720 scanner->opt[OPT_SCAN_LAMP_DEN].cap |= SANE_CAP_INACTIVE;
5722 if (scanner->device->inquiry_lamp_ctrl == 0)
5724 scanner->opt[OPT_SELECT_LAMP_DENSITY].cap |= SANE_CAP_INACTIVE;
5730 scanner->opt[OPT_DISABLE_PRE_FOCUS].name = "disable-pre-focus";
5731 scanner->opt[OPT_DISABLE_PRE_FOCUS].title = SANE_I18N("Disable pre focus");
5732 scanner->opt[OPT_DISABLE_PRE_FOCUS].desc = SANE_I18N("Do not calibrate focus");
5733 scanner->opt[OPT_DISABLE_PRE_FOCUS].type = SANE_TYPE_BOOL;
5734 scanner->val[OPT_DISABLE_PRE_FOCUS].w = SANE_FALSE;
5736 if (scanner->device->inquiry_manual_focus == 0)
5738 scanner->opt[OPT_DISABLE_PRE_FOCUS].cap |= SANE_CAP_INACTIVE;
5742 scanner->opt[OPT_MANUAL_PRE_FOCUS].name = "manual-pre-focus";
5743 scanner->opt[OPT_MANUAL_PRE_FOCUS].title = SANE_I18N("Manual pre focus");
5744 scanner->opt[OPT_MANUAL_PRE_FOCUS].desc = "";
5745 scanner->opt[OPT_MANUAL_PRE_FOCUS].type = SANE_TYPE_BOOL;
5746 scanner->val[OPT_MANUAL_PRE_FOCUS].w = SANE_FALSE;
5748 if (scanner->device->inquiry_manual_focus == 0)
5750 scanner->opt[OPT_MANUAL_PRE_FOCUS].cap |= SANE_CAP_INACTIVE;
5754 scanner->opt[OPT_FIX_FOCUS_POSITION].name = "fix-focus-position";
5755 scanner->opt[OPT_FIX_FOCUS_POSITION].title = SANE_I18N("Fix focus position");
5756 scanner->opt[OPT_FIX_FOCUS_POSITION].desc = "";
5757 scanner->opt[OPT_FIX_FOCUS_POSITION].type = SANE_TYPE_BOOL;
5758 scanner->val[OPT_FIX_FOCUS_POSITION].w = SANE_FALSE;
5760 if (scanner->device->inquiry_manual_focus == 0)
5762 scanner->opt[OPT_FIX_FOCUS_POSITION].cap |= SANE_CAP_INACTIVE;
5766 scanner->opt[OPT_LENS_CALIBRATION_DOC_POS].name = "lens-calibration-in-doc-position";
5767 scanner->opt[OPT_LENS_CALIBRATION_DOC_POS].title = SANE_I18N("Lens calibration in doc position");
5768 scanner->opt[OPT_LENS_CALIBRATION_DOC_POS].desc = SANE_I18N("Calibrate lens focus in document position");
5769 scanner->opt[OPT_LENS_CALIBRATION_DOC_POS].type = SANE_TYPE_BOOL;
5770 scanner->val[OPT_LENS_CALIBRATION_DOC_POS].w = SANE_FALSE;
5772 if (scanner->device->inquiry_lens_cal_in_doc_pos == 0)
5774 scanner->opt[OPT_LENS_CALIBRATION_DOC_POS].cap |= SANE_CAP_INACTIVE;
5778 scanner->opt[OPT_HOLDER_FOCUS_POS_0MM].name = "holder-focus-position-0mm";
5779 scanner->opt[OPT_HOLDER_FOCUS_POS_0MM].title = SANE_I18N("Holder focus position 0mm");
5780 scanner->opt[OPT_HOLDER_FOCUS_POS_0MM].desc = SANE_I18N("Use 0mm holder focus position instead of 0.6mm");
5781 scanner->opt[OPT_HOLDER_FOCUS_POS_0MM].type = SANE_TYPE_BOOL;
5782 scanner->val[OPT_HOLDER_FOCUS_POS_0MM].w = SANE_FALSE;
5784 if (scanner->device->inquiry_sel_uta_lens_cal_pos == 0)
5786 scanner->opt[OPT_HOLDER_FOCUS_POS_0MM].cap |= SANE_CAP_INACTIVE;
5792 scanner->opt[OPT_LAMP_ON].name = "lamp-on";
5793 scanner->opt[OPT_LAMP_ON].title = SANE_I18N("Lamp on");
5794 scanner->opt[OPT_LAMP_ON].desc = SANE_I18N("Turn on scanner lamp");
5795 scanner->opt[OPT_LAMP_ON].type = SANE_TYPE_BUTTON;
5796 scanner->opt[OPT_LAMP_ON].unit = SANE_UNIT_NONE;
5797 scanner->opt[OPT_LAMP_ON].size = 0;
5798 scanner->opt[OPT_LAMP_ON].constraint_type = SANE_CONSTRAINT_NONE;
5799 scanner->val[OPT_LAMP_ON].w = 0;
5801 if (!scanner->device->lamp_control_available) /* lamp state can not be controlled by driver */
5803 scanner->opt[OPT_LAMP_ON].cap |= SANE_CAP_INACTIVE;
5809 scanner->opt[OPT_LAMP_OFF].name = "lamp-off";
5810 scanner->opt[OPT_LAMP_OFF].title = SANE_I18N("Lamp off");
5811 scanner->opt[OPT_LAMP_OFF].desc = SANE_I18N("Turn off scanner lamp");
5812 scanner->opt[OPT_LAMP_OFF].type = SANE_TYPE_BUTTON;
5813 scanner->opt[OPT_LAMP_OFF].unit = SANE_UNIT_NONE;
5814 scanner->opt[OPT_LAMP_OFF].size = 0;
5815 scanner->opt[OPT_LAMP_OFF].constraint_type = SANE_CONSTRAINT_NONE;
5816 scanner->val[OPT_LAMP_OFF].w = 0;
5818 if (!scanner->device->lamp_control_available) /* lamp state can not be controlled by driver */
5820 scanner->opt[OPT_LAMP_OFF].cap |= SANE_CAP_INACTIVE;
5826 scanner->opt[OPT_LAMP_OFF_AT_EXIT].name = "lamp-off-at-exit";
5827 scanner->opt[OPT_LAMP_OFF_AT_EXIT].title = SANE_I18N("Lamp off at exit");
5828 scanner->opt[OPT_LAMP_OFF_AT_EXIT].desc = SANE_I18N("Turn off lamp when program exits");
5829 scanner->opt[OPT_LAMP_OFF_AT_EXIT].type = SANE_TYPE_BOOL;
5830 scanner->val[OPT_LAMP_OFF_AT_EXIT].w = SANE_FALSE;
5832 if (!scanner->device->lamp_control_available) /* lamp state can not be controlled by driver */
5834 scanner->opt[OPT_LAMP_OFF_AT_EXIT].cap |= SANE_CAP_INACTIVE;
5840 scanner->opt[OPT_BATCH_SCAN_START].name = SANE_NAME_BATCH_SCAN_START;
5841 scanner->opt[OPT_BATCH_SCAN_START].title = SANE_TITLE_BATCH_SCAN_START;
5842 scanner->opt[OPT_BATCH_SCAN_START].desc = SANE_DESC_BATCH_SCAN_START;
5843 scanner->opt[OPT_BATCH_SCAN_START].type = SANE_TYPE_BOOL;
5844 scanner->val[OPT_BATCH_SCAN_START].w = SANE_FALSE;
5847 scanner->opt[OPT_BATCH_SCAN_LOOP].name = SANE_NAME_BATCH_SCAN_LOOP;
5848 scanner->opt[OPT_BATCH_SCAN_LOOP].title = SANE_TITLE_BATCH_SCAN_LOOP;
5849 scanner->opt[OPT_BATCH_SCAN_LOOP].desc = SANE_DESC_BATCH_SCAN_LOOP;
5850 scanner->opt[OPT_BATCH_SCAN_LOOP].type = SANE_TYPE_BOOL;
5851 scanner->val[OPT_BATCH_SCAN_LOOP].w = SANE_FALSE;
5854 scanner->opt[OPT_BATCH_SCAN_END].name = SANE_NAME_BATCH_SCAN_END;
5855 scanner->opt[OPT_BATCH_SCAN_END].title = SANE_TITLE_BATCH_SCAN_END;
5856 scanner->opt[OPT_BATCH_SCAN_END].desc = SANE_DESC_BATCH_SCAN_END;
5857 scanner->opt[OPT_BATCH_SCAN_END].type = SANE_TYPE_BOOL;
5858 scanner->val[OPT_BATCH_SCAN_END].w = SANE_FALSE;
5861 scanner->opt[OPT_BATCH_NEXT_TL_Y].name = SANE_NAME_BATCH_NEXT_TL_Y;
5862 scanner->opt[OPT_BATCH_NEXT_TL_Y].title = SANE_TITLE_BATCH_NEXT_TL_Y;
5863 scanner->opt[OPT_BATCH_NEXT_TL_Y].desc = SANE_DESC_BATCH_NEXT_TL_Y;
5864 scanner->opt[OPT_BATCH_NEXT_TL_Y].type = SANE_TYPE_FIXED;
5865 scanner->opt[OPT_BATCH_NEXT_TL_Y].unit = SANE_UNIT_MM;
5866 scanner->opt[OPT_BATCH_NEXT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
5867 scanner->opt[OPT_BATCH_NEXT_TL_Y].constraint.range = &(scanner->device->y_range);
5868 scanner->val[OPT_BATCH_NEXT_TL_Y].w = 0xFFFF; /* mark value as not touched */
5870 if (scanner->device->inquiry_batch_scan == 0)
5872 scanner->opt[OPT_BATCH_SCAN_START].cap |= SANE_CAP_INACTIVE;
5873 scanner->opt[OPT_BATCH_SCAN_LOOP].cap |= SANE_CAP_INACTIVE;
5874 scanner->opt[OPT_BATCH_SCAN_END].cap |= SANE_CAP_INACTIVE;
5875 scanner->opt[OPT_BATCH_NEXT_TL_Y].cap |= SANE_CAP_INACTIVE;
5882 scanner->opt[OPT_CALIB_MODE].name = "calibrationmode";
5883 scanner->opt[OPT_CALIB_MODE].title = SANE_I18N("Calibration mode");
5884 scanner->opt[OPT_CALIB_MODE].desc = SANE_I18N("Define calibration mode");
5885 scanner->opt[OPT_CALIB_MODE].type = SANE_TYPE_STRING;
5886 scanner->opt[OPT_CALIB_MODE].size = max_string_size(calibration_list);
5887 scanner->opt[OPT_CALIB_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
5888 scanner->opt[OPT_CALIB_MODE].constraint.string_list = calibration_list;
5889 scanner->val[OPT_CALIB_MODE].s = (SANE_Char*)strdup(calibration_list[0]);
5891 if (scanner->device->inquiry_calibration == 0)
5893 scanner->opt[OPT_CALIB_MODE].cap |= SANE_CAP_INACTIVE;
5898 scanner->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
5899 scanner->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
5900 scanner->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
5901 scanner->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
5902 scanner->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
5903 scanner->val[OPT_PREVIEW].w = SANE_FALSE;
5905 sane_control_option(scanner, OPT_MODE, SANE_ACTION_SET_VALUE,
6016 /* no config-file: try /dev/scanner and /dev/usbscanner. */
6017 attach_scanner("/dev/scanner", 0, SANE_UMAX_SCSI);
6164 Umax_Scanner *scanner;
6201 scanner = malloc(sizeof (*scanner));
6202 if (!scanner)
6207 memset(scanner, 0, sizeof (*scanner));
6209 scanner->device = dev;
6211 if (scanner->device->inquiry_GIB & 32)
6213 scanner->gamma_length = 65536; /* 16 bits input */
6216 else if (scanner->device->inquiry_GIB & 16)
6218 scanner->gamma_length = 16384; /* 14 bits input */
6221 else if (scanner->device->inquiry_GIB & 8)
6223 scanner->gamma_length = 4096; /* 12 bits input */
6226 else if (scanner->device->inquiry_GIB & 4)
6228 scanner->gamma_length = 1024; /* 10 bits input */
6231 else if (scanner->device->inquiry_GIB & 2)
6233 scanner->gamma_length = 512; /* 9 bits input */
6238 scanner->gamma_length = 256; /* 8 bits input */
6242 scanner->output_bytes = 1; /* 8 bits output */
6244 scanner->gamma_range.min = 0;
6245 scanner->gamma_range.max = scanner->gamma_length-1;
6246 scanner->gamma_range.quant = 0;
6248 scanner->gamma_table[0] = (SANE_Int *) malloc(scanner->gamma_length * sizeof(SANE_Int));
6249 scanner->gamma_table[1] = (SANE_Int *) malloc(scanner->gamma_length * sizeof(SANE_Int));
6250 scanner->gamma_table[2] = (SANE_Int *) malloc(scanner->gamma_length * sizeof(SANE_Int));
6251 scanner->gamma_table[3] = (SANE_Int *) malloc(scanner->gamma_length * sizeof(SANE_Int));
6253 for (j = 0; j < scanner->gamma_length; ++j) /* gamma_table[0] : converts GIB to GOB */
6255 scanner->gamma_table[0][j] = j * scanner->device->max_value / scanner->gamma_length;
6260 for (j = 0; j < scanner->gamma_length; ++j)
6262 scanner->gamma_table[i][j] = j;
6266 scanner->exposure_time_range.min = scanner->device->inquiry_exposure_time_c_min *
6267 scanner->device->inquiry_exposure_time_step_unit;
6268 scanner->exposure_time_range.quant = scanner->device->inquiry_exposure_time_step_unit;
6269 scanner->exposure_time_range.max = scanner->device->inquiry_exposure_time_max *
6270 scanner->device->inquiry_exposure_time_step_unit;
6272 init_options(scanner);
6274 scanner->next = first_handle; /* insert newly opened handle into list of open handles: */
6275 first_handle = scanner;
6277 *handle = scanner;
6287 Umax_Scanner *prev, *scanner;
6300 for (scanner = first_handle; scanner; scanner = scanner->next)
6302 if (scanner == handle)
6307 prev = scanner;
6310 if (!scanner)
6316 if (scanner->scanning) /* stop scan if still scanning */
6321 if (scanner->device->lamp_control_available) /* lamp state can be controlled by driver */
6323 if (scanner->val[OPT_LAMP_OFF_AT_EXIT].w) /* turn off scanner lamp on sane_close */
6331 prev->next = scanner->next;
6335 first_handle = scanner->next;
6338 free(scanner->gamma_table[0]); /* free custom gamma tables */
6339 free(scanner->gamma_table[1]);
6340 free(scanner->gamma_table[2]);
6341 free(scanner->gamma_table[3]);
6343 free(scanner->device->buffer[0]); /* free buffer allocated by umax_initialize_values */
6344 scanner->device->buffer[0] = NULL;
6345 scanner->device->bufsize = 0;
6347 free(scanner); /* free scanner */
6356 Umax_Scanner *scanner = handle;
6365 return scanner->opt + option;
6370 static void umax_set_max_geometry(Umax_Scanner *scanner)
6373 if (scanner->val[OPT_DOR].w)
6375 scanner->device->x_range.min = SANE_FIX(scanner->device->inquiry_dor_x_off * MM_PER_INCH);
6376 scanner->device->x_range.max = SANE_FIX( (scanner->device->inquiry_dor_x_off + scanner->device->inquiry_dor_width) * MM_PER_INCH);
6377 scanner->device->y_range.min = SANE_FIX(scanner->device->inquiry_dor_y_off * MM_PER_INCH);
6378 scanner->device->y_range.max = SANE_FIX( (scanner->device->inquiry_dor_y_off + scanner->device->inquiry_dor_length) * MM_PER_INCH);
6380 scanner->device->x_dpi_range.max = SANE_FIX(scanner->device->inquiry_dor_x_res);
6381 scanner->device->y_dpi_range.max = SANE_FIX(scanner->device->inquiry_dor_y_res);
6383 else if ( (strcmp(scanner->val[OPT_SOURCE].s, FLB_STR) == 0) || (strcmp(scanner->val[OPT_SOURCE].s, ADF_STR) == 0) )
6385 scanner->device->x_range.min = 0;
6386 scanner->device->x_range.max = SANE_FIX(scanner->device->inquiry_fb_width * MM_PER_INCH);
6387 scanner->device->y_range.min = 0;
6388 scanner->device->y_range.max = SANE_FIX(scanner->device->inquiry_fb_length * MM_PER_INCH);
6390 scanner->device->x_dpi_range.max = SANE_FIX(scanner->device->inquiry_x_res);
6391 scanner->device->y_dpi_range.max = SANE_FIX(scanner->device->inquiry_y_res);
6393 else if (strcmp(scanner->val[OPT_SOURCE].s, UTA_STR) == 0)
6395 scanner->device->x_range.min = SANE_FIX(scanner->device->inquiry_uta_x_off * MM_PER_INCH);
6396 scanner->device->x_range.max = SANE_FIX( (scanner->device->inquiry_uta_x_off + scanner->device->inquiry_uta_width) * MM_PER_INCH);
6397 scanner->device->y_range.min = SANE_FIX(scanner->device->inquiry_uta_y_off * MM_PER_INCH);
6398 scanner->device->y_range.max = SANE_FIX( ( scanner->device->inquiry_uta_y_off + scanner->device->inquiry_uta_length) * MM_PER_INCH);
6400 scanner->device->x_dpi_range.max = SANE_FIX(scanner->device->inquiry_x_res);
6401 scanner->device->y_dpi_range.max = SANE_FIX(scanner->device->inquiry_y_res);
6404 DBG(DBG_info,"x_range = [%f .. %f]\n", SANE_UNFIX(scanner->device->x_range.min), SANE_UNFIX(scanner->device->x_range.max));
6405 DBG(DBG_info,"y_range = [%f .. %f]\n", SANE_UNFIX(scanner->device->y_range.min), SANE_UNFIX(scanner->device->y_range.max));
6406 DBG(DBG_info,"x_dpi_range = [1 .. %f]\n", SANE_UNFIX(scanner->device->x_dpi_range.max));
6407 DBG(DBG_info,"y_dpi_range = [1 .. %f]\n", SANE_UNFIX(scanner->device->y_dpi_range.max));
6411 if ( scanner->val[OPT_TL_X].w < scanner->device->x_range.min)
6413 scanner->val[OPT_TL_X].w = scanner->device->x_range.min;
6416 if (scanner->val[OPT_TL_Y].w < scanner->device->y_range.min)
6418 scanner->val[OPT_TL_Y].w = scanner->device->y_range.min;
6421 if ( scanner->val[OPT_BR_X].w > scanner->device->x_range.max)
6423 scanner->val[OPT_BR_X].w = scanner->device->x_range.max;
6426 if (scanner->val[OPT_BR_Y].w > scanner->device->y_range.max)
6428 scanner->val[OPT_BR_Y].w = scanner->device->y_range.max;
6438 Umax_Scanner *scanner = handle;
6448 if (scanner->scanning)
6458 cap = scanner->opt[option].cap;
6464 name = scanner->opt[option].name;
6532 *(SANE_Word *) val = scanner->val[option].w;
6541 memcpy (val, scanner->val[option].wa, scanner->opt[option].size);
6553 strcpy (val, scanner->val[option].s);
6559 switch (scanner->opt[option].type)
6587 status = sanei_constrain_value(scanner->opt+option, val, info);
6648 scanner->val[option].w = *(SANE_Word *) val;
6653 if (scanner->val[option].w != *(SANE_Word *) val)
6655 scanner->val[option].w = *(SANE_Word *) val; /* update valure for umax_set_max_geometry */
6663 DBG(DBG_info,"sane_control_option: set DOR = %d\n", scanner->val[option].w);
6664 umax_set_max_geometry(scanner);
6671 if (scanner->val[option].w != *(SANE_Word *) val)
6673 scanner->val[option].w = *(SANE_Word *) val;
6680 scanner->output_range.min = 0;
6681 scanner->output_range.quant = 0;
6683 if (scanner->val[option].w == 8) /* 8 bit mode */
6685 scanner->output_bytes = 1; /* 1 bytes output */
6686 scanner->output_range.max = 255;
6690 scanner->output_bytes = 2; /* 2 bytes output */
6692 if (scanner->device->gamma_lsb_padded) /* e.g. astra 1220s need lsb padded data */
6694 scanner->output_range.max = (int) pow(2, scanner->val[option].w) - 1;
6698 scanner->output_range.max = 65535; /* define maxval for msb padded data */
6713 if (scanner->val[option].w != *(SANE_Word *) val)
6715 scanner->val[option].w = *(SANE_Word *) val;
6721 umax_set_rgb_bind(scanner);
6728 if (scanner->val[option].w != *(SANE_Word *) val)
6730 scanner->val[option].w = *(SANE_Word *) val;
6736 if (scanner->val[option].w == SANE_FALSE)
6738 scanner->opt[OPT_Y_RESOLUTION].cap &= ~SANE_CAP_INACTIVE;
6739 scanner->opt[OPT_X_RESOLUTION].title = SANE_TITLE_SCAN_X_RESOLUTION;
6740 scanner->opt[OPT_X_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
6741 scanner->opt[OPT_X_RESOLUTION].desc = SANE_DESC_SCAN_X_RESOLUTION;
6745 scanner->opt[OPT_Y_RESOLUTION].cap |= SANE_CAP_INACTIVE;
6746 scanner->opt[OPT_X_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
6747 scanner->opt[OPT_X_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
6748 scanner->opt[OPT_X_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
6757 if (scanner->val[option].w != *(SANE_Word *) val)
6759 scanner->val[option].w = *(SANE_Word *) val;
6766 if (scanner->val[OPT_SELECT_EXPOSURE_TIME].w == SANE_FALSE)
6768 scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].cap |= SANE_CAP_INACTIVE;
6770 scanner->opt[OPT_CAL_EXPOS_TIME].cap |= SANE_CAP_INACTIVE;
6771 scanner->opt[OPT_CAL_EXPOS_TIME_R].cap |= SANE_CAP_INACTIVE;
6772 scanner->opt[OPT_CAL_EXPOS_TIME_G].cap |= SANE_CAP_INACTIVE;
6773 scanner->opt[OPT_CAL_EXPOS_TIME_B].cap |= SANE_CAP_INACTIVE;
6775 scanner->opt[OPT_SCAN_EXPOS_TIME].cap |= SANE_CAP_INACTIVE;
6776 scanner->opt[OPT_SCAN_EXPOS_TIME_R].cap |= SANE_CAP_INACTIVE;
6777 scanner->opt[OPT_SCAN_EXPOS_TIME_G].cap |= SANE_CAP_INACTIVE;
6778 scanner->opt[OPT_SCAN_EXPOS_TIME_B].cap |= SANE_CAP_INACTIVE;
6782 scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].cap &= ~SANE_CAP_INACTIVE;
6784 if ( (strcmp(scanner->val[OPT_MODE].s, COLOR_STR) != 0) ||
6785 (scanner->val[OPT_RGB_BIND].w == SANE_TRUE) ||
6786 (scanner->device->exposure_time_rgb_bind) ) /* RGB bind */
6788 if (scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w)
6790 scanner->opt[OPT_CAL_EXPOS_TIME].cap &= ~SANE_CAP_INACTIVE;
6794 scanner->opt[OPT_CAL_EXPOS_TIME].cap |= SANE_CAP_INACTIVE;
6797 scanner->opt[OPT_SCAN_EXPOS_TIME].cap &= ~SANE_CAP_INACTIVE;
6801 if (scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w)
6803 scanner->opt[OPT_CAL_EXPOS_TIME_R].cap &= ~SANE_CAP_INACTIVE;
6804 scanner->opt[OPT_CAL_EXPOS_TIME_G].cap &= ~SANE_CAP_INACTIVE;
6805 scanner->opt[OPT_CAL_EXPOS_TIME_B].cap &= ~SANE_CAP_INACTIVE;
6809 scanner->opt[OPT_CAL_EXPOS_TIME_R].cap |= SANE_CAP_INACTIVE;
6810 scanner->opt[OPT_CAL_EXPOS_TIME_G].cap |= SANE_CAP_INACTIVE;
6811 scanner->opt[OPT_CAL_EXPOS_TIME_B].cap |= SANE_CAP_INACTIVE;
6814 scanner->opt[OPT_SCAN_EXPOS_TIME_R].cap &= ~SANE_CAP_INACTIVE;
6815 scanner->opt[OPT_SCAN_EXPOS_TIME_G].cap &= ~SANE_CAP_INACTIVE;
6816 scanner->opt[OPT_SCAN_EXPOS_TIME_B].cap &= ~SANE_CAP_INACTIVE;
6825 if (scanner->val[option].w != *(SANE_Word *) val)
6827 scanner->val[option].w = *(SANE_Word *) val;
6833 if (scanner->val[option].w == SANE_FALSE)
6835 scanner->opt[OPT_CAL_LAMP_DEN].cap |= SANE_CAP_INACTIVE;
6836 scanner->opt[OPT_SCAN_LAMP_DEN].cap |= SANE_CAP_INACTIVE;
6840 scanner->opt[OPT_CAL_LAMP_DEN].cap &= ~SANE_CAP_INACTIVE;
6841 scanner->opt[OPT_SCAN_LAMP_DEN].cap &= ~SANE_CAP_INACTIVE;
6853 memcpy (scanner->val[option].wa, val, scanner->opt[option].size);
6859 if (scanner->val[option].s)
6861 free(scanner->val[option].s);
6863 scanner->val[option].s = (SANE_Char *) strdup(val); /* update string for umax_set_max_geometry */
6866 umax_set_max_geometry(scanner);
6883 if (scanner->val[option].s)
6885 free (scanner->val[option].s);
6887 scanner->val[option].s = (SANE_Char*)strdup(val);
6896 if (w == scanner->val[OPT_CUSTOM_GAMMA].w) { return SANE_STATUS_GOOD; }
6898 scanner->val[OPT_CUSTOM_GAMMA].w = w;
6901 const char *mode = scanner->val[OPT_MODE].s;
6906 { scanner->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE; }
6909 scanner->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
6910 scanner->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
6911 scanner->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
6912 scanner->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
6917 scanner->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
6918 scanner->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
6919 scanner->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
6920 scanner->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
6933 if (scanner->val[option].s)
6935 free (scanner->val[option].s);
6938 scanner->val[option].s = (SANE_Char*)strdup(val);
6945 scanner->opt[OPT_NEGATIVE].cap |= SANE_CAP_INACTIVE;
6947 scanner->opt[OPT_BIT_DEPTH].cap |= SANE_CAP_INACTIVE;
6949 scanner->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
6950 scanner->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
6951 scanner->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
6952 scanner->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
6953 scanner->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
6955 scanner->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE;
6956 scanner->opt[OPT_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
6957 scanner->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
6959 scanner->opt[OPT_RGB_BIND].cap |= SANE_CAP_INACTIVE;
6961 scanner->opt[OPT_ANALOG_GAMMA].cap |= SANE_CAP_INACTIVE;
6962 scanner->opt[OPT_ANALOG_GAMMA_R].cap |= SANE_CAP_INACTIVE;
6963 scanner->opt[OPT_ANALOG_GAMMA_G].cap |= SANE_CAP_INACTIVE;
6964 scanner->opt[OPT_ANALOG_GAMMA_B].cap |= SANE_CAP_INACTIVE;
6966 scanner->opt[OPT_HIGHLIGHT].cap |= SANE_CAP_INACTIVE;
6967 scanner->opt[OPT_HIGHLIGHT_R].cap |= SANE_CAP_INACTIVE;
6968 scanner->opt[OPT_HIGHLIGHT_G].cap |= SANE_CAP_INACTIVE;
6969 scanner->opt[OPT_HIGHLIGHT_B].cap |= SANE_CAP_INACTIVE;
6971 scanner->opt[OPT_SHADOW].cap |= SANE_CAP_INACTIVE;
6972 scanner->opt[OPT_SHADOW_R].cap |= SANE_CAP_INACTIVE;
6973 scanner->opt[OPT_SHADOW_G].cap |= SANE_CAP_INACTIVE;
6974 scanner->opt[OPT_SHADOW_B].cap |= SANE_CAP_INACTIVE;
6976 scanner->opt[OPT_CAL_EXPOS_TIME].cap |= SANE_CAP_INACTIVE;
6977 scanner->opt[OPT_CAL_EXPOS_TIME_R].cap |= SANE_CAP_INACTIVE;
6978 scanner->opt[OPT_CAL_EXPOS_TIME_G].cap |= SANE_CAP_INACTIVE;
6979 scanner->opt[OPT_CAL_EXPOS_TIME_B].cap |= SANE_CAP_INACTIVE;
6981 scanner->opt[OPT_SCAN_EXPOS_TIME].cap |= SANE_CAP_INACTIVE;
6982 scanner->opt[OPT_SCAN_EXPOS_TIME_R].cap |= SANE_CAP_INACTIVE;
6983 scanner->opt[OPT_SCAN_EXPOS_TIME_G].cap |= SANE_CAP_INACTIVE;
6984 scanner->opt[OPT_SCAN_EXPOS_TIME_B].cap |= SANE_CAP_INACTIVE;
6986 scanner->opt[OPT_HALFTONE_DIMENSION].cap |= SANE_CAP_INACTIVE;
6987 scanner->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
6994 if (scanner->device->inquiry_reverse)
6996 scanner->opt[OPT_NEGATIVE].cap &= ~SANE_CAP_INACTIVE;
7001 scanner->opt[OPT_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
7002 scanner->opt[OPT_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE;
7004 if (scanner->device->inquiry_highlight)
7006 scanner->opt[OPT_HIGHLIGHT].cap &= ~SANE_CAP_INACTIVE;
7009 if (scanner->device->inquiry_shadow)
7011 scanner->opt[OPT_SHADOW].cap &= ~SANE_CAP_INACTIVE;
7016 scanner->opt[OPT_HALFTONE_DIMENSION].cap &= ~SANE_CAP_INACTIVE;
7018 if (scanner->val[OPT_HALFTONE_DIMENSION].w)
7020 scanner->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE;
7024 if (scanner->val[OPT_SELECT_EXPOSURE_TIME].w == SANE_TRUE)
7026 scanner->opt[OPT_CAL_EXPOS_TIME].cap &= ~SANE_CAP_INACTIVE;
7027 scanner->opt[OPT_SCAN_EXPOS_TIME].cap &= ~SANE_CAP_INACTIVE;
7030 scanner->exposure_time_range.min = scanner->device->inquiry_exposure_time_h_min
7031 * scanner->device->inquiry_exposure_time_step_unit;
7035 scanner->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
7037 if (scanner->val[OPT_SELECT_EXPOSURE_TIME].w == SANE_TRUE)
7039 scanner->opt[OPT_CAL_EXPOS_TIME].cap &= ~SANE_CAP_INACTIVE;
7040 scanner->opt[OPT_SCAN_EXPOS_TIME].cap &= ~SANE_CAP_INACTIVE;
7043 scanner->exposure_time_range.min = scanner->device->inquiry_exposure_time_l_min
7044 * scanner->device->inquiry_exposure_time_step_unit;
7049 scanner->opt[OPT_BIT_DEPTH].cap &= ~SANE_CAP_INACTIVE;
7051 if (scanner->device->inquiry_highlight)
7053 scanner->opt[OPT_HIGHLIGHT].cap &= ~SANE_CAP_INACTIVE;
7056 if (scanner->device->inquiry_shadow)
7058 scanner->opt[OPT_SHADOW].cap &= ~SANE_CAP_INACTIVE;
7061 if (scanner->device->inquiry_reverse_multi)
7063 scanner->opt[OPT_NEGATIVE].cap &= ~SANE_CAP_INACTIVE;
7066 if (scanner->device->inquiry_gamma_dwload)
7068 scanner->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
7072 scanner->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
7075 if (scanner->device->inquiry_analog_gamma)
7077 scanner->opt[OPT_ANALOG_GAMMA].cap &= ~SANE_CAP_INACTIVE;
7080 if (scanner->val[OPT_SELECT_EXPOSURE_TIME].w == SANE_TRUE)
7082 scanner->opt[OPT_CAL_EXPOS_TIME].cap &= ~SANE_CAP_INACTIVE;
7083 scanner->opt[OPT_SCAN_EXPOS_TIME].cap &= ~SANE_CAP_INACTIVE;
7088 if ( (scanner->device->inquiry_analog_gamma) ||
7089 (scanner->device->inquiry_highlight) ||
7090 (scanner->device->inquiry_shadow) ||
7091 (scanner->device->inquiry_exposure_adj) )
7093 scanner->opt[OPT_RGB_BIND].cap &= ~SANE_CAP_INACTIVE;
7096 scanner->exposure_time_range.min = scanner->device->inquiry_exposure_time_c_min
7097 * scanner->device->inquiry_exposure_time_step_unit;
7101 scanner->exposure_time_range.min = scanner->device->inquiry_exposure_time_g_min
7102 * scanner->device->inquiry_exposure_time_step_unit;
7106 umax_set_rgb_bind(scanner);
7108 if (scanner->val[OPT_CUSTOM_GAMMA].w)
7112 scanner->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
7116 scanner->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
7117 scanner->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
7118 scanner->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
7119 scanner->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
7129 scanner->val[option].w = dim;
7136 scanner->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
7140 scanner->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE;
7141 scanner->opt[OPT_HALFTONE_PATTERN].size = dim * sizeof (SANE_Word);
7180 Umax_Scanner *scanner = handle;
7185 if (!scanner->scanning)
7189 memset(&scanner->params, 0, sizeof (scanner->params));
7191 width = SANE_UNFIX(scanner->val[OPT_BR_X].w - scanner->val[OPT_TL_X].w);
7192 length = SANE_UNFIX(scanner->val[OPT_BR_Y].w - scanner->val[OPT_TL_Y].w);
7193 x_dpi = SANE_UNFIX(scanner->val[OPT_X_RESOLUTION].w);
7194 y_dpi = SANE_UNFIX(scanner->val[OPT_Y_RESOLUTION].w);
7196 if ( (scanner->val[OPT_RESOLUTION_BIND].w == SANE_TRUE) || (scanner->val[OPT_PREVIEW].w == SANE_TRUE) )
7206 scanner->params.pixels_per_line = width * x_dots_per_mm;
7207 scanner->params.lines = length * y_dots_per_mm;
7211 mode = scanner->val[OPT_MODE].s;
7215 scanner->params.format = SANE_FRAME_GRAY;
7216 scanner->params.bytes_per_line = (scanner->params.pixels_per_line + 7) / 8;
7217 scanner->params.depth = 1;
7221 scanner->params.format = SANE_FRAME_GRAY;
7222 scanner->params.bytes_per_line = scanner->params.pixels_per_line * scanner->output_bytes;
7223 scanner->params.depth = 8 * scanner->output_bytes;
7227 if (scanner->device->inquiry_one_pass_color)
7229 scanner->device->three_pass = 0;
7230 scanner->params.format = SANE_FRAME_RGB;
7231 scanner->params.bytes_per_line = 3 * scanner->params.pixels_per_line;
7232 scanner->params.depth = 8;
7236 scanner->device->three_pass = 1;
7237 scanner->params.format = SANE_FRAME_RED + scanner->device->three_pass_color - 1;
7238 scanner->params.bytes_per_line = scanner->params.pixels_per_line;
7239 scanner->params.depth = 8;
7244 if (scanner->device->inquiry_one_pass_color)
7246 scanner->device->three_pass = 0;
7247 scanner->params.format = SANE_FRAME_RGB;
7248 scanner->params.bytes_per_line = 3 * scanner->params.pixels_per_line * scanner->output_bytes;
7249 scanner->params.depth = 8 * scanner->output_bytes;
7253 scanner->device->three_pass = 1;
7254 scanner->params.format = SANE_FRAME_RED + scanner->device->three_pass_color - 1;
7255 scanner->params.bytes_per_line = scanner->params.pixels_per_line * scanner->output_bytes;
7256 scanner->params.depth = 8 * scanner->output_bytes;
7260 scanner->params.last_frame = (scanner->params.format != SANE_FRAME_RED && scanner->params.format != SANE_FRAME_GREEN);
7264 *params = scanner->params;
7276 Umax_Scanner *scanner = handle;
7288 sanei_thread_invalidate(scanner->reader_pid);
7290 mode = scanner->val[OPT_MODE].s;
7292 if (scanner->device->sfd == -1) /* first call, don`t run this routine again on multi frame or multi image scan */
7294 umax_initialize_values(scanner->device); /* reset values */
7296 scanner->device->three_pass_color = 1;
7299 scan_source = scanner->val[OPT_SOURCE].s;
7303 if ( (scanner->device->inquiry_uta != 0) && (scanner->device->inquiry_transavail != 0) )
7305 scanner->device->uta = 1;
7310 umax_scsi_close(scanner->device);
7316 scanner->device->uta = 0;
7320 if ( (scanner->device->inquiry_adf) && (scanner->device->inquiry_adfmode) )
7322 scanner->device->adf = 1;
7327 umax_scsi_close(scanner->device);
7333 scanner->device->adf = 0;
7337 if (scanner->device->inquiry_GIB & 32) /* 16 bit input mode */
7339 scanner->device->gamma_input_bits_code = 32;
7342 else if (scanner->device->inquiry_GIB & 16) /* 14 bit input mode */
7344 scanner->device->gamma_input_bits_code = 16;
7347 else if (scanner->device->inquiry_GIB & 8) /* 12 bit input mode */
7349 scanner->device->gamma_input_bits_code = 8;
7352 else if (scanner->device->inquiry_GIB & 4) /* 10 bit input mode */
7354 scanner->device->gamma_input_bits_code = 4;
7357 else if (scanner->device->inquiry_GIB & 2) /* 9 bit input mode */
7359 scanner->device->gamma_input_bits_code = 2;
7364 scanner->device->gamma_input_bits_code = 1;
7368 if (scanner->val[OPT_BIT_DEPTH].w == 16) /* 16 bit output mode */
7370 scanner->device->bits_per_pixel = 16;
7371 scanner->device->bits_per_pixel_code = 32;
7372 scanner->device->max_value = 65535;
7375 else if (scanner->val[OPT_BIT_DEPTH].w == 14) /* 14 bit output mode */
7377 scanner->device->bits_per_pixel = 14;
7378 scanner->device->bits_per_pixel_code = 16;
7379 scanner->device->max_value = 16383;
7382 else if (scanner->val[OPT_BIT_DEPTH].w == 12) /* 12 bit output mode */
7384 scanner->device->bits_per_pixel = 12;
7385 scanner->device->bits_per_pixel_code = 8;
7386 scanner->device->max_value = 4095;
7389 else if (scanner->val[OPT_BIT_DEPTH].w == 10) /* 10 bit output mode */
7391 scanner->device->bits_per_pixel = 10;
7392 scanner->device->bits_per_pixel_code = 4;
7393 scanner->device->max_value = 1023;
7396 else if (scanner->val[OPT_BIT_DEPTH].w == 9) /* 9 bit output mode */
7398 scanner->device->bits_per_pixel = 9;
7399 scanner->device->bits_per_pixel_code = 2;
7400 scanner->device->max_value = 511;
7405 scanner->device->bits_per_pixel = 8;
7406 scanner->device->bits_per_pixel_code = 1;
7407 scanner->device->max_value = 255;
7411 scanner->device->reverse = scanner->device->reverse_multi = scanner->val[OPT_NEGATIVE].w;
7413 scanner->device->threshold = P_100_TO_255(scanner->val[OPT_THRESHOLD].w);
7414 scanner->device->brightness = P_200_TO_255(scanner->val[OPT_BRIGHTNESS].w);
7415 scanner->device->contrast = P_200_TO_255(scanner->val[OPT_CONTRAST].w);
7417 scanner->device->batch_scan = ( scanner->val[OPT_BATCH_SCAN_START].w ||
7418 scanner->val[OPT_BATCH_SCAN_LOOP].w ||
7419 scanner->val[OPT_BATCH_SCAN_END].w );
7420 scanner->device->batch_end = scanner->val[OPT_BATCH_SCAN_END].w;
7421 scanner->device->batch_next_tl_y = SANE_UNFIX(scanner->val[OPT_BATCH_NEXT_TL_Y].w) * scanner->device->y_coordinate_base / MM_PER_INCH;
7423 if (scanner->val[OPT_BATCH_NEXT_TL_Y].w == 0xFFFF) /* option not set: use br_y => scanhead stops at end of batch area */
7425 scanner->device->batch_next_tl_y = SANE_UNFIX(scanner->val[OPT_BR_Y].w) * scanner->device->y_coordinate_base / MM_PER_INCH;
7428 if ((scanner->device->batch_scan) && !scanner->val[OPT_BATCH_SCAN_START].w)
7430 scanner->device->calibration = 9; /* no calibration - otherwise the scanhead will go into calibration position */
7434 scanner->device->calibration = 0; /* calibration defined by image type */
7437 scanner->device->quality = scanner->val[OPT_QUALITY].w;
7438 scanner->device->dor = scanner->val[OPT_DOR].w;
7439 scanner->device->preview = scanner->val[OPT_PREVIEW].w;
7440 scanner->device->warmup = scanner->val[OPT_WARMUP].w;
7442 scanner->device->fix_focus_position = scanner->val[OPT_FIX_FOCUS_POSITION].w;
7443 scanner->device->lens_cal_in_doc_pos = scanner->val[OPT_LENS_CALIBRATION_DOC_POS].w;
7444 scanner->device->disable_pre_focus = scanner->val[OPT_DISABLE_PRE_FOCUS].w;
7445 scanner->device->holder_focus_pos_0mm = scanner->val[OPT_HOLDER_FOCUS_POS_0MM].w;
7446 scanner->device->manual_focus = scanner->val[OPT_MANUAL_PRE_FOCUS].w;
7448 scanner->device->analog_gamma_r =
7449 scanner->device->analog_gamma_g =
7450 scanner->device->analog_gamma_b = umax_calculate_analog_gamma(SANE_UNFIX(scanner->val[OPT_ANALOG_GAMMA].w));
7452 scanner->device->highlight_r =
7453 scanner->device->highlight_g =
7454 scanner->device->highlight_b = P_100_TO_255(scanner->val[OPT_HIGHLIGHT].w);
7456 scanner->device->shadow_r =
7457 scanner->device->shadow_g =
7458 scanner->device->shadow_b = P_100_TO_255(scanner->val[OPT_SHADOW].w);
7460 if (scanner->val[OPT_SELECT_EXPOSURE_TIME].w == SANE_TRUE)
7462 if (scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w) /* separate calibration exposure time */
7464 scanner->device->exposure_time_calibration_r =
7465 scanner->device->exposure_time_calibration_g =
7466 scanner->device->exposure_time_calibration_b = scanner->val[OPT_CAL_EXPOS_TIME].w;
7470 scanner->device->exposure_time_calibration_r =
7471 scanner->device->exposure_time_calibration_g =
7472 scanner->device->exposure_time_calibration_b = scanner->val[OPT_SCAN_EXPOS_TIME].w;
7475 scanner->device->exposure_time_scan_r =
7476 scanner->device->exposure_time_scan_g =
7477 scanner->device->exposure_time_scan_b = scanner->val[OPT_SCAN_EXPOS_TIME].w;
7480 if (scanner->val[OPT_SELECT_LAMP_DENSITY].w == SANE_TRUE)
7482 scanner->device->c_density = P_100_TO_254(scanner->val[OPT_CAL_LAMP_DEN].w);
7483 scanner->device->s_density = P_100_TO_254(scanner->val[OPT_SCAN_LAMP_DEN].w);
7488 scanner->device->colormode = LINEART;
7492 scanner->device->colormode = HALFTONE;
7496 scanner->device->colormode = GRAYSCALE;
7500 scanner->device->colormode = RGB_LINEART;
7504 scanner->device->colormode = RGB_HALFTONE;
7508 scanner->device->colormode = RGB;
7509 if (scanner->val[OPT_RGB_BIND].w == SANE_FALSE)
7511 scanner->device->analog_gamma_r =
7512 umax_calculate_analog_gamma( SANE_UNFIX(scanner->val[OPT_ANALOG_GAMMA_R].w) );
7513 scanner->device->analog_gamma_g =
7514 umax_calculate_analog_gamma( SANE_UNFIX(scanner->val[OPT_ANALOG_GAMMA_G].w) );
7515 scanner->device->analog_gamma_b =
7516 umax_calculate_analog_gamma( SANE_UNFIX(scanner->val[OPT_ANALOG_GAMMA_B].w) );
7518 scanner->device->highlight_r = P_100_TO_255(scanner->val[OPT_HIGHLIGHT_R].w);
7519 scanner->device->highlight_g = P_100_TO_255(scanner->val[OPT_HIGHLIGHT_G].w);
7520 scanner->device->highlight_b = P_100_TO_255(scanner->val[OPT_HIGHLIGHT_B].w);
7522 scanner->device->shadow_r = P_100_TO_255(scanner->val[OPT_SHADOW_R].w);
7523 scanner->device->shadow_g = P_100_TO_255(scanner->val[OPT_SHADOW_G].w);
7524 scanner->device->shadow_b = P_100_TO_255(scanner->val[OPT_SHADOW_B].w);
7526 if ((scanner->val[OPT_SELECT_EXPOSURE_TIME].w == SANE_TRUE) && (!scanner->device->exposure_time_rgb_bind))
7528 if (scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w) /* separate calibration exposure time */
7530 scanner->device->exposure_time_calibration_r = scanner->val[OPT_CAL_EXPOS_TIME_R].w;
7531 scanner->device->exposure_time_calibration_g = scanner->val[OPT_CAL_EXPOS_TIME_G].w;
7532 scanner->device->exposure_time_calibration_b = scanner->val[OPT_CAL_EXPOS_TIME_B].w;
7536 scanner->device->exposure_time_calibration_r = scanner->val[OPT_SCAN_EXPOS_TIME_R].w;
7537 scanner->device->exposure_time_calibration_g = scanner->val[OPT_SCAN_EXPOS_TIME_G].w;
7538 scanner->device->exposure_time_calibration_b = scanner->val[OPT_SCAN_EXPOS_TIME_B].w;
7541 scanner->device->exposure_time_scan_r = scanner->val[OPT_SCAN_EXPOS_TIME_R].w;
7542 scanner->device->exposure_time_scan_g = scanner->val[OPT_SCAN_EXPOS_TIME_G].w;
7543 scanner->device->exposure_time_scan_b = scanner->val[OPT_SCAN_EXPOS_TIME_B].w;
7548 if (scanner->device->force_preview_bit_rgb != 0) /* in RGB-mode set preview bit, eg. for UMAX S6E */
7550 if (scanner->device->colormode == RGB)
7553 scanner->device->preview = SANE_TRUE;
7559 if (strcmp(scanner->val[OPT_CALIB_MODE].s, CALIB_MODE_0000) == 0)
7561 scanner->device->calibration = 0;
7563 else if (strcmp(scanner->val[OPT_CALIB_MODE].s, CALIB_MODE_1111) == 0)
7565 scanner->device->calibration = 15;
7567 else if (strcmp(scanner->val[OPT_CALIB_MODE].s, CALIB_MODE_1110) == 0)
7569 scanner->device->calibration = 14;
7571 else if (strcmp(scanner->val[OPT_CALIB_MODE].s, CALIB_MODE_1101) == 0)
7573 scanner->device->calibration = 13;
7575 else if (strcmp(scanner->val[OPT_CALIB_MODE].s, CALIB_MODE_1010) == 0)
7577 scanner->device->calibration = 10;
7579 else if (strcmp(scanner->val[OPT_CALIB_MODE].s, CALIB_MODE_1001) == 0)
7581 scanner->device->calibration = 9;
7586 scanner->device->x_resolution = SANE_UNFIX(scanner->val[OPT_X_RESOLUTION].w);
7587 scanner->device->y_resolution = SANE_UNFIX(scanner->val[OPT_Y_RESOLUTION].w);
7589 if ( (scanner->val[OPT_RESOLUTION_BIND].w == SANE_TRUE) || (scanner->val[OPT_PREVIEW].w == SANE_TRUE) )
7591 scanner->device->y_resolution = scanner->device->x_resolution;
7594 xbasedots = scanner->device->x_coordinate_base / MM_PER_INCH;
7595 ybasedots = scanner->device->y_coordinate_base / MM_PER_INCH;
7598 scanner->device->upper_left_x = ((int) (SANE_UNFIX(scanner->val[OPT_TL_X].w) * xbasedots)) & 65534;
7599 scanner->device->upper_left_y = ((int) (SANE_UNFIX(scanner->val[OPT_TL_Y].w) * ybasedots)) & 65534;
7601 scanner->device->scanwidth = ((int)((SANE_UNFIX(scanner->val[OPT_BR_X].w - scanner->val[OPT_TL_X].w)) * xbasedots)) & 65534;
7602 scanner->device->scanlength = ((int)((SANE_UNFIX(scanner->val[OPT_BR_Y].w - scanner->val[OPT_TL_Y].w)) * ybasedots)) & 65534;
7605 scanner->device->upper_left_x = (int) (SANE_UNFIX(scanner->val[OPT_TL_X].w) * xbasedots);
7606 scanner->device->upper_left_y = (int) (SANE_UNFIX(scanner->val[OPT_TL_Y].w) * ybasedots);
7608 scanner->device->scanwidth = (int)((SANE_UNFIX(scanner->val[OPT_BR_X].w - scanner->val[OPT_TL_X].w)) * xbasedots);
7609 scanner->device->scanlength = (int)((SANE_UNFIX(scanner->val[OPT_BR_Y].w - scanner->val[OPT_TL_Y].w)) * ybasedots);
7612 if (umax_check_values(scanner->device) != 0)
7615 scanner->scanning = SANE_FALSE;
7619 /* The scanner defines a x-origin-offset for DOR mode, this offset is used for the */
7621 /* scanner's surface. But the scanner wants x values from origin 0 instead */
7622 /* of the x-origin defined by the scanner`s inquiry */
7623 if (scanner->device->dor != 0) /* dor mode active */
7626 scanner->device->upper_left_x -= scanner->device->inquiry_dor_x_off * scanner->device->x_coordinate_base; /* correct DOR x-origin */
7628 if (scanner->device->upper_left_x < 0) /* rounding errors may create a negative value */
7630 scanner->device->upper_left_x = 0; /* but negative values are not allowed */
7634 scanner->params.bytes_per_line = scanner->device->row_len;
7635 scanner->params.pixels_per_line = scanner->device->width_in_pixels;
7636 scanner->params.lines = scanner->device->length_in_pixels;
7640 if ( scanner->device->inquiry_exposure_adj )
7642 umax_calculate_exposure_time(scanner->device, scanner->device->use_exposure_time_def_r, &scanner->device->exposure_time_calibration_r);
7643 umax_calculate_exposure_time(scanner->device, scanner->device->use_exposure_time_def_g, &scanner->device->exposure_time_calibration_g);
7644 umax_calculate_exposure_time(scanner->device, scanner->device->use_exposure_time_def_b, &scanner->device->exposure_time_calibration_b);
7646 umax_calculate_exposure_time(scanner->device, scanner->device->use_exposure_time_def_r, &scanner->device->exposure_time_scan_r);
7647 umax_calculate_exposure_time(scanner->device, scanner->device->use_exposure_time_def_g, &scanner->device->exposure_time_scan_g);
7648 umax_calculate_exposure_time(scanner->device, scanner->device->use_exposure_time_def_b, &scanner->device->exposure_time_scan_b);
7652 scanner->device->exposure_time_calibration_r = scanner->device->exposure_time_calibration_g = scanner->device->exposure_time_calibration_b =
7653 scanner->device->exposure_time_scan_r = scanner->device->exposure_time_scan_g = scanner->device->exposure_time_scan_b = 0;
7657 scanner->scanning = SANE_TRUE;
7658 sane_get_parameters(scanner, 0);
7660 DBG(DBG_sane_info,"x_resolution (dpi) = %u\n", scanner->device->x_resolution);
7661 DBG(DBG_sane_info,"y_resolution (dpi) = %u\n", scanner->device->y_resolution);
7662 DBG(DBG_sane_info,"x_coordinate_base (dpi) = %u\n", scanner->device->x_coordinate_base);
7663 DBG(DBG_sane_info,"y_coordinate_base (dpi) = %u\n", scanner->device->y_coordinate_base);
7664 DBG(DBG_sane_info,"upper_left_x (xbase) = %d\n", scanner->device->upper_left_x);
7665 DBG(DBG_sane_info,"upper_left_y (ybase) = %d\n", scanner->device->upper_left_y);
7666 DBG(DBG_sane_info,"scanwidth (xbase) = %u\n", scanner->device->scanwidth);
7667 DBG(DBG_sane_info,"scanlength (ybase) = %u\n", scanner->device->scanlength);
7668 DBG(DBG_sane_info,"width in pixels = %u\n", scanner->device->width_in_pixels);
7669 DBG(DBG_sane_info,"length in pixels = %u\n", scanner->device->length_in_pixels);
7670 DBG(DBG_sane_info,"bits per pixel/color = %u\n", scanner->device->bits_per_pixel);
7671 DBG(DBG_sane_info,"bytes per line = %d\n", scanner->params.bytes_per_line);
7672 DBG(DBG_sane_info,"pixels_per_line = %d\n", scanner->params.pixels_per_line);
7673 DBG(DBG_sane_info,"lines = %d\n", scanner->params.lines);
7674 DBG(DBG_sane_info,"negative = %d\n", scanner->device->reverse);
7675 DBG(DBG_sane_info,"threshold (lineart) = %d\n", scanner->device->threshold);
7676 DBG(DBG_sane_info,"brightness (halftone) = %d\n", scanner->device->brightness);
7677 DBG(DBG_sane_info,"contrast (halftone) = %d\n", scanner->device->contrast);
7680 scanner->device->analog_gamma_r,
7681 scanner->device->analog_gamma_g,
7682 scanner->device->analog_gamma_b);
7684 scanner->device->highlight_r,
7685 scanner->device->highlight_g,
7686 scanner->device->highlight_b);
7688 scanner->device->shadow_r,
7689 scanner->device->shadow_g,
7690 scanner->device->shadow_b);
7692 scanner->device->exposure_time_calibration_r,
7693 scanner->device->exposure_time_calibration_g,
7694 scanner->device->exposure_time_calibration_b);
7696 scanner->device->exposure_time_scan_r,
7697 scanner->device->exposure_time_scan_g,
7698 scanner->device->exposure_time_scan_b);
7701 DBG(DBG_sane_info,"calibration = %s\n", scanner->val[OPT_CALIB_MODE].s);
7703 DBG(DBG_sane_info,"calibration mode number = %d\n", scanner->device->calibration);
7705 DBG(DBG_sane_info,"batch scan = %d\n", scanner->device->batch_scan);
7706 DBG(DBG_sane_info,"batch end = %d\n", scanner->device->batch_end);
7707 DBG(DBG_sane_info,"batch next top left y = %d\n", scanner->device->batch_next_tl_y);
7708 DBG(DBG_sane_info,"quality calibration = %d\n", scanner->device->quality);
7709 DBG(DBG_sane_info,"warm up = %d\n", scanner->device->warmup);
7710 DBG(DBG_sane_info,"fast preview function = %d\n", scanner->device->preview);
7711 DBG(DBG_sane_info,"DOR = %d\n", scanner->device->dor);
7712 DBG(DBG_sane_info,"ADF = %d\n", scanner->device->adf);
7713 DBG(DBG_sane_info,"manual focus = %d\n", scanner->device->manual_focus);
7714 DBG(DBG_sane_info,"fix focus position = %d\n", scanner->device->fix_focus_position);
7715 DBG(DBG_sane_info,"disable pre focus = %d\n", scanner->device->disable_pre_focus);
7716 DBG(DBG_sane_info,"lens cal in doc pos = %d\n", scanner->device->lens_cal_in_doc_pos);
7717 DBG(DBG_sane_info,"holder focus pos 0mm = %d\n", scanner->device->holder_focus_pos_0mm);
7719 if (scanner->val[OPT_PREVIEW].w) /* preview mode */
7721 scanner->device->lines_max = scanner->device->request_preview_lines;
7725 scanner->device->lines_max = scanner->device->request_scan_lines;
7732 scsi_bufsize = scanner->device->width_in_pixels * scanner->device->lines_max;
7734 if (scsi_bufsize == 0) /* no scsi buffer size, take scanner buffer size */
7736 scsi_bufsize = scanner->device->inquiry_vidmem;
7739 if (scsi_bufsize < scanner->device->scsi_buffer_size_min) /* make sure buffer has at least minimum size */
7741 scsi_bufsize = scanner->device->scsi_buffer_size_min;
7743 else if (scsi_bufsize > scanner->device->scsi_buffer_size_max) /* make sure buffer does not exceed maximum size */
7745 scsi_bufsize = scanner->device->scsi_buffer_size_max;
7748 if (umax_scsi_open_extended(scanner->device->sane.name, scanner->device, sense_handler,
7749 scanner->device, (int *) &scsi_bufsize) != 0)
7752 scanner->scanning = SANE_FALSE;
7756 if (scsi_bufsize < scanner->device->scsi_buffer_size_min) /* minimum size must be available */
7759 umax_scsi_close((scanner->device));
7760 scanner->scanning = SANE_FALSE;
7765 if (scsi_bufsize < scanner->device->width_in_pixels) /* print warning when buffer is smaller than one scanline */
7770 if (scsi_bufsize != scanner->device->bufsize)
7774 if (scanner->device->buffer[0])
7777 free(scanner->device->buffer[0]); /* free buffer */
7780 scanner->device->bufsize = scsi_bufsize;
7783 scanner->device->buffer[0] = malloc(scanner->device->bufsize); /* allocate buffer */
7785 if (!scanner->device->buffer[0]) /* malloc failed */
7788 umax_scsi_close(scanner->device);
7789 scanner->device->bufsize = 0;
7790 scanner->scanning = SANE_FALSE;
7796 if ( umax_scsi_open(scanner->device->sane.name, scanner->device, sense_handler,
7797 scanner->device) != SANE_STATUS_GOOD )
7799 scanner->scanning = SANE_FALSE;
7800 DBG(DBG_error, "ERROR: sane_start: open of %s failed:\n", scanner->device->sane.name);
7807 /* grab scanner */
7808 if (umax_grab_scanner(scanner->device))
7810 umax_scsi_close(scanner->device);
7811 scanner->scanning = SANE_FALSE;
7812 DBG(DBG_warning,"WARNING: unable to reserve scanner: device busy\n");
7821 umax_send_halftone_pattern(scanner->device, (char *) &(scanner->halftone_pattern[0]),
7822 scanner->val[OPT_HALFTONE_DIMENSION].w );
7823 scanner->device->halftone = WD_halftone_download;
7831 if (scanner->val[OPT_CUSTOM_GAMMA].w == SANE_TRUE)
7835 if (scanner->device->three_pass == 0) /* one pass color scan */
7840 gamma = malloc( (size_t) (3 * scanner->gamma_length * scanner->output_bytes) );
7850 for(i=0; i < scanner->gamma_length; i++)
7852 value = scanner->gamma_table[color][i];
7853 if (scanner->output_bytes == 2)
7855 gamma[dest++] = scanner->gamma_table[0][value] / 256;
7857 gamma[dest++] = (scanner->gamma_table[0][value] & 255);
7862 scanner->gamma_length * scanner->output_bytes);
7864 umax_send_gamma_data(scanner->device, &gamma[0], 3);
7865 scanner->device->digital_gamma_r =
7866 scanner->device->digital_gamma_g =
7867 scanner->device->digital_gamma_b = WD_gamma_download;
7876 gamma = malloc( (size_t) (scanner->gamma_length * scanner->output_bytes) );
7884 color = scanner->device->three_pass_color;
7886 for(i = 0; i < scanner->gamma_length; i++)
7888 value = scanner->gamma_table[color][i];
7890 if (scanner->output_bytes == 2)
7892 gamma[dest++] = scanner->gamma_table[0][value] / 256;
7894 gamma[dest++] = (scanner->gamma_table[0][value] & 255);
7898 scanner->gamma_length * scanner->output_bytes, color);
7900 umax_send_gamma_data(scanner->device, &gamma[0], 1);
7901 scanner->device->digital_gamma_r =
7902 scanner->device->digital_gamma_g =
7903 scanner->device->digital_gamma_b = WD_gamma_download;
7913 gamma = malloc( (size_t) (scanner->gamma_length * scanner->output_bytes) );
7921 for(i=0; i < scanner->gamma_length; i++)
7923 if (scanner->output_bytes == 2)
7925 gamma[dest++] = scanner->gamma_table[0][i] / 256;
7927 gamma[dest++] = (scanner->gamma_table[0][i] & 255);
7931 scanner->gamma_length * scanner->output_bytes);
7933 umax_send_gamma_data(scanner->device, &gamma[0], 1);
7934 scanner->device->digital_gamma_r = WD_gamma_download;
7940 if ( scanner->device->three_pass_color > WD_wid_red) /* three pass scan, not first pass */
7942 umax_reposition_scanner(scanner->device);
7945 umax_set_window_param(scanner->device);
7946 status = umax_start_scan(scanner->device);
7949 umax_give_scanner(scanner->device); /* reposition and release scanner */
7953 pause = scanner->device->pause_for_color_calibration;
7955 if (scanner->device->colormode != RGB)
7957 pause = scanner->device->pause_for_gray_calibration;
7967 status = umax_do_calibration(scanner->device);
7970 umax_give_scanner(scanner->device); /* reposition and release scanner */
7974 if (scanner->device->pause_after_calibration) /* may be useful */
7976 DBG(DBG_info2,"pause after calibration %d msec ...\n", scanner->device->pause_after_calibration);
7977 usleep(((long) scanner->device->pause_after_calibration) * 1000); /* time in ms */
7985 scanner->scanning = SANE_FALSE;
7986 umax_give_scanner(scanner->device); /* reposition and release scanner */
7987 umax_scsi_close(scanner->device);
7991 scanner->pipe_read_fd = fds[0];
7992 scanner->pipe_write_fd = fds[1];
7995 scanner->reader_pid = sanei_thread_begin(reader_process, (void *) scanner);
7997 if (!sanei_thread_is_valid (scanner->reader_pid))
8000 scanner->scanning = SANE_FALSE;
8001 umax_give_scanner(scanner->device); /* reposition and release scanner */
8002 umax_scsi_close(scanner->device);
8008 close(scanner->pipe_write_fd);
8009 scanner->pipe_write_fd = -1;
8021 Umax_Scanner *scanner = handle;
8026 nread = read(scanner->pipe_read_fd, buf, max_len);
8030 if (!(scanner->scanning)) /* OOPS, not scanning */
8032 return do_cancel(scanner);
8044 do_cancel(scanner); /* we had an error, stop scanner */
8053 if ( (scanner->device->three_pass == 0) ||
8054 (scanner->device->colormode <= RGB_LINEART) ||
8055 (++(scanner->device->three_pass_color) > 3) )
8057 do_cancel(scanner);
8062 if (scanner->pipe_read_fd >= 0)
8064 close(scanner->pipe_read_fd);
8065 scanner->pipe_read_fd = -1;
8080 Umax_Scanner *scanner = handle;
8084 if (scanner->scanning)
8086 do_cancel(scanner);
8096 Umax_Scanner *scanner = handle;
8100 if (!scanner->scanning) { return SANE_STATUS_INVAL; }
8102 if (fcntl(scanner->pipe_read_fd, F_SETFL, non_blocking ? O_NONBLOCK : 0) < 0)
8115 Umax_Scanner *scanner = handle;
8119 if (!scanner->scanning)
8124 *fd = scanner->pipe_read_fd;