New upstream version 1.0.31upstream/1.0.31

1 files changed, 77 insertions, 58 deletions

diff --git a/backend/pixma/pixma_mp800.c b/backend/pixma/pixma_mp800.c
index feef611..905c246 100644
--- a/backend/pixma/pixma_mp800.c
+++ b/backend/pixma/pixma_mp800.c
@@ -1,6 +1,6 @@
 /* SANE - Scanner Access Now Easy.
 
- Copyright (C) 2011-2019 Rolf Bensch <rolf at bensch hyphen online dot de>
+ Copyright (C) 2011-2020 Rolf Bensch <rolf at bensch hyphen online dot de>
  Copyright (C) 2007-2009 Nicolas Martin, <nicols-guest at alioth dot debian dot org>
  Copyright (C) 2006-2007 Wittawat Yamwong <wittawat@web.de>
 
@@ -91,7 +91,6 @@
  4096 = size of gamma table. 24 = header + checksum */
 #define IMAGE_BLOCK_SIZE (512*1024)
 #define CMDBUF_SIZE (4096 + 24)
-#define DEFAULT_GAMMA 2.0	/***** Gamma different from 1.0 is potentially impacting color profile generation *****/
 #define UNKNOWN_PID 0xffff
 
 #define CANON_VID 0x04a9
@@ -153,8 +152,6 @@
 <ivec:param_set servicetype=\"scan\"><ivec:jobID>00000001</ivec:jobID>\
 </ivec:param_set></ivec:contents></cmd>"
 
-#define XML_OK   "<ivec:response>OK</ivec:response>"
-
 enum mp810_state_t
 {
   state_idle,
@@ -294,7 +291,7 @@ static int send_xml_dialog (pixma_t * s, const char * xml_message)
   PDBG(pixma_dbg (10, "XML message sent to scanner:\n%s\n", xml_message));
   PDBG(pixma_dbg (10, "XML response back from scanner:\n%s\n", mp->cb.buf));
 
-  return (strcasestr ((const char *) mp->cb.buf, XML_OK) != NULL);
+  return pixma_parse_xml_response((const char*)mp->cb.buf) == PIXMA_STATUS_OK;
 }
 
 static void new_cmd_tpu_msg (pixma_t *s, pixma_cmdbuf_t * cb, uint16_t cmd)
@@ -438,44 +435,47 @@ static int send_gamma_table (pixma_t * s)
   const uint8_t *lut = s->param->gamma_table;
   uint8_t *data;
 
-  if (mp->generation == 1)
+  if (s->cfg->cap & PIXMA_CAP_GT_4096)
   {
     data = pixma_newcmd (&mp->cb, cmd_gamma, 4096 + 8, 0);
     data[0] = (s->param->channels == 3) ? 0x10 : 0x01;
     pixma_set_be16 (0x1004, data + 2);
     if (lut)
-      memcpy (data + 4, lut, 4096);
-    else
-      pixma_fill_gamma_table (DEFAULT_GAMMA, data + 4, 4096);
-  }
-  else
-  {
-    /* FIXME: Gamma table for 2nd generation: 1024 * uint16_le */
-    data = pixma_newcmd (&mp->cb, cmd_gamma, 2048 + 8, 0);
-    data[0] = 0x10;
-    pixma_set_be16 (0x0804, data + 2);
-    if (lut)
-    {
-      int i;
-      for (i = 0; i < 1024; i++)
       {
-        int j = (i << 2) + (i >> 8);
-        data[4 + 2 * i + 0] = lut[j];
-        data[4 + 2 * i + 1] = lut[j];
+        /* PDBG (pixma_dbg (4, "*send_gamma_table***** Use 4096 bytes from LUT ***** \n")); */
+        /* PDBG (pixma_hexdump (4, lut, 4096)); */
+        memcpy (data + 4, lut, 4096);
       }
-    }
     else
-    {
-      int i;
-      pixma_fill_gamma_table (DEFAULT_GAMMA, data + 4, 2048);
-      for (i = 0; i < 1024; i++)
       {
-        int j = (i << 1) + (i >> 9);
-        data[4 + 2 * i + 0] = data[4 + j];
-        data[4 + 2 * i + 1] = data[4 + j];
+        /* fallback: we should never see this */
+        PDBG (pixma_dbg (4, "*send_gamma_table***** Generate 4096 bytes Table with %f ***** \n",
+                         s->param->gamma));
+        pixma_fill_gamma_table (s->param->gamma, data + 4, 4096);
+        /* PDBG (pixma_hexdump (4, data + 4, 4096)); */
       }
-    }
   }
