/* sane - Scanner Access Now Easy.

   Copyright (C) 2005 Gerard Klaver  <gerard at gkall dot hobby dot nl>
   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: pac20x.c,v 1.01 2005/02/19 17:37:22 gekl-guest Exp $

   pac20x 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/02/19  update 23-02-2005 */
#define BACKEND_NAME pac20x
#define PAC20X_CONFIG_FILE "pac20x.conf" 

/* --------------------- SANE INTERNATIONALISATION ------------------------ */

/* must be first include */
#include "../include/sane/config.h"

#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#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 <time.h>
#include "font_6x11.h"
/*-----------------------*/

#include "pac20x.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 pac207_dpi_color_adjust[] = {

  /*dpi, y, x, color sequence R G or B */
  {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}
};

static const struct dpi_color_adjust pac20x_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 352

static const struct vidcam_hardware vidcams[] = {

  {0x093a, 0x2460, USB_CLASS_VENDOR_SPEC,
   "Q-TEC webcam 100 USB", "PAC207",
   pac207_dpi_color_adjust},

  {0x093a, 0x2468, USB_CLASS_VENDOR_SPEC,
   "PixArt", "PAC207BCA-32",
   pac207_dpi_color_adjust}
};

/* List of vidcams attached. */
static Pac20x_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 Pac20x_Vidcam *
pac20x_init (void)
{
  Pac20x_Vidcam *dev;

  DBG (DBG_proc, "pac20x_init: enter\n");

  /* Allocate a new vidcam entry. */
  dev = calloc (1, sizeof (Pac20x_Vidcam));
  if (dev == NULL)
    {
      return NULL;
    }
  memset (dev, 0, sizeof (Pac20x_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, "pac20x_init: exit\n");

  return (dev);
}

static Pac20x_Vidcam *
pac20x_init_2 (void)
{
  Pac20x_Vidcam *dev;

  DBG (DBG_proc, "pac20x_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, "pac20x_init_2: dev->bufffer = 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->header_length;

  dev->output = malloc (dev->output_size);
  if (dev->output == NULL)
    {
      free (dev);
      return NULL;
    }

  DBG (DBG_proc, "pac20x_init_2: exit\n");

  return (dev);
}

/* Closes an open vidcams. */
static void
pac20x_close (Pac20x_Vidcam * dev)
{
  DBG (DBG_proc, "pac20x_close: enter \n");

  if (dev->fd != -1)
    {

      DBG (DBG_proc, "pac20x_close: fd !=-1 \n");
      sanei_usb_close (dev->fd);
      dev->fd = -1;
    }

  DBG (DBG_proc, "pac20x_close: exit\n");
}

/* Frees the memory used by a vidcam. */
static void
pac20x_free (Pac20x_Vidcam * dev)
{
  int i;

  DBG (DBG_proc, "pac20x_free: enter\n");

  if (dev == NULL)
    return;

  pac20x_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, "pac20x_free: exit\n");
}

static SANE_Status
pac20x_set_config (Pac20x_Vidcam * dev, int configuration, int interface,
		    int alternate)
{
  SANE_Status status;
  DBG (DBG_proc, "pac20x_set_config: open\n");
  status = sanei_usb_set_configuration (dev->fd, configuration);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_error,
	   "pac20x_vidcam_init: PAC20X 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,
	   "pac20x_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,
	   "pac20x_vidcam_init: STV0680 FAILED to set alternate interface %d\n",
	   alternate);
      return status;
    }
  DBG (DBG_proc,
       "pac20x_vidcam_init: configuration=%d, interface=%d, alternate=%d\n",
       configuration, interface, alternate);

  DBG (DBG_proc, "pac20x_set_config: exit\n");
  return status;
}

/*---------------------------------------------------------*/
/* Reset vidcam */
static SANE_Status
pac20x_reset_vidcam (Pac20x_Vidcam * dev)
{
  SANE_Status status;
  size_t sizew;			/* significant size of window */
  size_t sizer;

  DBG (DBG_proc, "pac20x_reset_vidcam: enter\n");

      sizew = dev->windoww_size;
      sizer = dev->windowr_size;

      memset (dev->windoww, 0, sizew);
      memset (dev->windowr, 0, sizer);

      sizew = 0x00;

  status = SANE_STATUS_GOOD;
  DBG (DBG_proc, "pac20x_reset_vidcam: exit\n");

  return status;
}

