/* sane - Scanner Access Now Easy. Copyright (C) 2005 Gerard Klaver The teco2 and gl646 backend (Frank Zago) are used as a template for this backend. At this moment some parts for the usb commands, bayer decoding, add_text, parts of stv680 kernel module, pencam and libgphoto2 program are used/included. 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: sipix.c,v 1.01 2005/03/24 17:37:22 gekl-guest Exp $ sipix vidcam driver Gerard Klaver */ /*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) . . go back to sane_start() if more frames desired . . - sane_cancel() : cancel operation . - sane_close() : close opened vidcam device - sane_exit() : terminate use of backend */ /*--------------------------------------------------------------------------*/ #define BUILD 1 /* 2005/03/24 update 24-03-2005 */ #define BACKEND_NAME sipix #define SIPIX_CONFIG_FILE "sipix.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" /* for add-text routine */ #include #include "font_6x11.h" /*-----------------------*/ #include "sipix.h" #define TIMEOUT 1000 /*--------------------------------------------------------------------------*/ /* Lists of possible scan modes. */ static SANE_String_Const scan_mode_list[] = { COLOR_RGB_STR, COLOR_RGB_TEXT_STR, SANE_VALUE_SCAN_MODE_COLOR, COLOR_RGB_USB_ISO_STR, COLOR_RAW_STR, NULL }; /*-----------------------------------------minium, maximum, quantization----*/ static const SANE_Range brightness_range = { -128, 128, 1 }; static const SANE_Range red_level_range = { -32, 32, 1 }; static const SANE_Range green_level_range = { -32, 32, 1 }; static const SANE_Range blue_level_range = { -32, 32, 1 }; /*--------------------------------------------------------------------------*/ static const struct dpi_color_adjust sipix_dpi_color_adjust[] = { /*dpi, y, x, color sequence R G or B */ {160, 120, 0, 1, 2}, /* QSIF */ {320, 240, 0, 1, 2}, /* QVGA (SIF) */ {640, 480, 0, 1, 2}, /* CIF */ /* must be the last entry */ {0, 0, 0, 0, 0} }; static const struct dpi_color_adjust sipix2_dpi_color_adjust[] = { /*dpi, y, x, color sequence R G or B */ {640, 480, 0, 1, 2}, /* VGA */ {352, 288, 0, 1, 2}, /* CIF */ {320, 240, 0, 1, 2}, /* QVGA (SIF) */ {176, 144, 0, 1, 2}, /* QCIF */ {160, 120, 0, 1, 2}, /* QSIF */ /* must be the last entry */ {0, 0, 0, 0, 0} }; /* For all vidcams must appear in the ...._dpi_color_adjust list of * all supported vidcams */ #define DEF_RESOLUTION 320 static const struct vidcam_hardware vidcams[] = { {0x0c77, 0x1010, USB_CLASS_VENDOR_SPEC, "SiPix StyleCam", "Snap", sipix_dpi_color_adjust}, {0x0c77, 0x1011, USB_CLASS_VENDOR_SPEC, "SiPix", ".....", sipix_dpi_color_adjust} }; /* List of vidcams attached. */ static Sipix_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 Sipix_Vidcam * sipix_init (void) { Sipix_Vidcam *dev; DBG (DBG_proc, "sipix_init: enter\n"); /* Allocate a new vidcam entry. */ dev = calloc (1, sizeof (Sipix_Vidcam)); if (dev == NULL) { return NULL; } memset (dev, 0, sizeof (Sipix_Vidcam)); /* Allocate the windoww buffer*/ dev->windoww_size = 0x20; dev->windoww = malloc (dev->windoww_size); if (dev->windoww == NULL) { free (dev); return NULL; } /* Allocate the windowr buffer*/ dev->windowr_size = 0x20; dev->windowr = malloc (dev->windowr_size); if (dev->windowr == NULL) { free (dev); return NULL; } dev->fd = -1; DBG (DBG_proc, "sipix_init: exit\n"); return (dev); } static Sipix_Vidcam * sipix_init_2 (void) { Sipix_Vidcam *dev; DBG (DBG_proc, "sipix_init_2: enter\n"); /* Allocate the buffer used to transfer the USB data */ /* Check for max. format image size so buffer size can * be adjusted */ /* if (dev->CIF) dev->buffer_size = 352 * 288 * 3; if (dev->VGA) */ dev->buffer_size = (914 * 1024); /*644 * 484 * 3 VGA + 4 format, 914 * 1024 */ DBG (DBG_proc, "sipix_init_2: dev->bufffer_size = 0x%x\n", dev->buffer_size); dev->buffer = malloc (dev->buffer_size); if (dev->buffer == NULL) { free (dev); return NULL; } /* Allocate the output buffer * used for bayer conversion */ dev->output_size = dev->buffer_size; dev->output = malloc (dev->output_size); if (dev->output == NULL) { free (dev); return NULL; } DBG (DBG_proc, "sipix_init_2: exit\n"); return (dev); } /* Closes an open vidcams. */ static void sipix_close (Sipix_Vidcam * dev) { DBG (DBG_proc, "sipix_close: enter \n"); if (dev->fd != -1) { DBG (DBG_proc, "sipix_close: fd !=-1 \n"); sanei_usb_close (dev->fd); dev->fd = -1; } DBG (DBG_proc, "sipix_close: exit\n"); } /* Frees the memory used by a vidcam. */ static void sipix_free (Sipix_Vidcam * dev) { int i; DBG (DBG_proc, "sipix_free: enter\n"); if (dev == NULL) return; sipix_close (dev); if (dev->devicename) { free (dev->devicename); } if (dev->buffer) { free (dev->buffer); } if (dev->output) { free (dev->output); } if (dev->windoww) { free (dev->windoww); } if (dev->windowr) { free (dev->windowr); } 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, "sipix_free: exit\n"); } static SANE_Status sipix_set_config (Sipix_Vidcam * dev, int configuration, int interface, int alternate) { SANE_Status status; DBG (DBG_proc, "sipix_set_config: open\n"); status = sanei_usb_set_configuration (dev->fd, configuration); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "sipix_vidcam_init: SIPIX 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, "sipix_vidcam_init: SIPIX FAILED to claim interface\n"); return status; } status = sanei_usb_set_altinterface (dev->fd, alternate); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "sipix_vidcam_init: SIPIX FAILED to set alternate interface %d\n", alternate); return status; } DBG (DBG_proc, "sipix_vidcam_init: configuration=%d, interface=%d, alternate=%d\n", configuration, interface, alternate); DBG (DBG_proc, "sipix_set_config: exit\n"); return status; } /*---------------------------------------------------------*/ /* Reset vidcam */ static SANE_Status sipix_reset_vidcam (Sipix_Vidcam * dev) { SANE_Status status; size_t sizew; /* significant size of window */ size_t sizer; DBG (DBG_proc, "sipix_reset_vidcam: enter\n"); sizew = dev->windoww_size; sizer = dev->windowr_size; memset (dev->windoww, 0, sizew); memset (dev->windowr, 0, sizer); status = SANE_STATUS_GOOD; DBG (DBG_proc, "sipix_reset_vidcam: exit\n"); return status; } /* Inquiry a device and returns TRUE if is supported. */ static int sipix_identify_vidcam (Sipix_Vidcam * dev) { SANE_Status status; SANE_Word vendor; SANE_Word product; int i; size_t sizew; size_t sizer; DBG (DBG_info, "sipix_identify_vidcam: open\n"); sizew = dev->windoww_size; sizer = dev->windowr_size; memset (dev->windoww, 0, sizew); memset (dev->windowr, 0, sizer); 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) { DBG (DBG_info, "sipix_identify_vidcam: vidcam 0x%x:0x%x is in list\n", vendor, product); dev->hw = &(vidcams[i]); sizer = dev->windowr_size; memset (dev->windowr, 0, sizer); /* urb 4 configuration = 1, interface = 0, alternate = 0 */ status = sipix_set_config (dev, 1, 0, 1); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "sipix_set_config: SIPIX FAILED to set configure\n"); return status; } /* check reading ASIC ID ? */ sizer = 0x06; /* [264 ms] >>> URB 5: c0 18 03 00 00 00 06 00 data read 06 00 00 02 0a 18 * version of camera? */ status = sanei_usb_control_msg (dev->fd, 0xc0, 0x18, 0x03, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb5, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb16, data=15", dev->windowr, sizer); /* [264 ms] >>> URB get images nr.*/ /*sizer = 0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x08, 0x03, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb get images nr. \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb get images nr, data=15", dev->windowr, sizer); */ /* [264 ms] >>> URB get images nr. blocks disabled*/ /* status = sanei_usb_control_msg (dev->fd, 0xc0, 0x08, 0x03, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb get images nr. \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb get images nr, data=15", dev->windowr, sizer); */ /* [264 ms] >>> URB delete all images blocks, seems (not) to work*/ sizer = 0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x12, 0x03, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_identify_vidcam: urb delete all images \n"); } hexdump (DBG_proc, "sipix_identify_vidcam: urb delete all images, data=15", dev->windowr, sizer); DBG (DBG_proc, "sipix_identify_vidcam: exit vidcam supported\n"); return SANE_TRUE; } } DBG (DBG_error, "sipix_identify_vidcam: exit this is not a SIPIX exit\n"); return SANE_FALSE; } static SANE_Status sipix_vidcam_init (Sipix_Vidcam * dev) { SANE_Status status; size_t sizew; size_t sizer; DBG (DBG_proc, "sipix_vidcam_init: open\n"); sizew = dev->windoww_size; sizer = dev->windowr_size; memset (dev->windoww, 0, sizew); memset (dev->windowr, 0, sizer); dev->windoww[0] = 0x00; /* urb 6 configuration = 1, interface = 0, alternate = 1 */ status = sipix_set_config (dev, 1, 0, 1); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "sipix_set_config: SIPIX FAILED to set configure\n"); return status; } /* 00000000: urb 7 data=15 UrbLink : c0 1d 03 00 63 00 01 00 */ /*sizer= 0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x1d, 0x03, 0x63, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb7, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb7 data=15 ", dev->windowr, sizer); */ /* URB 8 data= 15 Ur: c0 17 03 00 3d 00 01 00 */ /* sizer=0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x17, 0x03, 0x3d, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb8, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb8 data=15", dev->windowr, sizer); */ /* URB 9 data= 15 Ur: c0 1b 03 00 ff 00 01 00 */ /* sizer=0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x1b, 0x03, 0xff, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb9, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb9 data=15", dev->windowr, sizer); */ /* URB 10 data= 15 Ur: c0 14 03 00 00 00 01 00 */ /* sizer=0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, dev->video_mode, 0x03, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb10, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb10 data=15", dev->windowr, sizer); */ /* URB 11 data= 15 Ur: c0 04 01 00 00 00 01 00 */ /* sizer=0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x04, 0x01, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb11, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb11 data=15", dev->windowr, sizer); usleep (400000); */ /* URB 12 data= 76 11 Ur: c0 07 00 00 00 00 02 00 */ /* sizer=0x02; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x07, 0x00, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb12, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb12 data = 76 11", dev->windowr, sizer); */ /* urb 13 configuration = 1, interface = 0, alternate = 0 */ /* status = sipix_set_config (dev, 1, 0, 0); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "sipix_set_config: SIPIX FAILED to set configure\n"); return status; } */ /* urb 14 configuration = 1, interface = 0, alternate = 1 */ /* status = sipix_set_config (dev, 1, 0, 1); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "sipix_set_config: SIPIX FAILED to set configure\n"); return status; } */ /* 00000000: urb 15 data=15 UrbLink : c0 1d 03 00 63 00 01 00 */ sizer= 0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x1d, 0x03, 0x63, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb15, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb15 data=15", dev->windowr, sizer); /* URB 16 data= 15 Ur: c0 17 03 00 3d 00 01 00 */ sizer=0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x17, 0x03, 0x3d, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb16, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb16, data=15", dev->windowr, sizer); /* URB 17 data= 15 Ur: c0 1b 03 00 ff 00 01 00 */ sizer=0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x1b, 0x03, 0xff, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb17, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb17, data=15", dev->windowr, sizer); /* URB 18 data= 15 Ur: c0 14 03 00 00 00 01 00 */ sizer=0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, dev->video_mode, 0x03, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb18, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb18, data=15", dev->windowr, sizer); usleep (1500); /* URB 19 data= 15 Ur: c0 04 01 00 00 00 01 00, for bulkmode?, 02 or 03 NOK*/ sizer=0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x04, 0x01, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb19, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb19, data=15", dev->windowr, sizer); usleep (1000); /* URB 20 data= 6e 11 Ur: c0 07 00 00 00 00 02 00 */ /* sizer=0x02; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x07, 0x00, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb20, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb20, data= 6e 11", dev->windowr, sizer); */ DBG (DBG_proc, "sipix_vidcam_init: exit, status=%d\n", status); return status; } /* Attach a vidcam to this backend. */ static SANE_Status attach_vidcam (SANE_String_Const devicename, Sipix_Vidcam ** devp) { Sipix_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 = sipix_init (); if (dev == NULL) { DBG (DBG_error, "sipix_init 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"); sipix_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 (sipix_identify_vidcam (dev) == SANE_FALSE) { DBG (DBG_error, "ERROR: attach_vidcam: vidcam-identification failed\n"); sipix_free (dev); return SANE_STATUS_INVAL; } /* Allocate a buffer memory. */ dev = sipix_init_2 (); if (dev == NULL) { DBG (DBG_error, "sipix_initi_2, ERROR: not enough memory\n"); return SANE_STATUS_NO_MEM; } sipix_close (dev); DBG (DBG_info, "attach_vidcam: opening USB device %s\n", devicename); /* 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"); sipix_free (dev); return SANE_STATUS_NO_MEM; } num_entries = 3; 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 sipix_init_options (Sipix_Vidcam * dev) { int i; DBG (DBG_proc, "sipix_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; } DBG (DBG_proc, "sipix_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; /* Vidcam 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 = dev->resolutions_list[1]; */ 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 = 0; /* 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; /* 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 = 00; /* 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 = 00; /* 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 = 00; /* to get middle value */ DBG (DBG_proc, "sipix_init_options: after blue level\n"); /* 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, "sipix_init_options: exit\n"); } /* Read the image from the vidcam and fill the temporary buffer with it. */ static SANE_Status sipix_fill_image (Sipix_Vidcam * dev) { SANE_Status status; size_t size; size_t sizer; int ep; int i=0; assert (dev->image_begin == dev->image_end); /* assert (dev->real_bytes_left > 0); */ DBG (DBG_proc, "sipix_fill_image: enter\n"); DBG (DBG_proc, "sipix_fill_image: real dev bytes left=0x%x \n", dev->real_bytes_left); /* urb 21 reset pipe */ /* ep =0x83; status = sanei_usb_clear_halt (dev->fd, ep); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "sipix_fill_image: clear halt ep\n"); return status; } DBG (DBG_proc, "sipix_fill_image: urb 21 usb_clear_halt ep %x\n", ep); */ /* urb 22 get frame number */ /* urb 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 35 iso blocks 31713 (0x20 * 1023) */ /* 00000000: urb 34 data=15 UrbLink : c0 13 00 00 00 00 01 00 */ /*sizer= 0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x13, 0x00, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb34, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb34 data=15", dev->windowr, sizer); */ do { /* URB 36 data= c0 12 Ur: c0 07 00 00 00 00 02 00 */ sizer=0x02; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x07, 0x00, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: urb36, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: urb36 data= ??size of jpeg frame if not 00 00", dev->windowr, sizer); usleep (35000); dev->real_bytes_left = (dev->windowr[0] << 8) + dev->windowr[1]; DBG (DBG_proc, "dev->real_bytes, size jpeg frame 0x%x, loopcount=%d\n", dev->real_bytes_left, i); i++; } while (dev->windowr[0] == 0x00); /* && dev->windowr[1] == 0x00); only for file sizes > 0xff */ /*dev->real_bytes_left= 0x1ffff; dev->bytes_left = 0x1ffff; */ ep = 0x83; usleep (6000); while (dev->real_bytes_left) { /* Try to read the maximum number of bytes. */ DBG (DBG_proc, "sipix_fill_image: real dev bytes left, while loop=0x%x \n", dev->real_bytes_left); /* size = dev->real_bytes_left; */ size = dev->real_bytes_left; if (size == 0) { /* Probably reached the end of the buffer. Check, just in case. */ assert (dev->image_end != 0); return (SANE_STATUS_GOOD); } /* Do the transfer */ DBG (DBG_proc, "sipix_fill_image: dev->real_bytes_left: 0x%x size: 0x%x\n", dev->real_bytes_left, size); /* urb 44 first read bulk */ status = sanei_usb_read_bulk_ep (dev->fd, ep, dev->buffer, &size); if (status != SANE_STATUS_GOOD) { return status; } DBG (DBG_info, "sipix_fill_image: size (read) = 0x%lx bytes\n", (long) size); memcpy (dev->image + dev->image_end, dev->buffer, size); sizer = 0x20; hexdump (DBG_proc, "sipix_vidcam_init: first 0x20 bytes frame", dev->buffer, sizer); dev->image_end += size; if (dev->real_bytes_left = size) { dev->real_bytes_left = 0; } else if (dev->real_bytes_left > size) { dev->real_bytes_left -= size; } else if (dev->real_bytes_left < size) dev->real_bytes_left = 0; DBG (DBG_info, "sipix_fill_image: real bytes left = 0x%x\n", dev->real_bytes_left); } /* dev->origGain = window[12]; maybe values of last image can be read?? */ DBG (DBG_proc, "sipix_fill_image: exit\n"); return (SANE_STATUS_GOOD); /* unreachable */ } /* Read the image from the vidcam and fill the temporary buffer with it. * this one is for testing the isochronous mode webcam * has to be edit to insert more iso stuff.*/ static SANE_Status sipix_fill_image_iso (Sipix_Vidcam * dev) { SANE_Status status; size_t size; size_t iso_size_read; size_t sizer; size_t sizew; assert (dev->image_begin == dev->image_end); assert (dev->real_bytes_left > 0); DBG (DBG_proc, "sipix_fill_image: enter\n"); DBG (DBG_proc, "sipix_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, "sipix_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; /* it seems size can not be smaller then read by iso */ } if (size == 0) { /* Probably reached the end of the buffer. Check, just in case. */ assert (dev->image_end != 0); return (SANE_STATUS_GOOD); } /* Do the transfer */ DBG (DBG_proc, "sipix_fill_image: dev->real_bytes_left: 0x%x size: 0x%x\n", dev->real_bytes_left, size); usleep (2000); /* urb 30 first read iso, not yet placed */ /* Capture Picture: control read 0x0e, 0x03, 0x00 -> buf[1] */ sizer= 0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x0e, 0x03, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: com 0x0e, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: com 0x0e data=15", dev->windowr, sizer); dev->windowr[0]= 0x00; do { /* control read 0x16, 0x03, 0x00 -> buf[1] */ sizer= 0x01; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x16, 0x03, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: com 0x16, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: com 0x16 data=15", dev->windowr, sizer); sleep(1); } while (dev->windowr[0] == 0x00); hexdump (DBG_proc, "sipix_vidcam_init: com 0x16 data=15", dev->windowr, sizer); /* Afterwards the image is in the camera memory. */ /* Get Memory: Prepare buffer as: buf[0..4] start (MSB first) buf[5..7] length (MSB first) */ /* control write 0x0a, 0x03, 0x00, buf[8] */ sizer= 0x08; status = sanei_usb_control_msg (dev->fd, 0xc0, 0x0a, 0x03, 0x00, sizer, dev->windowr); if (status != SANE_STATUS_GOOD) { DBG (DBG_proc, "sipix_vidcam_init: com 0x0a, Can't read \n"); } hexdump (DBG_proc, "sipix_vidcam_init: com 0x0a data=msb, lsb", dev->windowr, sizer); /* bulk read (length) */ status = sanei_usb_read_bulk (dev->fd, dev->buffer, &size); /* Gets the memory (imagedata) as specified. */ if (status != SANE_STATUS_GOOD) { return status; } DBG (DBG_info, "sipix_fill_image: size (read) = 0x%lx bytes (bpl=0x%lx)\n", (long) size, (long) dev->params.bytes_per_line); 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, "sipix_fill_image: real bytes left = 0x%x\n", dev->real_bytes_left); } DBG (DBG_proc, "sipix_fill_image: exit\n"); return (SANE_STATUS_GOOD); /* unreachable */ } /********************************************************************** * * The add_text routine and font_6x11.h file are taken from the (GPLed) * webcam.c file, part of xawtv, (c) 1998-2002 Gerd Knorr. * add_text was slightly modified for the pencam2 program. * sipix_add_text was taken from the pencam2 program and changed on * some points * *********************************************************************/ #define MSG_MAXLEN 45 #define CHAR_HEIGHT 11 #define CHAR_WIDTH 6 #define CHAR_START 4 static SANE_Status sipix_add_text (SANE_Byte * image, int width, int height, char *txt) { SANE_Status status; time_t t; struct tm *tm; char line[MSG_MAXLEN + 1]; SANE_Byte *ptr; int i, x, y, f, len; char fmtstring[25] = " %Y-%m-%d %H:%M:%S"; char fmttxt[46]; DBG (DBG_proc, "sipix_add_text: enter\n"); time (&t); tm = localtime (&t); if (strlen (txt) > (MSG_MAXLEN - 23)) strncpy (fmttxt, txt, (MSG_MAXLEN - 23)); else strcpy (fmttxt, txt); strcat (fmttxt, fmtstring); len = strftime (line, MSG_MAXLEN, fmttxt, tm); for (y = 0; y < CHAR_HEIGHT; y++) { ptr = image + 3 * width * (height - CHAR_HEIGHT - 2 + y) + 12; for (x = 0; x < len; x++) { f = fontdata[line[x] * CHAR_HEIGHT + y]; for (i = CHAR_WIDTH - 1; i >= 0; i--) { if (f & (CHAR_START << i)) { ptr[0] = 255; ptr[1] = 255; ptr[2] = 255; } ptr += 3; } /* for i */ } /* for x */ } /* for y */ DBG (DBG_proc, "sipix_add_text: exit vw=%d, vh=%d\n", width, height); status = (SANE_STATUS_GOOD); return status; } /* add_text end */ /* ************************** Video Decoding ********************* */ static SANE_Status sipix_bayer_unshuffle (Sipix_Vidcam * dev, SANE_Byte * buf, size_t * len) { SANE_Status status; size_t size; int x, y, z; unsigned int i = 0, j = 0, u = 0; int RED, GREEN, BLUE; unsigned int vw; unsigned int vh; int bright_red; int bright_green; int bright_blue; int count; RED = dev->red; GREEN = dev->green; BLUE = dev->blue; DBG (DBG_proc, "sipix_bayer_unshuffle: enter\n"); DBG (DBG_proc, "sipix_bayer_unshuffle: color read RED=%d, GREEN=%d, BLUE=%d\n", RED, GREEN, BLUE); vw = dev->vwidth; vh = dev->vheight; DBG (DBG_proc, "sipix_bayer_unshuffle: vw=%d, vh=%d, len=0x%x\n", vw, vh, (size_t) len); size = vw * vh * dev->bytes_pixel; ; if ((dev->scan_mode != SIPIX_COLOR_RGB) || (dev->scan_mode != SIPIX_COLOR)) { for (i = 0; i < size; i++) *(dev->output + i) = *(dev->image + i); DBG (DBG_proc, "sipix image ->output buf done\n"); } /* brightness adjustment */ count = vw * vh * dev->bytes_pixel; bright_red = (dev->val[OPT_BRIGHTNESS].w) + (dev->val[OPT_WHITE_LEVEL_R].w); bright_green = (dev->val[OPT_BRIGHTNESS].w) + (dev->val[OPT_WHITE_LEVEL_G].w); bright_blue = (dev->val[OPT_BRIGHTNESS].w) + (dev->val[OPT_WHITE_LEVEL_B].w); for (x = 0; x < count; x++) { y = x + 1; z = x + 2; if ((*(dev->output + x) + bright_red) >= 255) *(dev->output + x) = 255; else if ((*(dev->output + x) + bright_red) <= 0) *(dev->output + x) = 0; else *(dev->output + x) += bright_red; if ((*(dev->output + y) + bright_green) >= 255) *(dev->output + y) = 255; else if ((*(dev->output + y) + bright_green) <= 0) *(dev->output + y) = 0; else *(dev->output + y) += bright_green; if ((*(dev->output + z) + bright_blue) >= 255) *(dev->output + z) = 255; else if ((*(dev->output + z) + bright_blue) <= 0) *(dev->output + z) = 0; else *(dev->output + z) += bright_blue; x += 2; } DBG (DBG_proc, "sipix_bayer_unshuffle: brightness done\n"); /* insert add text routine */ /********************************************************************** * * The add_text routine and font_6x11.h file are taken from the (GPLed) * webcam.c file, part of xawtv, (c) 1998-2002 Gerd Knorr. * add_text was slightly modified for this program. * *********************************************************************/ if (dev->scan_mode == SIPIX_COLOR_RGB_TEXT) { strcpy (dev->picmsg_ps, "PixArt "); status = sipix_add_text (dev->output, vw, vh, dev->picmsg_ps); if (status != SANE_STATUS_GOOD) { DBG (DBG_info, "sipix_bayer_unshuffle status NOK\n"); return (status); } DBG (DBG_proc, "sipix_bayer_unshuffle: text added done\n"); } /* end of add text routine */ /* copy from output to buf, */ size = vw * vh * dev->bytes_pixel; memcpy (buf, dev->output, size); DBG (DBG_proc, "sipix_bayer_unshuffle: exit vw=%d, vh=%d\n", vw, vh); status = (SANE_STATUS_GOOD); return status; } /* end routines from the decoding image routine bayer_unshuffle *********/ /* Sane entry points */ SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) { FILE *fp; char line[PATH_MAX]; size_t len; int i; SANE_Word vendor; SANE_Word product; DBG_INIT (); DBG (DBG_proc, "sane_init: enter\n"); authorize = authorize; /* silence gcc */ DBG (DBG_error, "This is sane-sipix version %d.%d-%d\n", V_MAJOR, V_MINOR, BUILD); DBG (DBG_error, "(C) 2005 by Gerard Klaver\n"); if (version_code) { *version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, BUILD); } sanei_usb_init (); /* not ready yet, goal is to remove sipix.conf file with it for (i = 0; i < NELEMS (vidcams); i++) { if (vidcams[i].vendor == vendor && vidcams[i].product == product) { sprintf (line, "usb %i %i", vendor, product); sanei_usb_attach_matching_devices (line, attach_one); DBG (DBG_proc, "sane_init: vidcam 0x%x:0x%x is in list\n", vendor, product); } } */ fp = sanei_config_open (SIPIX_CONFIG_FILE); if (!fp) { /* No default vidcam? */ DBG (DBG_warning, "configuration file not found (%s)\n", SIPIX_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: exit\n"); return SANE_STATUS_GOOD; } SANE_Status sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) { Sipix_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) { Sipix_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; } sipix_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) { Sipix_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) { Sipix_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_BRIGHTNESS: 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_RESOLUTION: case OPT_BRIGHTNESS: 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; /* 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_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, COLOR_RAW_STR) == 0) dev->scan_mode = SIPIX_COLOR_RAW; else if (strcmp (dev->val[OPT_MODE].s, COLOR_RGB_STR) == 0) dev->scan_mode = SIPIX_COLOR_RGB; else if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0) dev->scan_mode = SIPIX_COLOR; else if (strcmp (dev->val[OPT_MODE].s, COLOR_RGB_TEXT_STR) == 0) dev->scan_mode = SIPIX_COLOR_RGB_TEXT; else if (strcmp (dev->val[OPT_MODE].s, COLOR_RGB_USB_ISO_STR) == 0) dev->scan_mode = SIPIX_COLOR_RGB_USB_ISO; /* The SIPIX supports only a handful of resolution. */ /* This the default resolution range for the SIPIX */ dev->depth = 8; 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 lowest. */ dev->val[OPT_RESOLUTION].w = dev->resolutions_list[1]; } 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) { Sipix_Vidcam *dev = handle; int i; DBG (DBG_proc, "sane_get_parameters: enter\n"); if (!(dev->scanning)) { dev->x_resolution = dev->val[OPT_RESOLUTION].w; /* Prepare the parameters for the caller. */ memset (&dev->params, 0, sizeof (SANE_Parameters)); dev->params.last_frame = SANE_TRUE; switch (dev->scan_mode) { case SIPIX_COLOR_RAW: dev->bytes_pixel = 2; break; case SIPIX_COLOR: case SIPIX_COLOR_RGB_TEXT: case SIPIX_COLOR_RGB_USB_ISO: dev->bytes_pixel = 3; break; case SIPIX_COLOR_RGB: dev->bytes_pixel = 3; break; } dev->params.format = SANE_FRAME_RGB; dev->params.pixels_per_line = dev->x_resolution; dev->params.bytes_per_line = dev->params.pixels_per_line * dev->bytes_pixel; dev->params.depth = 8; if (dev->resolutions_list != NULL) { /* This vidcam has a fixed number of supported * resolutions. Find the color sequence for that * resolution. */ for (i = 0; dev->hw->color_adjust[i].resolution_x != dev->x_resolution; i++); dev->red = dev->hw->color_adjust[i].z1_color_0; dev->green = dev->hw->color_adjust[i].z1_color_1; dev->blue = dev->hw->color_adjust[i].z1_color_2; dev->y_resolution = dev->hw->color_adjust[i].resolution_y; } dev->params.lines = dev->y_resolution; switch (dev->val[OPT_RESOLUTION].w) { case 160: /* not checked yet */ dev->video_mode = 0x14; /* needs subsampling ? */ dev->video_mode1 = 0x0b; dev->video_mode2 = 0x76; dev->video_mode3 = 0x02; break; case 320: /* not checked yet */ dev->video_mode = 0x14; dev->video_mode1 = 0x0b; dev->video_mode2 = 0x76; dev->video_mode3 = 0x02; break; case 640: /*not checked yet */ dev->video_mode = 0x15; dev->video_mode1 = 0x0b; dev->video_mode2 = 0x76; dev->video_mode3 = 0x02; break; } dev->params.pixels_per_line = dev->x_resolution; dev->params.lines = dev->y_resolution; dev->vwidth = dev->x_resolution; dev->vheight = dev->y_resolution; DBG (DBG_info, "sane_get_parameters: x=%d, y=%d\n", dev->x_resolution, 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) { Sipix_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 = sipix_vidcam_init (dev); if (status) { DBG (DBG_error, "ERROR: failed to init the vidcam\n"); sipix_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->real_bytes_left = dev->params.bytes_per_line * dev->params.lines; dev->bytes_left = dev->params.bytes_per_line * dev->params.lines; */ dev->real_bytes_left= 0x1ffff; dev->bytes_left = 0x1ffff; /* values for max jpeg size */ 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; Sipix_Vidcam *dev = handle; size_t size; DBG (DBG_proc, "sane_read: enter\n"); *len = 0; if (!(dev->scanning)) { /* OOPS, not scanning, stop a scan. */ sipix_reset_vidcam (dev); sipix_close (dev); dev->scanning = SANE_FALSE; return SANE_STATUS_CANCELLED; } if (dev->bytes_left <= 0) { return (SANE_STATUS_EOF); } if (dev->image_begin == dev->image_end) { if (dev->scan_mode != SIPIX_COLOR_RGB_USB_ISO) { /* Fill image, use bulk mode read */ status = sipix_fill_image (dev); if (status != SANE_STATUS_GOOD) { DBG (DBG_info, "sane_read: sipix_fill_image status NOK\n"); return (status); } } else { /* Fill image use isochronous mode (under development) */ status = sipix_fill_image_iso (dev); if (status != SANE_STATUS_GOOD) { DBG (DBG_info, "sane_read: sipix_fill_image_iso status NOK\n"); 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; } size = dev->bytes_left; if (((unsigned int) max_len) < size) { DBG (DBG_error, "sane_read: max_len < size\n"); return (SANE_FALSE); } if ((dev->image_end - dev->image_begin) > size) { size = dev->image_end - dev->image_begin; DBG (DBG_proc, "sane_read: size < dev->image_end - dev->image_begin\n"); } DBG (DBG_info, "sane_read: size =0x%x bytes, max_len=0x%x bytes\n", size, max_len); if (dev->scan_mode != SIPIX_COLOR_RAW) { /* dev->bytes_left -= size; */ *len = dev->bytes_left; /* needed */ dev->bytes_left = 0; /* needed for frontend or ? */ /* do bayer unshuffle after complete frame is read */ status = sipix_bayer_unshuffle (dev, buf, &size); if (status != SANE_STATUS_GOOD) { DBG (DBG_info, "sane_read: sipix_bayer_unshuffle status NOK\n"); return (status); } } else { /* Copy the raw data to the frontend buffer. */ *len = dev->bytes_left; /* needed */ size = dev->bytes_left; dev->bytes_left = 0; /* needed for frontend or? */ memcpy (buf, dev->image, size); /* *len = size; */ DBG (DBG_info, "sane_read: raw mode\n"); } DBG (DBG_info, "sane_read: exit\n"); 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) { Sipix_Vidcam *dev = handle; DBG (DBG_proc, "sane_cancel: enter\n"); /* Stop a scan. */ if (dev->scanning == SANE_TRUE) { /* Reset the vidcam */ sipix_reset_vidcam (dev); sipix_close (dev); } dev->scanning = SANE_FALSE; /* return SANE_STATUS_CANCELLED; */ DBG (DBG_proc, "sane_cancel: exit\n"); } void sane_close (SANE_Handle handle) { Sipix_Vidcam *dev = handle; Sipix_Vidcam *dev_tmp; DBG (DBG_proc, "sane_close: enter\n"); /* Stop a scan. */ if (dev->scanning == SANE_TRUE) { sipix_reset_vidcam (dev); sipix_close (dev); } dev->scanning = SANE_FALSE; /* 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; } } sipix_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"); }