Lines Matching refs:dev
527 matsushita_read_document_size (Matsushita_Scanner * dev)
538 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
539 NULL, 0, dev->buffer, &size);
548 hexdump (DBG_info2, "document size", dev->buffer, 16);
552 assert (dev->params.lines == B32TOI (&dev->buffer[4]));
553 assert (dev->params.pixels_per_line == B32TOI (&dev->buffer[0]));
566 Matsushita_Scanner *dev;
571 dev = malloc (sizeof (Matsushita_Scanner));
572 if (dev == NULL)
577 memset (dev, 0, sizeof (Matsushita_Scanner));
580 dev->buffer_size = 64 * 1024;
581 dev->buffer = malloc (dev->buffer_size);
582 if (dev->buffer == NULL)
584 free (dev);
589 dev->image_size = 64 * 1024; /* enough for 1 line at max res */
590 dev->image = malloc (dev->image_size);
591 if (dev->image == NULL)
593 free (dev->buffer);
594 free (dev);
598 dev->sfd = -1;
602 return (dev);
607 matsushita_close (Matsushita_Scanner * dev)
611 if (dev->sfd != -1)
613 sanei_scsi_close (dev->sfd);
614 dev->sfd = -1;
622 matsushita_free (Matsushita_Scanner * dev)
628 if (dev == NULL)
631 matsushita_close (dev);
632 if (dev->devicename)
634 free (dev->devicename);
636 if (dev->buffer)
638 free (dev->buffer);
640 if (dev->image)
642 free (dev->image);
646 if (dev->opt[i].type == SANE_TYPE_STRING && dev->val[i].s)
648 free (dev->val[i].s);
651 free (dev->paper_sizes_list);
652 free (dev->paper_sizes_val);
654 free (dev);
661 matsushita_identify_scanner (Matsushita_Scanner * dev)
672 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
673 NULL, 0, dev->buffer, &size);
683 size = dev->buffer[4] + 5; /* total length of the inquiry data */
693 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
694 NULL, 0, dev->buffer, &size);
704 hexdump (DBG_info2, "inquiry", dev->buffer, size);
706 dev->scsi_type = dev->buffer[0] & 0x1f;
707 memcpy (dev->scsi_vendor, dev->buffer + 0x08, 0x08);
708 dev->scsi_vendor[0x08] = 0;
709 memcpy (dev->scsi_product, dev->buffer + 0x10, 0x010);
710 dev->scsi_product[0x10] = 0;
711 memcpy (dev->scsi_version, dev->buffer + 0x20, 0x04);
712 dev->scsi_version[0x04] = 0;
715 dev->scsi_vendor, dev->scsi_product, dev->scsi_version);
721 if (dev->scsi_type == scanners[i].scsi_type &&
722 strcmp (dev->scsi_vendor, scanners[i].scsi_vendor) == 0 &&
723 strcmp (dev->scsi_product, scanners[i].scsi_product) == 0)
728 dev->scnum = i;
742 matsushita_build_paper_sizes (Matsushita_Scanner * dev)
768 if (SANE_UNFIX (scanners[dev->scnum].x_range.max) >=
770 && SANE_UNFIX (scanners[dev->scnum].y_range.max) >=
782 dev->paper_sizes_list = psl;
783 dev->paper_sizes_val = psv;
951 matsushita_check_next_page (Matsushita_Scanner * dev)
959 cdb.data[4] = dev->page_num; /* May be cdb.data[3] too? */
960 cdb.data[5] = dev->page_side;
962 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL);
973 Matsushita_Scanner *dev;
982 for (dev = first_dev; dev; dev = dev->next)
984 if (strcmp (dev->sane.name, devicename) == 0)
988 *devp = dev;
996 dev = matsushita_init ();
997 if (dev == NULL)
1005 if (sanei_scsi_open (devicename, &sfd, matsushita_sense_handler, dev) != 0)
1008 matsushita_free (dev);
1013 dev->devicename = strdup (devicename);
1014 dev->sfd = sfd;
1017 if (matsushita_identify_scanner (dev) == SANE_FALSE)
1021 matsushita_free (dev);
1025 matsushita_close (dev);
1028 dev->sane.name = dev->devicename;
1029 dev->sane.vendor = "Panasonic";
1030 dev->sane.model = dev->scsi_product;
1031 dev->sane.type = SANE_I18N ("sheetfed scanner");
1034 dev->next = first_dev;
1035 first_dev = dev;
1039 *devp = dev;
1050 attach_one (const char *dev)
1052 attach_scanner (dev, NULL);
1058 matsushita_init_options (Matsushita_Scanner * dev)
1063 memset (dev->opt, 0, sizeof (dev->opt));
1064 memset (dev->val, 0, sizeof (dev->val));
1068 dev->opt[i].size = sizeof (SANE_Word);
1069 dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
1073 dev->opt[OPT_NUM_OPTS].name = "";
1074 dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
1075 dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
1076 dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
1077 dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
1078 dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS;
1081 dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode");
1082 dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */
1083 dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
1084 dev->opt[OPT_MODE_GROUP].cap = 0;
1085 dev->opt[OPT_MODE_GROUP].size = 0;
1086 dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
1089 dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
1090 dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
1091 dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
1092 dev->opt[OPT_MODE].type = SANE_TYPE_STRING;
1093 dev->opt[OPT_MODE].size =
1094 max_string_size (scanners[dev->scnum].scan_mode_list);
1095 dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1096 dev->opt[OPT_MODE].constraint.string_list =
1097 scanners[dev->scnum].scan_mode_list;
1098 dev->val[OPT_MODE].s = (SANE_Char *) strdup (""); /* will be set later */
1101 dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
1102 dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
1103 dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
1104 dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
1105 dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
1106 dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
1107 dev->opt[OPT_RESOLUTION].constraint.word_list =
1108 scanners[dev->scnum].resolutions_list;
1109 dev->val[OPT_RESOLUTION].w = resolutions_list_300[1];
1112 dev->opt[OPT_DUPLEX].name = SANE_NAME_DUPLEX;
1113 dev->opt[OPT_DUPLEX].title = SANE_TITLE_DUPLEX;
1114 dev->opt[OPT_DUPLEX].desc = SANE_DESC_DUPLEX;
1115 dev->opt[OPT_DUPLEX].type = SANE_TYPE_BOOL;
1116 dev->opt[OPT_DUPLEX].unit = SANE_UNIT_NONE;
1117 dev->val[OPT_DUPLEX].w = SANE_FALSE;
1118 if ((scanners[dev->scnum].cap & MAT_CAP_DUPLEX) == 0)
1119 dev->opt[OPT_DUPLEX].cap |= SANE_CAP_INACTIVE;
1122 dev->opt[OPT_FEEDER_MODE].name = "feeder-mode";
1123 dev->opt[OPT_FEEDER_MODE].title = SANE_I18N ("Feeder mode");
1124 dev->opt[OPT_FEEDER_MODE].desc = SANE_I18N ("Sets the feeding mode");
1125 dev->opt[OPT_FEEDER_MODE].type = SANE_TYPE_STRING;
1126 dev->opt[OPT_FEEDER_MODE].size = max_string_size (feeder_mode_list);
1127 dev->opt[OPT_FEEDER_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1128 dev->opt[OPT_FEEDER_MODE].constraint.string_list = feeder_mode_list;
1129 dev->val[OPT_FEEDER_MODE].s = strdup (feeder_mode_list[0]);
1132 dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry");
1133 dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */
1134 dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
1135 dev->opt[OPT_GEOMETRY_GROUP].cap = 0;
1136 dev->opt[OPT_GEOMETRY_GROUP].size = 0;
1137 dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
1140 dev->opt[OPT_PAPER_SIZE].name = SANE_NAME_PAPER_SIZE;
1141 dev->opt[OPT_PAPER_SIZE].title = SANE_TITLE_PAPER_SIZE;
1142 dev->opt[OPT_PAPER_SIZE].desc = SANE_DESC_PAPER_SIZE;
1143 dev->opt[OPT_PAPER_SIZE].type = SANE_TYPE_STRING;
1144 dev->opt[OPT_PAPER_SIZE].size = max_string_size (dev->paper_sizes_list);
1145 dev->opt[OPT_PAPER_SIZE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1146 dev->opt[OPT_PAPER_SIZE].constraint.string_list = dev->paper_sizes_list;
1147 dev->val[OPT_PAPER_SIZE].s = strdup (""); /* will do it later */
1150 dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
1151 dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
1152 dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
1153 dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
1154 dev->opt[OPT_TL_X].unit = SANE_UNIT_MM;
1155 dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
1156 dev->opt[OPT_TL_X].constraint.range = &(scanners[dev->scnum].x_range);
1159 dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
1160 dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
1161 dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
1162 dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
1163 dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
1164 dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
1165 dev->opt[OPT_TL_Y].constraint.range = &(scanners[dev->scnum].y_range);
1168 dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
1169 dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
1170 dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
1171 dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
1172 dev->opt[OPT_BR_X].unit = SANE_UNIT_MM;
1173 dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
1174 dev->opt[OPT_BR_X].constraint.range = &(scanners[dev->scnum].x_range);
1177 dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
1178 dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
1179 dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
1180 dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
1181 dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
1182 dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
1183 dev->opt[OPT_BR_Y].constraint.range = &(scanners[dev->scnum].y_range);
1186 dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
1187 dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */
1188 dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
1189 dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED;
1190 dev->opt[OPT_ENHANCEMENT_GROUP].size = 0;
1191 dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
1194 dev->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
1195 dev->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
1196 dev->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
1197 dev->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
1198 dev->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
1199 dev->opt[OPT_BRIGHTNESS].size = sizeof (SANE_Int);
1200 dev->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
1201 dev->opt[OPT_BRIGHTNESS].constraint.range =
1202 &(scanners[dev->scnum].brightness_range);
1203 dev->val[OPT_BRIGHTNESS].w = 128;
1206 dev->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
1207 dev->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
1208 dev->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
1209 dev->opt[OPT_CONTRAST].type = SANE_TYPE_INT;
1210 dev->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE;
1211 dev->opt[OPT_CONTRAST].size = sizeof (SANE_Int);
1212 dev->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
1213 dev->opt[OPT_CONTRAST].constraint.range =
1214 &(scanners[dev->scnum].contrast_range);
1215 dev->val[OPT_CONTRAST].w = 128;
1216 if ((scanners[dev->scnum].cap & MAT_CAP_CONTRAST) == 0)
1217 dev->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE;
1220 dev->opt[OPT_AUTOMATIC_THRESHOLD].name = "automatic-threshold";
1221 dev->opt[OPT_AUTOMATIC_THRESHOLD].title = SANE_I18N ("Automatic threshold");
1222 dev->opt[OPT_AUTOMATIC_THRESHOLD].desc =
1225 dev->opt[OPT_AUTOMATIC_THRESHOLD].type = SANE_TYPE_STRING;
1226 dev->opt[OPT_AUTOMATIC_THRESHOLD].size =
1228 dev->opt[OPT_AUTOMATIC_THRESHOLD].constraint_type =
1230 dev->opt[OPT_AUTOMATIC_THRESHOLD].constraint.string_list =
1232 dev->val[OPT_AUTOMATIC_THRESHOLD].s = strdup (automatic_threshold_list[0]);
1233 if ((scanners[dev->scnum].cap & MAT_CAP_AUTOMATIC_THRESHOLD) == 0)
1234 dev->opt[OPT_AUTOMATIC_THRESHOLD].cap |= SANE_CAP_INACTIVE;
1237 dev->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN;
1238 dev->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN;
1239 dev->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN;
1240 dev->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING;
1241 dev->opt[OPT_HALFTONE_PATTERN].size =
1243 dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
1244 dev->opt[OPT_HALFTONE_PATTERN].constraint_type =
1246 dev->opt[OPT_HALFTONE_PATTERN].constraint.string_list =
1248 dev->val[OPT_HALFTONE_PATTERN].s = strdup (halftone_pattern_list[0]);
1251 dev->opt[OPT_AUTOMATIC_SEPARATION].name = SANE_NAME_AUTOSEP;
1252 dev->opt[OPT_AUTOMATIC_SEPARATION].title = SANE_TITLE_AUTOSEP;
1253 dev->opt[OPT_AUTOMATIC_SEPARATION].desc = SANE_DESC_AUTOSEP;
1254 dev->opt[OPT_AUTOMATIC_SEPARATION].type = SANE_TYPE_BOOL;
1255 dev->opt[OPT_AUTOMATIC_SEPARATION].unit = SANE_UNIT_NONE;
1256 dev->val[OPT_AUTOMATIC_SEPARATION].w = SANE_FALSE;
1259 dev->opt[OPT_WHITE_LEVEL].name = SANE_NAME_WHITE_LEVEL;
1260 dev->opt[OPT_WHITE_LEVEL].title = SANE_TITLE_WHITE_LEVEL;
1261 dev->opt[OPT_WHITE_LEVEL].desc = SANE_DESC_WHITE_LEVEL;
1262 dev->opt[OPT_WHITE_LEVEL].type = SANE_TYPE_STRING;
1263 dev->opt[OPT_WHITE_LEVEL].size = max_string_size (white_level_list);
1264 dev->opt[OPT_WHITE_LEVEL].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1265 dev->opt[OPT_WHITE_LEVEL].constraint.string_list = white_level_list;
1266 dev->val[OPT_WHITE_LEVEL].s = strdup (white_level_list[0]);
1267 if ((scanners[dev->scnum].cap & MAT_CAP_WHITE_LEVEL) == 0)
1268 dev->opt[OPT_WHITE_LEVEL].cap |= SANE_CAP_INACTIVE;
1271 dev->opt[OPT_NOISE_REDUCTION].name = "noise-reduction";
1272 dev->opt[OPT_NOISE_REDUCTION].title = SANE_I18N ("Noise reduction");
1273 dev->opt[OPT_NOISE_REDUCTION].desc =
1275 dev->opt[OPT_NOISE_REDUCTION].type = SANE_TYPE_STRING;
1276 dev->opt[OPT_NOISE_REDUCTION].size = max_string_size (noise_reduction_list);
1277 dev->opt[OPT_NOISE_REDUCTION].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1278 dev->opt[OPT_NOISE_REDUCTION].constraint.string_list = noise_reduction_list;
1279 dev->val[OPT_NOISE_REDUCTION].s = strdup (noise_reduction_list[0]);
1280 if ((scanners[dev->scnum].cap & MAT_CAP_NOISE_REDUCTION) == 0)
1281 dev->opt[OPT_NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE;
1284 dev->opt[OPT_IMAGE_EMPHASIS].name = "image-emphasis";
1285 dev->opt[OPT_IMAGE_EMPHASIS].title = SANE_I18N ("Image emphasis");
1286 dev->opt[OPT_IMAGE_EMPHASIS].desc = SANE_I18N ("Sets the image emphasis");
1287 dev->opt[OPT_IMAGE_EMPHASIS].type = SANE_TYPE_STRING;
1288 dev->opt[OPT_IMAGE_EMPHASIS].size =
1289 max_string_size (scanners[dev->scnum].image_emphasis_list);
1290 dev->opt[OPT_IMAGE_EMPHASIS].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1291 dev->opt[OPT_IMAGE_EMPHASIS].constraint.string_list =
1292 scanners[dev->scnum].image_emphasis_list;
1293 dev->val[OPT_IMAGE_EMPHASIS].s = strdup (SANE_I18N ("Medium"));
1296 dev->opt[OPT_GAMMA].name = "gamma";
1297 dev->opt[OPT_GAMMA].title = SANE_I18N ("Gamma");
1298 dev->opt[OPT_GAMMA].desc = SANE_I18N ("Gamma");
1299 dev->opt[OPT_GAMMA].type = SANE_TYPE_STRING;
1300 dev->opt[OPT_GAMMA].size = max_string_size (gamma_list);
1301 dev->opt[OPT_GAMMA].constraint_type = SANE_CONSTRAINT_STRING_LIST;
1302 dev->opt[OPT_GAMMA].constraint.string_list = gamma_list;
1303 dev->val[OPT_GAMMA].s = strdup (gamma_list[0]);
1307 sane_control_option (dev, OPT_PAPER_SIZE, SANE_ACTION_SET_VALUE,
1308 (SANE_String_Const *) dev->paper_sizes_list[0], NULL);
1309 sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE,
1310 (SANE_String_Const *) scanners[dev->scnum].
1320 matsushita_wait_scanner (Matsushita_Scanner * dev)
1337 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1354 matsushita_reset_window (Matsushita_Scanner * dev)
1363 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL);
1372 matsushita_set_window (Matsushita_Scanner * dev, int side)
1394 Ito16 (dev->resolution, &window[10]);
1395 Ito16 (dev->resolution, &window[12]);
1398 Ito32 (dev->x_tl, &window[14]);
1399 Ito32 (dev->y_tl, &window[18]);
1402 Ito32 (dev->width, &window[22]);
1403 Ito32 (dev->length, &window[26]);
1404 Ito32 (dev->width, &window[56]); /* again, verso? */
1405 Ito32 (dev->length, &window[60]); /* again, verso? */
1408 window[30] = 255 - dev->val[OPT_BRIGHTNESS].w;
1412 window[32] = dev->val[OPT_CONTRAST].w;
1415 switch (dev->scan_mode)
1429 window[34] = dev->depth;
1432 if (dev->scan_mode == MATSUSHITA_HALFTONE)
1435 dev->val[OPT_HALFTONE_PATTERN].s);
1440 if (dev->scan_mode == MATSUSHITA_GRAYSCALE)
1442 i = get_string_list_index (gamma_list, dev->val[OPT_GAMMA].s);
1447 i = get_string_list_index (feeder_mode_list, dev->val[OPT_FEEDER_MODE].s);
1451 i = get_string_list_index (scanners[dev->scnum].image_emphasis_list,
1452 dev->val[OPT_IMAGE_EMPHASIS].s);
1453 window[51] = scanners[dev->scnum].image_emphasis_val[i];
1456 i = get_string_list_index (white_level_list, dev->val[OPT_WHITE_LEVEL].s);
1459 if (dev->scan_mode == MATSUSHITA_BW ||
1460 dev->scan_mode == MATSUSHITA_HALFTONE)
1465 dev->val[OPT_NOISE_REDUCTION].s);
1469 if (dev->val[OPT_AUTOMATIC_SEPARATION].w)
1477 dev->val[OPT_AUTOMATIC_THRESHOLD].s);
1497 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1507 matsushita_fill_image (Matsushita_Scanner * dev)
1515 assert (dev->image_begin == dev->image_end);
1516 assert (dev->real_bytes_left > 0);
1518 dev->image_begin = 0;
1519 dev->image_end = 0;
1521 while (dev->real_bytes_left)
1537 size = dev->real_bytes_left;
1538 if (size > dev->image_size - dev->image_end)
1539 size = dev->image_size - dev->image_end;
1547 assert (dev->image_end != 0);
1552 (long) size, dev->params.bytes_per_line);
1555 cdb.data[4] = dev->page_num; /* May be cdb.data[3] too? */
1556 cdb.data[5] = dev->page_side;
1560 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1561 NULL, 0, dev->buffer, &size);
1575 dev->real_bytes_left -= size;
1577 switch (dev->depth)
1584 unsigned char *src = dev->buffer;
1585 unsigned char *dest = dev->image + dev->image_end;
1623 unsigned char *src = dev->buffer;
1624 unsigned char *dest = dev->image + dev->image_end;
1643 memcpy (dev->image + dev->image_end, dev->buffer, size);
1647 dev->image_end += size;
1660 matsushita_copy_raw_to_frontend (Matsushita_Scanner * dev, SANE_Byte * buf,
1665 size = dev->image_end - dev->image_begin;
1672 memcpy (buf, dev->image + dev->image_begin, size);
1673 dev->image_begin += size;
1678 do_cancel (Matsushita_Scanner * dev)
1682 if (dev->scanning == SANE_TRUE)
1686 matsushita_reset_window (dev);
1688 matsushita_close (dev);
1691 dev->scanning = SANE_FALSE;
1725 /* default to /dev/scanner instead of insisting on config file */
1726 attach_scanner ("/dev/scanner", 0);
1752 Matsushita_Scanner *dev;
1765 for (dev = first_dev; i < num_devices; dev = dev->next)
1766 devlist[i++] = &dev->sane;
1779 Matsushita_Scanner *dev;
1789 for (dev = first_dev; dev; dev = dev->next)
1791 if (strcmp (dev->sane.name, devicename) == 0)
1797 if (!dev)
1799 status = attach_scanner (devicename, &dev);
1809 dev = first_dev; /* empty devicename -> use first device */
1812 if (!dev)
1820 matsushita_build_paper_sizes (dev);
1822 matsushita_init_options (dev);
1824 *handle = dev;
1834 Matsushita_Scanner *dev = handle;
1845 return dev->opt + option;
1852 Matsushita_Scanner *dev = handle;
1868 if (dev->scanning)
1878 cap = dev->opt[option].cap;
1884 name = dev->opt[option].name;
1905 *(SANE_Word *) val = dev->val[option].w;
1918 strcpy (val, dev->val[option].s);
1934 status = sanei_constrain_value (dev->opt + option, val, info);
1952 dev->val[option].w = *(SANE_Word *) val;
1961 i = get_int_list_index (scanners[dev->scnum].resolutions_list,
1962 dev->val[OPT_RESOLUTION].w);
1964 if (value & (scanners[dev->scnum].resolutions_round[i] - 1))
1967 (value | (scanners[dev->scnum].resolutions_round[i] - 1)) + 1;
1976 dev->val[option].w = *(SANE_Word *) val;
1990 dev->val[option].w = *(SANE_Word *) val;
1999 free (dev->val[option].s);
2000 dev->val[option].s = (SANE_String) strdup (val);
2004 if (strcmp (dev->val[option].s, val) == 0)
2007 free (dev->val[OPT_MODE].s);
2008 dev->val[OPT_MODE].s = (SANE_Char *) strdup (val);
2011 dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
2012 dev->opt[OPT_AUTOMATIC_THRESHOLD].cap |= SANE_CAP_INACTIVE;
2013 dev->opt[OPT_AUTOMATIC_SEPARATION].cap |= SANE_CAP_INACTIVE;
2014 dev->opt[OPT_NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE;
2015 dev->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE;
2017 if (strcmp (dev->val[OPT_MODE].s, BLACK_WHITE_STR) == 0)
2019 dev->depth = 1;
2021 dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE;
2022 dev->opt[OPT_AUTOMATIC_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
2023 dev->opt[OPT_AUTOMATIC_SEPARATION].cap &= ~SANE_CAP_INACTIVE;
2024 dev->opt[OPT_NOISE_REDUCTION].cap &= ~SANE_CAP_INACTIVE;
2027 dev->val[OPT_HALFTONE_PATTERN].s);
2030 dev->scan_mode = MATSUSHITA_BW;
2034 dev->scan_mode = MATSUSHITA_HALFTONE;
2037 else if (strcmp (dev->val[OPT_MODE].s, GRAY4_STR) == 0)
2039 dev->scan_mode = MATSUSHITA_GRAYSCALE;
2040 dev->depth = 4;
2042 dev->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE;
2044 else if (strcmp (dev->val[OPT_MODE].s, GRAY8_STR) == 0)
2046 dev->scan_mode = MATSUSHITA_GRAYSCALE;
2047 dev->depth = 8;
2049 dev->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE;
2057 if ((scanners[dev->scnum].cap & MAT_CAP_GAMMA) == 0)
2058 dev->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE;
2067 free (dev->val[option].s);
2068 dev->val[option].s = (SANE_String) strdup (val);
2070 dev->val[OPT_HALFTONE_PATTERN].s);
2073 dev->scan_mode = MATSUSHITA_BW;
2077 dev->scan_mode = MATSUSHITA_HALFTONE;
2083 if (strcmp (dev->val[option].s, val) == 0)
2086 free (dev->val[OPT_PAPER_SIZE].s);
2087 dev->val[OPT_PAPER_SIZE].s = (SANE_Char *) strdup (val);
2089 i = get_string_list_index (dev->paper_sizes_list,
2090 dev->val[OPT_PAPER_SIZE].s);
2091 i = dev->paper_sizes_val[i];
2120 if (strcmp (dev->val[option].s, val) == 0)
2123 free (dev->val[option].s);
2124 dev->val[option].s = (SANE_Char *) strdup (val);
2128 dev->opt[OPT_WHITE_LEVEL].cap |= SANE_CAP_INACTIVE;
2129 dev->opt[OPT_NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE;
2130 dev->opt[OPT_IMAGE_EMPHASIS].cap |= SANE_CAP_INACTIVE;
2131 dev->opt[OPT_AUTOMATIC_SEPARATION].cap |= SANE_CAP_INACTIVE;
2132 dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
2134 if (strcmp (dev->val[option].s, automatic_threshold_list[0]) == 0)
2136 dev->opt[OPT_WHITE_LEVEL].cap &= ~SANE_CAP_INACTIVE;
2137 dev->opt[OPT_NOISE_REDUCTION].cap &= ~SANE_CAP_INACTIVE;
2138 dev->opt[OPT_IMAGE_EMPHASIS].cap &= ~SANE_CAP_INACTIVE;
2139 dev->opt[OPT_AUTOMATIC_SEPARATION].cap &= ~SANE_CAP_INACTIVE;
2140 if (dev->scan_mode == MATSUSHITA_BW
2141 || dev->scan_mode == MATSUSHITA_HALFTONE)
2143 dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE;
2166 Matsushita_Scanner *dev = handle;
2170 if (!(dev->scanning))
2175 dev->resolution = dev->val[OPT_RESOLUTION].w;
2177 dev->x_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w));
2178 dev->y_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_Y].w));
2179 dev->x_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w));
2180 dev->y_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_Y].w));
2183 if (dev->x_tl > dev->x_br)
2186 s = dev->x_tl;
2187 dev->x_tl = dev->x_br;
2188 dev->x_br = s;
2190 if (dev->y_tl > dev->y_br)
2193 s = dev->y_tl;
2194 dev->y_tl = dev->y_br;
2195 dev->y_br = s;
2198 dev->width = dev->x_br - dev->x_tl;
2199 dev->length = dev->y_br - dev->y_tl;
2202 memset (&dev->params, 0, sizeof (SANE_Parameters));
2204 dev->params.format = SANE_FRAME_GRAY;
2205 dev->params.last_frame = SANE_TRUE;
2206 dev->params.pixels_per_line =
2207 (((dev->width * dev->resolution) / 1200) + 7) & ~0x7;
2209 if (dev->depth == 4)
2211 dev->params.depth = 8;
2215 dev->params.depth = dev->depth;
2217 dev->params.bytes_per_line =
2218 (dev->params.pixels_per_line / 8) * dev->params.depth;
2219 dev->params.lines = (dev->length * dev->resolution) / 1200;
2225 *params = (dev->params);
2236 Matsushita_Scanner *dev = handle;
2241 if (!(dev->scanning))
2244 sane_get_parameters (dev, NULL);
2246 if (dev->image == NULL)
2248 dev->image_size = 3 * dev->buffer_size;
2249 dev->image = malloc (dev->image_size);
2250 if (dev->image == NULL)
2258 (dev->devicename, &(dev->sfd), matsushita_sense_handler, dev) != 0)
2264 dev->page_side = 0; /* page front */
2265 dev->page_num = 0; /* first page */
2268 status = matsushita_wait_scanner (dev);
2271 matsushita_close (dev);
2275 status = matsushita_reset_window (dev);
2278 matsushita_close (dev);
2282 status = matsushita_set_window (dev, PAGE_FRONT);
2285 matsushita_close (dev);
2289 if (dev->val[OPT_DUPLEX].w == SANE_TRUE)
2291 status = matsushita_set_window (dev, PAGE_BACK);
2294 matsushita_close (dev);
2299 status = matsushita_read_document_size (dev);
2302 matsushita_close (dev);
2309 if (dev->val[OPT_DUPLEX].w == SANE_TRUE && dev->page_side == PAGE_FRONT)
2311 dev->page_side = PAGE_BACK;
2316 dev->page_side = PAGE_FRONT;
2317 dev->page_num++;
2320 status = matsushita_check_next_page (dev);
2327 dev->bytes_left = dev->params.bytes_per_line * dev->params.lines;
2328 dev->real_bytes_left = dev->params.bytes_per_line * dev->params.lines;
2329 if (dev->depth == 4)
2332 dev->real_bytes_left /= 2;
2335 dev->image_end = 0;
2336 dev->image_begin = 0;
2338 dev->scanning = SANE_TRUE;
2350 Matsushita_Scanner *dev = handle;
2358 if (!(dev->scanning))
2361 return do_cancel (dev);
2364 if (dev->bytes_left <= 0)
2373 if (dev->image_begin == dev->image_end)
2376 status = matsushita_fill_image (dev);
2384 if (dev->image_begin == dev->image_end)
2392 if (size > dev->bytes_left)
2394 size = dev->bytes_left;
2396 matsushita_copy_raw_to_frontend (dev, buf + buf_offset, &size);
2400 dev->bytes_left -= size;
2404 while ((buf_offset != max_len) && dev->bytes_left);
2406 DBG (DBG_info, "sane_read: leave, bytes_left=%ld\n", (long)dev->bytes_left);
2415 Matsushita_Scanner *dev = handle;
2419 if (dev->scanning == SANE_FALSE)
2448 Matsushita_Scanner *dev = handle;
2452 do_cancel (dev);
2460 Matsushita_Scanner *dev = handle;
2465 do_cancel (dev);
2466 matsushita_close (dev);
2468 /* Unlink dev. */
2469 if (first_dev == dev)
2471 first_dev = dev->next;
2476 while (dev_tmp->next && dev_tmp->next != dev)
2486 matsushita_free (dev);