/* Inquiry a device and returns TRUE if is supported. */
static int
pac20x_identify_vidcam (Pac20x_Vidcam * dev)
{
  SANE_Status status;
  SANE_Word vendor;
  SANE_Word product;
  int i;
  size_t sizer;

  DBG (DBG_info, "pac20x_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)
	{

	  DBG (DBG_info,
	       "pac20x_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);

	  /*  configuration = 1, interface = 0, alternate = 0 */
	  status = pac20x_set_config (dev, 1, 0, 0);
	  if (status != SANE_STATUS_GOOD)
	    {
	      DBG (DBG_error,
		   "pac20x_set_config: PAC20X FAILED to set configure\n");
	      return status;
	    }

	  DBG (DBG_proc,
	       "pac20x_identify_vicdam: urb xx CMDID_PING, check if PAC20X is present\n");

	  /*----------------------------
           * check with reading ASIC ID ? 
	   *                             */
	  /* Sensor detection is based on USB pid/vid */
	  if (product == 0x2460 || product == 0x2468 )
	    {
	      dev->sensortype = 0x0106;
	    }
	  DBG (DBG_info, "pac20x_identify_vidcam: sensor = 0x%x\n",
	       dev->sensortype);

	  dev->SupportedModes = dev->windowr[7];
	  i = dev->SupportedModes;
	  dev->QSIF = 0;
	  if (dev->sensortype == 0x0106)
	    dev->CIF = 1;	/* use dummy value for now */

	  dev->QCIF = 0;
	  dev->VGA = 0;
	  dev->QVGA = 0;

	  DBG (DBG_info, "pac20x_identify_vidcam: exit vidcam supported\n");
	  return SANE_TRUE;
	}
    }
  dev->framecount = 0;
  DBG (DBG_error,
       "pac20x_identify_vidcam: exit this is not a PAC20X exit\n");
  return SANE_FALSE;
}

static SANE_Status
pac20x_vidcam_init (Pac20x_Vidcam * dev)
{
  SANE_Status status;
  size_t sizew;
  
  DBG (DBG_proc, "pac20x_vidcam_init: open\n");

  dev->windoww[0] = 0x00;
  dev->windoww[1] = 0x00;
  dev->windoww[2] = 0x00;
  dev->windoww[3] = 0x00;
  dev->windoww[4] = 0x00;
  dev->windoww[5] = 0x00;
  dev->windoww[6] = 0x00;
  dev->windoww[7] = 0x00;

  sizew = 0x00;
/* [264 ms]  >>>  URB 6: 41 00 02 00 41 00 00 00  */
  status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x00, 0x02, 0x41, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb6, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb6", dev->windoww, sizew);

/*[267 ms]  >>>  URB 7: 41 00 00 00 0f 00 00 00  */
  
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x00, 0x00, 0x0f, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb7, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb7", dev->windoww, sizew);

/* [270 ms]  >>>  URB 8: 41 00 30 00 11 00 00 00 */
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x00, 0x30, 0x11, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb8, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb8", dev->windoww, sizew);

/* [273 ms]  >>>  URB 9 URB_FUNCTION_RESET_PIPE: [endpoint 0x00000083]  */
  
/* [276 ms]  >>>  URB 10 URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: [endpoint 0x00000083] */
  
/* [5670 ms]  >>>  URB 11 URB_FUNCTION_ABORT_PIPE:  [endpoint 0x00000083] */
  
/* [5673 ms]  <<<  URB 10  00000003 (USBD_TRANSFER_DIRECTION_IN, USBD_SHORT_TRANSFER_OK) */
  
/* [5673 ms]  <<<  URB 11  URB_FUNCTION_ABORT_PIPE: */
  
/* [5828 ms]  >>>  URB 12 going down  >>> Interface: Length            = 136 */
  
/*urb 12  configuration = 1, interface = 0, alternate = 8 */
/* [5923 ms]  <<<  URB 12 Interface: Length =136 InterfaceNumber=0 AlternateSetting=8 NumberOfPipes=6 */
  status = pac20x_set_config (dev, 1, 0, 8);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_error,
	   "pac20x_vidcam_init: PAC20X FAILED to set configure\n");
      return status;
    }

