New upstream version 1.2.1upstream/1.2.1

1 files changed, 929 insertions, 8 deletions

diff --git a/backend/canon_dr.c b/backend/canon_dr.c
index 95799e7..58299d7 100644
--- a/backend/canon_dr.c
+++ b/backend/canon_dr.c
@@ -3,7 +3,7 @@
    This file is part of the SANE package, and implements a SANE backend
    for various Canon DR-series scanners.
 
-   Copyright (C) 2008-2021 m. allan noah
+   Copyright (C) 2008-2022 m. allan noah
 
    Yabarana Corp. www.yabarana.com provided significant funding
    EvriChart, Inc. www.evrichart.com provided funding and loaned equipment
@@ -355,6 +355,10 @@
          - rewrite do_cmd() timeout handling
          - remove long timeout TUR from v61 (did not help)
          - allow config file to set initial tur timeout for DR-X10C (#142)
+      v63 2022-11-18, CQ, MAN
+         - add support for reading the total and roller counters
+      v64 2022-11-18, CQ, MAN
+         - add complete support for imprinters on X10C (#585)
 
    SANE FLOW DIAGRAM
 
@@ -393,6 +397,7 @@
 #include <math.h> /*tan*/
 #include <unistd.h> /*usleep*/
 #include <sys/time.h> /*gettimeofday*/
+#include <time.h> /*localtime*/
 #include <stdlib.h> /*strtol*/
 
 #include "../include/sane/sanei_backend.h"
@@ -406,7 +411,7 @@
 #include "canon_dr.h"
 
 #define DEBUG 1
-#define BUILD 62
+#define BUILD 64
 
 /* values for SANE_DEBUG_CANON_DR env var:
  - errors           5
@@ -449,6 +454,13 @@
 #define STRING_NONE SANE_I18N("None")
 #define STRING_JPEG SANE_I18N("JPEG")
 
+#define STRING_IMPRINTER_8x12_FONT SANE_I18N("8x12")
+#define STRING_IMPRINTER_12x12_FONT SANE_I18N("12x12")
+
+#define STRING_IMPRINTER_ADDON_BoW SANE_I18N("Black-on-White")
+#define STRING_IMPRINTER_ADDON_BoI SANE_I18N("Black-on-Image")
+#define STRING_IMPRINTER_ADDON_WoB SANE_I18N("White-on-Black")
+
 /* Also set via config file. */
 static int global_buffer_size;
 static int global_buffer_size_default = 2 * 1024 * 1024;
@@ -494,7 +506,7 @@ static struct scanner *scanner_devList = NULL;
 SANE_Status
 sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
 {
-  authorize = authorize;        /* get rid of compiler warning */
+  (void) authorize;             /* get rid of compiler warning */
 
   DBG_INIT ();
   DBG (10, "sane_init: start\n");
@@ -547,7 +559,7 @@ sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
   int num_devices=0;
   int i=0;
 
-  local_only = local_only;        /* get rid of compiler warning */
+  (void) local_only;            /* get rid of compiler warning */
 
   DBG (10, "sane_get_devices: start\n");
 
@@ -992,6 +1004,12 @@ attach_one (const char *device_name, int connType)
     return ret;
   }
 
+  /* this detects imprinters if they are available */
+  ret = init_imprinters (s);
+  if (ret != SANE_STATUS_GOOD) {
+    DBG (5, "attach_one: errors while trying to detect optional imprinters, continuing\n");
+  }
+
   /* enable/read the buttons */
   ret = init_panel (s);
   if (ret != SANE_STATUS_GOOD) {
@@ -1001,6 +1019,13 @@ attach_one (const char *device_name, int connType)
     return ret;
   }
 
+  /* enable/read the lifecycle counters */
+  ret = init_counters (s);
+  if (ret != SANE_STATUS_GOOD) {
+    DBG (5, "attach_one: unable to detect lifecycle counters, continuing\n");
+    return ret;
+  }
+
   /* sets SANE option 'values' to good defaults */
   ret = init_user (s);
   if (ret != SANE_STATUS_GOOD) {
@@ -1168,6 +1193,7 @@ init_inquire (struct scanner *s)
   if (strncmp ("DR", s->model_name, 2)
    && strncmp ("CR", s->model_name, 2)
    && strncmp ("P-", s->model_name, 2)
+   && strncmp ("R", s->model_name, 1)
   ) {
     DBG (5, "The device at '%s' is reported to be a '%s'\n",
       s->device_name, s->model_name);
@@ -1388,8 +1414,9 @@ init_model (struct scanner *s)
   s->max_x_fb = s->max_x;
   s->max_y_fb = s->max_y;
 
-  /* missing from vpd- we will unset this for b&w machines below */
+  /* missing from vpd- we will unset these for some machines below */
   s->can_color = 1;
+  s->can_read_lifecycle_counters = 1;
 
   /* specific settings missing from vpd */
   if (strstr (s->model_name,"DR-9080")){
@@ -1491,6 +1518,34 @@ init_model (struct scanner *s)
     s->can_monochrome=0;
   }
 
+  else if (strstr (s->model_name,"R40")
+  ){
+	/* confirmed */
+    s->gray_interlace[SIDE_FRONT] = GRAY_INTERLACE_C120;
+    s->gray_interlace[SIDE_BACK] = GRAY_INTERLACE_C120;
+    s->color_interlace[SIDE_FRONT] = COLOR_INTERLACE_C120;
+    s->color_interlace[SIDE_BACK] = COLOR_INTERLACE_C120;
+    s->duplex_interlace = DUPLEX_INTERLACE_2510;
+    /*s->duplex_offset = 320; now set in config file*/
+    s->fixed_width = 1;
+    s->need_ccal = 1;
+    s->fcal_src = FCAL_SRC_SCAN;
+    s->fcal_dest = FCAL_DEST_SW;
+    s->rgb_format = 1;
+    s->sw_lut = 1;
+
+    /*only in Y direction, so we trash them in X*/
+    s->std_res_x[DPI_100]=0;
+    s->std_res_x[DPI_150]=0;
+    s->std_res_x[DPI_200]=0;
+    s->std_res_x[DPI_240]=0;
+    s->std_res_x[DPI_400]=0;
+
+    /* suspected settings */
+    s->ccal_version = 3;
+    s->has_df_ultra = 1;
+  }
+
   /* copied from 2510, possibly incorrect */
   else if (strstr (s->model_name,"DR-3010")){
     s->rgb_format = 1;
@@ -1840,6 +1895,7 @@ init_model (struct scanner *s)
   }
 
   else if (strstr (s->model_name,"DR-X10C")){
+    int i = 0;
 
     /* Required for USB coms */
     s->has_ssm = 0;
@@ -1862,6 +1918,61 @@ init_model (struct scanner *s)
     s->std_res_y[DPI_600]=1;
 
     s->has_hwcrop = 1;
+
+    /*valid horizontal offsets for post-imprinter*/
+    s->post_imprinter_h_offset_list[++i] = 21;
+    s->post_imprinter_h_offset_list[++i] = 35;
+    s->post_imprinter_h_offset_list[++i] = 47;
+    s->post_imprinter_h_offset_list[++i] = 59;
+    s->post_imprinter_h_offset_list[++i] = 72;
+    s->post_imprinter_h_offset_list[++i] = 99;
+    s->post_imprinter_h_offset_list[++i] = 114;
+    s->post_imprinter_h_offset_list[++i] = 143;
+    s->post_imprinter_h_offset_list[++i] = 155;
+    s->post_imprinter_h_offset_list[++i] = 167;
+    s->post_imprinter_h_offset_list[++i] = 196;
+    s->post_imprinter_h_offset_list[++i] = 211;
+    s->post_imprinter_h_offset_list[++i] = 239;
+    s->post_imprinter_h_offset_list[++i] = 251;
+    s->post_imprinter_h_offset_list[++i] = 263;
+    s->post_imprinter_h_offset_list[++i] = 275;
+    s->post_imprinter_h_offset_list[++i] = 289;
+    s->post_imprinter_h_offset_list[0] = i;
+
+    i = 0;
+    /*valid horizontal offsets for pre-imprinter*/
+    s->pre_imprinter_h_offset_list[++i] = 14;
+    s->pre_imprinter_h_offset_list[++i] = 28;
+    s->pre_imprinter_h_offset_list[++i] = 41;
+    s->pre_imprinter_h_offset_list[++i] = 53;
+    s->pre_imprinter_h_offset_list[++i] = 65;
+    s->pre_imprinter_h_offset_list[++i] = 106;
+    s->pre_imprinter_h_offset_list[0] = i;
+
+    /*valid vertical offsets for imprinters*/
+    s->imprinter_v_offset_range.min = 0;
+    s->imprinter_v_offset_range.max = 500;
+    s->imprinter_v_offset_range.quant = 1;
+
+    i = 0;
+    /*valid font angles for imprinters*/
+    s->imprinter_font_angle_list[++i] = 0;
+    s->imprinter_font_angle_list[++i] = 90;
+    s->imprinter_font_angle_list[++i] = 180;
+    s->imprinter_font_angle_list[++i] = 270;
+    s->imprinter_font_angle_list[0] = i;
+
+    i = 0;
+    s->imprint_font_size_list[i++] = STRING_IMPRINTER_8x12_FONT;
+    s->imprint_font_size_list[i++] = STRING_IMPRINTER_12x12_FONT;
+    s->imprint_font_size_list[i] = NULL;
+
+    i = 0;
+    s->imprint_addon_mode_list[i++] = STRING_IMPRINTER_ADDON_BoI;
+    s->imprint_addon_mode_list[i++] = STRING_IMPRINTER_ADDON_BoW;
+    s->imprint_addon_mode_list[i++] = STRING_IMPRINTER_ADDON_WoB;
+    s->imprint_addon_mode_list[i++] = STRING_NONE;
+    s->imprint_addon_mode_list[i] = NULL;
   }
 
   DBG (10, "init_model: finish\n");
@@ -1870,6 +1981,30 @@ init_model (struct scanner *s)
 }
 
 /*
+ * try to detect imprinters.
+ */
+static SANE_Status
+init_imprinters (struct scanner *s)
+{
+  SANE_Status ret = SANE_STATUS_GOOD;
+
+  s->has_pre_imprinter = 0;
+  s->has_post_imprinter = 0;
+
+  ret = detect_imprinter(s,R_PRE_IMPRINTER);
+  if(ret != SANE_STATUS_GOOD){
+    return ret;
+  }
+
+  ret = detect_imprinter(s,R_POST_IMPRINTER);
+  if(ret != SANE_STATUS_GOOD){
+    return ret;
+  }
+
+  return ret;
+}
+
+/*
  * This function enables the buttons and preloads the current panel values
  */
 static SANE_Status
@@ -1901,6 +2036,28 @@ init_panel (struct scanner *s)
 }
 
 /*
+ * This function disables the lifecycle counters if not available
+ */
+static SANE_Status
+init_counters (struct scanner *s)
+{
+  SANE_Status ret = SANE_STATUS_GOOD;
+
+  DBG (10, "init_counters: start\n");
+
+  ret = read_counters(s);
+  if(ret){
+    DBG (5, "init_counters: disabling lifecycle counters\n");
+    s->can_read_lifecycle_counters = 0;
+    return ret;
+  }
+
+  DBG (10, "init_counters: finish\n");
+
+  return ret;
+}
+
+/*
  * set good default user values.
  * struct is already initialized to 0.
  */
@@ -1953,6 +2110,10 @@ init_user (struct scanner *s)
   s->threshold = 90;
   s->compress_arg = 50;
 
+  s->pre_imprint.h_offset = 65;
+  s->post_imprint.h_offset = 155;
+  s->post_imprint_addon_mode = ADDON_BoI;
+
   DBG (10, "init_user: finish\n");
 
   return SANE_STATUS_GOOD;
@@ -2737,6 +2898,197 @@ sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
      opt->cap = SANE_CAP_INACTIVE;
   }
 
+  /* "Imprinter" group --------------------------------------------------- */
+  if(option==OPT_IMPRINT_GROUP){
+    opt->name = "imprinter-options";
+    opt->title = SANE_I18N ("Imprinter Options");
+    opt->desc = SANE_I18N ("Controls for imprinter units");
+    opt->type = SANE_TYPE_GROUP;
+    opt->constraint_type = SANE_CONSTRAINT_NONE;
+
+    /*flaming hack to get scanimage to hide group*/
+    if ( !(s->has_pre_imprinter || s->has_post_imprinter) )
+      opt->type = SANE_TYPE_BOOL;
+  }
+
+  if(option==OPT_PRE_IMPRINT_SPECSTRING){
+    opt->name = "pre-imprint-string";
+    opt->title = "Pre-Imprinter string";
+    opt->desc = "String specifier for the pre-imprinter text";
+    opt->type = SANE_TYPE_STRING;
+    opt->size = IMPRINT_SPECSTRING_LEN;
+    if (s->has_pre_imprinter)
+     opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+    else
+     opt->cap = SANE_CAP_INACTIVE;
+  }
+
+  if(option==OPT_PRE_IMPRINT_H_OFFSET){
+    opt->name = "pre-imprint-h-offset";
+    opt->title = "Pre-Imprinter horizontal offset";
+    opt->desc = "Integer specifying the horizontal positioning of the pre-imprinter";
+    opt->type = SANE_TYPE_INT;
+    opt->unit = SANE_UNIT_MM;
+    opt->size = sizeof(SANE_Word);
+    opt->constraint_type = SANE_CONSTRAINT_WORD_LIST;
+    opt->constraint.word_list = s->pre_imprinter_h_offset_list;
+    if (s->has_pre_imprinter)
+     opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+    else
+     opt->cap = SANE_CAP_INACTIVE;
+  }
+
+  if(option==OPT_PRE_IMPRINT_V_OFFSET){
+    opt->name = "pre-imprint-v-offset";
+    opt->title = "Pre-Imprinter vertical offset";
+    opt->desc = "Integer specifying the vertical positioning of the pre-imprinter";
+    opt->type = SANE_TYPE_INT;
+    opt->unit = SANE_UNIT_MM;
+    opt->size = sizeof(SANE_Word);
+    opt->constraint_type = SANE_CONSTRAINT_RANGE;
+    opt->constraint.range = &s->imprinter_v_offset_range;
+    if (s->has_pre_imprinter)
+     opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+    else
+     opt->cap = SANE_CAP_INACTIVE;
+  }
+
+  if(option==OPT_PRE_IMPRINT_FONT_SIZE){
+    opt->name = "pre-imprint-font-size";
+    opt->title = "Pre-Imprinter font size";
+    opt->desc = "Integer specifying the pre-imprint font size";
+    opt->type = SANE_TYPE_STRING;
+    opt->constraint_type = SANE_CONSTRAINT_STRING_LIST;
+    opt->constraint.string_list = s->imprint_font_size_list;
+    opt->size = maxStringSize (opt->constraint.string_list);
+    if (s->has_pre_imprinter)
+     opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+    else
+     opt->cap = SANE_CAP_INACTIVE;
+  }
+
+  if(option==OPT_PRE_IMPRINT_FONT_ROT){
+    opt->name = "pre-imprint-font-rot";
+    opt->title = "Pre-Imprinter font rotation";
+    opt->desc = "Integer specifying the pre-imprint font rotation";
+    opt->type = SANE_TYPE_INT;
+    opt->unit = SANE_UNIT_NONE;
+    opt->size = sizeof(SANE_Word);
+    opt->constraint_type = SANE_CONSTRAINT_WORD_LIST;
+    opt->constraint.word_list = s->imprinter_font_angle_list;
+    if (s->has_pre_imprinter)
+     opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+    else
+     opt->cap = SANE_CAP_INACTIVE;
+  }
+
+  if(option==OPT_PRE_IMPRINT_SPACING){
+    opt->name = "pre-imprint-spacing";
+    opt->title = "Pre-Imprinter spacing";
+    opt->desc = "Enables the pre-imprint extra spacing";
+    opt->type = SANE_TYPE_BOOL;
+    if (s->has_pre_imprinter)
+     opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+    else
+     opt->cap = SANE_CAP_INACTIVE;
+  }
+
+  if(option==OPT_POST_IMPRINT_SPECSTRING){
+    opt->name = "post-imprint-string";
+    opt->title = "Post-Imprinter string";
+    opt->desc = "String specifier for the post-imprinter text";
+    opt->type = SANE_TYPE_STRING;
+    opt->size = IMPRINT_SPECSTRING_LEN;
+    if (s->has_post_imprinter)
+     opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+    else
+     opt->cap = SANE_CAP_INACTIVE;
+  }
+
+  if(option==OPT_POST_IMPRINT_H_OFFSET){
+    opt->name = "post-imprint-h-offset";
+    opt->title = "Post-Imprinter horizontal offset";
+    opt->desc = "Integer specifying the horizontal positioning of the post-imprinter";
+    opt->type = SANE_TYPE_INT;
+    opt->unit = SANE_UNIT_MM;
+    opt->size = sizeof(SANE_Word);
+    opt->constraint_type = SANE_CONSTRAINT_WORD_LIST;
+    opt->constraint.word_list = s->post_imprinter_h_offset_list;
+    if (s->has_post_imprinter)
+     opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+    else
+     opt->cap = SANE_CAP_INACTIVE;
+  }
+
+  if(option==OPT_POST_IMPRINT_V_OFFSET){
+    opt->name = "post-imprint-v-offset";
+    opt->title = "Post-Imprinter vertical offset";
+    opt->desc = "Integer specifying the vertical positioning of the post-imprinter";
+    opt->type = SANE_TYPE_INT;
+    opt->unit = SANE_UNIT_MM;
+    opt->size = sizeof(SANE_Word);
+    opt->constraint_type = SANE_CONSTRAINT_RANGE;
+    opt->constraint.range = &s->imprinter_v_offset_range;
+    if (s->has_post_imprinter)
+     opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+    else
+     opt->cap = SANE_CAP_INACTIVE;
+  }
+
+  if(option==OPT_POST_IMPRINT_FONT_SIZE){
+    opt->name = "post-imprint-font-size";
+    opt->title = "Post-Imprinter font size";
+    opt->desc = "Integer specifying the post-imprint font size";
+    opt->type = SANE_TYPE_STRING;
+    opt->constraint_type = SANE_CONSTRAINT_STRING_LIST;
+    opt->constraint.string_list = s->imprint_font_size_list;
+    opt->size = maxStringSize (opt->constraint.string_list);
+    if (s->has_post_imprinter)
+     opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+    else
+     opt->cap = SANE_CAP_INACTIVE;
+  }
+
+  if(option==OPT_POST_IMPRINT_FONT_ROT){
+    opt->name = "post-imprint-font-rot";
+    opt->title = "Post-Imprinter font rotation";
+    opt->desc = "Integer specifying the post-imprint font rotation";
+    opt->type = SANE_TYPE_INT;
+    opt->unit = SANE_UNIT_NONE;
+    opt->size = sizeof(SANE_Word);
+    opt->constraint_type = SANE_CONSTRAINT_WORD_LIST;
+    opt->constraint.word_list = s->imprinter_font_angle_list;
+    if (s->has_post_imprinter)
+     opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+    else
+     opt->cap = SANE_CAP_INACTIVE;
+  }
+
+  if(option==OPT_POST_IMPRINT_SPACING){
+    opt->name = "post-imprint-spacing";
+    opt->title = "Post-Imprinter spacing";
+    opt->desc = "Enables the post-imprint extra spacing";
+    opt->type = SANE_TYPE_BOOL;
+    if (s->has_post_imprinter)
+     opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+    else
+     opt->cap = SANE_CAP_INACTIVE;
+  }
+
+  if(option==OPT_POST_IMPRINT_ADDON_MODE){
+    opt->name = "post-imprint-addon-mode";
+    opt->title = "Post-Imprinter addon mode";
+    opt->desc = "Integer specifying the type of post-imprint addon rendered in the scanned image";
+    opt->type = SANE_TYPE_STRING;
+    opt->constraint_type = SANE_CONSTRAINT_STRING_LIST;
+    opt->constraint.string_list = s->imprint_addon_mode_list;
+    opt->size = maxStringSize (opt->constraint.string_list);
+    if (s->has_post_imprinter)
+     opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED;
+    else
+     opt->cap = SANE_CAP_INACTIVE;
+  }
+
   /* "Sensor" group ------------------------------------------------------ */
   if(option==OPT_SENSOR_GROUP){
     opt->name = SANE_NAME_SENSORS;
@@ -2830,6 +3182,34 @@ sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
       opt->cap = SANE_CAP_INACTIVE;
   }
 
+  if(option==OPT_ROLLERCOUNTER){
+    opt->name = "roller-counter";
+    opt->title = "Roller Counter";
+    opt->desc = "Scans since last roller replacement";
+    opt->type = SANE_TYPE_INT;
+    opt->unit = SANE_UNIT_NONE;
+    opt->constraint_type = SANE_CONSTRAINT_NONE;
+
+    if (s->can_read_lifecycle_counters)
+      opt->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+    else
+      opt->cap = SANE_CAP_INACTIVE;
+  }
+
+  if(option==OPT_TOTALCOUNTER){
+    opt->name = "total-counter";
+    opt->title = "Total Counter";
+    opt->desc = "Total scan count of the device";
+    opt->type = SANE_TYPE_INT;
+    opt->unit = SANE_UNIT_NONE;
+    opt->constraint_type = SANE_CONSTRAINT_NONE;
+
+    if (s->can_read_lifecycle_counters)
+      opt->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+    else
+      opt->cap = SANE_CAP_INACTIVE;
+  }
+
   if(option==OPT_ADF_LOADED){
     opt->name = "adf-loaded";
     opt->title = "ADF Loaded";
@@ -3108,6 +3488,122 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
           *val_p = s->hwcrop;
           return SANE_STATUS_GOOD;
 
+        case OPT_PRE_IMPRINT_SPECSTRING:
+          strcpy(val, s->pre_imprint.specstring);
+          return SANE_STATUS_GOOD;
+
+        case OPT_PRE_IMPRINT_H_OFFSET:
+          *val_p = s->pre_imprint.h_offset;
+          return SANE_STATUS_GOOD;
+
+        case OPT_PRE_IMPRINT_V_OFFSET:
+          *val_p = s->pre_imprint.v_offset;
+          return SANE_STATUS_GOOD;
+
+        case OPT_PRE_IMPRINT_FONT_SIZE:
+          switch (s->pre_imprint.font_size){
+            case IMPRINTER_12x12_FONT:
+              strcpy(val, STRING_IMPRINTER_12x12_FONT);
+              break;
+
+            case IMPRINTER_8x12_FONT:
+              strcpy(val, STRING_IMPRINTER_8x12_FONT);
+              break;
+          }
+          return SANE_STATUS_GOOD;
+
+        case OPT_PRE_IMPRINT_FONT_ROT:
+          switch (s->pre_imprint.font_rot){
+            case IMPRINTER_0_FONT_ROT:
+              *val_p = 0;
+              break;
+
+            case IMPRINTER_90_FONT_ROT:
+              *val_p = 90;
+              break;
+
+            case IMPRINTER_180_FONT_ROT:
+              *val_p = 180;
+              break;
+
+            case IMPRINTER_270_FONT_ROT:
+              *val_p = 270;
+              break;
+          }
+          return SANE_STATUS_GOOD;
+
+        case OPT_PRE_IMPRINT_SPACING:
+          *val_p = s->pre_imprint.spacing;
+          return SANE_STATUS_GOOD;
+
+        case OPT_POST_IMPRINT_SPECSTRING:
+          strcpy(val, s->post_imprint.specstring);
+          return SANE_STATUS_GOOD;
+
+        case OPT_POST_IMPRINT_H_OFFSET:
+          *val_p = s->post_imprint.h_offset;
+          return SANE_STATUS_GOOD;
+
+        case OPT_POST_IMPRINT_V_OFFSET:
+          *val_p = s->post_imprint.v_offset;
+          return SANE_STATUS_GOOD;
+
+        case OPT_POST_IMPRINT_FONT_SIZE:
+          switch (s->post_imprint.font_size){
+            case IMPRINTER_12x12_FONT:
+              strcpy(val, STRING_IMPRINTER_12x12_FONT);
+              break;
+
+            case IMPRINTER_8x12_FONT:
+              strcpy(val, STRING_IMPRINTER_8x12_FONT);
+              break;
+          }
+          return SANE_STATUS_GOOD;
+
+        case OPT_POST_IMPRINT_FONT_ROT:
+          switch (s->post_imprint.font_rot){
+            case IMPRINTER_0_FONT_ROT:
+              *val_p = 0;
+              break;
+
+            case IMPRINTER_90_FONT_ROT:
+              *val_p = 90;
+              break;
+
+            case IMPRINTER_180_FONT_ROT:
+              *val_p = 180;
+              break;
+
+            case IMPRINTER_270_FONT_ROT:
+              *val_p = 270;
+              break;
+          }
+          return SANE_STATUS_GOOD;
+
+        case OPT_POST_IMPRINT_SPACING:
+          *val_p = s->post_imprint.spacing;
+          return SANE_STATUS_GOOD;
+
+        case OPT_POST_IMPRINT_ADDON_MODE:
+          switch (s->post_imprint_addon_mode){
+            case ADDON_BoW:
+              strcpy(val, STRING_IMPRINTER_ADDON_BoW);
+              break;
+
+            case ADDON_BoI:
+              strcpy(val, STRING_IMPRINTER_ADDON_BoI);
+              break;
+
+            case ADDON_WoB:
+              strcpy(val, STRING_IMPRINTER_ADDON_WoB);
+              break;
+
+            case ADDON_DISABLED:
+              strcpy(val, STRING_NONE);
+              break;
+          }
+          return SANE_STATUS_GOOD;
+
         /* Sensor Group */
         case OPT_START:
           ret = read_panel(s,OPT_START);
@@ -3144,6 +3640,16 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
           *val_p = s->panel_counter;
           return ret;
 
+        case OPT_ROLLERCOUNTER:
+          ret = read_counters(s);
+          *val_p = s->roller_counter;
+          return ret;
+
+        case OPT_TOTALCOUNTER:
+          ret = read_counters(s);
+          *val_p = s->total_counter;
+          return ret;
+
         case OPT_ADF_LOADED:
           ret = read_sensors(s,OPT_ADF_LOADED);
           *val_p = s->sensor_adf_loaded;
@@ -3431,6 +3937,119 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
           s->hwcrop = val_c;
           return SANE_STATUS_GOOD;
 
+        case OPT_PRE_IMPRINT_SPECSTRING:
+          if (strlen(val) < IMPRINT_SPECSTRING_LEN){
+            strncpy(s->pre_imprint.specstring, val, IMPRINT_SPECSTRING_LEN);
+            return SANE_STATUS_GOOD;
+          }
+          DBG (5, "sane_control_option: pre-imprint spec string '%s' exceed the limit of %d characters\n", (SANE_String)val, IMPRINT_SPECSTRING_LEN);
+          return SANE_STATUS_INVAL;
+
+        case OPT_PRE_IMPRINT_H_OFFSET:
+          s->pre_imprint.h_offset = val_c;
+          return SANE_STATUS_GOOD;
+
+        case OPT_PRE_IMPRINT_V_OFFSET:
+          s->pre_imprint.v_offset = val_c;
+          return SANE_STATUS_GOOD;
+
+        case OPT_PRE_IMPRINT_FONT_SIZE:
+          if (!strcmp (val, STRING_IMPRINTER_12x12_FONT)) {
+            s->pre_imprint.font_size = IMPRINTER_12x12_FONT;
+          }
+          if (!strcmp (val, STRING_IMPRINTER_8x12_FONT)) {
+            s->pre_imprint.font_size = IMPRINTER_8x12_FONT;
+          }
+          return SANE_STATUS_GOOD;
+
+        case OPT_PRE_IMPRINT_FONT_ROT:
+          switch (val_c){
+            case 0:
+              s->pre_imprint.font_rot = IMPRINTER_0_FONT_ROT;
+              break;
+
+            case 90:
+              s->pre_imprint.font_rot = IMPRINTER_90_FONT_ROT;
+              break;
+
+            case 180:
+              s->pre_imprint.font_rot = IMPRINTER_180_FONT_ROT;
+              break;
+
+            case 270:
+              s->pre_imprint.font_rot = IMPRINTER_270_FONT_ROT;
+              break;
+          }
+          return SANE_STATUS_GOOD;
+
+        case OPT_PRE_IMPRINT_SPACING:
+          s->pre_imprint.spacing = val_c;
+          return SANE_STATUS_GOOD;
+
+        case OPT_POST_IMPRINT_SPECSTRING:
+          if (strlen(val) < IMPRINT_SPECSTRING_LEN){
+            strncpy(s->post_imprint.specstring, val, IMPRINT_SPECSTRING_LEN);
+            return SANE_STATUS_GOOD;
+          }
+          DBG (5, "sane_control_option: post-imprint spec string '%s' exceed the limit of %d characters\n", (SANE_String)val, IMPRINT_SPECSTRING_LEN);
+          return SANE_STATUS_INVAL;
+
+        case OPT_POST_IMPRINT_H_OFFSET:
+          s->post_imprint.h_offset = val_c;
+          return SANE_STATUS_GOOD;
+
+        case OPT_POST_IMPRINT_V_OFFSET:
+          s->post_imprint.v_offset = val_c;
+          return SANE_STATUS_GOOD;
+
+        case OPT_POST_IMPRINT_FONT_SIZE:
+          if (!strcmp (val, STRING_IMPRINTER_12x12_FONT)) {
+            s->post_imprint.font_size = IMPRINTER_12x12_FONT;
+          }
+          if (!strcmp (val, STRING_IMPRINTER_8x12_FONT)) {
+            s->post_imprint.font_size = IMPRINTER_8x12_FONT;
+          }
+          return SANE_STATUS_GOOD;
+
+        case OPT_POST_IMPRINT_FONT_ROT:
+          switch (val_c){
+            case 0:
+              s->post_imprint.font_rot = IMPRINTER_0_FONT_ROT;
+              break;
+
+            case 90:
+              s->post_imprint.font_rot = IMPRINTER_90_FONT_ROT;
+              break;
+
+            case 180:
+              s->post_imprint.font_rot = IMPRINTER_180_FONT_ROT;
+              break;
+
+            case 270:
+              s->post_imprint.font_rot = IMPRINTER_270_FONT_ROT;
+              break;
+          }
+          return SANE_STATUS_GOOD;
+
+        case OPT_POST_IMPRINT_SPACING:
+          s->post_imprint.spacing = val_c;
+          return SANE_STATUS_GOOD;
+
+        case OPT_POST_IMPRINT_ADDON_MODE:
+          if (!strcmp (val, STRING_IMPRINTER_ADDON_BoW)) {
+            s->post_imprint_addon_mode = ADDON_BoW;
+          }
+          if (!strcmp (val, STRING_IMPRINTER_ADDON_BoI)) {
+            s->post_imprint_addon_mode = ADDON_BoI;
+          }
+          if (!strcmp (val, STRING_IMPRINTER_ADDON_WoB)) {
+            s->post_imprint_addon_mode = ADDON_WoB;
+          }
+          if (!strcmp (val, STRING_NONE)) {
+            s->post_imprint_addon_mode = ADDON_DISABLED;
+          }
+          return SANE_STATUS_GOOD;
+
       }
   }                           /* else */
 
