New upstream version 1.0.27upstream/1.0.27

1 files changed, 603 insertions, 233 deletions

diff --git a/backend/hp3500.c b/backend/hp3500.c
index 48a8035..26fe071 100644
--- a/backend/hp3500.c
+++ b/backend/hp3500.c
@@ -84,6 +84,7 @@
 #include <string.h>
 #include <ctype.h>
 #include <time.h>
+#include <math.h>
 
 #include <sys/types.h>
 #include <unistd.h>
@@ -145,6 +146,7 @@ enum hp3500_option
   OPT_MODE,
   OPT_BRIGHTNESS,
   OPT_CONTRAST,
+  OPT_GAMMA,
 
   NUM_OPTIONS
 };
@@ -189,6 +191,8 @@ struct hp3500_data
   int brightness;
   int contrast;
 
+  double gamma;
+
   SANE_Option_Descriptor opt[NUM_OPTIONS];
   SANE_Device sane;
 };
@@ -218,6 +222,8 @@ static const SANE_Range range_brightness =
   { 0, 255, 0 };
 static const SANE_Range range_contrast =
   { 0, 255, 0 };
+static const SANE_Range range_gamma =
+  { SANE_FIX (0.2), SANE_FIX(4.0), SANE_FIX(0.01) };
 
 
 #define HP3500_COLOR_SCAN 0
@@ -233,6 +239,7 @@ static int reader_process (void *);
 static void calculateDerivedValues (struct hp3500_data *scanner);
 static void do_reset (struct hp3500_data *scanner);
 static void do_cancel (struct hp3500_data *scanner);
+static size_t max_string_size(char const **);
 
 /*
  * used by sane_get_devices
@@ -382,6 +389,7 @@ sane_open (SANE_String_Const name, SANE_Handle * handle)
   scanner->mode = 0;
   scanner->brightness = 128;
   scanner->contrast = 64;
+  scanner->gamma = 2.2;
   calculateDerivedValues (scanner);
 
   return SANE_STATUS_GOOD;
@@ -536,6 +544,10 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
 	  *(SANE_Word *) val = scanner->contrast;
 	  return SANE_STATUS_GOOD;
 
+        case OPT_GAMMA:
+          *(SANE_Word *) val = SANE_FIX(scanner->gamma);
+	  return SANE_STATUS_GOOD;
+
 	case OPT_BRIGHTNESS:
 	  *(SANE_Word *) val = scanner->brightness;
 	  return SANE_STATUS_GOOD;
@@ -649,6 +661,10 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
 	case OPT_CONTRAST:
 	  scanner->contrast = *(SANE_Word *) val;
 	  return SANE_STATUS_GOOD;
+
+        case OPT_GAMMA:
+          scanner->gamma = SANE_UNFIX(*(SANE_Word *) val);
+          return SANE_STATUS_GOOD;
 	}			/* switch */
     }				/* else */
   return SANE_STATUS_INVAL;
@@ -703,7 +719,7 @@ sane_start (SANE_Handle handle)
   scanner->reader_pid = sanei_thread_begin (reader_process, scanner);
   time (&scanner->last_scan);
 
-  if (scanner->reader_pid == -1)
+  if (!sanei_thread_is_valid (scanner->reader_pid))
     {
       DBG (MSG_ERR, "cannot fork reader process.\n");
       DBG (MSG_ERR, "%s", strerror (errno));
@@ -952,7 +968,7 @@ attachScanner (const char *devicename)
   dev->devicename = strdup (devicename);
   dev->sfd = -1;
   dev->last_scan = 0;
-  dev->reader_pid = -1;
+  dev->reader_pid = (SANE_Pid) -1;
   dev->pipe_r = dev->pipe_w = -1;
 
   dev->sane.name = dev->devicename;
@@ -1064,8 +1080,9 @@ init_options (struct hp3500_data *scanner)
   opt->title = SANE_TITLE_SCAN_MODE;
   opt->desc = SANE_DESC_SCAN_MODE;
   opt->type = SANE_TYPE_STRING;
+  opt->size = max_string_size(scan_mode_list);
   opt->constraint_type = SANE_CONSTRAINT_STRING_LIST;
-  opt->constraint.string_list = scan_mode_list;
+  opt->constraint.string_list = (SANE_String_Const *) scan_mode_list;
   opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
 
   opt = scanner->opt + OPT_BRIGHTNESS;
@@ -1086,6 +1103,16 @@ init_options (struct hp3500_data *scanner)
   opt->constraint.range = &range_contrast;
   opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
 
+  opt = scanner->opt + OPT_GAMMA;
+  opt->name = SANE_NAME_ANALOG_GAMMA;
+  opt->title = SANE_TITLE_ANALOG_GAMMA;
+  opt->desc = SANE_DESC_ANALOG_GAMMA;
+  opt->type = SANE_TYPE_FIXED;
+  opt->unit = SANE_UNIT_NONE;
+  opt->constraint_type = SANE_CONSTRAINT_RANGE;
+  opt->constraint.range = &range_gamma;
+  opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+
   return SANE_STATUS_GOOD;
 }
 