/* [5923 ms]  >>>  URB 13 URB_FUNCTION_RESET_PIPE: [endpoint 0x00000083] interrupt in */

  /* [5926 ms]  >>>  URB 14 0x00000083] TransferBufferLength = 00000002 interrupt in ????? */
  
/* [5930 ms]  >>>  URB 15: 03 12 0d 00 6f 03 29 00 : 41 01 00 00 02 00 08 00 */
  dev->windoww[0] = 0x03;
  dev->windoww[1] = 0x12;
  dev->windoww[2] = 0x0d;
  dev->windoww[3] = 0x00;
  dev->windoww[4] = 0x6f;
  dev->windoww[5] = 0x03;
  dev->windoww[6] = 0x29;
  dev->windoww[7] = 0x00;
sizew=0x08;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x01, 0x00, 0x02, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb15, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb15", dev->windoww, sizew);

/*[5934 ms]  >>>  URB 16: 00 96 80 a0 04 10 f0 30 : 41 01 00 00 0a 00 08 00 */
  dev->windoww[0] = 0x00;
  dev->windoww[1] = 0x96;
  dev->windoww[2] = 0x80;
  dev->windoww[3] = 0xa0;
  dev->windoww[4] = 0x04;
  dev->windoww[5] = 0x10;
  dev->windoww[6] = 0xf0;
  dev->windoww[7] = 0x30;
sizew=0x08;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x01, 0x00, 0x0a, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb16, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb16", dev->windoww, sizew);

/* [5938 ms]  >>>  URB 17: 00 00 00 70 a0 f8 00 00 : 41 01 00 00 12 00 08 00  */
  dev->windoww[0] = 0x00;
  dev->windoww[1] = 0x00;
  dev->windoww[2] = 0x00;
  dev->windoww[3] = 0x70;
  dev->windoww[4] = 0xa0;
  dev->windoww[5] = 0xf8;
  dev->windoww[6] = 0x00;
  dev->windoww[7] = 0x00;
sizew=0x08;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x01, 0x00, 0x12, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb17, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb17", dev->windoww, sizew);

/* [5942 ms]  >>>  URB 18  00 00 32 00 96 00 a2 02 : 41 01 00 00 40 00 08 00 */
  dev->windoww[0] = 0x00;
  dev->windoww[1] = 0x00;
  dev->windoww[2] = 0x32;
  dev->windoww[3] = 0x00;
  dev->windoww[4] = 0x96;
  dev->windoww[5] = 0x00;
  dev->windoww[6] = 0xa2;
  dev->windoww[7] = 0x02;
sizew=0x08;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x01, 0x00, 0x40, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb18, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb18", dev->windoww, sizew);

/* [5946 ms]  >>>  URB 19: 00 00 36 00             : 41 01 00 00 48 00 04 00  */
  dev->windoww[0] = 0x00;
  dev->windoww[1] = 0x00;
  dev->windoww[2] = 0x36;
  dev->windoww[3] = 0x00;
sizew=0x04;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x01, 0x00, 0x48, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb19, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb19", dev->windoww, sizew);

/* [5950 ms]  >>>  URB 20:                         : 41 00 01 00 13 00 00 00 */
sizew=0x00;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x00, 0x01, 0x13, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb20, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb20", dev->windoww, sizew);

/* [5953 ms]  >>>  URB 21:                         : 41 00 01 00 1c 00 00 00  */
sizew=0x00;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x00, 0x01, 0x1c, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb21, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb21", dev->windoww, sizew);


/* [5956 ms]  >>>  URB 22:                         : 41 00 00 00 41 00 00 00  */
sizew=0x00;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x00, 0x00, 0x41, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb22, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb22", dev->windoww, sizew);

/* [5961 ms]  >>>  URB 23: 04 12 05 0b 76 02 29    : 41 01 00 00 02 00 07 00 */
  dev->windoww[0] = 0x04;
  dev->windoww[1] = 0x12;
  dev->windoww[2] = 0x05;
  dev->windoww[3] = dev->video_mode1;
  dev->windoww[4] = dev->video_mode2;
  dev->windoww[5] = dev->video_mode3;
  dev->windoww[6] = 0x29;
