Merge branch '318-canoscan-lide-400-potentially-supports-48-bit-depth' into 'master'

Resolve "CanoScan LiDE 400 potentially supports 48-bit depth"

Closes #318

See merge request sane-project/backends!486

backend/pixma/pixma.c

@@ -470,7 +470,7 @@ create_dpi_list (pixma_sane_t * ss)
                 || ss->mode_map[OVAL (opt_mode).w] == PIXMA_SCAN_MODE_GRAY_16))
   { /* 48 bits flatbed */
     /*PDBG (pixma_dbg (4, "*create_dpi_list***** 48 bits flatbed mode\n"));*/
-    min_dpi = 150;
+    min_dpi = (cfg->min_xdpi_16) ? cfg->min_xdpi_16 : 75;
   }
 
   /* set j for min. dpi

backend/pixma/pixma.h

@@ -373,6 +373,7 @@ struct pixma_config_t
   unsigned iface;	     /**< USB Interface number */
   const pixma_scan_ops_t *ops;	  /**< Subdriver ops */
   unsigned min_xdpi;   /**< Minimum horizontal resolution[DPI] */
+  unsigned min_xdpi_16;/**< Minimum horizontal resolution[DPI] for 16-bit scans */
   unsigned xdpi;	     /**< Maximum horizontal resolution[DPI] */
   unsigned ydpi;	     /**< Maximum vertical resolution[DPI] */
   unsigned adftpu_min_dpi;    /**< Maximum horizontal resolution[DPI] for adf/tpu

backend/pixma/pixma_imageclass.c

@@ -917,7 +917,7 @@ static const pixma_scan_ops_t pixma_iclass_ops = {
             0x04a9, pid,              /* vid pid */	\
             1,                        /* iface */		\
             &pixma_iclass_ops,        /* ops */		\
-            0,                        /* min_xdpi not used in this subdriver */ \
+            0, 0,                     /* min_xdpi & min_xdpi_16 not used in this subdriver */ \
             dpi, dpi,                 /* xdpi, ydpi */	\
             0,                        /* adftpu_min_dpi not used in this subdriver */ \
             adftpu_max_dpi,           /* adftpu_max_dpi */ \

backend/pixma/pixma_mp150.c

@@ -633,6 +633,12 @@ calc_raw_width (const mp150_t * mp, const pixma_scan_param_t * param)
   return raw_width;
 }
 
+static int
+is_gray_16 (pixma_t * s)
+{
+  return (s->param->mode == PIXMA_SCAN_MODE_GRAY_16);
+}
+
 static unsigned
 get_cis_line_size (pixma_t * s)
 {
@@ -642,7 +648,9 @@ get_cis_line_size (pixma_t * s)
                    __func__, s->param->line_size, s->param->w, s->param->wx, mp->scale));*/
 
   return (s->param->wx ? s->param->line_size / s->param->w * s->param->wx
-                       : s->param->line_size) * mp->scale;
+                       : s->param->line_size)
+         * mp->scale
+         * (is_gray_16(s) ? 3 : 1);
 }
 
 static int
@@ -707,10 +715,12 @@ send_scan_param (pixma_t * s)
       pixma_set_be32 (y, data + 0x10);
       pixma_set_be32 (wx, data + 0x14);
       pixma_set_be32 (h, data + 0x18);
-      data[0x1c] = (s->param->channels != 1) ? 0x08 : 0x04;
+      /*PDBG (pixma_dbg (4, "*send_scan_param gen. 3+ ***** Setting: channels=%hi depth=%hi ***** \n",
+                       s->param->channels, s->param->depth));*/
+      data[0x1c] = ((s->param->channels != 1) || (is_gray_16(s)) ? 0x08 : 0x04);
 
       data[0x1d] = ((s->param->software_lineart) ? 8 : s->param->depth)
-                    * s->param->channels;   /* bits per pixel */
+                    * (is_gray_16(s) ? 3 : s->param->channels); /* bits per pixel */
 
       data[0x1f] = 0x01;        /* This one also seen at 0. Don't know yet what's used for */
       data[0x20] = 0xff;
@@ -1066,7 +1076,7 @@ post_process_image_data (pixma_t * s, pixma_imagebuf_t * ib)
     }
 
   /* process image sizes */
-  c = s->param->channels
+  c = (is_gray_16(s) ? 3 : s->param->channels)
       * ((s->param->software_lineart) ? 8 : s->param->depth) / 8;   /* color channels count */
   cw = c * s->param->w;                                             /* image width */
   cx = c * s->param->xs;                                            /* x-offset */
@@ -1140,6 +1150,9 @@ post_process_image_data (pixma_t * s, pixma_imagebuf_t * ib)
           /* Color / Gray to Lineart convert */
           if (s->param->software_lineart)
               cptr = gptr = pixma_binarize_line (s->param, gptr, cptr, s->param->w, c);
+          /* Color to Grayscale convert for 16bit gray */
+          else if (is_gray_16(s))
+            cptr = gptr = pixma_rgb_to_gray (gptr, cptr, s->param->w, c);
           else
               cptr += cw;
         }
@@ -1225,18 +1238,37 @@ mp150_check_param (pixma_t * s, pixma_scan_param_t * sp)
   /* PDBG (pixma_dbg (4, "*mp150_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)); */
 
