Lines Matching refs:dev
170 Sceptre_Scanner *dev;
175 dev = malloc (sizeof (Sceptre_Scanner));
176 if (dev == NULL)
181 memset (dev, 0, sizeof (Sceptre_Scanner));
184 dev->buffer_size = 64 * 1024;
185 dev->buffer = malloc (dev->buffer_size);
186 if (dev->buffer == NULL)
188 free (dev);
192 dev->sfd = -1;
196 return (dev);
201 sceptre_close (Sceptre_Scanner * dev)
205 if (dev->sfd != -1)
207 sanei_scsi_close (dev->sfd);
208 dev->sfd = -1;
216 sceptre_free (Sceptre_Scanner * dev)
222 if (dev == NULL)
225 sceptre_close (dev);
226 if (dev->devicename)
228 free (dev->devicename);
230 if (dev->buffer)
232 free (dev->buffer);
234 if (dev->image)
236 free (dev->image);
240 if (dev->opt[i].type == SANE_TYPE_STRING && dev->val[i].s)
242 free (dev->val[i].s);
246 free (dev);
253 sceptre_identify_scanner (Sceptre_Scanner * dev)
264 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
265 NULL, 0, dev->buffer, &size);
282 dev->scsi_type = dev->buffer[0] & 0x1f;
283 memcpy (dev->scsi_vendor, dev->buffer + 0x08, 0x08);
284 dev->scsi_vendor[0x08] = 0;
285 memcpy (dev->scsi_product, dev->buffer + 0x10, 0x010);
286 dev->scsi_product[0x10] = 0;
287 memcpy (dev->scsi_version, dev->buffer + 0x20, 0x04);
288 dev->scsi_version[0x04] = 0;
291 dev->scsi_vendor, dev->scsi_product, dev->scsi_version);
297 if (dev->scsi_type == scanners[i].scsi_type &&
298 strcmp (dev->scsi_vendor, scanners[i].scsi_vendor) == 0 &&
299 strcmp (dev->scsi_product, scanners[i].scsi_product) == 0)
304 dev->scnum = i;
317 sceptre_get_status (Sceptre_Scanner * dev, size_t * data_left)
328 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
329 NULL, 0, dev->buffer, &size);
346 hexdump (DBG_info2, "GET BUFFER STATUS result", dev->buffer, 16);
350 *data_left = B32TOI (&dev->buffer[8]);
352 if (dev->raster_real == 0)
355 dev->raster_real = B16TOI (&dev->buffer[12]) * 3;
356 dev->params.lines = B16TOI (&dev->buffer[12]);
357 dev->params.pixels_per_line = B16TOI (&dev->buffer[14]);
378 * dev->buffer and write the output in dev->image. size_in the the
379 * length of the valid data in dev->buffer.
382 sceptre_adjust_raster (Sceptre_Scanner * dev, size_t size_in)
384 int nb_rasters; /* number of rasters in dev->buffer */
393 assert (dev->scan_mode == SCEPTRE_COLOR);
394 assert ((size_in % dev->params.bytes_per_line) == 0);
406 nb_rasters = size_in / dev->raster_size;
420 if (dev->raster_num < dev->color_shift)
423 line = dev->raster_num;
425 else if (dev->raster_num < (3 * dev->color_shift))
428 colour = (dev->raster_num - dev->color_shift) % 2;
432 line = (dev->raster_num - dev->color_shift) / 2;
437 line = (dev->raster_num + dev->color_shift) / 2;
440 else if (dev->raster_num >= dev->raster_real - dev->color_shift)
444 line = dev->line;
446 else if (dev->raster_num >= dev->raster_real - 3 * dev->color_shift)
450 (dev->raster_real - dev->raster_num - dev->color_shift) % 2 + 1;
454 line = dev->line + dev->color_shift;
459 line = dev->line;
464 colour = (dev->raster_num - 3 * dev->color_shift) % 3;
469 line = (dev->raster_num + 3 * dev->color_shift) / 3;
473 line = dev->raster_num / 3;
477 line = (dev->raster_num - 3 * dev->color_shift) / 3;
483 line -= dev->line;
485 offset = dev->image_end + line * dev->params.bytes_per_line;
487 assert (offset <= (dev->image_size - dev->raster_size));
492 unsigned char *src = dev->buffer + raster * dev->raster_size;
493 unsigned char *dest = dev->image + offset + colour;
495 for (i = 0; i < dev->raster_size; i++)
506 dev->line++;
507 dev->image_end += dev->params.bytes_per_line;
510 dev->raster_num++;
532 Sceptre_Scanner *dev;
541 for (dev = first_dev; dev; dev = dev->next)
543 if (strcmp (dev->sane.name, devicename) == 0)
547 *devp = dev;
555 dev = sceptre_init ();
556 if (dev == NULL)
564 if (sanei_scsi_open (devicename, &sfd, sceptre_sense_handler, dev) != 0)
567 sceptre_free (dev);
572 dev->devicename = strdup (devicename);
573 dev->sfd = sfd;
576 if (sceptre_identify_scanner (dev) == SANE_FALSE)
580 sceptre_free (dev);
584 sceptre_close (dev);
587 dev->sane.name = dev->devicename;
588 dev->sane.vendor = scanners[dev->scnum].real_vendor;
589 dev->sane.model = scanners[dev->scnum].real_product;
590 dev->sane.type = SANE_I18N ("flatbed scanner");
592 dev->resolution_range.min = SANE_FIX (50);
593 dev->resolution_range.max = SANE_FIX (1200);
594 dev->resolution_range.quant = SANE_FIX (1);
612 dev->x_range.min = SANE_FIX (0);
613 dev->x_range.max = SANE_FIX (215.90); /* in mm */
614 dev->x_range.quant = 0;
616 dev->y_range.min = SANE_FIX (0);
617 dev->y_range.max = SANE_FIX (297.14); /* in mm */
618 dev->y_range.quant = SANE_FIX (0);
621 dev->next = first_dev;
622 first_dev = dev;
626 *devp = dev;
637 attach_one (const char *dev)
639 attach_scanner (dev, NULL);
645 sceptre_init_options (Sceptre_Scanner * dev)
652 memset (dev->opt, 0, sizeof (dev->opt));
653 memset (dev->val, 0, sizeof (dev->val));
657 dev->opt[i].size = sizeof (SANE_Word);
658 dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
662 dev->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
663 dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
664 dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
665 dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
666 dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
667 dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS;
670 dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode");
671 dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */
672 dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
673 dev->opt[OPT_MODE_GROUP].cap = 0;
674 dev->opt[OPT_MODE_GROUP].size = 0;
675 dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
678 dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
679 dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
680 dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
681 dev->opt[OPT_MODE].type = SANE_TYPE_STRING;
682 dev->opt[OPT_MODE].size = 30; /* should define yet another max_string_size() */
683 dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
684 dev->opt[OPT_MODE].constraint.string_list =
686 dev->val[OPT_MODE].s = (SANE_Char *) strdup (scan_mode_list[0]);
689 dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
690 dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
691 dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
692 dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
693 dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
694 dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
695 dev->opt[OPT_RESOLUTION].constraint.word_list = resolutions_list;
696 dev->val[OPT_RESOLUTION].w = 150;
699 dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry");
700 dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */
701 dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
702 dev->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
703 dev->opt[OPT_GEOMETRY_GROUP].size = 0;
704 dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
707 dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
708 dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
709 dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
710 dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
711 dev->opt[OPT_TL_X].unit = SANE_UNIT_MM;
712 dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
713 dev->opt[OPT_TL_X].constraint.range = &(dev->x_range);
714 dev->val[OPT_TL_X].w = dev->x_range.min;
717 dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
718 dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
719 dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
720 dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
721 dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
722 dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
723 dev->opt[OPT_TL_Y].constraint.range = &(dev->y_range);
724 dev->val[OPT_TL_Y].w = dev->y_range.min;
727 dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
728 dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
729 dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
730 dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
731 dev->opt[OPT_BR_X].unit = SANE_UNIT_MM;
732 dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
733 dev->opt[OPT_BR_X].constraint.range = &(dev->x_range);
734 dev->val[OPT_BR_X].w = dev->x_range.max;
737 dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
738 dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
739 dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
740 dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
741 dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
742 dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
743 dev->opt[OPT_BR_Y].constraint.range = &(dev->y_range);
744 dev->val[OPT_BR_Y].w = dev->y_range.max;
747 dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
748 dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */
749 dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
750 dev->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
751 dev->opt[OPT_ENHANCEMENT_GROUP].size = 0;
752 dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
755 dev->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
756 dev->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
757 dev->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
758 dev->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
759 dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
760 dev->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
763 dev->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
764 dev->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
765 dev->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
766 dev->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
767 dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
768 dev->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
769 dev->opt[OPT_GAMMA_VECTOR_R].size = GAMMA_LENGTH * sizeof (SANE_Word);
770 dev->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
771 dev->opt[OPT_GAMMA_VECTOR_R].constraint.range = &gamma_range;
772 dev->val[OPT_GAMMA_VECTOR_R].wa = dev->gamma_R;
775 dev->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
776 dev->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
777 dev->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
778 dev->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
779 dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
780 dev->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
781 dev->opt[OPT_GAMMA_VECTOR_G].size = GAMMA_LENGTH * sizeof (SANE_Word);
782 dev->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
783 dev->opt[OPT_GAMMA_VECTOR_G].constraint.range = &gamma_range;
784 dev->val[OPT_GAMMA_VECTOR_G].wa = dev->gamma_G;
787 dev->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
788 dev->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
789 dev->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
790 dev->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
791 dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
792 dev->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
793 dev->opt[OPT_GAMMA_VECTOR_B].size = GAMMA_LENGTH * sizeof (SANE_Word);
794 dev->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
795 dev->opt[OPT_GAMMA_VECTOR_B].constraint.range = &gamma_range;
796 dev->val[OPT_GAMMA_VECTOR_B].wa = dev->gamma_B;
799 dev->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD;
800 dev->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
801 dev->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
802 dev->opt[OPT_THRESHOLD].type = SANE_TYPE_INT;
803 dev->opt[OPT_THRESHOLD].unit = SANE_UNIT_NONE;
804 dev->opt[OPT_THRESHOLD].size = sizeof (SANE_Int);
805 dev->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
806 dev->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
807 dev->opt[OPT_THRESHOLD].constraint.range = &threshold_range;
808 dev->val[OPT_THRESHOLD].w = 128;
811 dev->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN;
812 dev->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN;
813 dev->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN;
814 dev->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_INT;
815 dev->opt[OPT_HALFTONE_PATTERN].size = sizeof (SANE_Int);
816 dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
817 dev->opt[OPT_HALFTONE_PATTERN].constraint_type = SANE_CONSTRAINT_RANGE;
818 dev->opt[OPT_HALFTONE_PATTERN].constraint.range = &halftone_range;
819 dev->val[OPT_HALFTONE_PATTERN].w = 1;
822 dev->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
823 dev->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
824 dev->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
825 dev->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
826 dev->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
827 dev->val[OPT_PREVIEW].w = SANE_FALSE;
831 sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE,
843 sceptre_wait_scanner (Sceptre_Scanner * dev)
864 sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
865 NULL, 0, dev->buffer, &size);
877 if (dev->buffer[0] != 0x00)
894 sceptre_do_diag (Sceptre_Scanner * dev)
908 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL);
922 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
923 NULL, 0, dev->buffer, &size);
940 sceptre_set_mode (Sceptre_Scanner * dev)
951 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL);
960 sceptre_scan (Sceptre_Scanner * dev)
969 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len, NULL, 0, NULL, NULL);
978 sceptre_set_window (Sceptre_Scanner * dev)
996 Ito16 (dev->resolution, &window[10]);
997 Ito16 (dev->resolution, &window[12]);
1000 Ito32 (dev->x_tl, &window[14]);
1001 Ito32 (dev->y_tl, &window[18]);
1004 Ito32 (dev->width, &window[22]);
1005 Ito32 (dev->length, &window[26]);
1008 switch (dev->scan_mode)
1011 window[31] = dev->val[OPT_THRESHOLD].w;
1020 window[36] = dev->val[OPT_HALFTONE_PATTERN].w;
1043 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1053 sceptre_fill_image (Sceptre_Scanner * dev)
1062 assert (dev->image_begin == dev->image_end);
1063 assert (dev->real_bytes_left > 0);
1071 memmove (dev->image, dev->image + dev->image_begin, dev->raster_ahead);
1072 dev->image_begin = 0;
1073 dev->image_end = 0;
1075 while (dev->real_bytes_left)
1078 if ((status = sceptre_get_status (dev, &data_left)) != SANE_STATUS_GOOD)
1087 if (size > dev->real_bytes_left)
1089 size = dev->real_bytes_left;
1091 if (size > dev->image_size - dev->raster_ahead - dev->image_end)
1093 size = dev->image_size - dev->raster_ahead - dev->image_end;
1095 if (size > dev->buffer_size)
1097 size = dev->buffer_size;
1101 size = size - (size % dev->params.bytes_per_line);
1107 assert (dev->image_end != 0);
1112 (long) size, dev->params.bytes_per_line);
1118 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1119 NULL, 0, dev->buffer, &size);
1129 (long)dev->real_bytes_left);
1131 switch (dev->scan_mode)
1134 sceptre_adjust_raster (dev, size);
1140 unsigned char *src = dev->buffer;
1141 unsigned char *dest = dev->image + dev->image_end;
1149 dev->image_end += size;
1153 memcpy (dev->image + dev->image_end, dev->buffer, size);
1154 dev->image_end += size;
1157 dev->real_bytes_left -= size;
1169 sceptre_copy_raw_to_frontend (Sceptre_Scanner * dev, SANE_Byte * buf,
1174 size = dev->image_end - dev->image_begin;
1181 memcpy (buf, dev->image + dev->image_begin, size);
1183 dev->image_begin += size;
1188 do_cancel (Sceptre_Scanner * dev)
1192 if (dev->scanning == SANE_TRUE)
1196 dev->x_tl = 0;
1197 dev->x_tl = 0;
1198 dev->width = 0;
1199 dev->length = 0;
1200 sceptre_set_window (dev);
1201 sceptre_scan (dev);
1203 sceptre_close (dev);
1206 dev->scanning = SANE_FALSE;
1250 sceptre_send_gamma (Sceptre_Scanner * dev)
1272 if (dev->val[OPT_CUSTOM_GAMMA].w)
1277 param.gamma_R[i] = dev->gamma_R[i];
1278 param.gamma_G[i] = dev->gamma_G[i];
1279 param.gamma_B[i] = dev->gamma_B[i];
1294 status = sanei_scsi_cmd2 (dev->sfd, cdb.data, cdb.len,
1329 /* default to /dev/scanner instead of insisting on config file */
1330 attach_scanner ("/dev/scanner", 0);
1356 Sceptre_Scanner *dev;
1369 for (dev = first_dev; i < num_devices; dev = dev->next)
1370 devlist[i++] = &dev->sane;
1383 Sceptre_Scanner *dev;
1393 for (dev = first_dev; dev; dev = dev->next)
1395 if (strcmp (dev->sane.name, devicename) == 0)
1401 if (!dev)
1403 status = attach_scanner (devicename, &dev);
1413 dev = first_dev; /* empty devicename -> use first device */
1416 if (!dev)
1423 sceptre_init_options (dev);
1426 memcpy (dev->gamma_R, gamma_init, dev->opt[OPT_GAMMA_VECTOR_R].size);
1427 memcpy (dev->gamma_G, gamma_init, dev->opt[OPT_GAMMA_VECTOR_G].size);
1428 memcpy (dev->gamma_B, gamma_init, dev->opt[OPT_GAMMA_VECTOR_B].size);
1430 *handle = dev;
1440 Sceptre_Scanner *dev = handle;
1451 return dev->opt + option;
1458 Sceptre_Scanner *dev = handle;
1470 if (dev->scanning)
1480 cap = dev->opt[option].cap;
1503 *(SANE_Word *) val = dev->val[option].w;
1508 strcpy (val, dev->val[option].s);
1514 memcpy (val, dev->val[option].wa, dev->opt[option].size);
1530 status = sanei_constrain_value (dev->opt + option, val, info);
1550 dev->val[option].w = *(SANE_Word *) val;
1557 dev->val[option].w = *(SANE_Word *) val;
1561 free (dev->val[OPT_MODE].s);
1562 dev->val[OPT_MODE].s = (SANE_Char *) strdup (val);
1565 dev->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
1566 dev->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
1567 dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
1568 dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
1569 dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
1570 dev->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
1572 if (strcmp (dev->val[OPT_MODE].s, LINEART_STR) == 0)
1574 dev->scan_mode = SCEPTRE_LINEART;
1575 dev->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
1577 else if (strcmp (dev->val[OPT_MODE].s, HALFTONE_STR) == 0)
1579 dev->scan_mode = SCEPTRE_HALFTONE;
1580 dev->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE;
1582 else if (strcmp (dev->val[OPT_MODE].s, GRAY_STR) == 0)
1584 dev->scan_mode = SCEPTRE_GRAYSCALE;
1586 else if (strcmp (dev->val[OPT_MODE].s, COLOR_STR) == 0)
1588 dev->scan_mode = SCEPTRE_COLOR;
1589 dev->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
1590 if (dev->val[OPT_CUSTOM_GAMMA].w)
1592 dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
1593 dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
1594 dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
1607 memcpy (dev->val[option].wa, val, dev->opt[option].size);
1611 dev->val[OPT_CUSTOM_GAMMA].w = *(SANE_Word *) val;
1612 if (dev->val[OPT_CUSTOM_GAMMA].w)
1615 dev->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
1616 dev->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
1617 dev->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
1621 dev->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
1622 dev->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
1623 dev->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
1644 Sceptre_Scanner *dev = handle;
1649 if (!(dev->scanning))
1652 memset (&dev->params, 0, sizeof (SANE_Parameters));
1654 if (dev->val[OPT_PREVIEW].w == SANE_TRUE)
1656 dev->resolution = 30; /* Windows TWAIN does 32 */
1657 dev->x_tl = 0;
1658 dev->y_tl = 0;
1659 dev->x_br = mmToIlu (SANE_UNFIX (dev->x_range.max));
1660 dev->y_br = mmToIlu (SANE_UNFIX (dev->y_range.max));
1666 dev->resolution = dev->val[OPT_RESOLUTION].w;
1668 dev->x_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w));
1669 dev->y_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_Y].w));
1670 dev->x_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w));
1671 dev->y_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_Y].w));
1675 if (dev->x_tl > dev->x_br)
1678 s = dev->x_tl;
1679 dev->x_tl = dev->x_br;
1680 dev->x_br = s;
1682 if (dev->y_tl > dev->y_br)
1685 s = dev->y_tl;
1686 dev->y_tl = dev->y_br;
1687 dev->y_br = s;
1690 dev->width = dev->x_br - dev->x_tl;
1691 dev->length = dev->y_br - dev->y_tl;
1699 x_dpi = dev->resolution;
1706 switch (dev->scan_mode)
1709 dev->params.format = SANE_FRAME_GRAY;
1710 dev->depth = 1;
1713 dev->params.format = SANE_FRAME_GRAY;
1714 dev->depth = 1;
1717 dev->params.format = SANE_FRAME_GRAY;
1718 dev->depth = 8;
1721 dev->params.format = SANE_FRAME_RGB;
1722 dev->depth = 8;
1727 dev->params.last_frame = SANE_TRUE;
1728 dev->params.depth = dev->depth;
1731 switch (dev->scan_mode)
1735 dev->params.pixels_per_line = (dev->width * x_dpi) / 600;
1736 dev->params.pixels_per_line &= ~0x7; /* round down to 8 */
1738 dev->params.bytes_per_line = (dev->params.pixels_per_line) / 8;
1740 dev->params.lines = ((dev->length * dev->resolution) / 600);
1741 if ((dev->params.lines) * 600 != (dev->length * dev->resolution))
1744 dev->params.lines &= ~1;
1745 dev->params.lines += 2;
1756 dev->params.pixels_per_line = (dev->width * x_dpi) / 600;
1757 if (dev->params.pixels_per_line & 1)
1759 if ((dev->params.pixels_per_line * 600) == (dev->width * x_dpi))
1762 dev->params.pixels_per_line--;
1767 dev->params.pixels_per_line++;
1771 dev->params.bytes_per_line = dev->params.pixels_per_line;
1772 if (dev->scan_mode == SCEPTRE_COLOR)
1773 dev->params.bytes_per_line *= 3;
1781 dev->params.lines = (dev->length * dev->resolution) / 600;
1782 dev->params.lines &= ~1;
1788 if (dev->scan_mode == SCEPTRE_COLOR)
1791 while (resolutions_list[i] != dev->resolution)
1795 dev->color_shift = color_shift_list[i];
1799 dev->color_shift = 0;
1802 DBG (DBG_proc, "color_shift = %d\n", dev->color_shift);
1804 dev->bytes_left = dev->params.lines * dev->params.bytes_per_line;
1810 *params = (dev->params);
1821 Sceptre_Scanner *dev = handle;
1826 if (!(dev->scanning))
1829 sane_get_parameters (dev, NULL);
1831 if (dev->image)
1833 free (dev->image);
1839 dev->raster_ahead =
1840 (2 * dev->color_shift + 1) * dev->params.bytes_per_line;
1841 dev->image_size = dev->buffer_size + dev->raster_ahead;
1842 dev->image = malloc (dev->image_size);
1843 if (dev->image == NULL)
1847 dev->image_begin = 0;
1848 dev->image_end = 0;
1850 dev->raster_size = dev->params.bytes_per_line / 3;
1851 dev->raster_num = 0;
1852 dev->raster_real = 0;
1853 dev->line = 0;
1857 (dev->devicename, &(dev->sfd), sceptre_sense_handler, dev) != 0)
1864 status = sceptre_wait_scanner (dev);
1867 sceptre_close (dev);
1871 status = sceptre_do_diag (dev);
1874 sceptre_close (dev);
1878 status = sceptre_set_mode (dev);
1881 sceptre_close (dev);
1885 status = sceptre_set_window (dev);
1888 sceptre_close (dev);
1892 status = sceptre_send_gamma (dev);
1895 sceptre_close (dev);
1899 status = sceptre_scan (dev);
1902 sceptre_close (dev);
1906 status = sceptre_get_status (dev, &dev->real_bytes_left);
1909 sceptre_close (dev);
1915 dev->bytes_left = dev->params.bytes_per_line * dev->params.lines;
1917 dev->scanning = SANE_TRUE;
1929 Sceptre_Scanner *dev = handle;
1937 if (!(dev->scanning))
1940 return do_cancel (dev);
1943 if (dev->bytes_left <= 0)
1952 if (dev->image_begin == dev->image_end)
1955 status = sceptre_fill_image (dev);
1963 if (dev->image_begin == dev->image_end)
1971 if (size > dev->bytes_left)
1973 size = dev->bytes_left;
1975 sceptre_copy_raw_to_frontend (dev, buf + buf_offset, &size);
1979 dev->bytes_left -= size;
1983 while ((buf_offset != max_len) && dev->bytes_left);
1985 DBG (DBG_info, "sane_read: leave, bytes_left=%ld\n", (long)dev->bytes_left);
1994 Sceptre_Scanner *dev = handle;
1998 if (dev->scanning == SANE_FALSE)
2030 Sceptre_Scanner *dev = handle;
2034 do_cancel (dev);
2042 Sceptre_Scanner *dev = handle;
2047 do_cancel (dev);
2048 sceptre_close (dev);
2050 /* Unlink dev. */
2051 if (first_dev == dev)
2053 first_dev = dev->next;
2058 while (dev_tmp->next && dev_tmp->next != dev)
2068 sceptre_free (dev);