+  else
+  {
+      /* Gamma table for 2nd+ generation: 1024 * uint16_le */
+      data = pixma_newcmd (&mp->cb, cmd_gamma, 1024 * 2 + 8, 0);
+      data[0] = 0x10;
+      pixma_set_be16 (0x0804, data + 2);
+      if (lut)
+        {
+          /* PDBG (pixma_dbg (4, "*send_gamma_table***** Use 1024 * 2 bytes from LUT ***** \n")); */
+          /* PDBG (pixma_hexdump (4, lut, 1024 * 2)); */
+          memcpy (data + 4, lut, 1024 * 2);
+        }
+      else
+        {
+          /* fallback: we should never see this */
+          PDBG (pixma_dbg (4, "*send_gamma_table***** Generate 1024 * 2 bytes Table with %f ***** \n",
+                           s->param->gamma));
+          pixma_fill_gamma_table (s->param->gamma, data + 4, 1024);
+          /* PDBG (pixma_hexdump (4, data + 4, 1024 * 2)); */
+        }
+    }
   return pixma_exec (s, &mp->cb);
 }
 
@@ -1172,9 +1172,17 @@ static int handle_interrupt (pixma_t * s, int timeout)
    * target = format; original = size; scan-resolution = dpi */
   {
     if (buf[7] & 1)
-      s->events = PIXMA_EV_BUTTON1 | buf[11] | buf[10]<<8 | buf[12]<<16;    /* color scan */
+    {
+      /* color scan */
+      s->events = PIXMA_EV_BUTTON1 | (buf[11] & 0x0f) | (buf[10] & 0x0f) << 8
+                  | (buf[12] & 0x0f) << 16;
+    }
     if (buf[7] & 2)
-      s->events = PIXMA_EV_BUTTON2 | buf[11] | buf[10]<<8 | buf[12]<<16;    /* b/w scan */
+    {
+      /* b/w scan */
+      s->events = PIXMA_EV_BUTTON2 | (buf[11] & 0x0f) | (buf[10] & 0x0f) << 8
+                  | (buf[12] & 0x0f) << 16;
+    }
   }
   else if (s->cfg->pid == CS8800F_PID
             || s->cfg->pid == CS9000F_PID
@@ -1185,9 +1193,15 @@ static int handle_interrupt (pixma_t * s, int timeout)
   {
     if ((s->cfg->pid == CS8800F_PID && buf[1] == 0x70)
         || (s->cfg->pid != CS8800F_PID && buf[1] == 0x50))
-      s->events = PIXMA_EV_BUTTON2 | buf[1] >> 4;  /* button 2 = cancel / end scan */
+    {
+      /* button 2 = cancel / end scan */
+      s->events = PIXMA_EV_BUTTON2 | buf[1] >> 4;
+    }
     else
-      s->events = PIXMA_EV_BUTTON1 | buf[1] >> 4;  /* button 1 = start scan */
+    {
+      /* button 1 = start scan */
+      s->events = PIXMA_EV_BUTTON1 | buf[1] >> 4;
+    }
   }
   else
   /* button no. in buf[0]
@@ -1204,9 +1218,15 @@ static int handle_interrupt (pixma_t * s, int timeout)
       query_status (s);
 
     if (buf[0] & 2)
-      s->events = PIXMA_EV_BUTTON2 | buf[1] | ((buf[0] & 0xf0) << 4); /* b/w scan */
+    {
+      /* b/w scan */
+      s->events = PIXMA_EV_BUTTON2 | (buf[1] & 0x0f) | (buf[0] & 0xf0) << 4;
+    }
     if (buf[0] & 1)
-      s->events = PIXMA_EV_BUTTON1 | buf[1] | ((buf[0] & 0xf0) << 4); /* color scan */
+    {
+      /* color scan */
+      s->events = PIXMA_EV_BUTTON1 | (buf[1] & 0x0f) | (buf[0] & 0xf0) << 4;
+    }
   }
   return 1;
 }