-  /* MP150 only supports 8 bit per channel in color and grayscale mode */
+  sp->channels = 3;
-  if (sp->depth != 1)
-    {
   sp->software_lineart = 0;
-      sp->depth = 8;
+  switch (sp->mode)
-    }
-  else
   {
-      /* software lineart */
+    /* standard scan modes
-      sp->software_lineart = 1;
+     * 8 bit per channel in color and grayscale mode */
-      sp->depth = 1;
+    case PIXMA_SCAN_MODE_GRAY:
       sp->channels = 1;
+      /* fall through */
+    case PIXMA_SCAN_MODE_COLOR:
+      sp->depth = 8;
+      break;
+      /* extended scan modes for 48 bit flatbed scanners
+       * 16 bit per channel in color and grayscale mode */
+    case PIXMA_SCAN_MODE_GRAY_16:
+      sp->channels = 1;
+      sp->depth = 16;
+      break;
+    case PIXMA_SCAN_MODE_COLOR_48:
+      sp->channels = 3;
+      sp->depth = 16;
+      break;
+      /* software lineart
+       * 1 bit per channel */
+    case PIXMA_SCAN_MODE_LINEART:
+      sp->software_lineart = 1;
+      sp->channels = 1;
+      sp->depth = 1;
+      break;
+    default:
+      break;
   }
 
   /* for software lineart w must be a multiple of 8 */
@@ -1600,6 +1632,7 @@ static const pixma_scan_ops_t pixma_mp150_ops = {
         0,                 /* iface */              \
         &pixma_mp150_ops,  /* ops */                \
         min_dpi,           /* min_xdpi */           \
+        0,                 /* min_xdpi_16 not used in this subdriver */ \
         dpi, 2*(dpi),      /* xdpi, ydpi */         \
         adftpu_min_dpi, adftpu_max_dpi,         /* adftpu_min_dpi, adftpu_max_dpi */ \
         0, 0,              /* tpuir_min_dpi & tpuir_max_dpi not used in this subdriver */  \
@@ -1774,7 +1807,7 @@ const pixma_config_t pixma_mp150_devices[] = {
   DEVICE ("Canon PIXMA TR8500 Series", "TR8500", TR8500_PID, 0, 1200, 0, 0, 638, 877, PIXMA_CAP_CIS | PIXMA_CAP_ADF | PIXMA_CAP_ADF_JPEG),
   DEVICE ("Canon PIXMA TR7500 Series", "TR7500", TR7500_PID, 0, 1200, 0, 0, 638, 877, PIXMA_CAP_CIS | PIXMA_CAP_ADF),
   DEVICE ("Canon PIXMA TS9500 Series", "TS9500", TS9500_PID, 0, 1200, 0, 600, 638, 877, PIXMA_CAP_CIS | PIXMA_CAP_ADF),
-  DEVICE ("CanoScan LiDE 400", "LIDE400", LIDE400_PID, 300, 4800, 0, 0, 638, 877, PIXMA_CAP_CIS),
+  DEVICE ("CanoScan LiDE 400", "LIDE400", LIDE400_PID, 300, 4800, 0, 0, 638, 877, PIXMA_CAP_CIS | PIXMA_CAP_48BIT),
   DEVICE ("CanoScan LiDE 300", "LIDE300", LIDE300_PID, 300, 2400, 0, 0, 638, 877, PIXMA_CAP_CIS),
 
   /* Latest devices (2019) Generation 5 CIS */

backend/pixma/pixma_mp730.c

@@ -815,7 +815,7 @@ static const pixma_scan_ops_t pixma_mp730_ops = {
               0x04a9, pid,       /* vid pid */	      \
               1,                 /* iface */		      \
               &pixma_mp730_ops,  /* ops */            \
-              0,                 /* min_xdpi not used in this subdriver */ \
+              0, 0,              /* min_xdpi & min_xdpi_16 not used in this subdriver */ \
               dpi, dpi,          /* xdpi, ydpi */	    \
               0, 0,              /* adftpu_min_dpi & adftpu_max_dpi not used in this subdriver */ \
               0, 0,              /* tpuir_min_dpi & tpuir_max_dpi not used in this subdriver */  \

backend/pixma/pixma_mp750.c

@@ -955,7 +955,7 @@ static const pixma_scan_ops_t pixma_mp750_ops = {
 	0x04a9, pid,           /* vid pid */		\
 	0,                     /* iface */		\
 	&pixma_mp750_ops,      /* ops */		\
-        0,                     /* min_xdpi not used in this subdriver */ \
+  0, 0,                  /* min_xdpi & min_xdpi_16 not used in this subdriver */ \
 	dpi, 2*(dpi),          /* xdpi, ydpi */		\
         0, 0,                  /* adftpu_min_dpi & adftpu_max_dpi not used in this subdriver */ \
         0, 0,                  /* tpuir_min_dpi & tpuir_max_dpi not used in this subdriver */   \

backend/pixma/pixma_mp800.c

@@ -2066,9 +2066,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
+      /* 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 */
       k = MAX (sp->xdpi, 150) / sp->xdpi;
     else
       /* default */
@@ -2375,13 +2373,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 +2392,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 | PIXMA_CAP_GT_4096),
+  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, 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, 2400, 150, 0, 0, 0, 638, 877, PIXMA_CAP_ADFDUP | 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 MP810", "MP810", MP810_PID, 0, 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 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
 };