@@ -1098,7 +1125,7 @@ do_reset (struct hp3500_data *scanner)
 static void
 do_cancel (struct hp3500_data *scanner)
 {
-  if (scanner->reader_pid != -1)
+  if (sanei_thread_is_valid (scanner->reader_pid))
     {
 
       if (sanei_thread_kill (scanner->reader_pid) == 0)
@@ -1749,14 +1776,14 @@ rt_set_basic_calibration (unsigned char *regs,
 			  int greengain,
 			  int blueoffset1, int blueoffset2, int bluegain)
 {
-  regs[0x05] = redoffset1;
-  regs[0x02] = redoffset2;
+  regs[0x02] = redoffset1;
+  regs[0x05] = redoffset2;
   regs[0x08] = redgain;
-  regs[0x06] = greenoffset1;
-  regs[0x03] = greenoffset2;
+  regs[0x03] = greenoffset1;
+  regs[0x06] = greenoffset2;
   regs[0x09] = greengain;
-  regs[0x07] = blueoffset1;
-  regs[0x04] = blueoffset2;
+  regs[0x04] = blueoffset1;
+  regs[0x07] = blueoffset2;
   regs[0x0a] = bluegain;
   return 0;
 }
@@ -1765,13 +1792,36 @@ static int
 rt_set_calibration_addresses (unsigned char *regs,
 			      unsigned redaddr,
 			      unsigned greenaddr,
-			      unsigned blueaddr, unsigned endaddr)
+			      unsigned blueaddr,
+			      unsigned endaddr,
+			      unsigned width)
 {
+  unsigned endpage = (endaddr + 31) / 32;
+  unsigned scanline_pages = ((width + 1) * 3 + 31) / 32;
+
+  /* Red, green and blue detailed calibration addresses */
+
   regs[0x84] = redaddr;
   regs[0x8e] = (regs[0x8e] & 0x0f) | ((redaddr >> 4) & 0xf0);
   rt_set_value_lsbfirst (regs, 0x85, 2, greenaddr);
   rt_set_value_lsbfirst (regs, 0x87, 2, blueaddr);
-  rt_set_value_lsbfirst (regs, 0x89, 2, (endaddr + 31) / 32);
+
+  /* I don't know what the next three are used for, but each buffer commencing
+   * at 0x80 and 0x82 needs to hold a full scan line.
+   */
+
+  rt_set_value_lsbfirst (regs, 0x80, 2, endpage);
+  rt_set_value_lsbfirst (regs, 0x82, 2, endpage + scanline_pages);
+  rt_set_value_lsbfirst (regs, 0x89, 2, endpage + scanline_pages * 2);
+
+  /* I don't know what this is, but it seems to be a number of pages that can hold
+   * 16 complete scan lines, but not calculated as an offset from any other page
+   */
+
+  rt_set_value_lsbfirst (regs, 0x51, 2, (48 * (width + 1) + 31) / 32);
+
+  /* I don't know what this is either, but this is what the Windows driver does */
+  rt_set_value_lsbfirst (regs, 0x8f, 2, 0x1c00);
   return 0;
 }
 
@@ -1798,6 +1848,13 @@ rt_set_data_feed_on (unsigned char *regs)
 }
 
 static int
+rt_set_data_feed_off (unsigned char *regs)
+{
+  regs[0xb2] |= 0x04;
+  return 0;
+}
+
+static int
 rt_enable_ccd (unsigned char *regs, int enable)
 {
   if (enable)
@@ -2245,10 +2302,14 @@ rt_nvram_read (int block, int location, unsigned char *data, int bytes)
   return 0;
 }
 
+/* This is what we want as the initial registers, not what they
+ * are at power on time. In particular 13 bytes at 0x10 are
+ * different, and the byte at 0x94 is different.
+ */
 static unsigned char initial_regs[] = {
   /* 0x00 */ 0xf5, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   /* 0x08 */ 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00,
-  /* 0x10 */ 0xe1, 0xfc, 0xff, 0xff, 0x00, 0x00, 0x00, 0xfc,
+  /* 0x10 */ 0x81, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
   /* 0x18 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
   /* 0x20 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   /* 0x28 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x06, 0x19,
@@ -2264,7 +2325,7 @@ static unsigned char initial_regs[] = {
   /* 0x78 */ 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   /* 0x80 */ 0x0f, 0x02, 0x4b, 0x02, 0x00, 0xec, 0x19, 0xd8,
   /* 0x88 */ 0x2d, 0x87, 0x02, 0xff, 0x3f, 0x78, 0x60, 0x00,
-  /* 0x90 */ 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  /* 0x90 */ 0x1c, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
   /* 0x98 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   /* 0xa0 */ 0x00, 0x00, 0x00, 0x0c, 0x27, 0x64, 0x00, 0x00,
   /* 0xa8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -2363,14 +2424,14 @@ static struct resolution_parameters resparms[] = {
   /* My values - all work */
   /*res   r39 rC3 rC6 freq cph0s rgo gbo intra mmcm d3 tg            stepsz */
   {1200, 3, 6, 4, 2, 1, 22, 22, 4, 2, 1, RT_NORMAL_TG, 0x157b},
-  {600, 15, 6, 4, 1, 0, 9, 10, 0, 2, 1, RT_NORMAL_TG, 0x055e},
+  {600, 15, 6, 4, 1, 1, 9, 10, 0, 2, 1, RT_NORMAL_TG, 0x055e},
   {400, 3, 1, 4, 1, 1, 6, 6, 1, 2, 1, RT_NORMAL_TG, 0x157b},
-  {300, 15, 3, 4, 1, 0, 5, 4, 0, 2, 1, RT_NORMAL_TG, 0x02af},
-  {200, 7, 1, 4, 1, 0, 3, 3, 0, 2, 1, RT_NORMAL_TG, 0x055e},
-  {150, 15, 3, 1, 1, 0, 2, 2, 0, 2, 1, RT_NORMAL_TG, 0x02af},
-  {100, 3, 1, 3, 1, 0, 1, 1, 0, 2, 1, RT_NORMAL_TG, 0x0abd},
-  {75, 15, 3, 3, 1, 0, 1, 1, 0, 2, 1, RT_NORMAL_TG, 0x02af},
-  {50, 15, 1, 1, 1, 0, 0, 0, 0, 2, 1, RT_NORMAL_TG, 0x055e},
+  {300, 15, 3, 4, 1, 1, 5, 4, 0, 2, 1, RT_NORMAL_TG, 0x02af},
+  {200, 7, 1, 4, 1, 1, 3, 3, 0, 2, 1, RT_NORMAL_TG, 0x055e},
+  {150, 15, 3, 1, 1, 1, 2, 2, 0, 2, 1, RT_NORMAL_TG, 0x02af},
+  {100, 3, 1, 3, 1, 1, 1, 1, 0, 2, 1, RT_NORMAL_TG, 0x0abd},
+  {75, 15, 3, 3, 1, 1, 1, 1, 0, 2, 1, RT_NORMAL_TG, 0x02af},
+  {50, 15, 1, 1, 1, 1, 0, 0, 0, 2, 1, RT_NORMAL_TG, 0x055e},
   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 };
 
@@ -2597,6 +2658,90 @@ constrain (int val, int min, int max)
   return val;
 }
 