@@ -1871,8 +1891,8 @@ static int mp810_check_param (pixma_t * s, pixma_scan_param_t * sp)
   mp810_t *mp = (mp810_t *) s->subdriver;
   unsigned w_max;
 
-  /* PDBG (pixma_dbg (4, "*mp810_check_param***** Initially: channels=%u, depth=%u, x=%u, y=%u, w=%u, h=%u, xs=%u, wx=%u *****\n",
-                   sp->channels, sp->depth, sp->x, sp->y, sp->w, sp->h, sp->xs, sp->wx)); */
+  /* PDBG (pixma_dbg (4, "*mp810_check_param***** Initially: channels=%u, depth=%u, x=%u, y=%u, w=%u, h=%u, xs=%u, wx=%u, gamma=%f *****\n",
+                   sp->channels, sp->depth, sp->x, sp->y, sp->w, sp->h, sp->xs, sp->wx, sp->gamma)); */
 
   sp->channels = 3;
   sp->software_lineart = 0;
@@ -2066,9 +2086,7 @@ static int mp810_check_param (pixma_t * s, pixma_scan_param_t * sp)
       k = MAX (sp->xdpi, 300) / sp->xdpi;
     else if (sp->source == PIXMA_SOURCE_TPU
               || sp->mode == PIXMA_SCAN_MODE_COLOR_48 || sp->mode == PIXMA_SCAN_MODE_GRAY_16)
-      /* TPU mode and 16 bit flatbed scans
-       * TODO: either the frontend (xsane) cannot handle 48 bit flatbed scans @ 75 dpi (prescan)
-       *       or there is a bug in this subdriver */
+      /* TPU mode and 16 bit flatbed scans */
       k = MAX (sp->xdpi, 150) / sp->xdpi;
     else
       /* default */
@@ -2375,13 +2393,14 @@ static const pixma_scan_ops_t pixma_mp800_ops =
   mp810_get_status
 };
 
-#define DEVICE(name, model, pid, dpi, adftpu_min_dpi, adftpu_max_dpi, tpuir_min_dpi, tpuir_max_dpi, w, h, cap) { \
+#define DEVICE(name, model, pid, min_dpi_16, dpi, adftpu_min_dpi, adftpu_max_dpi, tpuir_min_dpi, tpuir_max_dpi, w, h, cap) { \
         name,              /* name */               \
         model,             /* model */              \
         CANON_VID, pid,    /* vid pid */            \
         0,                 /* iface */              \
         &pixma_mp800_ops,  /* ops */                \
         0,                 /* min_xdpi not used in this subdriver */ \
+        min_dpi_16,        /* min_xdpi_16 */        \
         dpi, 2*(dpi),      /* xdpi, ydpi */         \
         adftpu_min_dpi, adftpu_max_dpi,  /* adftpu_min_dpi, adftpu_max_dpi */ \
         tpuir_min_dpi, tpuir_max_dpi,    /* tpuir_min_dpi, tpuir_max_dpi */   \
@@ -2393,42 +2412,42 @@ static const pixma_scan_ops_t pixma_mp800_ops =
         PIXMA_CAP_GAMMA_TABLE|PIXMA_CAP_EVENTS|cap  \
 }
 