@@ -3636,6 +4255,14 @@ ssm_df (struct scanner *s)
       set_SSM2_DF_staple(out, 1);
     }
 
+    int requires_postimprint = s->has_post_imprinter && (strlen(s->post_imprint.specstring) > 0);
+    int requires_preimprint = s->has_pre_imprinter && (strlen(s->pre_imprint.specstring) > 0);
+    if (s->has_post_imprinter)
+      set_SSM2_DF_post_addon(out, requires_postimprint);
+    if (requires_postimprint || requires_preimprint){
+      set_SSM2_DF_imprint(out, 1);
+    }
+
     ret = do_cmd (
         s, 1, 0,
         cmd, cmdLen,
@@ -3897,6 +4524,50 @@ ssm_do (struct scanner *s)
 }
 
 static SANE_Status
+read_counters(struct scanner *s)
+{
+  SANE_Status ret = SANE_STATUS_GOOD;
+
+  unsigned char cmd[READ_len];
+  size_t cmdLen = READ_len;
+
+  unsigned char in[R_COUNTERS_len];
+  size_t inLen = R_COUNTERS_len;
+
+  if (!s->can_read_lifecycle_counters){
+    DBG(10, "read_counters: unsupported\n");
+    return ret;
+  }
+
+  DBG(10, "read_counters: start\n");
+
+  memset(cmd,0,cmdLen);
+  set_SCSI_opcode(cmd, READ_code);
+  set_R_datatype_code(cmd, SR_datatype_counters);
+  set_R_xfer_length(cmd, inLen);
+
+  ret = do_cmd(
+    s, 1, 0,
+    cmd, cmdLen,
+    NULL, 0,
+    in, &inLen
+  );
+
+  if (ret == SANE_STATUS_GOOD || ret == SANE_STATUS_EOF){
+
+    s->total_counter = get_R_COUNTERS_total(in);
+    s->roller_counter = s->total_counter - get_R_COUNTERS_last_srv(in);
+
+    DBG(10, "read_counters: total counter: %d roller_counter %d \n",s->total_counter,s->roller_counter);
+    ret = SANE_STATUS_GOOD;
+  }else{
+    DBG(10, "read_counters: ERROR: %d\n",ret);
+  }
+
+  return ret;
+}
+
+static SANE_Status
 read_sensors(struct scanner *s,SANE_Int option)
 {
   SANE_Status ret=SANE_STATUS_GOOD;
@@ -4382,6 +5053,248 @@ update_params(struct scanner *s, int calib)
     return ret;
 }
 