sizew=0x07;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x01, 0x00, 0x02, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb23, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb23", dev->windoww, sizew);

/* [5965 ms]  >>>  URB 24:                         : 41 00 0a 00 0e 00 00 00 */
sizew=0x00;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x00, 0x0a, 0x0e, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb24, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb24", dev->windoww, sizew);


/* [5968 ms]  >>>  URB 25:                         : 41 00 00 00 18 00 00 00 */
sizew=0x00;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x00, 0x00, 0x18, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb25, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb25", dev->windoww, sizew);

/* [5971 ms]  >>>  URB 26: 64 00 7d 00 93 02 96 00 : 41 01 00 00 42 00 08 00 */
  dev->windoww[0] = 0x64;
  dev->windoww[1] = 0x00;
  dev->windoww[2] = 0x7d;
  dev->windoww[3] = 0x00;
  dev->windoww[4] = 0x93;
  dev->windoww[5] = 0x02;
  dev->windoww[6] = 0x96;
  dev->windoww[7] = 0x00;

sizew=0x08;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x01, 0x00, 0x42, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb26, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb26", dev->windoww, sizew);

/*[5980 ms]  >>>  URB 27:                         : 41 00 48 00 4a 00 00 00 */
sizew=0x00;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x00, 0x48, 0x4a, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb27, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb27", dev->windoww, sizew);

/*[5983 ms]  >>>  URB 28:                         : 41 00 01 00 13 00 00 00 */
sizew=0x00;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x00, 0x01, 0x13, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb28, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb28", dev->windoww, sizew);

/* [5986 ms]  >>>  URB 29:                         : 41 00 01 00 1c 00 00 00 */
sizew=0x00;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x00, 0x01, 0x1c, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb29, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb29", dev->windoww, sizew);

/* [5998 ms]  >>>  URB 30:                         : 41 00 01 00 40 00 00 00 */
sizew=0x00;
status =
    sanei_usb_control_msg (dev->fd, 0x41, 0x00, 0x01, 0x40, sizew, dev->windoww);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (DBG_proc, "pac20x_vidcam_init: urb30, Can't write \n");
    }
  hexdump (DBG_proc, "pac20x_vidcam_init: urb30", dev->windoww, sizew);

/* [6001 ms]  >>>  URB 31 URB_FUNCTION_RESET_PIPE: endpoint 0x00000085]  */
/* [6001 ms]  >>>  URB 32 URB_FUNCTION_ISOCH_TRANSFER: [endpoint 0x00000085] */
  
  DBG (DBG_proc, "pac20x_vidcam_init: exit, status=%d\n", status);
  return status;
}