-#define END_OF_DEVICE_LIST DEVICE(NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+#define END_OF_DEVICE_LIST DEVICE(NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 
 const pixma_config_t pixma_mp800_devices[] =
 {
   /* Generation 1: CCD */
-  DEVICE ("Canon PIXMA MP800", "MP800", MP800_PID, 2400, 150, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
-  DEVICE ("Canon PIXMA MP800R", "MP800R", MP800R_PID, 2400, 150, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
-  DEVICE ("Canon PIXMA MP830", "MP830", MP830_PID, 2400, 150, 0, 0, 0, 638, 877, PIXMA_CAP_ADFDUP),
+  DEVICE ("Canon PIXMA MP800", "MP800", MP800_PID, 0, 2400, 150, 0, 0, 0, 638, 877, PIXMA_CAP_TPU | PIXMA_CAP_GT_4096),
+  DEVICE ("Canon PIXMA MP800R", "MP800R", MP800R_PID, 0, 2400, 150, 0, 0, 0, 638, 877, PIXMA_CAP_TPU | PIXMA_CAP_GT_4096),
+  DEVICE ("Canon PIXMA MP830", "MP830", MP830_PID, 0, 2400, 150, 0, 0, 0, 638, 877, PIXMA_CAP_ADFDUP | PIXMA_CAP_GT_4096),
 
   /* Generation 2: CCD */
-  DEVICE ("Canon PIXMA MP810", "MP810", MP810_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
-  DEVICE ("Canon PIXMA MP960", "MP960", MP960_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+  DEVICE ("Canon PIXMA MP810", "MP810", MP810_PID, 0, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+  DEVICE ("Canon PIXMA MP960", "MP960", MP960_PID, 0, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
 
   /* Generation 3 CCD not managed as Generation 2 */
-  DEVICE ("Canon Pixma MP970", "MP970", MP970_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+  DEVICE ("Canon Pixma MP970", "MP970", MP970_PID, 0, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
 
   /* Flatbed scanner CCD (2007) */
-  DEVICE ("Canoscan 8800F", "8800F", CS8800F_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU /*| PIXMA_CAP_NEGATIVE*/ | PIXMA_CAP_48BIT),
+  DEVICE ("Canoscan 8800F", "8800F", CS8800F_PID, 150, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU /*| PIXMA_CAP_NEGATIVE*/ | PIXMA_CAP_48BIT),
 
   /* PIXMA 2008 vintage CCD */
-  DEVICE ("Canon MP980 series", "MP980", MP980_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+  DEVICE ("Canon MP980 series", "MP980", MP980_PID, 0, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
 
   /* Generation 4 CCD */
-  DEVICE ("Canon MP990 series", "MP990", MP990_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+  DEVICE ("Canon MP990 series", "MP990", MP990_PID, 0, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
 
   /* Flatbed scanner (2010) */
-  DEVICE ("Canoscan 9000F", "9000F", CS9000F_PID, 4800, 300, 9600, 600, 2400, 638, 877, PIXMA_CAP_TPUIR /*| PIXMA_CAP_NEGATIVE*/ | PIXMA_CAP_48BIT),
+  DEVICE ("Canoscan 9000F", "9000F", CS9000F_PID, 150, 4800, 300, 9600, 600, 2400, 638, 877, PIXMA_CAP_TPUIR /*| PIXMA_CAP_NEGATIVE*/ | PIXMA_CAP_48BIT),
 
   /* Latest devices (2010) Generation 4 CCD untested */
-  DEVICE ("Canon PIXMA MG8100", "MG8100", MG8100_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+  DEVICE ("Canon PIXMA MG8100", "MG8100", MG8100_PID, 0, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
 
   /* Latest devices (2011) Generation 4 CCD untested */
-  DEVICE ("Canon PIXMA MG8200", "MG8200", MG8200_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+  DEVICE ("Canon PIXMA MG8200", "MG8200", MG8200_PID, 0, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
 
   /* Flatbed scanner (2013) */
-  DEVICE ("Canoscan 9000F Mark II", "9000FMarkII", CS9000F_MII_PID, 4800, 300, 9600, 600, 2400, 638, 877, PIXMA_CAP_TPUIR | PIXMA_CAP_48BIT),
+  DEVICE ("Canoscan 9000F Mark II", "9000FMarkII", CS9000F_MII_PID, 150, 4800, 300, 9600, 600, 2400, 638, 877, PIXMA_CAP_TPUIR | PIXMA_CAP_48BIT),
 
   END_OF_DEVICE_LIST
 };