+/* simplify handling cmd SANE_STATUS_EOF as SANE_STATUS_GOOD */
+SANE_Status
+send_cmd(struct scanner *s, unsigned char* cmd, size_t cmdLen,
+                            unsigned char* out, size_t outLen,
+                            unsigned char * inBuff, size_t * inLen)
+{
+  SANE_Status ret=SANE_STATUS_GOOD;
+
+    ret = do_cmd (
+      s, 1, 0,
+      cmd, cmdLen,
+      out, outLen,
+      inBuff, inLen
+    );
+
+    if (ret == SANE_STATUS_EOF) {
+        ret = SANE_STATUS_GOOD;
+    }
+
+    return ret;
+}
+
+SANE_Status
+send_imprint_positioning(struct scanner* s, int is_postimprint, int enabled)
+{
+  unsigned char cmd[SET_SCAN_MODE2_len];
+  size_t cmdLen=SET_SCAN_MODE2_len;
+
+  unsigned char out[SSM2_PAY_len];
+  size_t outLen=SSM2_PAY_len;
+
+  unsigned char out_prefix[5]={ 0x01, 0x00, 0x60, 0x00, 0x60 };
+  size_t outPrefixLen=5;
+
+  memset(cmd,0,cmdLen);
+  set_SCSI_opcode(cmd,SET_SCAN_MODE2_code);
+  set_SSM2_page_code(cmd,SM2_pc_imprinter_settings);
+  if (is_postimprint)
+    set_SSM2_postimprint_cmd(cmd);
+  set_SSM2_pay_len(cmd,outLen);
+
+  memset(out,0,outLen);
+  memcpy(out,out_prefix,outPrefixLen);
+
+  int h_offset;
+  int v_offset;
+  if (is_postimprint){
+    if (s->post_imprint_addon_mode != ADDON_DISABLED)
+      set_SSM2_postimprint_addon(out);
+    h_offset = s->post_imprint.h_offset;
+    v_offset = s->post_imprint.v_offset;
+
+    if (enabled)
+      DBG (10, "send_imprint_positioning: post-imprinter: h_offset: %d v_offset: %d\n",h_offset,v_offset);
+  }else{
+    h_offset = s->pre_imprint.h_offset;
+    v_offset = s->pre_imprint.v_offset;
+    if (enabled)
+      DBG (10, "send_imprint_positioning: pre-imprinter: h_offset: %d v_offset: %d\n",h_offset,v_offset);
+  }
+  if(!enabled)
+    h_offset = v_offset = 0;
+  set_SSM2_imprint_hoffset(out,h_offset);
+  set_SSM2_imprint_voffset(out,v_offset);
+
+  return send_cmd(s, cmd, cmdLen, out, outLen, NULL, NULL);
+}
+
+SANE_Status
+send_imprint_specstring(struct scanner* s, int is_postimprint)
+{
+  unsigned char cmd[SET_SCAN_MODE2_len];
+  size_t cmdLen = SET_SCAN_MODE2_len;
+
+  unsigned char out[SSM2_IMPRINTER_STRING_PAY_len];
+  size_t outLen = SSM2_IMPRINTER_STRING_PAY_len;
+
+  memset(cmd,0,cmdLen);
+  set_SCSI_opcode(cmd, SET_SCAN_MODE2_code);
+  set_SSM2_page_code(cmd, SM2_pc_imprinter_specstring);
+  if (is_postimprint)
+    set_SSM2_postimprint_cmd(cmd);
+  set_SSM2_pay_len(cmd, outLen);
+
+  memset(out,0,outLen);
+  /* most of these bytes have yet to be identified to specific functionalities,
+     as they never seem to change under different imprinting mode */
+  unsigned char out_prefix[32] = {
+      0x01, 0x00,
+      0x60, 0x00,
+      0x60, 0x00,
+      0x00, 0x00,
+      0x00, 0x00,
+      0x00, 0x00,
+      0x03, 0x00,
+      0x00, 0x00,
+      0x01, 0x00,
+      0x00, 0x00,
+      0x00, 0x00,
+      0x00, 0x00,
+      0x00, 0x00,
+      0x00, 0x01,
+      0x04, 0x00,
+      0x00, 0x00
+    };
+  memcpy(out, out_prefix, 32);
+  if (is_postimprint){
+    set_SSM2_imprint_fontsize(out, s->post_imprint.font_size);
+    set_SSM2_imprint_fontrot(out, s->post_imprint.font_rot);
+    set_SSM2_imprint_spacing(out, s->post_imprint.spacing);
+    if (s->post_imprint_addon_mode != ADDON_DISABLED)
+      set_SSM2_imprint_addonmode(out, s->post_imprint_addon_mode);
+    strcpy((SANE_Char*)(out + 45), (SANE_String_Const) s->post_imprint.specstring);
+    DBG (10, "send_imprint_specstring: post-imprinter: font size: %d rotation: %d spacing: %d text: '%s' imprint-addon-mode: %d\n",s->post_imprint.font_size,s->post_imprint.font_rot,s->post_imprint.spacing,s->post_imprint.specstring,s->post_imprint_addon_mode);
+  }else{
+    set_SSM2_imprint_fontsize(out, s->pre_imprint.font_size);
+    set_SSM2_imprint_fontrot(out, s->pre_imprint.font_rot);
+    set_SSM2_imprint_spacing(out, s->pre_imprint.spacing);
+    strcpy((SANE_Char*)(out + 45), (SANE_String_Const) s->pre_imprint.specstring);
+    DBG (10, "send_imprint_specstring: pre-imprinter: font size: %d rotation: %d spacing: %d text: '%s'\n",s->pre_imprint.font_size,s->pre_imprint.font_rot,s->pre_imprint.spacing,s->pre_imprint.specstring);
+  }
+
+  return send_cmd(s, cmd, cmdLen, out, outLen, NULL, NULL);
+}
+
+SANE_Status
+send_imprint_date_and_time(struct scanner* s)
+{
+  unsigned char cmd[SET_SCAN_MODE2_len];
+  size_t cmdLen = SET_SCAN_MODE2_len;
+
+  unsigned char out[SSM2_PAY_len];
+  size_t outLen = SSM2_PAY_len;
+
+  memset(cmd,0,cmdLen);
+  set_SCSI_opcode(cmd, SET_SCAN_MODE2_code);
+  set_SSM2_page_code(cmd, SM2_pc_date_time);
+  set_SSM2_pay_len(cmd, outLen);
+
+  memset(out,0,outLen);
+
+  time_t t = time(NULL);
+  struct tm tM = *localtime(&t);
+
+  set_SSM2_imprint_year(out, tM.tm_year + 1900);
+  set_SSM2_imprint_month(out, tM.tm_mon + 1);
+  set_SSM2_imprint_day(out, tM.tm_mday);
+  set_SSM2_imprint_hour(out, tM.tm_hour);
+  set_SSM2_imprint_min(out, tM.tm_min);
+  set_SSM2_imprint_sec(out, tM.tm_sec);
+
+  return send_cmd(s, cmd, cmdLen, out, outLen, NULL, NULL);
+}
+
+SANE_Status
+load_imprinting_settings(struct scanner *s)
+{
+  SANE_Status ret = SANE_STATUS_GOOD;
+
+  int requires_preimprint = (strlen(s->pre_imprint.specstring) > 0);
+  int requires_postimprint = (strlen(s->post_imprint.specstring) > 0);
+  int send_date_time = (s->has_pre_imprinter && requires_preimprint) || (s->has_post_imprinter && requires_postimprint);
+
+  if (s->has_pre_imprinter){
+    ret = send_imprint_positioning(s, 0, requires_preimprint);
+    DBG(10, "load_imprinting_settings: send_pre_imprint_positioning = %d \n", ret);
+    if (ret != SANE_STATUS_GOOD)
+      return ret;
+    if (requires_preimprint){
+      ret = send_imprint_specstring(s, 0);
+      DBG(10, "load_imprinting_settings: send_pre_imprint_specstring = %d \n", ret);
+      if (ret != SANE_STATUS_GOOD)
+        return ret;
+    }
+  }
+
+  if (s->has_post_imprinter){
+    ret = send_imprint_positioning(s, 1, requires_postimprint);
+    DBG(10, "load_imprinting_settings: send_post_imprint_positioning = %d \n", ret);
+    if (ret != SANE_STATUS_GOOD)
+      return ret;
+    if (requires_postimprint){
+      ret = send_imprint_specstring(s, 1);
+      DBG(10, "load_imprinting_settings: send_post_imprint_specstring = %d \n", ret);
+      if (ret != SANE_STATUS_GOOD)
+        return ret;
+    }
+  }
+
+  if (send_date_time){
+    ret = send_imprint_date_and_time(s);
+    DBG(10, "load_imprinting_settings: send_imprint_date_and_time = %d \n", ret);
+  }
+  return ret;
+}
+
+static SANE_Status
+detect_imprinter(struct scanner *s,SANE_Int option)
+{
+  SANE_Status ret = SANE_STATUS_GOOD;
+
+  unsigned char cmd[READ_len];
+  size_t cmdLen = READ_len;
+
+  unsigned char in[R_IMPRINTER_len];
+  size_t inLen = R_IMPRINTER_len;
+
+  DBG (10, "detect_imprinter: start %d\n", option);
+
+  memset(cmd,0,cmdLen);
+  set_SCSI_opcode(cmd, READ_code);
+  set_R_datatype_code(cmd, SR_datatype_imprinters);
+  set_R_xfer_uid(cmd, option);
+  set_R_xfer_length(cmd, inLen);
+
+  ret = do_cmd(
+    s, 1, 0,
+    cmd, cmdLen,
+    NULL, 0,
+    in, &inLen
+  );
+
+  if (ret == SANE_STATUS_GOOD || ret == SANE_STATUS_EOF) {
+    ret = SANE_STATUS_GOOD;
+  }
+
+  int imprinter_found = get_R_IMPRINTER_found(in);
+  const char* imprinter_type = "unknown";
+  if (option == R_PRE_IMPRINTER){
+    s->has_pre_imprinter = imprinter_found;
+    imprinter_type = "pre-imprinter";
+  }
+  else if (option == R_POST_IMPRINTER){
+    s->has_post_imprinter = imprinter_found;
+    imprinter_type = "post-imprinter";
+  }
+
+  DBG (10, "detect_imprinter:  type: %s. found status bit: %d \n",imprinter_type,imprinter_found);
+
+  return ret;
+}
+
 /* reset image size parameters after buffer_xxx functions changed them */
 SANE_Status
 update_i_params(struct scanner *s)
@@ -4471,6 +5384,14 @@ sane_start (SANE_Handle handle)
       goto errors;
     }
 
+    if (s->has_pre_imprinter || s->has_post_imprinter){
+      ret = load_imprinting_settings(s);
+      if (ret != SANE_STATUS_GOOD) {
+        DBG (5, "sane_start: ERROR: invalid imprinting settings\n");
+        goto errors;
+      }
+    }
+
     /* reset the page counter after calibration */
     s->panel_counter = 0;
     s->prev_page = 0;
@@ -7204,7 +8125,7 @@ sense_handler (int fd, unsigned char * sensed_data, void *arg)
   DBG (5, "sense_handler: start\n");
 
   /* kill compiler warning */
-  fd = fd;
+  (void) fd;
 
   /* copy the rs return data into the scanner struct
      so that the caller can use it if he wants
@@ -7465,8 +8386,8 @@ do_scsi_cmd(struct scanner *s, int runRS, int timeout,
   int ret;
 
   /*shut up compiler*/
-  runRS=runRS;
-  timeout=timeout;
+  (void) runRS;
+  (void) timeout;
 
   DBG(10, "do_scsi_cmd: start\n");