+#if 0
+static void
+sram_dump_byte(FILE *fp,
+               unsigned char const *left,
+               unsigned leftstart,
+               unsigned leftlimit,
+               unsigned char const *right,
+               unsigned rightstart,
+               unsigned rightlimit,
+               unsigned idx)
+{
+  unsigned ridx = rightstart + idx;
+  unsigned lidx = leftstart + idx;
+
+  putc(' ', fp);
+  if (rightstart < rightlimit && leftstart < leftlimit && left[lidx] != right[ridx])
+    fputs("<b>", fp);
+  if (leftstart < leftlimit)
+    fprintf(fp, "%02x", left[lidx]);
+  else
+    fputs("  ", fp);
+  if (rightstart < rightlimit && leftstart < leftlimit && left[lidx] != right[ridx])
+    fputs("</b>", fp);
+}
+
+static void
+dump_sram_to_file(char const *fname,
+                  unsigned char const *expected,
+                  unsigned end_calibration_offset)
+{
+  FILE *fp = fopen(fname, "w");
+  rt_set_sram_page(0);
+
+  if (fp)
+    {
+      unsigned char buf[1024];
+      unsigned loc = 0;
+
+      fprintf(fp, "<html><head></head><body><pre>\n");
+      while (loc < end_calibration_offset)
+        {
+          unsigned byte = 0;
+
+          rt_read_sram(1024, buf);
+
+          while (byte < 1024)
+            {
+              unsigned idx = 0;
+
+              fprintf(fp, "%06x:", loc);
+              do
+                {
+		  sram_dump_byte(fp, buf, byte, 1024, expected, loc, end_calibration_offset, idx);
+                } while (++idx & 0x7);
+              fprintf(fp, " -");
+              do
+                {
+		  sram_dump_byte(fp, buf, byte, 1024, expected, loc, end_calibration_offset, idx);
+                } while (++idx & 0x7);
+
+              idx = 0;
+              fputs("     ", fp);
+
+              do
+                {
+                  sram_dump_byte(fp, expected, loc, end_calibration_offset, buf, byte, 1024, idx);
+                } while (++idx & 0x7);
+              fprintf(fp, " -");
+              do
+                {
+                  sram_dump_byte(fp, expected, loc, end_calibration_offset, buf, byte, 1024, idx);
+                } while (++idx & 0x7);
+
+
+              fputs("\n", fp);
+              byte += 16;
+              loc += 16;
+            }
+        }
+      fprintf(fp, "</pre></body></html>");
+      fclose(fp);
+    }
+}
+#endif
 
 static int
 rts8801_doscan (unsigned width,
@@ -2610,13 +2755,13 @@ rts8801_doscan (unsigned width,
 		int oddfirst,
 		unsigned char const *calib_info,
 		int merged_channels,
-		detailed_calibration_data const *detailed_calib_data)
+		double *postprocess_offsets,
+		double *postprocess_gains)
 {
   unsigned rowbytes = 0;
   unsigned output_rowbytes = 0;
   unsigned channels = 0;
   unsigned total_rows = 0;
-  unsigned bytesperchannel;
   unsigned char *row_buffer;
   unsigned char *output_buffer;
   unsigned buffered_rows;
@@ -2638,7 +2783,7 @@ rts8801_doscan (unsigned width,
 
   channels = 3;
   rowbytes = width * 3;
-  bytesperchannel = width;
+
   switch (colour)
     {
     case HP3500_GRAY_SCAN:
@@ -2710,32 +2855,27 @@ rts8801_doscan (unsigned width,
 		      if (!rows_to_begin || !--rows_to_begin)
 			{
 			  unsigned char *outnow = output_buffer;
+                          unsigned x;
 
-			  for (i = 0;
-			       i < (merged_channels ? rowbytes : width);
-			       i += merged_channels ? channels : 1)
+			  for (i = x = 0;
+			       x < width;
+			       ++x, i += merged_channels ? channels : 1)
 			    {
 			      for (j = 0; j < channels; ++j)
 				{
 				  unsigned pix =
 				    (unsigned char) channel_data[j][i & 1][i];
 
-				  if (detailed_calib_data)
-				    {
-				      unsigned char const *calib_start =
-					detailed_calib_data->channeldata[j] +
-					2 *
-					detailed_calib_data->
-					resolution_divisor * i /
-					(merged_channels ? channels : 1);
-				      pix =
-					constrain ((int) pix -
-						   (int) calib_start[0], 0,
-						   255);
-				      pix =
-					constrain (pix * calib_start[1] /
-						   0x40, 0, 255);
-				    }
+                                  if (postprocess_gains && postprocess_offsets)
+                                  {
+                                    int ppidx = j * width + x;
+
+                                    pix = constrain ( pix
+                                                       * postprocess_gains[ppidx]
+                                                       - postprocess_offsets[ppidx],
+                                                      0,
+                                                      255);
+                                  }
 				  *outnow++ = pix;
 				}
 			    }
@@ -2818,6 +2958,9 @@ static unsigned local_sram_size;
 static unsigned char r93setting;
 
 #define RTS8801_F_SUPPRESS_MOVEMENT	1
+#define	RTS8801_F_LAMP_OFF		2
+#define RTS8801_F_NO_DISPLACEMENTS	4
+#define RTS8801_F_ODDX			8
 
 static int
 find_resolution_index (unsigned resolution)
@@ -2848,7 +2991,8 @@ rts8801_fullscan (unsigned x,
 		  int green_calib_offset,
 		  int blue_calib_offset,
 		  int end_calib_offset,
-		  detailed_calibration_data const *detailed_calib_data)
+                  double *postprocess_offsets,
+                  double *postprocess_gains)
 {
   int ires, jres;
   int tg_setting;
@@ -2856,6 +3000,10 @@ rts8801_fullscan (unsigned x,
   unsigned char offdutytime;
   int result;
   int scan_frequency;
+  unsigned intra_channel_offset;
+  unsigned red_green_offset;
+  unsigned green_blue_offset;
+  unsigned total_offsets;
 
   ires = find_resolution_index (xresolution);
   jres = find_resolution_index (yresolution);
@@ -2889,47 +3037,32 @@ rts8801_fullscan (unsigned x,
 
   rt_set_movement_pattern (regs, 0x800000);
 
-
-  tg_setting = resparms[jres].tg;
-  rt_set_ccd_shift_clock_multiplier (regs, tg_info[tg_setting].tg_cph0p);
-  rt_set_ccd_clock_reset_interval (regs, tg_info[tg_setting].tg_crsp);
-  rt_set_ccd_clamp_clock_multiplier (regs, tg_info[tg_setting].tg_cclpp);
-
-
-  rt_set_one_register (0xc6, 0);
-  rt_set_one_register (0xc6, 0);
-
-  rt_set_step_size (regs, resparms[jres].step_size);
-
   rt_set_direction_forwards (regs);
-
   rt_set_stop_when_rewound (regs, 0);
-  rt_set_data_feed_on (regs);
 
-  rt_set_calibration_addresses (regs, 0, 0, 0, 0);
+  rt_set_calibration_addresses (regs, 0, 0, 0, 0, 0);
 
   rt_set_basic_calibration (regs,
 			    calib_info[0], calib_info[1], calib_info[2],
 			    calib_info[3], calib_info[4], calib_info[5],
 			    calib_info[6], calib_info[7], calib_info[8]);
   regs[0x0b] = 0x70;		/* If set to 0x71, the alternative, all values are low */
+  regs[0x40] &= 0xc0;
 
   if (red_calib_offset >= 0
       && green_calib_offset >= 0
-      && blue_calib_offset >= 0 &&
-      yresolution < 400)
+      && blue_calib_offset >= 0)
     {
       rt_set_calibration_addresses (regs, red_calib_offset,
 				    green_calib_offset, blue_calib_offset,
-				    end_calib_offset);
+				    end_calib_offset,
+				    w);
       regs[0x40] |= 0x2f;
-      detailed_calib_data = 0;
     }
   else if (end_calib_offset >= 0)
     {
       rt_set_calibration_addresses (regs, 0x600, 0x600, 0x600,
-				    end_calib_offset);
-      regs[0x40] &= 0xc0;
+				    end_calib_offset, w);
     }
 
   rt_set_channel (regs, RT_CHANNEL_ALL);
@@ -2937,23 +3070,9 @@ rts8801_fullscan (unsigned x,
   rt_set_merge_channels (regs, 1);
   rt_set_colour_mode (regs, 1);
 
-  rt_set_motor_movement_clock_multiplier (regs,
-					  resparms[jres].
-					  motor_movement_clock_multiplier);
-
-  rt_set_cdss (regs, tg_info[tg_setting].tg_cdss1,
-	       tg_info[tg_setting].tg_cdss2);
-  rt_set_cdsc (regs, tg_info[tg_setting].tg_cdsc1,
-	       tg_info[tg_setting].tg_cdsc2);
-  rt_update_after_setting_cdss2 (regs);
-
   rt_set_last_sram_page (regs, (local_sram_size - 1) >> 5);
 
-  regs[0x39] = resparms[jres].reg_39_value;
-  regs[0xc3] = (regs[0xc3] & 0xf8) | resparms[jres].reg_c3_value;
-  regs[0xc6] = (regs[0xc6] & 0xf8) | resparms[jres].reg_c6_value;
   scan_frequency = resparms[jres].scan_frequency;
-  rt_set_scan_frequency (regs, scan_frequency);
   rt_set_cph0s (regs, resparms[ires].cph0s);
   if (resparms[ires].d3_bit_3_value)
     regs[0xd3] |= 0x08;
@@ -2962,15 +3081,10 @@ rts8801_fullscan (unsigned x,
 
   if (flags & RTS8801_F_SUPPRESS_MOVEMENT)
     regs[0xc3] &= 0x7f;
-  rt_set_horizontal_resolution (regs, xresolution);
 
-  rt_set_noscan_distance (regs, y * scan_frequency - 1);
-  rt_set_total_distance (regs, scan_frequency *
-			 (y +
-			  h +
-			  resparms[jres].red_green_offset +
-			  resparms[jres].green_blue_offset +
-			  resparms[jres].intra_channel_offset) - 1);
+  regs[0xb2] &= 0xf7;
+
+  rt_set_horizontal_resolution (regs, xresolution);
 
   rt_set_scanline_start (regs,
 			 x * (1200 / xresolution) /
@@ -2982,6 +3096,118 @@ rts8801_fullscan (unsigned x,
 		       (resparms[ires].cph0s ? 1 : 2) /
 		       (resparms[ires].d3_bit_3_value ? 1 : 2));
 
+  if (flags & RTS8801_F_NO_DISPLACEMENTS)
+    {
+      red_green_offset = green_blue_offset = intra_channel_offset = 0;
+    }
+  else
+    {
+      red_green_offset = resparms[jres].red_green_offset;
+      green_blue_offset = resparms[jres].green_blue_offset;
+      intra_channel_offset = resparms[jres].intra_channel_offset;
+    }
+  total_offsets = red_green_offset + green_blue_offset + intra_channel_offset;
+  if (y > total_offsets + 2)
+    y -= total_offsets;
+  h += total_offsets;
+
+  if (yresolution > 75 && !(flags & RTS8801_F_SUPPRESS_MOVEMENT))
+    {
+      int rmres = find_resolution_index (50);
+
+      if (rmres >= 0)
+	{
+	  int factor = yresolution / 50;
+	  int fastres = y / factor;
+	  int remainder = y % factor;
+
+	  while (remainder < 2)
+	    {
+		--fastres;
+		remainder += factor;
+	    }
+
+	  if (fastres >= 3)
+	    {
+	      y = remainder;
+
+	      rt_set_noscan_distance(regs, fastres * resparms[rmres].scan_frequency - 2);
+	      rt_set_total_distance(regs, fastres * resparms[rmres].scan_frequency - 1);
+
+	      rt_set_scan_frequency(regs, 1);
+
+	      tg_setting = resparms[rmres].tg;
+	      rt_set_ccd_shift_clock_multiplier (regs, tg_info[tg_setting].tg_cph0p);
+	      rt_set_ccd_clock_reset_interval (regs, tg_info[tg_setting].tg_crsp);
+	      rt_set_ccd_clamp_clock_multiplier (regs, tg_info[tg_setting].tg_cclpp);	      
+
+	      rt_set_one_register (0xc6, 0);
+	      rt_set_one_register (0xc6, 0);
+
+	      rt_set_step_size (regs, resparms[rmres].step_size);
+
+	      rt_set_motor_movement_clock_multiplier (regs,
+						      resparms[rmres].
+							  motor_movement_clock_multiplier);
+
+	      rt_set_cdss (regs, tg_info[tg_setting].tg_cdss1,
+			   tg_info[tg_setting].tg_cdss2);
+	      rt_set_cdsc (regs, tg_info[tg_setting].tg_cdsc1,
+			   tg_info[tg_setting].tg_cdsc2);
+	      rt_update_after_setting_cdss2 (regs);
+
+	      regs[0x39] = resparms[rmres].reg_39_value;
+	      regs[0xc3] = (regs[0xc3] & 0xf8) | resparms[rmres].reg_c3_value;
+	      regs[0xc6] = (regs[0xc6] & 0xf8) | resparms[rmres].reg_c6_value;
+
+	      rt_set_data_feed_off (regs);
+
+	      rt_set_all_registers (regs);
+
+  	      rt_set_one_register (0x2c, regs[0x2c]);
+
+	      if (DBG_LEVEL >= 5)
+	        dump_registers (regs);
+
+	      rt_start_moving ();
+	      while (rt_is_moving ());
+	    }
+	}
+    }
+
+
+  rt_set_noscan_distance (regs, y * scan_frequency - 1);
+  rt_set_total_distance (regs, scan_frequency * (y + h) - 1);
+
+  rt_set_scan_frequency (regs, scan_frequency);
+
+  tg_setting = resparms[jres].tg;
+
+  rt_set_ccd_shift_clock_multiplier (regs, tg_info[tg_setting].tg_cph0p);
+  rt_set_ccd_clock_reset_interval (regs, tg_info[tg_setting].tg_crsp);
+  rt_set_ccd_clamp_clock_multiplier (regs, tg_info[tg_setting].tg_cclpp);
+
+  rt_set_one_register (0xc6, 0);
+  rt_set_one_register (0xc6, 0);
+
+  rt_set_step_size (regs, resparms[jres].step_size);
+
+  rt_set_motor_movement_clock_multiplier (regs,
+					  resparms[jres].
+					  motor_movement_clock_multiplier);
+
+  rt_set_cdss (regs, tg_info[tg_setting].tg_cdss1,
+	       tg_info[tg_setting].tg_cdss2);
+  rt_set_cdsc (regs, tg_info[tg_setting].tg_cdsc1,
+	       tg_info[tg_setting].tg_cdsc2);
+  rt_update_after_setting_cdss2 (regs);
+
+  regs[0x39] = resparms[jres].reg_39_value;
+  regs[0xc3] = (regs[0xc3] & 0xf8) | resparms[jres].reg_c3_value;
+  regs[0xc6] = (regs[0xc6] & 0xf8) | resparms[jres].reg_c6_value;
+
+  rt_set_data_feed_on (regs);
+
   rt_set_all_registers (regs);
 
   rt_set_one_register (0x2c, regs[0x2c]);
@@ -2992,12 +3218,13 @@ rts8801_fullscan (unsigned x,
   result = rts8801_doscan (w,
 			   h,
 			   colour,
-			   resparms[jres].red_green_offset,
-			   resparms[jres].green_blue_offset,
-			   resparms[jres].intra_channel_offset,
+			   red_green_offset,
+			   green_blue_offset,
+			   intra_channel_offset,
 			   cbfunc, param, (x & 1), calib_info,
-			   (regs[0x2f] & 0x04) != 0, detailed_calib_data);
-
+			   (regs[0x2f] & 0x04) != 0,
+                           postprocess_offsets,
+                           postprocess_gains);
   return result;
 }
 
@@ -3080,6 +3307,11 @@ sum_channel (unsigned char *p, int n, int bytwo)
 
 static int do_warmup = 1;
 
+#define DETAILED_PASS_COUNT		3
+#define DETAILED_PASS_OFFSETS		0
+#define	DETAILED_PASS_GAINS_FIRSTPASS	1
+#define	DETAILED_PASS_GAINS_SECONDPASS	2
+
 static int
 rts8801_scan (unsigned x,
 	      unsigned y,
@@ -3090,26 +3322,22 @@ rts8801_scan (unsigned x,
 	      unsigned brightness,
 	      unsigned contrast,
 	      rts8801_callback cbfunc,
-	      void *param)
+	      void *param,
+	      double gamma)
 {
   unsigned char calib_info[9];
   unsigned char calibbuf[2400];
   struct dcalibdata dcd;
   struct calibdata cd;
   unsigned char *detail_buffer = 0;
-  int iCalibOffset;
-  int iCalibX;
   int iCalibY;
-  int iCalibWidth;
   int iCalibTarget;
-  int iCalibPixels;
   int iMoveFlags = 0;
-  unsigned int aiLow[3] = { 0, 0, 0 };
-  unsigned int aiHigh[3] = { 256, 256, 256 };
-  unsigned aiBestOffset[3];
+  unsigned aiBestOffset[6];
+  int aiPassed[6];
   int i;
   unsigned j;
-  int anychanged;
+  int k;
   int calibration_size;
   unsigned char *pDetailedCalib;
   int red_calibration_offset;
@@ -3121,7 +3349,13 @@ rts8801_scan (unsigned x,
   int resolution_index;
   int detailed_calibration_rows = 50;
   unsigned char *tdetail_buffer;
-  detailed_calibration_data detailed_calib_data;
+  int pass;
+  int onechanged;
+  double *postprocess_gains;
+  double *postprocess_offsets;
+  int needs_postprocessed_calibration = 0;
+  double contrast_adjust = (double) contrast / 64;
+  int brightness_adjust = brightness - 0x80;
 
   /* Initialise and power up */
 
@@ -3150,99 +3384,101 @@ rts8801_scan (unsigned x,
 
   calib_info[2] = calib_info[5] = calib_info[8] = 1;
 
-  calib_info[0] = calib_info[1] = calib_info[3] = calib_info[4] =
-    calib_info[6] = calib_info[7] = 0xb4;
-
-  iCalibOffset = 0;		/* Note that horizontal resolution is always 600dpi for calibration. 330 is 110 dots in (for R,G,B channels) */
-  iCalibX = 1;
-  iCalibPixels = 50;
-  iCalibY = (resolution == 25) ? 1 : 2;	/* Was 1200 / resolution, which would take us past the calibration area for 50dpi */
-  iCalibWidth = 100;
+  iCalibY = (resolution == 25) ? 1 : 2;
   iCalibTarget = 550;
+ 
+  rt_turn_off_lamp();
 
-  for (i = 0; i < 3; ++i)
-    aiBestOffset[i] = 0xb4;
-
+  for (i = 0; i < 6; ++i)
+    {
+      aiBestOffset[i] = 0xbf;
+      aiPassed[i] = 0;
+    }
+ 
   do
     {
       DBG (30, "Initial calibration pass commences\n");
-      anychanged = 0;
-
-      for (i = 0; i < 3; ++i)
-	{
-	  aiBestOffset[i] = (aiHigh[i] + aiLow[i] + 1) / 2;
-	}
 
+      onechanged = 0;
       for (i = 0; i < 3; ++i)
-	calib_info[i * 3] = calib_info[i * 3 + 1] = aiBestOffset[i];
-
+        {
+	  calib_info[i * 3] = aiBestOffset[i];
+	  calib_info[i * 3 + 1] = aiBestOffset[i + 3];
+        }
+ 
       cd.buffer = calibbuf;
       cd.space = sizeof (calibbuf);
       DBG (30, "Commencing scan for initial calibration pass\n");
-      rts8801_fullscan (iCalibX, iCalibY, iCalibWidth, 2, 600, resolution,
+      rts8801_fullscan (1401, iCalibY, 100, 2, 400, resolution,
 			HP3500_COLOR_SCAN, (rts8801_callback) storefunc, &cd,
-			calib_info, iMoveFlags, -1, -1, -1, -1, 0);
+			calib_info, iMoveFlags, -1, -1, -1, -1, 0, 0);
       DBG (30, "Completed scan for initial calibration pass\n");
-      iMoveFlags = RTS8801_F_SUPPRESS_MOVEMENT;
+      iMoveFlags = RTS8801_F_SUPPRESS_MOVEMENT | RTS8801_F_NO_DISPLACEMENTS;
+      iCalibY = 2;
 
-      for (i = 0; i < 3; ++i)
+      for (i = 0; i < 6; ++i)
 	{
 	  int sum;
 
-	  if (aiBestOffset[i] >= 255)
+	  if (aiBestOffset[i] >= 255 || aiPassed[i] > 2)
 	    continue;
-	  sum = sum_channel (calibbuf + iCalibOffset + i, iCalibPixels, 0);
+	  sum = sum_channel (calibbuf + i, 50, 1);
 	  DBG (20, "channel[%d] sum = %d (target %d)\n", i, sum,
 	       iCalibTarget);
 
-	  if (sum >= iCalibTarget)
-	    aiHigh[i] = aiBestOffset[i];
-	  else
-	    aiLow[i] = aiBestOffset[i];
+	  if (sum < iCalibTarget)
+            {
+              onechanged = 1;
+              ++aiBestOffset[i];
+            }
+          else
+            {
+              ++aiPassed[i];
+            }
 	}
       DBG (30, "Initial calibration pass completed\n");
     }
-  while (aiLow[0] < aiHigh[0] - 1 && aiLow[1] < aiHigh[1] - 1
-	 && aiLow[1] < aiHigh[1] + 1);
+  while (onechanged);
 
   DBG (20, "Offsets calculated\n");
-  cd.buffer = calibbuf;
-  cd.space = sizeof (calibbuf);
-  DBG (20, "Scanning for part 2 of initial calibration\n");
-  rts8801_fullscan (iCalibX + 2100, iCalibY, iCalibWidth, 2, 600, resolution,
-		    HP3500_COLOR_SCAN, (rts8801_callback) storefunc, &cd,
-		    calib_info, RTS8801_F_SUPPRESS_MOVEMENT, -1, -1, -1, -1,
-		    0);
-  DBG (20, "Scan for part 2 of initial calibration completed\n");
 
-  DBG (20, "Initial calibration completed\n");
+  rt_turn_on_lamp();
+  usleep(500000);
 
   tdetail_buffer =
     (unsigned char *) malloc (w * 3 * detailed_calibration_rows);
-  aiLow[0] = aiLow[1] = aiLow[2] = 1;
-  aiHigh[0] = aiHigh[1] = aiHigh[2] = 64;
 
+  for (i = 0; i < 3; ++i)
+    {
+      calib_info[i * 3 + 2] = 1;
+      aiPassed[i] = 0;
+    }
+ 
   do
     {
       struct dcalibdata dcdt;
 
-      for (i = 0; i < 3; ++i)
-	calib_info[i * 3 + 2] = (aiLow[i] + aiHigh[i]) / 2;
-
       dcdt.buffers[0] = tdetail_buffer;
       dcdt.buffers[1] = (tdetail_buffer + w * detailed_calibration_rows);
       dcdt.buffers[2] = (dcdt.buffers[1] + w * detailed_calibration_rows);
       dcdt.pixelsperrow = w;
       dcdt.pixelnow = dcdt.channelnow = dcdt.firstrowdone = 0;
+      DBG (20, "Scanning for part 2 of initial calibration\n");
       rts8801_fullscan (x, 4, w, detailed_calibration_rows + 1, resolution,
 			resolution, HP3500_COLOR_SCAN,
 			(rts8801_callback) accumfunc, &dcdt, calib_info,
-			RTS8801_F_SUPPRESS_MOVEMENT, -1, -1, -1, -1, 0);
+			RTS8801_F_SUPPRESS_MOVEMENT | RTS8801_F_NO_DISPLACEMENTS, -1, -1, -1, -1, 0, 0);
+      DBG (20, "Scan for part 2 of initial calibration completed\n");
+
+      onechanged = 0;
       for (i = 0; i < 3; ++i)
 	{
 	  int largest = 1;
 
-	  for (j = 0; j < w; ++j)
+          if (aiPassed[i] > 2 || calib_info[i * 3 + 2] >= 63)
+            continue;
+
+ 	  for (j = 0; j < w; ++j)
 	    {
 	      int val =
 		calcmedian (dcdt.buffers[i], j, w, detailed_calibration_rows);
@@ -3252,16 +3488,17 @@ rts8801_scan (unsigned x,
 	    }
 
 	  if (largest < 0xe0)
-	    aiLow[i] = calib_info[i * 3 + 2];
-	  else
-	    aiHigh[i] = calib_info[i * 3 + 2];
+            {
+              ++calib_info[i * 3 + 2];
+              onechanged = 1;
+            }
+          else
+            {
+              ++aiPassed[i];
+            }
 	}
     }
-  while (aiLow[0] < aiHigh[0] - 1 && aiLow[1] < aiHigh[1] - 1
-	 && aiLow[1] < aiHigh[1] + 1);
-
-  for (i = 0; i < 3; ++i)
-    calib_info[i * 3 + 2] = aiLow[i];
+  while (onechanged);
 
   for (i = 0; i < 3; ++i)
     {
@@ -3282,15 +3519,7 @@ rts8801_scan (unsigned x,
   dcd.buffers[1] = (detail_buffer + w * detailed_calibration_rows);
   dcd.buffers[2] = (dcd.buffers[1] + w * detailed_calibration_rows);
   dcd.pixelsperrow = w;
-  dcd.pixelnow = dcd.channelnow = dcd.firstrowdone = 0;
-
-  DBG (10, "Performing detailed calibration scan\n");
-  rts8801_fullscan (x, iCalibY, w, detailed_calibration_rows + 1,
-		    resolution, resolution, HP3500_COLOR_SCAN,
-		    (rts8801_callback) accumfunc, &dcd, calib_info,
-		    RTS8801_F_SUPPRESS_MOVEMENT, -1, -1, -1, -1, 0);
 
-  DBG (10, "Detailed calibration scan completed\n");
 
   /* And now for the detailed calibration */
   resolution_index = find_resolution_index (resolution);
@@ -3301,101 +3530,221 @@ rts8801_scan (unsigned x,
     base_resolution *= 2;
   resolution_divisor = base_resolution / resolution;
 
-  calibration_size = w * resolution_divisor * 6 + 1536;
-  red_calibration_offset = 1536;
-  blue_calibration_offset =
-    red_calibration_offset + w * resolution_divisor * 2;
+  calibration_size = w * resolution_divisor * 6 + 1568 + 96;
+  red_calibration_offset = 0x600;
   green_calibration_offset =
-    blue_calibration_offset + w * resolution_divisor * 2;
-  end_calibration_offset =
+    red_calibration_offset + w * resolution_divisor * 2;
+  blue_calibration_offset =
     green_calibration_offset + w * resolution_divisor * 2;
+  end_calibration_offset =
+    blue_calibration_offset + w * resolution_divisor * 2;
   pDetailedCalib = (unsigned char *) malloc (calibration_size);
 
   memset (pDetailedCalib, 0, calibration_size);
+
   for (i = 0; i < 3; ++i)
     {
       int idx =
-	(i == 0) ? red_calibration_offset : (i ==
-					     1) ? green_calibration_offset :
-	blue_calibration_offset;
-      double g = calib_info[i * 3 + 2];
+        (i == 0) ? red_calibration_offset :
+        (i == 1) ? green_calibration_offset :
+                       blue_calibration_offset;
 
       for (j = 0; j < 256; j++)
-	{
-	  int val = j;
-
-	  if (val < 0)
-	    val = 0;
-	  if (val > 255)
-	    val = 255;
-	  pDetailedCalib[i * 512 + j * 2] = val;
-	  pDetailedCalib[i * 512 + j * 2 + 1] = val;
-	}
+        {
+          /* Gamma table - appears to be 256 byte pairs for each input
+           * range (so the first entry cover inputs in the range 0 to 1,
+           * the second 1 to 2, and so on), mapping that input range
+           * (including the fractional parts within it) to an output
+           * range.
+           */
+          pDetailedCalib[i * 512 + j * 2] = j;
+          pDetailedCalib[i * 512 + j * 2 + 1] = j;
+        }
 
       for (j = 0; j < w; ++j)
-	{
-	  int multnow;
-	  int offnow;
-
-	  /* This seems to be the approach for reg 0x40 & 0x3f == 0x27, which allows detailed
-	   * calibration to return either higher or lower values.
-	   */
-	  int k;
-
-	  {
-	    double denom1 =
-	      calcmedian (dcd.buffers[i], j, w, detailed_calibration_rows);
-	    double f = 0xff / (denom1 - 2 * g);
-	    double contrast_adjust = (double) (contrast + 1) / 64;
-
-	    multnow = f * 64 * contrast_adjust;
-	    offnow = 4 * g + 128 - brightness;
-	  }
-	  if (multnow < 0)
-	    multnow = 0;
-	  if (multnow > 255)
-	    multnow = 255;
-	  if (offnow < 0)
-	    offnow = 0;
-	  if (offnow > 255)
-	    offnow = 255;
-
-	  for (k = 0; k < resolution_divisor; ++k)
-	    {
-	      /*multnow = j * resolution_divisor + k; */
-	      pDetailedCalib[idx++] = offnow;	/* Subtract this value from the result */
-	      pDetailedCalib[idx++] = multnow;	/* Then multiply by this value divided by 0x40 */
-	    }
-	}
+        {
+          for (k = 0; k < resolution_divisor; ++k)
+            {
+              pDetailedCalib[idx++] = 0;
+              pDetailedCalib[idx++] = 0x80;
+            }
+        }
     }
 
-  DBG (10, "\n");
-
   rt_set_sram_page (0);
   rt_set_one_register (0x93, r93setting);
   rt_write_sram (calibration_size, pDetailedCalib);
 
-  /* And finally, perform the scan */
+  postprocess_gains = (double *) malloc(sizeof(double) * 3 * w);
+  postprocess_offsets = (double *) malloc(sizeof(double) * 3 * w);
+
+  for (pass = 0; pass < DETAILED_PASS_COUNT; ++pass)
+    {
+      int ppidx = 0;
+
+      DBG (10, "Performing detailed calibration scan %d\n", pass);
+
+      switch (pass)
+      {
+      case DETAILED_PASS_OFFSETS:
+        rt_turn_off_lamp();
+	usleep(500000); /* To be sure it has gone off */
+        break;
+
+      case DETAILED_PASS_GAINS_FIRSTPASS:
+        rt_turn_on_lamp();
+	usleep(500000); /* Give the lamp time to settle */
+        break;
+      }
+
+      dcd.pixelnow = dcd.channelnow = dcd.firstrowdone = 0;
+      rts8801_fullscan (x, iCalibY, w, detailed_calibration_rows + 1,
+                        resolution, resolution, HP3500_COLOR_SCAN,
+                        (rts8801_callback) accumfunc, &dcd,
+			calib_info,
+                        RTS8801_F_SUPPRESS_MOVEMENT | RTS8801_F_NO_DISPLACEMENTS,
+			red_calibration_offset,
+			green_calibration_offset,
+			blue_calibration_offset,
+			end_calibration_offset,
+			0, 0);
+
+      DBG (10, " Detailed calibration scan %d completed\n", pass);
+
+      for (i = 0; i < 3; ++i)
+        {
+          int idx =
+            (i == 0) ? red_calibration_offset :
+	    (i == 1) ? green_calibration_offset :
+                       blue_calibration_offset;
+
+          for (j = 0; j < w; ++j)
+            {
+              double multnow = 0x80;
+              int offnow = 0;
+
+              /* This seems to be the approach for reg 0x40 & 0x3f == 0x27, which allows detailed
+               * calibration to return either higher or lower values.
+               */
+
+              {
+                double denom1 =
+                  calcmedian (dcd.buffers[i], j, w, detailed_calibration_rows);
+
+		switch (pass)
+                  {
+                  case DETAILED_PASS_OFFSETS:
+                    /* The offset is the number needed to be subtracted from "black" at detailed gain = 0x80,
+                     * which is the value we started with. For the next round, pull the gain down to 0x20. Our
+                     * next scan is a test scan to confirm the offset works.
+                     */
+                    multnow = 0x20;
+                    offnow = denom1;
+                    break;
+
+                  case DETAILED_PASS_GAINS_FIRSTPASS:
+                    multnow = 128.0 / denom1 * 0x20; /* Then bring it up to whatever we need to hit 192 */
+                    if (multnow > 255)
+                      multnow = 255;
+                    offnow = pDetailedCalib[idx];
+                    break;
+
+                  case DETAILED_PASS_GAINS_SECONDPASS:
+                    multnow = 255.0 / denom1 * contrast_adjust * pDetailedCalib[idx+1]; /* And finally to 255 */
+                    offnow = pDetailedCalib[idx] - brightness_adjust * 0x80 / multnow;
+
+                    if (offnow < 0)
+                      {
+                        postprocess_offsets[ppidx] = multnow * offnow / 0x80;
+                        offnow = 0;
+                        needs_postprocessed_calibration = 1;
+                      }
+                    else if (offnow > 255)
+                      {
+                        postprocess_offsets[ppidx] = multnow * (offnow - 255) / 0x80;
+                        offnow = 255;
+                        needs_postprocessed_calibration = 1;
+                      }
+                    else
+                      {
+                        postprocess_offsets[ppidx] = 0;
+                      }
+                    if (multnow > 255)
+                      {
+                        postprocess_gains[ppidx] = multnow / 255;
+                        multnow = 255;
+                        needs_postprocessed_calibration = 1;
+                      }
+                    else
+                      {
+                        postprocess_gains[ppidx] = 1.0;
+                      }
+                    break;
+                  }
+              }
+              if (offnow > 255)
+                offnow = 255;
+
+              for (k = 0; k < resolution_divisor; ++k)
+                {
+                  pDetailedCalib[idx++] = offnow;         /* Subtract this value from the result  at gains = 0x80*/
+                  pDetailedCalib[idx++] = multnow;        /* Then multiply by this value divided by 0x80	*/
+                }
+              ++ppidx;
+            }
+        }
+
+      if (pass == DETAILED_PASS_GAINS_SECONDPASS)
+        {
+           /* Build gamma table */
+           unsigned char *redgamma = pDetailedCalib;
+           unsigned char *greengamma = redgamma + 512;
+           unsigned char *bluegamma = greengamma + 512;
+           double val;
+	   double invgamma = 1.0l / gamma;
+
+           *redgamma++ = *bluegamma++ = *greengamma++ = 0;
+
+           /* The windows driver does a linear interpolation for the next 19 boundaries */
+           val = pow (20.0l / 255, invgamma) * 255;
+
+	   for (j = 1; j <= 20; ++j)
+             {
+               *redgamma++ = *bluegamma++ = *greengamma++ = val * j / 20 + 0.5;
+               *redgamma++ = *bluegamma++ = *greengamma++ = val * j / 20 + 0.5;
+             }
+
+           for (; j <= 255; ++j)
+             {
+               val = pow((double) j / 255, invgamma) * 255;
+
+               *redgamma++ = *bluegamma++ = *greengamma++ = val + 0.5;
+               *redgamma++ = *bluegamma++ = *greengamma++ = val + 0.5;
+             }
+           *redgamma++ = *bluegamma++ = *greengamma++ = 255;
+        }
+
+      DBG (10, "\n");
+
+      rt_set_sram_page (0);
+      rt_set_one_register (0x93, r93setting);
+      rt_write_sram (calibration_size, pDetailedCalib);
+    }
 
+  /* And finally, perform the scan */
   DBG (10, "Scanning\n");
 
   rts8801_rewind ();
 
-  detailed_calib_data.channeldata[0] =
-    pDetailedCalib + red_calibration_offset;
-  detailed_calib_data.channeldata[1] =
-    pDetailedCalib + green_calibration_offset;
-  detailed_calib_data.channeldata[2] =
-    pDetailedCalib + blue_calibration_offset;
-  detailed_calib_data.resolution_divisor = resolution_divisor;
-
   rts8801_fullscan (x, y, w, h, resolution, resolution, colour, cbfunc, param,
 		    calib_info, 0,
 		    red_calibration_offset, green_calibration_offset,
 		    blue_calibration_offset, end_calibration_offset,
-		    &detailed_calib_data);
+                    needs_postprocessed_calibration ? postprocess_offsets : 0,
+                    needs_postprocessed_calibration ? postprocess_gains : 0);
 
   rt_turn_off_lamp ();
+
   rts8801_rewind ();
   rt_set_powersave_mode (1);
 
@@ -3403,6 +3752,12 @@ rts8801_scan (unsigned x,
     free (pDetailedCalib);
   if (detail_buffer)
     free (detail_buffer);
+  if (tdetail_buffer)
+    free(tdetail_buffer);
+  if (postprocess_gains)
+    free(postprocess_gains);
+  if (postprocess_offsets)
+    free(postprocess_offsets);
   return 0;
 }
 
@@ -3466,7 +3821,6 @@ reader_process (void *pv)
       sigaction (SIGTERM, &act, 0);
     }
 
-
   /* Warm up the lamp again if our last scan ended more than 5 minutes ago. */
   time (&t);
   do_warmup = (t - scanner->last_scan) > 300;
@@ -3498,9 +3852,25 @@ reader_process (void *pv)
        scanner->actres_pixels.right - scanner->actres_pixels.left,
        scanner->actres_pixels.bottom - scanner->actres_pixels.top,
        scanner->resolution, scanner->mode, scanner->brightness,
-       scanner->contrast, (rts8801_callback) writefunc, &winfo) >= 0)
+       scanner->contrast, (rts8801_callback) writefunc, &winfo,
+       scanner->gamma) >= 0)
     status = SANE_STATUS_GOOD;
   status = SANE_STATUS_IO_ERROR;
   close (scanner->pipe_w);
   return status;
 }
+
+static size_t
+max_string_size (char const **strings)
+{
+  size_t size, max_size = 0;
+  SANE_Int i;
+
+  for (i = 0; strings[i]; ++i)
+    {
+      size = strlen (strings[i]) + 1;
+      if (size > max_size)
+	max_size = size;
+    }
+  return max_size;
+}