/* Attach a vidcam to this backend. */
static SANE_Status
attach_vidcam (SANE_String_Const devicename, Pac20x_Vidcam ** devp)
{
  Pac20x_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 = pac20x_init ();
  if (dev == NULL)
    {
      DBG (DBG_error, "pac20x_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");
      pac20x_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 (pac20x_identify_vidcam (dev) == SANE_FALSE)
    {
      DBG (DBG_error, "ERROR: attach_vidcam: vidcam-identification failed\n");
      pac20x_free (dev);
      return SANE_STATUS_INVAL;
    }

  /* Allocate a buffer memory. */
  dev = pac20x_init_2 ();
  if (dev == NULL)
    {
      DBG (DBG_error, "pac20x_initi_2, ERROR: not enough memory\n");
      return SANE_STATUS_NO_MEM;
    }

  pac20x_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");
	  pac20x_free (dev);
	  return SANE_STATUS_NO_MEM;
	}
      /* for CIF or VGA sensor different resolutions ? */
      if (dev->CIF)
	num_entries = 4;
      if (dev->VGA)
	num_entries = 4;
      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
pac20x_init_options (Pac20x_Vidcam * dev)
{
  int i;

  DBG (DBG_proc, "pac20x_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,
       "pac20x_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, "pac20x_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, "pac20x_init_options: exit\n");
}

/* Read the image from the vidcam and fill the temporary buffer with it. */
static SANE_Status
pac20x_fill_image (Pac20x_Vidcam * dev)
{
  SANE_Status status;
  size_t size;
  size_t bulk_size_read;

  assert (dev->image_begin == dev->image_end);
  assert (dev->real_bytes_left > 0);

  DBG (DBG_proc, "pac20x_fill_image: enter\n");

  DBG (DBG_proc, "pac20x_fill_image: real dev bytes left=0x%x \n",
       dev->real_bytes_left);
  bulk_size_read = dev->real_bytes_left;

  while (dev->real_bytes_left)
    {
      /* Try to read the maximum number of bytes. */
      DBG (DBG_proc,
	   "pac20x_fill_image: real dev bytes left, while loop=0x%x \n",
	   dev->real_bytes_left);

      size = dev->real_bytes_left;
      if (size < bulk_size_read)
	{
	  size = bulk_size_read;	/* it seems size can not be smaller then read by bulk */
	}
      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,
	   "pac20x_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 (dev->fd, dev->buffer, &size);

      if (status != SANE_STATUS_GOOD)
	{
	  return status;
	}

      DBG (DBG_info,
	   "pac20x_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;
      bulk_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, "pac20x_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, "pac20x_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
pac20x_fill_image_iso (Pac20x_Vidcam * dev)
{
  SANE_Status status;
  size_t size;
  size_t iso_size_read;

  assert (dev->image_begin == dev->image_end);
  assert (dev->real_bytes_left > 0);

  DBG (DBG_proc, "pac20x_fill_image: enter\n");

  DBG (DBG_proc, "pac20x_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,
	   "pac20x_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,
	   "pac20x_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 */

      status = sanei_usb_read_bulk (dev->fd, dev->buffer, &size);

      if (status != SANE_STATUS_GOOD)
	{
	  return status;
	}

      DBG (DBG_info,
	   "pac20x_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, "pac20x_fill_image: real bytes left = 0x%x\n",
	   dev->real_bytes_left);
    }

  DBG (DBG_proc, "pac20x_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.
* pac20x_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
pac20x_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, "pac20x_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, "pac20x_add_text: exit vw=%d, vh=%d\n", width, height);
  status = (SANE_STATUS_GOOD);
  return status;
}				/*  add_text end */

/* **************************  Video Decoding  *********************  */
static SANE_Status
pac20x_bayer_unshuffle (Pac20x_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, "pac20x_bayer_unshuffle: enter\n");

  DBG (DBG_proc,
       "pac20x_bayer_unshuffle: color read RED=%d, GREEN=%d, BLUE=%d\n", RED,
       GREEN, BLUE);
  vw = dev->vwidth;
  vh = dev->vheight;

  DBG (DBG_proc, "pac20x_bayer_unshuffle: vw=%d, vh=%d, len=0x%x\n",
       vw, vh, (size_t) len);

  /* memset (dev->output, 0, 3 * vw * vh);       clear output matrix. */

/*-------------------------------------------------------------------
 * Image data format is a raw RGB bayer pattern.
 * BGBGBG...
 * GRGRGR...
 * header seems 0x12 bytes */
  
  size = vw * vh * dev->bytes_pixel + dev->header_length;
  for (i = 0; i < size; i++)
    *(dev->image + i) = *(dev->image + i + 0x12 + 0x28);

  DBG (DBG_proc, "pac20x_bayer_unshuffle: remove header done\n");

 if ((dev->scan_mode == PAC20X_COLOR_RGB) || (dev->scan_mode == PAC20X_COLOR))
    {
      size = (vw * vh);
      for (i = 0; i < size; i++)
	{
	  if ((i / vw) % 2 == 0)
	    {
	      if ((i % 2) == 0)
		{
		  /* B */
		  if ((i > vw) && ((i % vw) > 0))
		    {
		      *(dev->output++) = (*(dev->image - vw - 1) + *(dev->image - vw + 1) + *(dev->image + vw - 1) + *(dev->image + vw + 1)) / 4;	/* R */
		      *(dev->output++) = (*(dev->image - 1) + *(dev->image + 1) + *(dev->image + vw) + *(dev->image - vw)) / 4;	/* G */
		      *(dev->output++) = *(dev->image);	/* B */
		    }
		  else
		    {
		      /* first line or left column */
		      *(dev->output++) = *(dev->image + vw + 1);	/* R */
		      *(dev->output++) = (*(dev->image + 1) + *(dev->image + vw)) / 2;	/* G */
		      *(dev->output++) = *dev->image;	/* B */
		    }
		}
	      else
		{
		  /* (B)G */
		  if ((i > vw) && ((i % vw) < (vw - 1)))
		    {
		      *(dev->output++) = (*(dev->image + vw) + *(dev->image - vw)) / 2;	/* R */
		      *(dev->output++) = *dev->image;	/* G */
		      *(dev->output++) = (*(dev->image - 1) + *(dev->image + 1)) / 2;	/* B */
		    }
		  else
		    {
		      /* first line or right column */
		      *(dev->output++) = *(dev->image + vw);	/* R */
		      *(dev->output++) = *dev->image;	/* G */
		      *(dev->output++) = *(dev->image - 1);	/* B */
		    }
		}
	    }
	  else
	    {
	      if ((i % 2) == 0)
		{
		  /* G(R) */
		  if ((i < (vw * (vh - 1))) && ((i % vw) > 0))
		    {
		      *(dev->output++) = (*(dev->image - 1) + *(dev->image + 1)) / 2;	/* R */
		      *(dev->output++) = *dev->image;	/* G */
		      *(dev->output++) = (*(dev->image + vw) + *(dev->image - vw)) / 2;	/* B */
		    }
		  else
		    {
		      /* bottom line or left column */
		      *(dev->output++) = *(dev->image + 1);	/* R */
		      *(dev->output++) = *dev->image;	/* G */
		      *(dev->output++) = *(dev->image - vw);	/* B */
		    }
		}
	      else
		{
		  /* R */
		  if (i < (vw * (vh - 1)) && ((i % vw) < (vw - 1)))
		    {
		      *(dev->output++) = *dev->image;	/* R */
		      *(dev->output++) = (*(dev->image - 1) + *(dev->image + 1) + *(dev->image - vw) + *(dev->image + vw)) / 4;	/* G */
		      *(dev->output++) = (*(dev->image - vw - 1) + *(dev->image - vw + 1) + *(dev->image + vw - 1) + *(dev->image + vw + 1)) / 4;	/* B */
		    }
		  else
		    {
		      /* bottom line or right column */
		      *(dev->output++) = *dev->image;	/* R */
		      *(dev->output++) = (*(dev->image - 1) + *(dev->image - vw)) / 2;	/* G */
		      *(dev->output++) = *(dev->image - vw - 1);	/* B */
		    }
		}
	    }
	  dev->image++;
	}

      DBG (DBG_proc, "pac20x_bayer_unshuffle: RGB swap pac20x done\n");
    }
 
 size = vw * vh * dev->bytes_pixel;
	 ;
 if ((dev->scan_mode != PAC20X_COLOR_RGB) || (dev->scan_mode != PAC20X_COLOR))
 {
	 for (i = 0; i < size; i++)
           *(dev->output + i) = *(dev->image + i);
	 
	 DBG (DBG_proc, "pac20x 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, "pac20x_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 == PAC20X_COLOR_RGB_TEXT)
    {

      strcpy (dev->picmsg_ps, "PixArt ");

      status = pac20x_add_text (dev->output, vw, vh, dev->picmsg_ps);
      if (status != SANE_STATUS_GOOD)
	{
	  DBG (DBG_info, "pac20x_bayer_unshuffle status NOK\n");
	  return (status);
	}
      DBG (DBG_proc, "pac20x_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, "pac20x_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-pac20x 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 pac20x.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 (PAC20X_CONFIG_FILE);
  if (!fp)
    { 
      /* No default vidcam? */
      DBG (DBG_warning, "configuration file not found (%s)\n",
	   PAC20X_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)
{
  Pac20x_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)
{
  Pac20x_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;
    }

  pac20x_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)
{
  Pac20x_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)
{
  Pac20x_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 = PAC20X_COLOR_RAW;
	  else if (strcmp (dev->val[OPT_MODE].s, COLOR_RGB_STR) == 0)
	    dev->scan_mode = PAC20X_COLOR_RGB;
	  else if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR)
		   == 0)
	    dev->scan_mode = PAC20X_COLOR;
	  else if (strcmp (dev->val[OPT_MODE].s, COLOR_RGB_TEXT_STR) == 0)
	    dev->scan_mode = PAC20X_COLOR_RGB_TEXT;
	  else if (strcmp (dev->val[OPT_MODE].s, COLOR_RGB_USB_ISO_STR) == 0)
	    dev->scan_mode = PAC20X_COLOR_RGB_USB_ISO;

	  /* The PAC20X supports only a handful of resolution. */
	  /* This the default resolution range for the PAC20X */

	  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)
{
  Pac20x_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 PAC20X_COLOR_RAW:
	case PAC20X_COLOR:
	case PAC20X_COLOR_RGB_TEXT:
	case PAC20X_COLOR_RGB_USB_ISO:
	  dev->bytes_pixel = 3;
	  break;
	case PAC20X_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 176:
	  dev->video_mode = 0x0200;
          dev->video_mode1 = 0x0b;
          dev->video_mode2 = 0x76;
          dev->video_mode3 = 0x02;
	  break;
	case 160:  /* not checked yet */
	  dev->video_mode = 0x0300;
          dev->video_mode1 = 0x0b;
          dev->video_mode2 = 0x76;
          dev->video_mode3 = 0x02;
	  break;
	case 320: /* not checked yet */
	  dev->video_mode = 0x0300;
          dev->video_mode1 = 0x0b;
          dev->video_mode2 = 0x76;
          dev->video_mode3 = 0x02;
	  break;
	case 352:
	  dev->video_mode = 0x0000;
	  dev->video_mode1 = 0x22;
          dev->video_mode2 = 0x80;
          dev->video_mode3 = 0x00;
	  break;
	case 640:  /*not checked yet */
	  dev->video_mode = 0x0100;
          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)
{
  Pac20x_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 = pac20x_vidcam_init (dev);
      if (status)
	{
	  DBG (DBG_error, "ERROR: failed to init the vidcam\n");
	  pac20x_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->header_length = 0x40;  /* fixed on lengt of bulk read block of 0x40 */
  dev->real_bytes_left =
    dev->params.bytes_per_line * dev->params.lines + dev->header_length;
  dev->bytes_left =
    dev->params.bytes_per_line * dev->params.lines + dev->header_length;

  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;
  Pac20x_Vidcam *dev = handle;
  size_t size;

  DBG (DBG_proc, "sane_read: enter\n");

  *len = 0;

  if (!(dev->scanning))
    {
      /* OOPS, not scanning, stop a scan. */
      pac20x_reset_vidcam (dev);
      pac20x_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 != PAC20X_COLOR_RGB_USB_ISO)
	{
	  /* Fill image, use bulk mode read */
	  status = pac20x_fill_image (dev);
	  if (status != SANE_STATUS_GOOD)
	    {
	      DBG (DBG_info, "sane_read: pac20x_fill_image status NOK\n");
	      return (status);
	    }
	}
      else
	{
	  /* Fill image use isochronous mode (under development) */
	  status = pac20x_fill_image_iso (dev);
	  if (status != SANE_STATUS_GOOD)
	    {
	      DBG (DBG_info,
		   "sane_read: pac20x_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 != PAC20X_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 = pac20x_bayer_unshuffle (dev, buf, &size);
      if (status != SANE_STATUS_GOOD)
	{
	  DBG (DBG_info, "sane_read: pac20x_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)
{
  Pac20x_Vidcam *dev = handle;

  DBG (DBG_proc, "sane_cancel: enter\n");

  /* Stop a scan. */
  if (dev->scanning == SANE_TRUE)
    {
      /* Reset the vidcam */
      pac20x_reset_vidcam (dev);
      pac20x_close (dev);
    }
  dev->scanning = SANE_FALSE;

  /* return SANE_STATUS_CANCELLED; */
  DBG (DBG_proc, "sane_cancel: exit\n");
}

void
sane_close (SANE_Handle handle)
{
  Pac20x_Vidcam *dev = handle;
  Pac20x_Vidcam *dev_tmp;

  DBG (DBG_proc, "sane_close: enter\n");

/* Stop a scan. */

  if (dev->scanning == SANE_TRUE)
    {
      pac20x_reset_vidcam (dev);
      pac20x_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;
	}
    }

  pac20x_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");
}