/* sane - Scanner Access Now Easy. Copyright (C) 2004 Gerard Klaver The teco2 and gl646 backend (Frank Zago) are used as a template for this backend This file is part of the SANE package. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. As a special exception, the authors of SANE give permission for additional uses of the libraries contained in this release of SANE. The exception is that, if you link a SANE library with other files to produce an executable, this does not by itself cause the resulting executable to be covered by the GNU General Public License. Your use of that executable is in no way restricted on account of linking the SANE library code into it. This exception does not, however, invalidate any other reasons why the executable file might be covered by the GNU General Public License. If you submit changes to SANE to the maintainers to be included in a subsequent release, you agree by submitting the changes that those changes may be distributed with this exception intact. If you write modifications of your own for SANE, it is your choice whether to permit this exception to apply to your modifications. If you do not wish that, delete this exception notice. */ /* $Id: dvc323.c,v 1.01 2004/09/30 17:37:22 gekl-guest Exp $ Kodak dvc323 camera driver Gerard Klaver start 30-09-2004 */ /*SANE FLOW DIAGRAM - sane_init() : initialize backend, attach vidcams . - sane_get_devices() : query list of vidcam devices . - sane_open() : open a particular vidcam device . . - sane_set_io_mode : set blocking mode . . - sane_get_select_fd : get vidcam fd . . - sane_get_option_descriptor() : get option information . . - sane_control_option() : change option values . . . . - sane_start() : start image acquisition . . - sane_get_parameters() : returns actual scan parameters . . - sane_read() : read image data (from pipe) . . (sane_read called multiple times; after sane_read returns EOF, . . loop may continue with sane_start which may return a 2nd page . . when doing duplex scans, or load the next page from the ADF) . . . . - sane_cancel() : cancel operation . - sane_close() : close opened vidcam device - sane_exit() : terminate use of backend */ /*--------------------------------------------------------------------------*/ #define BUILD 1 /* 2004/09/30 update 30-09-2004*/ #define BACKEND_NAME dvc323 #define DVC3231_CONFIG_FILE "dvc323.conf" /* --------------------- SANE INTERNATIONALISATION ------------------------ */ /* must be first include */ #include "../include/sane/config.h" #include #include #include #include #include #include #include #include #include #include #include "../include/sane/sane.h" #include "../include/sane/sanei.h" #include "../include/sane/saneopts.h" #include "../include/sane/sanei_usb.h" #include "../include/sane/sanei_debug.h" #include "../include/sane/sanei_backend.h" #include "../include/sane/sanei_config.h" #include "../include/lassert.h" #include "dvc323.h" #define TIMEOUT 1000 /*--------------------------------------------------------------------------*/ /* Lists of possible scan modes. */ static SANE_String_Const scan_mode_list[] = { COLOR_RAW_STR, COLOR_8_STR, COLOR_5COMP_STR, SANE_VALUE_SCAN_MODE_LINEART, SANE_VALUE_SCAN_MODE_GRAY, SANE_VALUE_SCAN_MODE_COLOR, NULL }; /*--------------------------------------------------------------------------*/ /*-----------------------------------------minium, maximum, quantization----*/ static const SANE_Range brightness_range = { 0, 255, 1}; static const SANE_Range contrast_range = { 0, 255, 1}; static const SANE_Range hue_range = { 0, 255, 1}; static const SANE_Range saturation_range = { 0, 255,1}; static const SANE_Range threshold_range = { 0, 255, 0}; static const SANE_Range black_level_range = { 0, 255, 1}; static const SANE_Range red_level_range = { 0, 64, 1}; static const SANE_Range green_level_range = { 0, 64, 1}; static const SANE_Range blue_level_range = { 0, 64, 1}; /*--------------------------------------------------------------------------*/ static const struct dpi_color_adjust dvc323_dpi_color_adjust[] = { /*dpi, y, x, color sequence R G or B, 0 (-) or 1 (+) color skewing, lines skewing */ {160, 120, 1, 0, 2, 1, 2}, {320, 240, 1, 0, 2, 1, 2}, {640, 480, 1, 0, 2, 1, 2}, /* must be the last entry */ {0, 0, 0, 0, 0, 0, 0} }; /* For all vidcams. apear in the dvc323_dpi_color_adjust list. */ #define DEF_RESOLUTION 320 static const struct vidcam_hardware vidcams[] = { /* vid, pid, class, name, name, max x and y resolution, res. table name */ { 0x040a, 0x0001, USB_CLASS_VENDOR_SPEC, "KODAK", "DVC323", 320, 240, dvc323_dpi_color_adjust} }; /* List of vidcams attached. */ static Dvc323_Vidcam *first_dev = NULL; static int num_devices = 0; /* used by sane_get_devices */ static const SANE_Device **devlist = NULL; /*----------------------------------------------------------- */ /* Local functions. */ /* Display a buffer in the log. Display by lines of 16 bytes. */ static void hexdump (int level, const char *comment, unsigned char *buf, const int length) { int i; char line[128]; char *ptr; char asc_buf[17]; char *asc_ptr; DBG (level, " %s\n", comment); i = 0; goto start; do { if (i < length) { ptr += sprintf (ptr, " %2.2x", *buf); if (*buf >= 32 && *buf <= 127) { asc_ptr += sprintf (asc_ptr, "%c", *buf); } else { asc_ptr += sprintf (asc_ptr, "."); } } else { /* After the length; do nothing. */ ptr += sprintf (ptr, " "); } i++; buf++; if ((i % 16) == 0) { /* It's a new line */ DBG (level, " %s %s\n", line, asc_buf); start: ptr = line; *ptr = '\0'; asc_ptr = asc_buf; *asc_ptr = '\0'; ptr += sprintf (ptr, " %3.3d:", i); } } while (i < ((length + 15) & ~15)); } /* Returns the length of the longest string, including the terminating * character. */ static size_t max_string_size (SANE_String_Const strings[]) { size_t size, max_size = 0; int i; for (i = 0; strings[i]; ++i) { size = strlen (strings[i]) + 1; if (size > max_size) { max_size = size; } } return max_size; } /* Initialize a vidcam entry. Return an allocated vidcam with some * */ static Dvc323_Vidcam * dvc323_init (void) { Dvc323_Vidcam *dev; DBG (DBG_proc, "dvc323_init: enter\n"); /* Allocate a new vidcam entry. */ dev = calloc (1, sizeof (Dvc323_Vidcam)); if (dev == NULL) { return NULL; } memset (dev, 0, sizeof (Dvc323_Vidcam)); /* Allocate the buffer used to transfer the USB data */ dev->buffer_size = 914 * 1024; dev->buffer = malloc (dev->buffer_size); if (dev->buffer == NULL) { free (dev); return NULL; } /* Allocate the windoww buffer*/ dev->windoww_size = 0x40; dev->windoww = malloc (dev->windoww_size); if (dev->windoww == NULL) { free (dev); return NULL; } /* Allocate the windowr buffer*/ dev->windowr_size = 0x100; dev->windowr = malloc (dev->windowr_size); if (dev->windowr == NULL) { free (dev); return NULL; } dev->fd = -1; DBG (DBG_proc, "dvc323_init: exit\n"); return (dev); } /* Closes an open vidcams. */ static void dvc323_close (Dvc323_Vidcam * dev) { DBG (DBG_proc, "dvc323_close: enter \n"); if (dev->fd != -1) { sanei_usb_close (dev->fd); dev->fd = -1; } DBG (DBG_proc, "dvc323_close: exit\n"); } /* Frees the memory used by a vidcam. */ static void dvc323_free (Dvc323_Vidcam * dev) { int i; DBG (DBG_proc, "dvc323_free: enter\n"); if (dev == NULL) return; dvc323_close (dev); if (dev->devicename) { free (dev->devicename); } if (dev->buffer) { free (dev->buffer); } for (i = 1; i < OPT_NUM_OPTIONS; i++) { if (dev->opt[i].type == SANE_TYPE_STRING && dev->val[i].s) { free (dev->val[i].s); } } if (dev->resolutions_list) free (dev->resolutions_list); free (dev); DBG (DBG_proc, "dvc323_free: exit\n"); } static SANE_Status dvc323_set_config (Dvc323_Vidcam * dev, int configuration, int interface, int alternate) { SANE_Status status; DBG (DBG_proc, "dvc323_set_config: open\n"); status = sanei_usb_set_configuration (dev->fd, configuration); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "dvc323_vidcam_init: DVC323 FAILED to set configuration %d\n", configuration); return status; } status = sanei_usb_claim_interface (dev->fd, interface); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "dvc323_vidcam_init: STV0680 FAILED to claim interface\n"); return status; } status = sanei_usb_set_altinterface (dev->fd, alternate); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "dvc323_vidcam_init: STV0680 FAILED to set alternate interface %d\n", alternate); return status; } DBG (DBG_proc, "dvc323_vidcam_init: configuration=%d, interface=%d, alternate=%d\n", configuration, interface, alternate); DBG (DBG_proc, "dvc323_set_config: exit\n"); return status; } /* Reset vidcam */ static SANE_Status dvc323_reset_window (Dvc323_Vidcam * dev) { SANE_Status status; DBG (DBG_proc, "dvc323_reset_window: enter\n"); status = SANE_STATUS_GOOD; DBG (DBG_proc, "dvc323_reset_window: leave, status=%d\n", status); return status; } /* Inquiry a device and returns TRUE if is supported. */ static int dvc323_identify_scanner (Dvc323_Vidcam *dev) { SANE_Status status; SANE_Word vendor; SANE_Word product; int i; DBG (DBG_info, "dvc323_identify_vidcam: open\n"); status = sanei_usb_get_vendor_product(dev->fd, &vendor, &product); /* Loop through our list to make sure this scanner is supported. */ for (i = 0; i < NELEMS (vidcams); i++) { if (vidcams[i].vendor == vendor && vidcams[i].product == product) { unsigned char val; DBG (DBG_info, "dvc323_identify_scanner: scanner %x:%x is in list\n", vendor, product); status =1; if (status == 0) { DBG(DBG_error, "dvc323_identify_vidcam: this is not a GT8911 (idVendor = %d, bProduct = %d) writing register failed with %s\n", vendor, product, sane_strstatus (status)); return SANE_FALSE; } /* status = dvc323_read_reg (dev, 0x0c, &val); */ status =1; if (status == 0) { DBG (DBG_error, "dvc323_identify_vidcam: this is not a ICM532B (idVendor = %d, bProduct = %d), read register failed %s\n", vendor, product, sane_strstatus (status)); return SANE_FALSE; } val = 0xf8; if (val != 0xf8) { DBG (DBG_error, " this is not a DVC323 ( reg 0x0c. != val 0xf8 )\n"); return SANE_FALSE; } DBG (DBG_info, "dvc323_identify_vidcam: vidcam supported\n"); dev->hw = &(vidcams[i]); return SANE_TRUE; } } DBG (DBG_error, "dvc323_identify_vidcam: this is not a DVC323 ( reg0x0c. != val 0xf8 ) exit\n"); return SANE_FALSE; } static SANE_Status dvc323_vidcam_init(Dvc323_Vidcam *dev) { SANE_Status status; SANE_Word vendor; SANE_Word product; int command; size_t sizew; size_t sizer; size_t i; DBG(DBG_proc, "dvc323_vidcam_init: open\n"); sizew = dev->windoww_size; sizer = dev->windowr_size; memset (dev->windoww, 0, sizew); memset (dev->windowr, 0, sizer); sanei_usb_get_vendor_product(dev->fd, &vendor, &product); command = 5; /* configuration = 1, interface = 0, alternate = 0 */ status = dvc323_set_config (dev, 1, 0, 0); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "dvc323_vidcam_init: DVC323 FAILED to set configure\n"); return status; } /* urb0, reset device */ /* status = sanei_usb_control_msg (dev->fd, 0x00, 0x01, 0x01, 0x00, 0x00, val); if (status != SANE_STATUS_GOOD) goto done; DBG (DBG_proc, "12h bytes val: %s\n", val); command++; */ /* urb 5, first write string */ sizew = 0x40; for (i=0; i < sizew; i++) dev->windoww[i] = dvc323_init_str1[i]; status = sanei_usb_control_msg (dev->fd, 0x40, 0x01, 0x00, 0x00, sizew, dev->windoww); if (status != SANE_STATUS_GOOD) goto done; command++; hexdump (DBG_info2, "urb 5 dvc323_init_str1", dev->windoww, sizew); /* urb 6, write */ sizew =0x40; for (i=0; i < sizew; i++) dev->windoww[i] = dvc323_init_str2[i]; status = sanei_usb_control_msg (dev->fd, 0x40, 0x01, 0x00, 0x00, sizew, dev->windoww); if (status != SANE_STATUS_GOOD) goto done; command++; hexdump (DBG_info2, "urb 6 dvc323_init_str2", dev->windoww, sizew); /* urb 7, read */ sizer= 0x100; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x00, 0x00, 0x0004, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) goto done; command++; hexdump (DBG_info2, "urb 7 windowr", dev->windowr, sizer); /* urb 8, read */ sizer = 0x40; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x00, 0x00, 0x0000, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) goto done; command++; hexdump (DBG_info2, "urb 8 windowr", dev->windowr, sizer); /* urb 9, read */ sizer = 0x40; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x00, 0x00, 0x0001, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) goto done; command++; hexdump (DBG_info2, "urb 9 windowr", dev->windowr, sizer); /* urb 10, read 00 00 00 00 00 00 */ sizer = 0x06; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x00, 0x00, 0x0002, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) goto done; command++; hexdump (DBG_info2, "urb 10 windowr", dev->windowr, sizer); /* urb 11, write */ sizew = 0x40; for (i=0; i < sizew; i++) dev->windoww[i] = dvc323_init_str1[i]; status = sanei_usb_control_msg (dev->fd, 0x40, 0x01, 0x00, 0x00, sizew, dev->windoww); if (status != SANE_STATUS_GOOD) goto done; command++; hexdump (DBG_info2, "urb 11 dvc323_init_str1", dev->windoww, sizew); /* urb 12, write */ sizew= 0x40; for (i=0; i < sizew; i++) dev->windoww[i] = dvc323_init_str2[i]; status = sanei_usb_control_msg (dev->fd, 0x40, 0x01, 0x00, 0x00, sizew, dev->windoww); if (status != SANE_STATUS_GOOD) goto done; command++; hexdump (DBG_info2, "urb 12 dvc323_init_str2", dev->windoww, sizew); /* urb 13, write 00 00 00 00 00 00 00 */ sizew=0x06; for (i=0; i < sizew; i++) dev->windoww[i] = dvc323_init_str3[i]; status = sanei_usb_control_msg (dev->fd, 0x40, 0x01, 0x00, 0x0002, sizew, dev->windoww); if (status != SANE_STATUS_GOOD) goto done; command++; done: if (status) { DBG (DBG_error, "dvc323_vidcam_init failed for command %d: %s\n", command, sane_strstatus (status)); } return status; } /* Attach a vidcam to this backend. */ static SANE_Status attach_vidcam (SANE_String_Const devicename, Dvc323_Vidcam **devp) { Dvc323_Vidcam *dev; int fd; DBG (DBG_proc, "attach_vidcam: %s\n", devicename); if (devp) *devp = NULL; /* Check if we know this device name. */ for (dev = first_dev; dev; dev = dev->next) { if (strcmp (dev->sane.name, devicename) == 0) { if (devp) { *devp = dev; } DBG (DBG_info, "device is already known\n"); return SANE_STATUS_GOOD; } } /* Allocate a new vidcam entry. */ dev = dvc323_init (); if (dev == NULL) { DBG (DBG_error, "ERROR: not enough memory\n"); return SANE_STATUS_NO_MEM; } DBG (DBG_info, "attach_vidcam: opening USB device %s\n", devicename); if (sanei_usb_open (devicename, &fd) != 0) { DBG (DBG_error, "ERROR: attach_vidcam: open failed\n"); dvc323_free (dev); return SANE_STATUS_INVAL; } /* Fill some scanner specific values. */ dev->devicename = strdup (devicename); dev->fd = fd; /* Now, check that it is a vidcam we support. */ if (dvc323_identify_scanner (dev) == SANE_FALSE) { DBG (DBG_error, "ERROR: attach_vidcam: vidcam-identification failed\n"); dvc323_free (dev); return SANE_STATUS_INVAL; } dvc323_close (dev); /* Build list of vidcam supported resolutions. */ DBG (DBG_proc, "attach_vidcam: build resolution list\n"); if (dev->hw->color_adjust[0].resolution_x != 0) { int num_entries; int i; num_entries = 0 ; while (dev->hw->color_adjust[num_entries].resolution_x != 0) num_entries++; dev->resolutions_list = malloc (sizeof (SANE_Word) * (num_entries + 1)); if (dev->resolutions_list == NULL) { DBG (DBG_error, "ERROR: attach_vidcam: vidcam resolution list failed\n"); dvc323_free (dev); return SANE_STATUS_NO_MEM; } dev->resolutions_list[0] = num_entries; DBG (DBG_proc, "attach_vidcam: make color resolution table \n"); for (i = 0; i < num_entries; i++) { dev->resolutions_list[i + 1] = dev->hw->color_adjust[i].resolution_x; } } else { dev->resolutions_list = NULL; } /* Set the default options for that vidcam. */ dev->sane.name =dev->devicename; dev->sane.vendor = dev->hw->vendor_name; dev->sane.model = dev->hw->product_name; dev->sane.type = SANE_I18N ("vidcam/webcam"); /* Link the vidcam with the others. */ dev->next = first_dev; first_dev = dev; if (devp) { *devp = dev; } num_devices++; DBG (DBG_proc, "attach_vidcam: exit\n"); return SANE_STATUS_GOOD; } static SANE_Status attach_one (const char *dev) { DBG (DBG_proc, "attach_one: open \n"); attach_vidcam (dev, NULL); DBG (DBG_proc, "attach_one: exit \n"); return SANE_STATUS_GOOD; } /* Reset the options for that vidcam. */ static void dvc323_init_options (Dvc323_Vidcam * dev) { int i; DBG (DBG_proc, "dvc323_init_options: open\n"); /* Pre-initialize the options. */ memset (dev->opt, 0, sizeof (dev->opt)); memset (dev->val, 0, sizeof (dev->val)); for (i = 0; i < OPT_NUM_OPTIONS; ++i) { dev->opt[i].size = sizeof (SANE_Word); dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; } /* Default settings */ /* */ DBG (DBG_proc, "dvc323_init_options: done loop opt_num_options=%d, i=%d \n", OPT_NUM_OPTIONS, i); /* Number of options. */ dev->opt[OPT_NUM_OPTS].name = ""; dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT; dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS; /* Mode group */ dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode"); dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */ dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; dev->opt[OPT_MODE_GROUP].cap = 0; dev->opt[OPT_MODE_GROUP].size = 0; dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; /* Scanner supported modes */ dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE; dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE; dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE; dev->opt[OPT_MODE].type = SANE_TYPE_STRING; dev->opt[OPT_MODE].size = max_string_size (scan_mode_list); dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; dev->opt[OPT_MODE].constraint.string_list = scan_mode_list; dev->val[OPT_MODE].s = (SANE_Char *) strdup (""); /* will be set later */ /* X and Y resolution */ dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT; dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE; dev->val[OPT_RESOLUTION].w = DEF_RESOLUTION; /* brightness */ dev->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS; dev->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS; dev->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; dev->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT; dev->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE; dev->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_BRIGHTNESS].constraint.range = &brightness_range; dev->val[OPT_BRIGHTNESS].w = 80; /* to get middle value */ /* contrast */ dev->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST; dev->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST; dev->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST; dev->opt[OPT_CONTRAST].type = SANE_TYPE_INT; dev->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE; dev->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_CONTRAST].constraint.range = &contrast_range; dev->val[OPT_CONTRAST].w = 80; /* to get middle value */ /* hue */ dev->opt[OPT_HUE].name = SANE_NAME_HUE; dev->opt[OPT_HUE].title = SANE_TITLE_HUE; dev->opt[OPT_HUE].desc = SANE_DESC_HUE; dev->opt[OPT_HUE].type = SANE_TYPE_INT; dev->opt[OPT_HUE].unit = SANE_UNIT_NONE; dev->opt[OPT_HUE].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_HUE].constraint.range = &hue_range; dev->val[OPT_HUE].w = 02; /* to get middle value */ /* saturation */ dev->opt[OPT_SATURATION].name = SANE_NAME_SATURATION; dev->opt[OPT_SATURATION].title = SANE_TITLE_SATURATION; dev->opt[OPT_SATURATION].desc = SANE_DESC_SATURATION; dev->opt[OPT_SATURATION].type = SANE_TYPE_INT; dev->opt[OPT_SATURATION].unit = SANE_UNIT_NONE; dev->opt[OPT_SATURATION].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_SATURATION].constraint.range = &saturation_range; dev->val[OPT_SATURATION].w = 80; /* to get middle value */ /* Enhancement group */ dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement"); dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */ dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP; dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED; dev->opt[OPT_ENHANCEMENT_GROUP].size = 0; dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE; /* Threshold */ dev->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD; dev->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD; dev->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD; dev->opt[OPT_THRESHOLD].type = SANE_TYPE_INT; dev->opt[OPT_THRESHOLD].unit = SANE_UNIT_NONE; dev->opt[OPT_THRESHOLD].size = sizeof (SANE_Int); dev->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; dev->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_THRESHOLD].constraint.range = &threshold_range; dev->val[OPT_THRESHOLD].w = 128; /* black level correction */ dev->opt[OPT_BLACK_LEVEL].name = SANE_NAME_BLACK_LEVEL; dev->opt[OPT_BLACK_LEVEL].title = SANE_TITLE_BLACK_LEVEL; dev->opt[OPT_BLACK_LEVEL].desc = SANE_DESC_BLACK_LEVEL; dev->opt[OPT_BLACK_LEVEL].type = SANE_TYPE_INT; dev->opt[OPT_BLACK_LEVEL].unit = SANE_UNIT_NONE; dev->opt[OPT_BLACK_LEVEL].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_BLACK_LEVEL].constraint.range = &black_level_range; dev->val[OPT_BLACK_LEVEL].w = 02; /* to get middle value */ /* red level calibration manual correction */ dev->opt[OPT_WHITE_LEVEL_R].name = SANE_NAME_WHITE_LEVEL_R; dev->opt[OPT_WHITE_LEVEL_R].title = SANE_TITLE_WHITE_LEVEL_R; dev->opt[OPT_WHITE_LEVEL_R].desc = SANE_DESC_WHITE_LEVEL_R; dev->opt[OPT_WHITE_LEVEL_R].type = SANE_TYPE_INT; dev->opt[OPT_WHITE_LEVEL_R].unit = SANE_UNIT_NONE; dev->opt[OPT_WHITE_LEVEL_R].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_WHITE_LEVEL_R].constraint.range = &red_level_range; dev->val[OPT_WHITE_LEVEL_R].w = 02; /* to get middle value */ /* green level calibration manual correction */ dev->opt[OPT_WHITE_LEVEL_G].name = SANE_NAME_WHITE_LEVEL_G; dev->opt[OPT_WHITE_LEVEL_G].title = SANE_TITLE_WHITE_LEVEL_G; dev->opt[OPT_WHITE_LEVEL_G].desc = SANE_DESC_WHITE_LEVEL_G; dev->opt[OPT_WHITE_LEVEL_G].type = SANE_TYPE_INT; dev->opt[OPT_WHITE_LEVEL_G].unit = SANE_UNIT_NONE; dev->opt[OPT_WHITE_LEVEL_G].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_WHITE_LEVEL_G].constraint.range = &green_level_range; dev->val[OPT_WHITE_LEVEL_G].w = 02; /* to get middle value */ /* blue level calibration manual correction */ dev->opt[OPT_WHITE_LEVEL_B].name = SANE_NAME_WHITE_LEVEL_B; dev->opt[OPT_WHITE_LEVEL_B].title = SANE_TITLE_WHITE_LEVEL_B; dev->opt[OPT_WHITE_LEVEL_B].desc = SANE_DESC_WHITE_LEVEL_B; dev->opt[OPT_WHITE_LEVEL_B].type = SANE_TYPE_INT; dev->opt[OPT_WHITE_LEVEL_B].unit = SANE_UNIT_NONE; dev->opt[OPT_WHITE_LEVEL_B].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_WHITE_LEVEL_B].constraint.range = &blue_level_range; dev->val[OPT_WHITE_LEVEL_B].w = 02; /* to get middle value */ /* preview */ dev->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW; dev->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW; dev->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW; dev->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL; dev->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT; dev->val[OPT_PREVIEW].w = SANE_FALSE; /* Lastly, set the default scan mode. This might change some * values previously set here. */ sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE, (SANE_String_Const *) scan_mode_list[0], NULL); DBG (DBG_proc, "dvc323_init_options: exit\n"); } #define COLOR_0 (color_adjust->z3_color_0) #define COLOR_1 (color_adjust->z3_color_1) #define COLOR_2 (color_adjust->z3_color_2) /* Read the image from the vidcam and fill the temporary buffer with it. */ static SANE_Status dvc323_fill_image (Dvc323_Vidcam * dev) { SANE_Status status; size_t size; int command = 100; SANE_Int n_bytes; SANE_Int p_size; size_t sizew; size_t sizer; size_t iso_size_read; DBG (DBG_proc, "dvc323_fill_image: enter\n"); assert (dev->image_begin == dev->image_end); assert (dev->real_bytes_left > 0); sizew = dev->windoww_size; sizer = dev->windowr_size; memset (dev->windoww, 0, sizew); memset (dev->windowr, 0, sizer); DBG(DBG_proc, "dvc323 vidcam fill_image\n"); /* urb 14 configuration = 1, interface = 0, alternate = 3 */ status = dvc323_set_config (dev, 1, 0, 3); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "dvc323_vidcam_fill_image: DVC323 FAILED to set configure\n"); return status; } /* urb 15 write, 00 00 00 00 00 00 */ sizew = 0x06; status = sanei_usb_control_msg (dev->fd, 0x40, 0x01, 0x00, 0x0002, sizew, dev->windoww); if (status != SANE_STATUS_GOOD) goto done; command++; /* urb 16, read */ sizer =0x40; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x00, 0x00, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) goto done; command++; hexdump (DBG_info2, "urb 16 windowr", dev->windowr, sizer); /* urb 17, write */ sizew = 0x01; dev->windoww[0] = 0x01; status = sanei_usb_control_msg (dev->fd, 0x40, 0x01, 0x0004, 0x0002, sizew, dev->windoww); if (status != SANE_STATUS_GOOD) goto done; command++; DBG (DBG_proc, "dvc323_fill_image: real dev bytes left=0x%x \n", dev->real_bytes_left); iso_size_read = dev->real_bytes_left; while (dev->real_bytes_left) { /* * Try to read the maximum number of bytes. */ DBG (DBG_proc, "dvc323_fill_image: real dev bytes left, while loop=0x%x \n", dev->real_bytes_left); size = dev->real_bytes_left; if (size < iso_size_read) { size = iso_size_read; DBG (DBG_proc, "dvc323_fill_image: size = 0x%x \n", size); } if (size == 0) { /* Probably reached the end of the buffer. Check, just in case. */ assert (dev->image_end != 0); return (SANE_STATUS_GOOD); } /* Prepare the transfer, not tested, also sanei_usb_read_iso not yet ready. */ /* Do the transfer */ p_size= 0x0300; n_bytes = dev->bytes_left; if (size > 0x7fff) { size = 0x7fff; } DBG (DBG_proc, "dvc323_fill_image: dev->bytes_left: 0x%x p_size: 0x%x n_bytes: 0x%x\n", dev->bytes_left, p_size, n_bytes); /* urb 18 reset pipe * 19 get frame number * 20 iso transfer * 21 iso transfer * */ status = sanei_usb_read_iso(dev->fd, n_bytes, p_size, dev->buffer, &size); if (status != SANE_STATUS_GOOD) return status; /* if (size != dev->bytes_left) { DBG (DBG_error, "dvc323_fill_image: read %x bytes instead of %x\n", size, dev->bytes_left); status = SANE_STATUS_IO_ERROR; } */ if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "dvc323_fill_image: cannot read from the vidcam\n"); return status; } DBG (DBG_info, "dvc323_fill_image: size = 0x%lx bytes (bpl=%d)\n", (long) size, dev->params.bytes_per_line); /* dump 0x40 bytes for checking image data */ sizer = 0x40; hexdump (DBG_info2, "iso dev->buffer", dev->buffer, sizer); memcpy (dev->image + dev->image_end, dev->buffer, size); dev->image_end += size; iso_size_read = size; if (dev->real_bytes_left > size) dev->real_bytes_left-=size; else if (dev->real_bytes_left <=size) /* last loop */ dev->real_bytes_left = 0; DBG (DBG_info, "dvc323_fill_image: real bytes left = %lx\n", (long) dev->real_bytes_left); } /* urb 22, write */ sizew = 0x02; dev->windoww[0] = 0x00; dev->windoww[1] = 0x00; status = sanei_usb_control_msg (dev->fd, 0x40, 0x01, 0x0018, 0x0001, sizew, dev->windoww); if (status != SANE_STATUS_GOOD) goto done; command++; /* urb 23, write */ status = sanei_usb_control_msg (dev->fd, 0x40, 0x01, 0x001e, 0x0001, sizew, dev->windoww); if (status != SANE_STATUS_GOOD) goto done; command++; hexdump (DBG_info2, "urb 23 windoww", dev->windoww, sizew); /* urb 24, write */ sizew = 0x01; status = sanei_usb_control_msg (dev->fd, 0x40, 0x01, 0x0001, 0x0002, sizew, dev->windoww); if (status != SANE_STATUS_GOOD) goto done; command++; /* urb 20 coming back data * urb 25 down * urb 21 coming back data */ DBG (DBG_proc, "dvc323_fill_image: exit\n"); return (SANE_STATUS_GOOD); /* unreachable */ done: if (status) { DBG (DBG_error, "dvc323_fill_image failed for command %d: %s\n", command, sane_strstatus (status)); } return status; } /* Copy from the raw buffer to the buffer given by the backend. * * len in input is the maximum length available in buf, and, in * output, is the length written into buf. */ static void dvc323_copy_raw_to_frontend (Dvc323_Vidcam * dev, SANE_Byte * buf, size_t * len) { size_t size; DBG (DBG_proc, "dvc323_copy_raw_to_frontend: enter\n"); size = dev->image_end - dev->image_begin; if (size > *len) { size = *len; } *len = size; switch (dev->scan_mode) { case DVC323_LINEART: { /* Invert black and white. */ unsigned char *src = dev->image + dev->image_begin; size_t i; for (i = 0; i < size; i++) { *buf = *src ^ 0xff; src++; buf++; } } break; case DVC323_COLOR_RAW: case DVC323_COLOR_8: case DVC323_COLOR_5COMP: case DVC323_GRAY: case DVC323_COLOR: memcpy (buf, dev->image + dev->image_begin, size); break; } dev->image_begin += size; DBG (DBG_proc, "dvc323_copy_raw_to_frontend: exit\n"); } /* Stop a scan. */ static SANE_Status do_cancel (Dvc323_Vidcam * dev) { DBG (DBG_sane_proc, "do_cancel enter\n"); if (dev->scanning == SANE_TRUE) { /* Reset the vidcam */ dvc323_reset_window (dev); dvc323_close (dev); } dev->scanning = SANE_FALSE; DBG (DBG_sane_proc, "do_cancel exit\n"); return SANE_STATUS_CANCELLED; } /*--------------------------------------------------------------------------*/ /* Sane entry points */ SANE_Status sane_init (SANE_Int *version_code, SANE_Auth_Callback authorize) { FILE *fp; char line[PATH_MAX]; size_t len; DBG_INIT (); DBG (DBG_sane_init, "sane_init\n"); authorize = authorize; /* silence gcc */ DBG (DBG_error, "This is sane-dvc323 version %d.%d-%d\n", V_MAJOR, V_MINOR, BUILD); DBG (DBG_error, "(C) 2004 by Gerard Klaver\n"); if (version_code) { *version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, BUILD); } sanei_usb_init (); fp = sanei_config_open (DVC3231_CONFIG_FILE); if (!fp) { /* No default vidcam? */ DBG(DBG_warning, "configuration file not found (%s)\n", DVC3231_CONFIG_FILE); return SANE_STATUS_GOOD; } while (sanei_config_read (line, sizeof (line), fp)) { SANE_Word vendor; SANE_Word product; if (line[0] == '#') /* ignore line comments */ continue; len = strlen (line); if (!len) continue; /* ignore empty lines */ if (sscanf (line, "usb %i %i", &vendor, &product) == 2) { sanei_usb_attach_matching_devices (line, attach_one); } else { /* Garbage. Ignore. */ DBG(DBG_warning, "bad configuration line: \"%s\" - ignoring.\n", line); } } fclose (fp); DBG (DBG_proc, "sane_init: leave\n"); return SANE_STATUS_GOOD; } SANE_Status sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) { Dvc323_Vidcam *dev; int i; DBG (DBG_proc, "sane_get_devices: enter\n"); local_only = local_only; /* silence gcc */ if (devlist) free (devlist); devlist = malloc ((num_devices + 1) * sizeof (devlist[0])); if (!devlist) return SANE_STATUS_NO_MEM; i = 0; for (dev = first_dev; i < num_devices; dev = dev->next) devlist[i++] = &dev->sane; devlist[i++] = 0; *device_list = devlist; DBG (DBG_proc, "sane_get_devices: exit\n"); return SANE_STATUS_GOOD; } SANE_Status sane_open (SANE_String_Const devicename, SANE_Handle * handle) { Dvc323_Vidcam *dev; SANE_Status status; DBG (DBG_proc, "sane_open: enter\n"); /* search for devicename */ if (devicename[0]) { DBG (DBG_info, "sane_open: devicename=%s\n", devicename); for (dev = first_dev; dev; dev = dev->next) { if (strcmp (dev->sane.name, devicename) == 0) { break; } } if (!dev) { status = attach_vidcam (devicename, &dev); if (status != SANE_STATUS_GOOD) { return status; } } } else { DBG (DBG_sane_info, "sane_open: no devicename, opening first device\n"); dev = first_dev; /* empty devicename -> use first device */ } if (!dev) { DBG (DBG_error, "No vidcam found\n"); return SANE_STATUS_INVAL; } dvc323_init_options (dev); *handle = dev; DBG (DBG_proc, "sane_open: exit\n"); return SANE_STATUS_GOOD; } const SANE_Option_Descriptor * sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) { Dvc323_Vidcam *dev = handle; DBG (DBG_proc, "sane_get_option_descriptor: enter, option %d\n", option); if ((unsigned) option >= OPT_NUM_OPTIONS) { return NULL; } DBG (DBG_proc, "sane_get_option_descriptor: exit\n"); return dev->opt + option; } SANE_Status sane_control_option (SANE_Handle handle, SANE_Int option, SANE_Action action, void *val, SANE_Int * info) { Dvc323_Vidcam *dev = handle; SANE_Status status; SANE_Word cap; DBG (DBG_proc, "sane_control_option: enter, option %d, action %d\n", option, action); if (info) { *info = 0; } if (dev->scanning) { return SANE_STATUS_DEVICE_BUSY; } if (option < 0 || option >= OPT_NUM_OPTIONS) { return SANE_STATUS_INVAL; } cap = dev->opt[option].cap; if (!SANE_OPTION_IS_ACTIVE (cap)) { return SANE_STATUS_INVAL; } if (action == SANE_ACTION_GET_VALUE) { switch (option) { /* word options */ case OPT_NUM_OPTS: case OPT_RESOLUTION: case OPT_PREVIEW: case OPT_BRIGHTNESS: case OPT_CONTRAST: case OPT_HUE: case OPT_SATURATION: case OPT_THRESHOLD: case OPT_BLACK_LEVEL: case OPT_WHITE_LEVEL_R: case OPT_WHITE_LEVEL_G: case OPT_WHITE_LEVEL_B: *(SANE_Word *) val = dev->val[option].w; return SANE_STATUS_GOOD; case OPT_MODE: strcpy (val, dev->val[option].s); return SANE_STATUS_GOOD; default: return SANE_STATUS_INVAL; } } else if (action == SANE_ACTION_SET_VALUE) { if (!SANE_OPTION_IS_SETTABLE (cap)) { DBG (DBG_error, "could not set option, not settable\n"); return SANE_STATUS_INVAL; } status = sanei_constrain_value (dev->opt + option, val, info); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "could not set option, invalid value\n"); return status; } switch (option) { /* Numeric side-effect options */ case OPT_THRESHOLD: case OPT_RESOLUTION: case OPT_BRIGHTNESS: case OPT_CONTRAST: case OPT_HUE: case OPT_SATURATION: case OPT_BLACK_LEVEL: case OPT_WHITE_LEVEL_R: case OPT_WHITE_LEVEL_G: case OPT_WHITE_LEVEL_B: if (info) { *info |= SANE_INFO_RELOAD_PARAMS; } dev->val[option].w = *(SANE_Word *) val; return SANE_STATUS_GOOD; /* Numeric side-effect free options */ case OPT_PREVIEW: dev->val[option].w = *(SANE_Word *) val; return SANE_STATUS_GOOD; /* String side-effect options */ case OPT_MODE: if (strcmp(dev->val[option].s, val) == 0) return SANE_STATUS_GOOD; free (dev->val[OPT_MODE].s); dev->val[OPT_MODE].s = (SANE_Char *) strdup (val); dev->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_BLACK_LEVEL].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_WHITE_LEVEL_R].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_WHITE_LEVEL_G].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_WHITE_LEVEL_B].cap &= ~SANE_CAP_INACTIVE; if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) == 0) { dev->scan_mode = DVC323_LINEART; dev->depth = 8; dev->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; } else if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_GRAY) == 0) { dev->scan_mode = DVC323_GRAY; dev->depth = 8; dev->opt[OPT_WHITE_LEVEL_R].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_WHITE_LEVEL_G].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_WHITE_LEVEL_B].cap &= ~SANE_CAP_INACTIVE; } else if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0) { dev->scan_mode = DVC323_COLOR; dev->depth = 8; dev->opt[OPT_WHITE_LEVEL_R].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_WHITE_LEVEL_G].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_WHITE_LEVEL_B].cap &= ~SANE_CAP_INACTIVE; } else if (strcmp (dev->val[OPT_MODE].s, COLOR_RAW_STR) == 0) { dev->scan_mode = DVC323_COLOR_RAW; } else if (strcmp (dev->val[OPT_MODE].s, COLOR_8_STR) == 0) { dev->scan_mode = DVC323_COLOR_8; } else if (strcmp (dev->val[OPT_MODE].s, COLOR_5COMP_STR) == 0) { dev->scan_mode = DVC323_COLOR_5COMP; } /* The dvc323 supports only a handful of resolution. */ /* This the default resolution range for the DVC323_532 */ if (dev->resolutions_list != NULL) { int i; dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST; dev->opt[OPT_RESOLUTION].constraint.word_list = dev->resolutions_list; /* If the resolution isn't in the list, set a default. */ for (i = 1; i <= dev->resolutions_list[0]; i++) { if (dev->resolutions_list[i] >= dev->val[OPT_RESOLUTION].w) break; } if (i > dev->resolutions_list[0]) { /* Too big. Take default. */ dev->val[OPT_RESOLUTION].w = DEF_RESOLUTION; } else { /* Take immediate superioir value. */ dev->val[OPT_RESOLUTION].w = dev->resolutions_list[i]; } } /* String side-effect options */ if (info) { *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; } return SANE_STATUS_GOOD; default: return SANE_STATUS_INVAL; } } DBG (DBG_proc, "sane_control_option: exit, bad\n"); return SANE_STATUS_UNSUPPORTED; } SANE_Status sane_get_parameters (SANE_Handle handle, SANE_Parameters * params) { Dvc323_Vidcam *dev = handle; int bytes_pixel; DBG (DBG_proc, "sane_get_parameters: enter\n"); if (!(dev->scanning)) { /* Setup the parameters for the scan. These values will be re-used * in the SET WINDOWS command. */ if (dev->val[OPT_PREVIEW].w == SANE_TRUE) { dev->x_resolution = 320; dev->y_resolution = 240; } else { dev->x_resolution = dev->val[OPT_RESOLUTION].w; dev->y_resolution = dev->x_resolution * 3 / 4; } switch (dev->scan_mode) { case DVC323_LINEART: case DVC323_GRAY: bytes_pixel = 1; break; case DVC323_COLOR_RAW: bytes_pixel = 3; break; case DVC323_COLOR_8: case DVC323_COLOR_5COMP: case DVC323_COLOR: bytes_pixel = 1; break; } /* Prepare the parameters for the caller. */ memset (&dev->params, 0, sizeof (SANE_Parameters)); dev->params.last_frame = SANE_TRUE; dev->params.format = SANE_FRAME_RGB; dev->params.pixels_per_line = dev->x_resolution; dev->params.bytes_per_line = dev->params.pixels_per_line * bytes_pixel; dev->params.depth = 8; dev->params.lines = dev->y_resolution; } /* Return the current values. */ if (params) { *params = (dev->params); } DBG (DBG_proc, "sane_get_parameters: exit\n"); return SANE_STATUS_GOOD; } SANE_Status sane_start (SANE_Handle handle) { Dvc323_Vidcam *dev = handle; SANE_Status status; DBG (DBG_proc, "sane_start: enter\n"); if (!(dev->scanning)) { sane_get_parameters (dev, NULL); /* Open again the vidcam */ if (sanei_usb_open (dev->devicename, &(dev->fd)) != 0) { DBG (DBG_error, "ERROR: sane_start: open failed\n"); return SANE_STATUS_INVAL; } /* Initialize the vidcam. */ status = dvc323_vidcam_init(dev); if (status) { DBG (DBG_error, "ERROR: failed to init the vidcam\n"); dvc323_close (dev); return status; } dev->image_size = dev->buffer_size; dev->image = malloc (dev->image_size); if (dev->image == NULL) { return SANE_STATUS_NO_MEM; } } dev->image_end = 0; dev->image_begin = 0; dev->bytes_left = dev->params.bytes_per_line * dev->params.lines; dev->real_bytes_left = dev->params.bytes_per_line * dev->params.lines; dev->scanning = SANE_TRUE; DBG (DBG_proc, "sane_start: exit\n"); return SANE_STATUS_GOOD; } SANE_Status sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int * len) { SANE_Status status; Dvc323_Vidcam *dev = handle; size_t size; int buf_offset; /* offset into buf */ DBG (DBG_proc, "sane_read: enter\n"); *len = 0; if (!(dev->scanning)) { DBG (DBG_proc, "sane_read: before do_cancel enter\n"); /* OOPS, not scanning */ return do_cancel (dev); } if (dev->bytes_left <= 0) { return (SANE_STATUS_EOF); } buf_offset = 0; do { if (dev->image_begin == dev->image_end) { /* Fill image */ status = dvc323_fill_image (dev); if (status != SANE_STATUS_GOOD) { return (status); } } /* Something must have been read */ if (dev->image_begin == dev->image_end) { DBG (DBG_info, "sane_read: nothing read\n"); return SANE_STATUS_IO_ERROR; } /* Copy the data to the frontend buffer. */ size = max_len - buf_offset; if (size > dev->bytes_left) { size = dev->bytes_left; } dvc323_copy_raw_to_frontend (dev, buf + buf_offset, &size); buf_offset += size; dev->bytes_left -= size; *len += size; } while ((buf_offset != max_len) && dev->bytes_left); DBG (DBG_info, "sane_read: leave, bytes_left=%d\n", dev->bytes_left); return SANE_STATUS_GOOD; } SANE_Status sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) { DBG (DBG_proc, "sane_set_io_mode: enter\n"); handle = handle; /* silence gcc */ non_blocking = non_blocking; /* silence gcc */ DBG (DBG_proc, "sane_set_io_mode: exit\n"); return SANE_STATUS_UNSUPPORTED; } SANE_Status sane_get_select_fd (SANE_Handle handle, SANE_Int * fd) { DBG (DBG_proc, "sane_get_select_fd: enter\n"); handle = handle; /* silence gcc */ fd = fd; /* silence gcc */ DBG (DBG_proc, "sane_get_select_fd: exit\n"); return SANE_STATUS_UNSUPPORTED; } void sane_cancel (SANE_Handle handle) { Dvc323_Vidcam *dev = handle; DBG (DBG_proc, "sane_cancel: enter\n"); do_cancel (dev); DBG (DBG_proc, "sane_cancel: exit\n"); } void sane_close (SANE_Handle handle) { Dvc323_Vidcam *dev = handle; Dvc323_Vidcam *dev_tmp; DBG (DBG_proc, "sane_close: enter\n"); do_cancel (dev); dvc323_close (dev); /* Unlink dev. */ if (first_dev == dev) { first_dev = dev->next; } else { dev_tmp = first_dev; while (dev_tmp->next && dev_tmp->next != dev) { dev_tmp = dev_tmp->next; } if (dev_tmp->next != NULL) { dev_tmp->next = dev_tmp->next->next; } } dvc323_free (dev); num_devices--; DBG (DBG_proc, "sane_close: exit\n"); } void sane_exit (void) { DBG (DBG_proc, "sane_exit: enter\n"); while (first_dev) { sane_close (first_dev); } if (devlist) { free (devlist); devlist = NULL; } DBG (DBG_proc, "sane_exit: exit\n"); }