Imported Debian patch 0.84-2debian/0.84-2

1 files changed, 2179 insertions, 0 deletions

diff --git a/src/xsane-scan.c b/src/xsane-scan.c
new file mode 100644
index 0000000..a724e3e
--- /dev/null
+++ b/src/xsane-scan.c
@@ -0,0 +1,2179 @@
+/* xsane -- a graphical (X11, gtk) scanner-oriented SANE frontend
+
+   xsane-scan.c
+
+   Oliver Rauch <Oliver.Rauch@rauch-domain.de>
+   Copyright (C) 1998-2002 Oliver Rauch
+   This file is part of the XSANE package.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */ 
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+#include "xsane.h"
+#include "xsane-back-gtk.h"
+#include "xsane-front-gtk.h"
+#include "xsane-preferences.h"
+#include "xsane-preview.h"
+#include "xsane-viewer.h"
+#include "xsane-save.h"
+#include "xsane-gamma.h"
+#include "xsane-setup.h"
+
+#ifdef HAVE_LIBPNG
+#ifdef HAVE_LIBZ
+#include <png.h>
+#include <zlib.h>
+#endif
+#endif
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+/* forward declarations: */
+
+static int xsane_generate_dummy_filename(int conversion_level);
+static void xsane_read_image_data(gpointer data, gint source, GdkInputCondition cond);
+static RETSIGTYPE xsane_sigpipe_handler(int signal);
+static int xsane_test_multi_scan(void);
+void xsane_scan_done(SANE_Status status);
+void xsane_cancel(void);
+static void xsane_start_scan(void);
+void xsane_scan_dialog(GtkWidget * widget, gpointer call_data);
+static void xsane_create_internal_gamma_tables(void);
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+static int xsane_generate_dummy_filename(int conversion_level)
+/* conversion levels: */
+/* 0 = scan */
+/* 1 = rotate */
+/* 2 = pack */
+{
+ char filename[PATH_MAX];
+ int tempfile = FALSE; /* returns TRUE if file is a temporary file */
+
+  DBG(DBG_proc, "xsane_generate_dummy_filename(conversion_level=%d)\n", conversion_level);
+
+  if (xsane.dummy_filename)
+  {
+    free(xsane.dummy_filename);
+  }
+
+  if ( (conversion_level == 0) && (xsane.preview->rotation) ) /* scan level with rotation */
+  {
+    tempfile = TRUE;
+  }
+
+  if ( (conversion_level == 1) && (xsane.expand_lineart_to_grayscale) ) /* rotation level and expanded lineart*/
+  {
+    tempfile = TRUE;
+  }
+
+  if ( (xsane.xsane_mode == XSANE_COPY) ||
+       (xsane.xsane_mode == XSANE_FAX) ||
+       (xsane.xsane_mode == XSANE_MAIL) ||
+       (xsane.xsane_mode == XSANE_VIEWER) ||
+       ( (xsane.xsane_mode == XSANE_SAVE)  && (xsane.xsane_output_format != XSANE_PNM) &&
+         (xsane.xsane_output_format != XSANE_RAW16) && (xsane.xsane_output_format != XSANE_RGBA) ) )
+  {
+    tempfile = TRUE;
+  }
+
+  if (tempfile) /* save to temporary file */
+  {
+    xsane_back_gtk_make_path(sizeof(filename), filename, 0, 0, "conversion-", xsane.dev_name, ".ppm", XSANE_PATH_TMP);
+    xsane.dummy_filename = strdup(filename);
+    DBG(DBG_info, "xsane.dummy_filename = %s\n", xsane.dummy_filename);
+
+   return TRUE;
+  }
+  else /* no conversion following, save directly to the selected filename */
+  {
+    xsane.dummy_filename = strdup(xsane.output_filename);
+    DBG(DBG_info, "xsane.dummy_filename = %s\n", xsane.dummy_filename);
+
+   return FALSE;
+  }
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+static void xsane_read_image_data(gpointer data, gint source, GdkInputCondition cond)
+{
+ SANE_Handle dev = xsane.dev;
+ SANE_Status status;
+ SANE_Int len;
+ int i, j;
+ char buf[255];
+
+  DBG(DBG_proc, "xsane_read_image_data\n");
+
+  xsane.reading_data = TRUE;
+
+  if ( (xsane.param.depth == 1) || (xsane.param.depth == 8) )
+  {
+   unsigned char buf8[2*32768];
+   unsigned char *buf8ptr;
+
+    DBG(DBG_info, "depth = 1 or 8 bit\n");
+
+    while (1)
+    {
+      if (xsane.cancel_scan)
+      {
+        break; /* leave while loop */
+      }
+
+      status = sane_read(dev, (SANE_Byte *) buf8, sizeof(buf8), &len);
+
+      DBG(DBG_info, "sane_read returned with status %s\n", XSANE_STRSTATUS(status));
+      DBG(DBG_info, "sane_read: len = %d\n", len);
+
+      if (status == SANE_STATUS_EOF)
+      {
+        if (!xsane.param.last_frame)
+        {
+          DBG(DBG_info, "not last frame\n");
+
+          if (xsane.input_tag >= 0)
+          {
+            gdk_input_remove(xsane.input_tag);
+            xsane.input_tag = -1;
+          }
+          xsane_start_scan();
+          break; /* leave while loop */
+        }
+
+        xsane_scan_done(SANE_STATUS_EOF); /* image complete, stop scanning */
+        return;
+      }
+
+      if (status == SANE_STATUS_CANCELLED)
+      {
+        xsane_scan_done(status); /* status = return of sane_read */
+        snprintf(buf, sizeof(buf), "%s.", XSANE_STRSTATUS(status));
+        xsane_back_gtk_warning(buf, TRUE);
+        return;
+      }
+
+      if (status != SANE_STATUS_GOOD)
+      {
+        xsane_scan_done(status); /* status = return of sane_read */
+        snprintf(buf, sizeof(buf), "%s %s.", ERR_DURING_READ, XSANE_STRSTATUS(status));
+        xsane_back_gtk_error(buf, TRUE);
+        return;
+      }
+
+      if (!len) /* nothing read */
+      {
+        break; /* out of data for now, leave while loop */
+      }
+
+      xsane.bytes_read += len;
+      xsane_progress_update(xsane.bytes_read / (gfloat) xsane.num_bytes);
+
+      /* it is not allowed to call gtk_main_iteration when we have gdk_input active */
+      /* because xsan_read_image_data will be called several times */
+      if (xsane.input_tag < 0)
+      {
+        while (gtk_events_pending())
+        {
+          DBG(DBG_info, "calling gtk_main_iteration\n");
+          gtk_main_iteration();
+        }
+      }
+
+      switch (xsane.param.format)
+      {
+        case SANE_FRAME_GRAY:
+          {
+           int i;
+           u_char val;
+
+            DBG(DBG_info, "grayscale\n");
+
+            if ((!xsane.scanner_gamma_gray) && (xsane.param.depth > 1))
+            {
+              buf8ptr = buf8;
+
+              for (i=0; i < len; ++i) /* do gamma correction by xsane */
+              {
+                *buf8ptr = xsane.gamma_data[(int) (*buf8ptr)];
+                buf8ptr++;
+              }
+
+              fwrite(buf8, 1, len, xsane.out); /* write gamma corrected data */
+            }
+            else if ((xsane.param.depth == 1) && (xsane.expand_lineart_to_grayscale)) 
+            {
+             unsigned char *expanded_buf8;
+             unsigned char *expanded_buf8ptr;
+ 
+              /* if we want to do any postprocessing (e.g. rotation) */
+              /* we save lineart images in grayscale mode */
+              /* to speed up transformation and saving the transformed  expanded (1bit->1byte) */
+              /* is written in a buffer and saved as full buffer */
+ 
+              expanded_buf8 = malloc(len * 8); /* one byte for each pixel (bit) */
+              if (!expanded_buf8)
+              {
+                xsane_scan_done(-1); /* -1 = error */
+                snprintf(buf, sizeof(buf), "%s", ERR_NO_MEM);
+                xsane_back_gtk_error(buf, TRUE);
+               return;
+              }
+ 
+              expanded_buf8ptr = expanded_buf8;
+              buf8ptr = buf8;
+ 
+              for (i = 0; i < len; ++i)
+              {
+                val = *buf8ptr;
+                for (j = 7; j >= 0; --j)
+                {
+                  *expanded_buf8ptr = (val & (1 << j)) ? 0x00 : 0xff;
+                  expanded_buf8ptr++;
+                }
+                buf8ptr++;
+              }
+              fwrite(expanded_buf8, 1, len*8, xsane.out);
+              free(expanded_buf8);
+            }
+            else /* save direct to the file */
+            {
+              fwrite(buf8, 1, len, xsane.out);
+            }
+          }
+         break; /* SANE_FRAME_GRAY */
+
+        case SANE_FRAME_RGB:
+          {
+           int i;
+
+            DBG(DBG_info, "1 pass color\n");
+
+            if (!xsane.scanner_gamma_color) /* do gamma correction by xsane */
+            {
+              buf8ptr = buf8;
+              for (i=0; i < len; ++i)
+              {
+                if (xsane.pixelcolor == 0)
+                {
+                  *buf8ptr = xsane.gamma_data_red[(int) (*buf8ptr)];
+                  buf8ptr++;
+                  xsane.pixelcolor++;
+                }
+                else if (xsane.pixelcolor == 1)
+                {
+                  *buf8ptr = xsane.gamma_data_green[(int) (*buf8ptr)];
+                  buf8ptr++;
+                  xsane.pixelcolor++;
+                }
+                else
+                {
+                  *buf8ptr = xsane.gamma_data_blue[(int) (*buf8ptr)];
+                  buf8ptr++;
+                  xsane.pixelcolor = 0;
+                }
+              }
+              fwrite(buf8, 1, len, xsane.out); /* write buffer */
+            }
+            else /* gamma correction has been done by scanner */
+            {
+              fwrite(buf8, 1, len, xsane.out); /* write buffer */
+            }
+          }
+         break;
+
+        case SANE_FRAME_RED:
+        case SANE_FRAME_GREEN:
+        case SANE_FRAME_BLUE:
+          {
+            DBG(DBG_info, "3 pass color\n");
+
+            if (!xsane.scanner_gamma_color) /* gamma correction by xsane */
+            {
+             char val;
+             SANE_Int *gamma;
+
+              if (xsane.param.format == SANE_FRAME_RED)
+              {
+                gamma = xsane.gamma_data_red;
+              }
+              else if (xsane.param.format == SANE_FRAME_GREEN)
+              {
+                gamma = xsane.gamma_data_green;
+              }
+              else
+              {
+                gamma = xsane.gamma_data_blue;
+              }
+
+              for (i = 0; i < len; ++i)
+              {
+                val = gamma[(int) buf8[i]];
+                fputc(val, xsane.out);
+                fseek(xsane.out, 2, SEEK_CUR);
+              }
+            }
+            else /* gamma correction by scanner */
+            {
+              for (i = 0; i < len; ++i)
+              {
+                fputc(buf8[i], xsane.out);
+                fseek(xsane.out, 2, SEEK_CUR);
+              }
+            }
+          }
+         break;
+
+#ifdef SUPPORT_RGBA
+        case SANE_FRAME_RGBA: /* Scanning including Infrared channel */
+          {
+           int i;
+           char val;
+
+            DBG(DBG_info, "1 pass color+alpha (RGBA)\n");
+
+            if (!xsane.scanner_gamma_color) /* gamma correction by xsane */
+            {
+              buf8ptr = buf8;
+
+              for (i=0; i < len; ++i)
+              {
+                if (xsane.pixelcolor == 0)
+                {
+                  *buf8ptr = xsane.gamma_data_red[(int) (*buf8ptr)];
+                  buf8ptr++;
+                  xsane.pixelcolor++;
+                }
+                else if (xsane.pixelcolor == 1)
+                {
+                  *buf8ptr = xsane.gamma_data_green[(int) (*buf8ptr)];
+                  buf8ptr++;
+                  xsane.pixelcolor++;
+                }
+                else if (xsane.pixelcolor == 2)
+                {
+                  *buf8ptr = xsane.gamma_data_blue[(int) (*buf8ptr)];
+                  buf8ptr++;
+                  xsane.pixelcolor++;
+                }
+                else
+                {
+                  /* no gamma table for infrared channel */
+                  buf8ptr++;
+                  xsane.pixelcolor = 0;
+                }
+              }
+
+              fwrite(buf8, 1, len, xsane.out);
+            }
+            else /* gamma correction has been done by scanner */
+            {
+              fwrite(buf8, 1, len, xsane.out);
+            }
+          }
+         break;
+#endif
+
+        default:
+          xsane_scan_done(-1); /* -1 = error */
+          DBG(DBG_error, "xsane_read_image_data: %s %d\n", ERR_BAD_FRAME_FORMAT, xsane.param.format);
+          return;
+         break;
+      }
+    }
+  }
+  else if ( xsane.param.depth == 16 )
+  {
+   guint16 buf16[32768];
+   guint16 *buf16ptr;
+   unsigned char *buf8 = (unsigned char *) buf16;
+   unsigned char *buf8ptr;
+   char buf[255];
+   char last = 0;
+   int offset = 0;
+
+    DBG(DBG_info, "depth = 16 bit\n");
+
+    while (1)
+    {
+      if (xsane.cancel_scan)
+      {
+        break; /* leave while loop */
+      }
+
+      if (offset) /* if we have had an odd number of bytes */
+      {
+        buf16[0] = last;  /* ATTENTION: that is wrong! */
+        status = sane_read(dev, ((SANE_Byte *) buf16) + 1, sizeof(buf16) - 1, &len);
+        if (len)
+        {
+          len++;
+        }
+      }
+      else /* last read we had an even number of bytes */
+      {
+        status = sane_read(dev, (SANE_Byte *) buf16, sizeof(buf16), &len);
+      }
+
+
+      if (!xsane.scanning) /* scan may have been canceled while sane_read was executed */
+      {
+        return; /* ok, the scan has been canceled */
+      }
+
+
+      if (len % 2) /* odd number of bytes */
+      {
+        len--;
+        last = buf16[len];
+        offset = 1;
+      }
+      else /* even number of bytes */
+      {
+        offset = 0;
+      }
+
+      if (status == SANE_STATUS_EOF)
+      {
+        if (!xsane.param.last_frame)
+        {
+          DBG(DBG_info, "not last frame\n");
+          if (xsane.input_tag >= 0)
+          {
+            gdk_input_remove(xsane.input_tag);
+            xsane.input_tag = -1;
+          }
+          xsane_start_scan();
+          break; /* leave while loop */
+        }
+
+        xsane_scan_done(SANE_STATUS_EOF); /* image complete, stop scanning */
+        return;
+      }
+
+      if (status == SANE_STATUS_CANCELLED)
+      {
+        xsane_scan_done(status); /* status = return of sane_read */
+        snprintf(buf, sizeof(buf), "%s.", XSANE_STRSTATUS(status));
+        xsane_back_gtk_warning(buf, TRUE);
+        return;
+      }
+
+      if (status != SANE_STATUS_GOOD)
+      {
+        xsane_scan_done(status); /* status = return of sane_read */
+        snprintf(buf, sizeof(buf), "%s %s.", ERR_DURING_READ, XSANE_STRSTATUS(status));
+        xsane_back_gtk_error(buf, TRUE);
+        return;
+      }
+
+      if (!len) /* nothing read */
+      {
+        break; /* out of data for now, leave while loop */
+      }
+
+      xsane.bytes_read += len;
+      xsane_progress_update(xsane.bytes_read / (gfloat) xsane.num_bytes);
+
+      if (xsane.input_tag < 0)
+      {
+        while (gtk_events_pending())
+        {
+          gtk_main_iteration();
+        }
+      }
+
+      switch (xsane.param.format)
+      {
+        case SANE_FRAME_GRAY:
+          {
+           int i;
+
+            if (xsane.reduce_16bit_to_8bit) /* reduce 16 bit image to 8 bit */
+            {
+              DBG(DBG_info, "reducing 16 bit image to 8 bit\n");
+
+              if (!xsane.scanner_gamma_gray) /* gamma correction by xsane */
+              {
+                buf8ptr = buf8;
+                buf16ptr = buf16;
+
+                for (i=0; i < len/2; ++i)
+                {
+                  *buf8ptr = (xsane.gamma_data[(*buf16ptr)]) >> 8; /* reduce to 8 bit */
+                  buf8ptr++;
+                  buf16ptr++;
+                }
+
+                fwrite(buf8, 1, len/2, xsane.out);
+              }
+              else /* gamma correction by scanner */
+              {
+                buf8ptr = buf8;
+                buf16ptr = buf16;
+
+                for (i=0; i < len/2; ++i)
+                {
+                  *buf8ptr = (*buf16ptr) >> 8; /* reduce to 8 bit */
+                  buf8ptr++;
+                  buf16ptr++;
+                }
+
+                fwrite(buf8, 1, len/2, xsane.out);
+              }
+            }
+            else /* save as 16 bit image */
+            {
+              if (!xsane.scanner_gamma_gray) /* gamma correction by xsane */
+              {
+                buf16ptr = buf16;
+
+                for (i=0; i < len/2; ++i)
+                {
+                  *buf16ptr = xsane.gamma_data[(*buf16ptr)];
+                  buf16ptr++;
+                }
+                fwrite(buf16, 2, len/2, xsane.out);
+              }
+              else /* gamma correction by scanner */
+              {
+                fwrite(buf16, 2, len/2, xsane.out);
+              }
+            }
+          }
+         break;
+
+        case SANE_FRAME_RGB:
+          {
+           int i;
+
+            if (xsane.reduce_16bit_to_8bit) /* reduce 16 bit image to 8 bit */
+            {
+              DBG(DBG_info, "reducing 16 bit image to 8 bit\n");
+
+              if (!xsane.scanner_gamma_color) /* gamma correction by xsane */
+              {
+                buf8ptr = buf8;
+                buf16ptr = buf16;
+
+                for (i=0; i < len/2; ++i)
+                {
+                  if (xsane.pixelcolor == 0)
+                  {
+                    *buf8ptr = (xsane.gamma_data_red[(*buf16ptr)]) >> 8; /* reduce to 8 bit */
+                    buf8ptr++;
+                    buf16ptr++;
+                    xsane.pixelcolor++;
+                  }
+                  else if (xsane.pixelcolor == 1)
+                  {
+                    *buf8ptr = (xsane.gamma_data_green[(*buf16ptr)]) >> 8; /* reduce to 8 bit */
+                    buf8ptr++;
+                    buf16ptr++;
+                    xsane.pixelcolor++;
+                  }
+                  else
+                  {
+                    *buf8ptr = (xsane.gamma_data_blue[(*buf16ptr)]) >> 8; /* reduce to 8 bit */
+                    buf8ptr++;
+                    buf16ptr++;
+                    xsane.pixelcolor = 0;
+                  }
+                }
+                fwrite(buf8, 1, len/2, xsane.out);
+              }
+              else /* gamma correction by scanner */
+              {
+                buf8ptr = buf8;
+                buf16ptr = buf16;
+
+                for (i=0; i < len/2; ++i)
+                {
+                  *buf8ptr = (*buf16ptr) >> 8; /* reduce to 8 bit */
+                  buf8ptr++;
+                  buf16ptr++;
+                  xsane.pixelcolor++;
+                }
+                fwrite(buf8, 1, len/2, xsane.out);
+              }
+            }
+            else /* save as 16 bit image */
+            {
+              if (!xsane.scanner_gamma_color) /* gamma correction by xsane */
+              {
+                buf16ptr = buf16;
+
+                for (i=0; i < len/2; ++i)
+                {
+                  if (xsane.pixelcolor == 0)
+                  {
+                    *buf16ptr = xsane.gamma_data_red[(*buf16ptr)];
+                    buf16ptr++;
+                    xsane.pixelcolor++;
+                  }
+                  else if (xsane.pixelcolor == 1)
+                  {
+                    *buf16ptr = xsane.gamma_data_green[(*buf16ptr)];
+                    buf16ptr++;
+                    xsane.pixelcolor++;
+                  }
+                  else
+                  {
+                    *buf16ptr = xsane.gamma_data_blue[(*buf16ptr)];
+                    buf16ptr++;
+                    xsane.pixelcolor = 0;
+                  }
+                }
+                fwrite(buf16, 2, len/2, xsane.out);
+              }
+              else /* gamma correction by scanner */
+              {
+                fwrite(buf16, 2, len/2, xsane.out);
+              }
+            }
+          }
+         break;
+
+        case SANE_FRAME_RED:
+        case SANE_FRAME_GREEN:
+        case SANE_FRAME_BLUE:
+          /* this is incomplete:
+             - missing: gamma correction by xsane
+             - missing: reduction to 8 bit
+             but I do not think there are 3 pass scanners with more
+             than 24 bits/pixel */
+          {
+            for (i = 0; i < len/2; ++i)
+            {
+              fwrite(buf16 + i*2, 2, 1, xsane.out);
+              fseek(xsane.out, 4, SEEK_CUR);
+            }
+          }
+         break;
+
+#ifdef SUPPORT_RGBA
+        case SANE_FRAME_RGBA:
+          {
+           int i;
+           guint16 val;
+
+            if (xsane.reduce_16bit_to_8bit) /* reduce 16 bit image to 8 bit */
+            {
+              DBG(DBG_info, "reducing 16 bit image to 8 bit\n");
+
+              if (!xsane.scanner_gamma_color)
+              {
+                buf8ptr = buf8;
+                buf16ptr = buf16;
+
+                for (i=0; i < len/2; ++i)
+                {
+                  if (xsane.pixelcolor == 0)
+                  {
+                    *buf8ptr = (xsane.gamma_data_red[(*buf16ptr)]) >> 8; /* reduce to 8 bit */
+                    buf8ptr++;
+                    buf16ptr++;
+                    xsane.pixelcolor++;
+                  }
+                  else if (xsane.pixelcolor == 1)
+                  {
+                    *buf8ptr = (xsane.gamma_data_green[(*buf16ptr)]) >> 8; /* reduce to 8 bit */
+                    buf8ptr++;
+                    buf16ptr++;
+                    xsane.pixelcolor++;
+                  }
+                  else if (xsane.pixelcolor == 2)
+                  {
+                    *buf8ptr = (xsane.gamma_data_blue[(*buf16ptr)]) >> 8; /* reduce to 8 bit */
+                    buf8ptr++;
+                    buf16ptr++;
+                    xsane.pixelcolor++;
+                  }
+                  else
+                  {
+                    /* no gamma table for infrared channel */
+                    *buf8ptr = (*buf16ptr) >> 8; /* reduce to 8 bit */
+                    buf8ptr++;
+                    buf16ptr++;
+                    xsane.pixelcolor = 0;
+                  }
+                }
+
+                fwrite(buf8, 1, len, xsane.out);
+              }
+              else /* gamma correction done by scanner */
+              {
+                buf8ptr = buf8;
+                buf16ptr = buf16;
+
+                for (i=0; i < len/2; ++i)
+                {
+                  *buf8ptr = (*buf16ptr) >> 8; /* reduce to 8 bit */
+                  buf8ptr++;
+                  buf16ptr++;
+                }
+
+                fwrite(buf8, 1, len, xsane.out);
+              }
+            }
+            else /* save as 16 bit image */
+            {
+              if (!xsane.scanner_gamma_color)
+              {
+                buf16ptr = buf16;
+
+                for (i=0; i < len/2; ++i)
+                {
+                  if (xsane.pixelcolor == 0)
+                  {
+                    *buf16ptr = xsane.gamma_data_red[(*buf16ptr)];
+                    buf16ptr++;
+                    xsane.pixelcolor++;
+                  }
+                  else if (xsane.pixelcolor == 1)
+                  {
+                    *buf16ptr = xsane.gamma_data_green[(*buf16ptr)];
+                    buf16ptr++;
+                    xsane.pixelcolor++;
+                  }
+                  else if (xsane.pixelcolor == 2)
+                  {
+                    *buf16ptr = xsane.gamma_data_blue[(*buf16ptr)];
+                    buf16ptr++;
+                    xsane.pixelcolor++;
+                  }
+                  else
+                  {
+                    /* no gamma table for infrared channel */
+                    buf16ptr++;
+                    xsane.pixelcolor = 0;
+                  }
+                }
+
+                fwrite(buf16, 2, len/2, xsane.out);
+              }
+              else /* gamma correction done by scanner */
+              {
+                fwrite(buf16, 2, len/2, xsane.out);
+              }
+            }
+          }
+         break;
+#endif
+
+        default:
+          xsane_scan_done(-1); /* -1 = error */
+          DBG(DBG_error, "xsane_read_image_data: %s %d\n", ERR_BAD_FRAME_FORMAT, xsane.param.format);
+          return;
+         break;
+      }
+    }
+  }
+  else
+  {
+    xsane_scan_done(-1); /* -1 = error */
+    snprintf(buf, sizeof(buf), "%s %d.", ERR_BAD_DEPTH, xsane.param.depth);
+    xsane_back_gtk_error(buf, TRUE);
+    return;
+  }
+
+  if (xsane.cancel_scan)
+  {
+    xsane.cancel_scan = FALSE; /* make sure we do not get an infinite loop */
+    
+    xsane_read_image_data(0, -1, GDK_INPUT_READ);
+  }
+
+  xsane.reading_data = FALSE;
+
+ return;
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+static RETSIGTYPE xsane_sigpipe_handler(int signal)
+/* this is to catch a broken pipe while writing to printercommand */
+{
+  DBG(DBG_proc, "xsane_sigpipe_handler\n");
+
+  xsane_cancel_save(&xsane.cancel_save);
+  xsane.broken_pipe = 1;
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+static int xsane_test_multi_scan(void)
+{
+ char *set;
+ SANE_Status status;
+ const SANE_Option_Descriptor *opt;
+
+  DBG(DBG_proc, "xsane_test_multi_scan\n");
+
+  opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.scansource);
+  if (opt)
+  {
+    if (SANE_OPTION_IS_ACTIVE(opt->cap))
+    {
+      if (opt->constraint_type == SANE_CONSTRAINT_STRING_LIST)
+      {
+        set = malloc(opt->size);
+        status = xsane_control_option(xsane.dev, xsane.well_known.scansource, SANE_ACTION_GET_VALUE, set, 0);
+
+        if (status == SANE_STATUS_GOOD)
+        {
+          if (xsane.adf_scansource)
+          {
+            if (!strcmp(set, xsane.adf_scansource))
+            {
+              free(set);
+              return TRUE;
+            }
+          }
+        }
+        free(set);
+      }
+    }
+  }
+
+#if 0 /* this is planned for the next sane-standard */
+  if (xsane.param.bitfield & XSANE_PARAM_STATUS_MORE_IMAGES)
+  {
+    return TRUE;
+  }
+#endif
+
+  return FALSE;
+}
+                                    
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+static int xsane_reduce_to_lineart()
+/* returns 1 on abort, 0 on success */
+{
+ char *old_dummy_filename;
+ int abort = 0;
+
+  /* open progressbar */
+  xsane_progress_new(PROGRESS_PACKING_DATA, PROGRESS_TRANSFERING_DATA, (GtkSignalFunc) xsane_cancel_save, &xsane.cancel_save);
+  while (gtk_events_pending())
+  {
+    gtk_main_iteration();
+  }
+
+  /* on some filesystems it is not allowed to erase an opened file and access the
+     file after that, so we must wait until the file is closed */
+  old_dummy_filename = strdup(xsane.dummy_filename);
+
+  /* temporary file is created with permission 0600 in xsane_generate_dummy_filename */
+  if (!xsane_generate_dummy_filename(2)) /* create filename for packing */
+  {
+    /* no temporary file */
+    if (xsane_create_secure_file(xsane.dummy_filename)) /* remove possibly existing symbolic links for security */
+    {
+     char buf[256];
+
+      snprintf(buf, sizeof(buf), "%s %s %s\n", ERR_DURING_SAVE, ERR_CREATE_SECURE_FILE, xsane.dummy_filename);
+      xsane_back_gtk_error(buf, TRUE);
+      abort = 1; /* abort scanning */
+    }
+  }
+
+  if (!abort)
+  {
+    abort = xsane_save_image_as_lineart(old_dummy_filename, xsane.dummy_filename, xsane.progress_bar, &xsane.cancel_save);
+  }
+
+  if (abort)
+  {
+    xsane_set_sensitivity(TRUE);		/* reactivate buttons etc */
+    sane_cancel(xsane.dev); /* stop scanning */
+    xsane_update_histogram(TRUE /* update raw */);
+    xsane_update_param(0);
+    xsane.header_size = 0;
+   return 1;
+  }
+
+  remove(old_dummy_filename); /* remove the unrotated image file */
+  free(old_dummy_filename); /* release memory */
+  xsane_progress_clear();
+
+ return 0;
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+void xsane_scan_done(SANE_Status status)
+{
+ Image_info image_info;
+
+  DBG(DBG_proc, "xsane_scan_done\n");
+
+  if (!xsane.scanning)
+  {
+    return;
+  }
+
+  xsane.reading_data = FALSE;
+  xsane.scanning = FALSE; /* set marker that sane_start is called */
+
+  if (xsane.input_tag >= 0)
+  {
+    gdk_input_remove(xsane.input_tag);
+    xsane.input_tag = -1;
+  }
+
+  xsane_progress_clear(); /* clear progress bar and reset cancel callback */
+
+  while(gtk_events_pending())	/* let gtk remove the progress bar and update everything that needs it */
+  {
+    DBG(DBG_info, "calling gtk_main_iteration\n");
+    gtk_main_iteration();
+  }
+
+
+  /* we have to free the gamma tables if we used software gamma correction */
+  
+  if (xsane.gamma_data) 
+  {
+    DBG(DBG_info, "freeing gray gamma table\n");
+
+    free(xsane.gamma_data);
+    xsane.gamma_data = 0;
+  }
+
+  if (xsane.gamma_data_red)
+  {
+    DBG(DBG_info, "freeing color gamma tables\n");
+
+    free(xsane.gamma_data_red);
+    free(xsane.gamma_data_green);
+    free(xsane.gamma_data_blue);
+
+    xsane.gamma_data_red   = 0;
+    xsane.gamma_data_green = 0;
+    xsane.gamma_data_blue  = 0;
+  }
+
+  if (xsane.out) /* close file - this is dummy_file but if there is no conversion it is the wanted file */
+  {
+   int pixel_height = xsane.bytes_read / xsane.param.bytes_per_line;
+
+    /* correct image height if necessary, e.g. when scanning with hand scanner */
+
+    if (xsane.param.lines != pixel_height)
+    {
+      DBG(DBG_info, "correcting image height to %d lines\n", pixel_height);
+      xsane.param.lines = pixel_height;
+
+      image_info.image_width      = xsane.param.pixels_per_line;
+      image_info.image_height     = pixel_height;
+      image_info.depth            = xsane.depth;
+      image_info.colors           = xsane.xsane_colors;
+
+      image_info.resolution_x     = xsane.resolution_x;
+      image_info.resolution_y     = xsane.resolution_y;
+
+      image_info.gamma            = xsane.gamma;
+      image_info.gamma_red        = xsane.gamma_red;
+      image_info.gamma_green      = xsane.gamma_green;
+      image_info.gamma_blue       = xsane.gamma_blue;
+
+      image_info.brightness       = xsane.brightness;
+      image_info.brightness_red   = xsane.brightness_red;
+      image_info.brightness_green = xsane.brightness_green;
+      image_info.brightness_blue  = xsane.brightness_blue;
+ 
+      image_info.contrast         = xsane.contrast;
+      image_info.contrast_red     = xsane.contrast_red;
+      image_info.contrast_green   = xsane.contrast_green;
+      image_info.contrast_blue    = xsane.contrast_blue;
+ 
+      image_info.threshold        = xsane.threshold;
+
+
+      xsane_write_pnm_header(xsane.out, &image_info);
+    }
+
+    DBG(DBG_info, "closing output file\n");
+
+    fflush(xsane.out);
+    fclose(xsane.out);
+    xsane.out = 0;
+  }
+
+  if ( (status == SANE_STATUS_GOOD) || (status == SANE_STATUS_EOF) ) /* no error, do conversion etc. */
+  {
+    /* do we have to rotate the image ? */
+    if (xsane.preview->rotation)
+    {
+     char *old_dummy_filename;
+     int abort = 0;
+     FILE *outfile;
+     FILE *infile;
+
+      infile = fopen(xsane.dummy_filename, "rb"); /* read binary (b for win32) */
+      if (infile != 0)
+      {
+        xsane_read_pnm_header(infile, &image_info);
+
+        /* open progressbar */
+        xsane_progress_new(PROGRESS_ROTATING_DATA, PROGRESS_TRANSFERING_DATA, (GtkSignalFunc) xsane_cancel_save, &xsane.cancel_save);
+        while (gtk_events_pending())
+        {
+          gtk_main_iteration();
+        }
+
+        /* on some filesystems it is not allowed to erase an opened file and access the
+           file after that, so we must wait until the file is closed */
+        old_dummy_filename = strdup(xsane.dummy_filename);
+
+        /* temporary file is created with permission 0600 in xsane_generate_dummy_filename */
+        if (!xsane_generate_dummy_filename(1)) /* create filename for rotation */
+        {
+          /* no temporary file */
+          if (xsane_create_secure_file(xsane.dummy_filename)) /* remove possibly existing symbolic links for security */
+          {
+           char buf[256];
+
+            snprintf(buf, sizeof(buf), "%s %s %s\n", ERR_DURING_SAVE, ERR_CREATE_SECURE_FILE, xsane.dummy_filename);
+            xsane_back_gtk_error(buf, TRUE);
+            abort = 1; /* abort scanning */
+          }
+        }
+
+        if (!abort)
+        {
+          /* rotate image */
+          outfile = fopen(xsane.dummy_filename, "wb"); /* read binary (b for win32) */
+
+          if (outfile)
+          {
+            if (xsane_save_rotate_image(outfile, infile, &image_info, xsane.preview->rotation, xsane.progress_bar, &xsane.cancel_save))
+            {
+              abort = 1;
+            }
+          }
+          else
+          {
+           char buf[256];
+            DBG(DBG_info, "open of file `%s'failed : %s\n", xsane.dummy_filename, strerror(errno));
+            snprintf(buf, sizeof(buf), "%s `%s': %s", ERR_OPEN_FAILED, xsane.dummy_filename, strerror(errno));
+            xsane_back_gtk_error(buf, TRUE);
+            abort = 1;
+          }
+
+          fclose(outfile);
+        }
+
+        fclose(infile);
+        remove(old_dummy_filename); /* remove the unrotated image file */
+
+        free(old_dummy_filename); /* release memory */
+        xsane_progress_clear();
+      }
+      else
+      {
+       char buf[256];
+        DBG(DBG_info, "open of file `%s'failed : %s\n", xsane.dummy_filename, strerror(errno));
+        snprintf(buf, sizeof(buf), "%s `%s': %s", ERR_OPEN_FAILED, xsane.dummy_filename, strerror(errno));
+        xsane_back_gtk_error(buf, TRUE);
+        abort = 1;
+      }
+
+      if (abort)
+      {
+        xsane_set_sensitivity(TRUE);		/* reactivate buttons etc */
+        sane_cancel(xsane.dev); /* stop scanning */
+        xsane_update_histogram(TRUE /* update raw */);
+        xsane_update_param(0);
+        xsane.header_size = 0;
+        return;
+      }
+    }
+
+    if (xsane.xsane_mode == XSANE_VIEWER)
+    {
+      xsane_viewer_new(xsane.dummy_filename, xsane.expand_lineart_to_grayscale, 0);
+      xsane.expand_lineart_to_grayscale = 0;
+    }
+
+    /* when we are scanning in lineart mode and we are transforming the image */
+    /* it is saved as grayscale while scanning so we can use the standard transformations */
+    /* but now we have to save the lineart image as packed lineart again */
+    if ((xsane.param.depth == 1) && (xsane.expand_lineart_to_grayscale)) 
+    {
+      if (xsane_reduce_to_lineart())
+      {
+        return; /* aborted */
+      }
+    }
+
+    if (xsane.xsane_mode == XSANE_SAVE)
+    {
+      if (xsane.print_filenames) /* print created filenames to stdout? */
+      {
+        if (xsane.output_filename[0] != '/') /* relative path */
+        {
+         char pathname[512];
+          getcwd(pathname, sizeof(pathname));
+          printf("XSANE_IMAGE_FILENAME: %s/%s\n", pathname, xsane.output_filename);
+          fflush(stdout);
+        }
+        else /* absolute path */
+        {
+          printf("XSANE_IMAGE_FILENAME: %s\n", xsane.output_filename);
+          fflush(stdout);
+        }
+      }
+
+      if ( ( (xsane.xsane_output_format != XSANE_PNM) && /* these files do not need any transformation */
+             (xsane.xsane_output_format != XSANE_RAW16) &&
+             (xsane.xsane_output_format != XSANE_RGBA) ) ||
+           (xsane.mode == XSANE_GIMP_EXTENSION) )
+      { /* ok, we have to do a transformation */
+
+        /* open progressbar */
+        xsane_progress_new(PROGRESS_CONVERTING_DATA, PROGRESS_TRANSFERING_DATA, (GtkSignalFunc) xsane_cancel_save, &xsane.cancel_save);
+        while (gtk_events_pending())
+        {
+          gtk_main_iteration();
+        }
+
+
+#ifdef HAVE_LIBGIMP_GIMP_H
+        if (xsane.mode == XSANE_GIMP_EXTENSION)	/* xsane runs as gimp plugin */
+        {
+          xsane_transfer_to_gimp(xsane.dummy_filename, xsane.progress_bar, &xsane.cancel_save);
+        }
+        else
+#endif /* HAVE_LIBGIMP_GIMP_H */
+        {
+          xsane_save_image_as(xsane.dummy_filename, xsane.output_filename, xsane.xsane_output_format, xsane.progress_bar, &xsane.cancel_save);
+        }
+
+        xsane_progress_clear();
+
+        while (gtk_events_pending())
+        { 
+          gtk_main_iteration();
+        }
+
+        remove(xsane.dummy_filename);
+      }
+    }
+    else if (xsane.xsane_mode == XSANE_COPY)
+    {
+     FILE *outfile;
+     FILE *infile;
+     char buf[256];
+
+      DBG(DBG_info, "XSANE_COPY\n");
+
+      xsane_update_int(xsane.copy_number_entry, &xsane.copy_number); /* get number of copies */
+      if (xsane.copy_number < 1)
+      {
+        xsane.copy_number = 1;
+      }
+
+      /* open progressbar */
+      xsane_progress_new(PROGRESS_CONVERTING_DATA, PROGRESS_TRANSFERING_DATA, (GtkSignalFunc) xsane_cancel_save, &xsane.cancel_save);
+
+      while (gtk_events_pending())
+      {
+        gtk_main_iteration();
+      }
+
+      xsane.broken_pipe = 0;
+      infile = fopen(xsane.dummy_filename, "rb"); /* read binary (b for win32) */
+
+      snprintf(buf, sizeof(buf), "%s %s%d", preferences.printer[preferences.printernr]->command,
+                                            preferences.printer[preferences.printernr]->copy_number_option,
+                                            xsane.copy_number);
+      outfile = popen(buf, "w");
+/*      outfile = popen(preferences.printer[preferences.printernr]->command, "w"); */
+      if ((outfile != 0) && (infile != 0)) /* copy mode, use zoom size */
+      {
+       struct SIGACTION act;
+       float imagewidth, imageheight;
+       int printer_resolution;
+
+         switch (xsane.param.format)
+        {
+          case SANE_FRAME_GRAY:
+            if (xsane.depth == 1)
+            {
+              printer_resolution = preferences.printer[preferences.printernr]->lineart_resolution;
+            }
+            else
+            {
+              printer_resolution = preferences.printer[preferences.printernr]->grayscale_resolution;
+            }
+          break; /* switch format == SANE_FRAME_GRAY */
+
+          case SANE_FRAME_RGB:
+          case SANE_FRAME_RED:
+          case SANE_FRAME_GREEN:
+          case SANE_FRAME_BLUE:
+          default:
+            printer_resolution = preferences.printer[preferences.printernr]->color_resolution;
+          break; /* switch format == SANE_FRAME_{color} */
+        }        
+
+        xsane_read_pnm_header(infile, &image_info);
+
+        imagewidth  = image_info.image_width/(float)printer_resolution; /* width in inch */
+        imageheight = image_info.image_height/(float)printer_resolution; /* height in inch */
+
+        memset (&act, 0, sizeof (act)); /* define broken pipe handler */
+        act.sa_handler = xsane_sigpipe_handler;
+        sigaction (SIGPIPE, &act, 0);
+
+
+        if (preferences.psrotate) /* rotate: landscape */
+        {
+          xsane_save_ps(outfile, infile,
+                        &image_info,
+                        (preferences.printer[preferences.printernr]->bottomoffset +
+                         preferences.printer[preferences.printernr]->height) * 36.0/MM_PER_INCH - imagewidth * 36.0, /* left edge */
+                        (preferences.printer[preferences.printernr]->leftoffset +
+                         preferences.printer[preferences.printernr]->width) * 36.0/MM_PER_INCH - imageheight * 36.0, /* bottom edge */
+                        imagewidth, imageheight,
+                        (preferences.printer[preferences.printernr]->leftoffset +
+                         preferences.printer[preferences.printernr]->width ) * 72.0/MM_PER_INCH,  /* paperwidth */
+                        (preferences.printer[preferences.printernr]->bottomoffset +
+                         preferences.printer[preferences.printernr]->height) * 72.0/MM_PER_INCH, /* paperheight */
+                        1 /* landscape */,
+                        xsane.progress_bar,
+                        &xsane.cancel_save);
+        }
+        else /* do not rotate: portrait */
+        {
+          xsane_save_ps(outfile, infile,
+                        &image_info,
+                        (preferences.printer[preferences.printernr]->leftoffset +
+                         preferences.printer[preferences.printernr]->width) * 36.0/MM_PER_INCH - imagewidth * 36.0, /* left edge */
+                        (preferences.printer[preferences.printernr]->bottomoffset +
+                         preferences.printer[preferences.printernr]->height) * 36.0/MM_PER_INCH - imageheight * 36.0, /* bottom edge */
+                        imagewidth, imageheight,
+                        (preferences.printer[preferences.printernr]->leftoffset +
+                         preferences.printer[preferences.printernr]->width ) * 72.0/MM_PER_INCH,  /* paperwidth */
+                        (preferences.printer[preferences.printernr]->bottomoffset +
+                         preferences.printer[preferences.printernr]->height) * 72.0/MM_PER_INCH, /* paperheight */
+                        0 /* portrait */,
+                        xsane.progress_bar,
+                        &xsane.cancel_save);
+        }
+      }
+      else
+      {
+       char buf[256];
+
+        if (!infile)
+        {
+          snprintf(buf, sizeof(buf), "%s `%s': %s", ERR_OPEN_FAILED, xsane.output_filename, strerror(errno));
+          xsane_back_gtk_error(buf, TRUE);
+        }
+        else if (!outfile)
+        {
+          xsane_back_gtk_error(ERR_FAILED_PRINTER_PIPE, TRUE);
+        }
+      }
+
+      if (xsane.broken_pipe)
+      {
+        snprintf(buf, sizeof(buf), "%s \"%s\"", ERR_FAILED_EXEC_PRINTER_CMD, preferences.printer[preferences.printernr]->command);
+        xsane_back_gtk_error(buf, TRUE);
+      }
+
+      xsane_progress_clear();
+      while (gtk_events_pending())
+      {
+        gtk_main_iteration();
+      }
+
+      if (infile)
+      {
+        fclose(infile);
+        remove(xsane.dummy_filename);
+      }
+
+      if (outfile)
+      {
+        pclose(outfile);
+      }
+    }
+    else if (xsane.xsane_mode == XSANE_FAX)
+    {
+     FILE *outfile;
+     FILE *infile;
+
+       /* open progressbar */
+       xsane_progress_new(PROGRESS_CONVERTING_DATA, PROGRESS_TRANSFERING_DATA, (GtkSignalFunc) xsane_cancel_save, &xsane.cancel_save);
+
+       while (gtk_events_pending())
+       {
+         gtk_main_iteration();
+       }
+
+       infile = fopen(xsane.dummy_filename, "rb"); /* read binary (b for win32) */
+       if (infile != 0)
+       {
+         xsane_read_pnm_header(infile, &image_info);
+
+         umask((mode_t) preferences.image_umask); /* define image file permissions */   
+         outfile = fopen(xsane.fax_filename, "wb"); /* b = binary mode for win32 */
+         umask(XSANE_DEFAULT_UMASK); /* define new file permissions */   
+         if (outfile != 0)
+         {
+          float imagewidth, imageheight;
+
+           imagewidth  = image_info.image_width/xsane.resolution_x; /* width in inch */
+           imageheight = image_info.image_height/xsane.resolution_y; /* height in inch */
+
+           DBG(DBG_info, "imagewidth  = %f\n", imagewidth);
+           DBG(DBG_info, "imageheight = %f\n", imageheight);
+
+           xsane_save_ps(outfile, infile,
+                         &image_info,
+                         (preferences.fax_leftoffset   + preferences.fax_width)  * 36.0/MM_PER_INCH - imagewidth * 36.0,
+                         (preferences.fax_bottomoffset + preferences.fax_height) * 36.0/MM_PER_INCH - imageheight * 36.0,
+                         imagewidth, imageheight,
+                         (preferences.fax_leftoffset   + preferences.fax_width ) * 72.0/MM_PER_INCH, /* paperwidth */
+                         (preferences.fax_bottomoffset + preferences.fax_height) * 72.0/MM_PER_INCH, /* paperheight */
+                         0 /* portrait */,
+                         xsane.progress_bar,
+                         &xsane.cancel_save);
+           fclose(outfile);
+         }
+         else
+         {
+          char buf[256];
+
+           DBG(DBG_info, "open of faxfile `%s'failed : %s\n", xsane.fax_filename, strerror(errno));
+
+           snprintf(buf, sizeof(buf), "%s `%s': %s", ERR_OPEN_FAILED, xsane.fax_filename, strerror(errno));
+           xsane_back_gtk_error(buf, TRUE);
+         }
+
+         fclose(infile);
+         remove(xsane.dummy_filename);
+       }
+       else
+       {
+        char buf[256];
+
+         DBG(DBG_info, "open of faxfile `%s'failed : %s\n", xsane.fax_filename, strerror(errno));
+
+         snprintf(buf, sizeof(buf), "%s `%s': %s", ERR_OPEN_FAILED, xsane.fax_filename, strerror(errno));
+         xsane_back_gtk_error(buf, TRUE);
+       }
+       xsane_progress_clear();
+
+       while (gtk_events_pending())
+       {
+         DBG(DBG_info, "calling gtk_main_iteration");
+         gtk_main_iteration();
+       }
+    }
+#ifdef XSANE_ACTIVATE_MAIL
+    else if (xsane.xsane_mode == XSANE_MAIL)
+    {
+     FILE *infile;
+
+       /* open progressbar */
+       xsane_progress_new(PROGRESS_CONVERTING_DATA, PROGRESS_TRANSFERING_DATA, (GtkSignalFunc) xsane_cancel_save, &xsane.cancel_save);
+
+       while (gtk_events_pending())
+       {
+         gtk_main_iteration();
+       }
+
+       infile = fopen(xsane.dummy_filename, "rb"); /* read binary (b for win32) */
+       if (infile != 0)
+       {
+         xsane_read_pnm_header(infile, &image_info);
+
+         xsane_save_image_as(xsane.dummy_filename, xsane.mail_filename, XSANE_PNG, xsane.progress_bar, &xsane.cancel_save);
+
+         fclose(infile);
+         remove(xsane.dummy_filename);
+       }
+       else
+       {
+        char buf[256];
+
+         DBG(DBG_info, "open of mailfile `%s'failed : %s\n", xsane.dummy_filename, strerror(errno));
+
+         snprintf(buf, sizeof(buf), "%s `%s': %s", ERR_OPEN_FAILED, xsane.dummy_filename, strerror(errno));
+         xsane_back_gtk_error(buf, TRUE);
+       }
+       xsane_progress_clear();
+
+       while (gtk_events_pending())
+       {
+         DBG(DBG_info, "calling gtk_main_iteration");
+         gtk_main_iteration();
+       }
+    }
+#endif
+
+    if ( (xsane.xsane_mode == XSANE_SAVE) && (xsane.mode == XSANE_STANDALONE) )
+    {
+      if (!xsane.force_filename) /* user filename selection active */
+      {
+        if (preferences.filename_counter_step) /* increase filename counter ? */
+        {
+          xsane_update_counter_in_filename(&preferences.filename, preferences.skip_existing_numbers,
+                                           preferences.filename_counter_step, preferences.filename_counter_len);
+          gtk_entry_set_text(GTK_ENTRY(xsane.outputfilename_entry), (char *) preferences.filename); /* update filename in entry */
+          gtk_entry_set_position(GTK_ENTRY(xsane.outputfilename_entry), strlen(preferences.filename)); /* set cursor to right position of filename */
+        }
+      }
+      else /* external filename */
+      {
+        xsane_update_counter_in_filename(&xsane.external_filename, TRUE, 1, 0);
+      }
+    }
+    else if (xsane.xsane_mode == XSANE_FAX)
+    {
+     GtkWidget *list_item;
+     char *page;
+     char *extension;
+
+      page = strdup(strrchr(xsane.fax_filename,'/')+1);
+      extension = strrchr(page, '.');
+      if (extension)
+      {
+        *extension = 0;
+      }
+      list_item = gtk_list_item_new_with_label(page);
+      gtk_object_set_data(GTK_OBJECT(list_item), "list_item_data", strdup(page));
+      gtk_container_add(GTK_CONTAINER(xsane.fax_list), list_item);
+      gtk_widget_show(list_item);
+
+      xsane_update_counter_in_filename(&xsane.fax_filename, TRUE, 1, preferences.filename_counter_len);
+      xsane_fax_project_save();
+      free(page);
+    }
+#ifdef XSANE_ACTIVATE_MAIL
+    else if (xsane.xsane_mode == XSANE_MAIL)
+    {
+     GtkWidget *list_item;
+     char *image;
+     char *extension;
+
+      image = strdup(strrchr(xsane.mail_filename,'/')+1);
+      extension = strrchr(image, '.');
+      if (extension)
+      {
+        *extension = 0;
+      }
+      list_item = gtk_list_item_new_with_label(image);
+      gtk_object_set_data(GTK_OBJECT(list_item), "list_item_data", strdup(image));
+      gtk_container_add(GTK_CONTAINER(xsane.mail_list), list_item);
+      gtk_widget_show(list_item);
+
+      xsane_update_counter_in_filename(&xsane.mail_filename, TRUE, 1, preferences.filename_counter_len);
+      xsane_mail_project_save();
+      free(image);
+    }
+#endif
+  }
+  else /* an error occured, remove the dummy_file */
+  {
+    if (xsane.dummy_filename) /* remove corrupt file */
+    {
+      remove(xsane.dummy_filename);
+    }
+  }
+
+  free(xsane.dummy_filename); /* no dummy_filename, needed if an error occurs */
+  xsane.dummy_filename = 0;
+
+  if (xsane.output_filename)
+  {
+    free(xsane.output_filename);
+    xsane.output_filename = 0;
+  }
+
+  xsane.header_size = 0;
+
+  if ( ( (status == SANE_STATUS_GOOD) || (status == SANE_STATUS_EOF) ) && (xsane_test_multi_scan()) )
+  {
+    /* multi scan (eg ADF): scan again			*/
+    /* stopped when:					*/
+    /*  a) xsane_test_multi_scan returns false		*/
+    /*  b) sane_start returns SANE_STATUS_NO_DOCS	*/
+    /*  c) an error occurs 				*/
+
+    xsane.adf_page_counter += 1;
+    gtk_signal_emit_by_name(xsane.start_button, "clicked"); /* press START button */
+  }
+  else /* last scan: update histogram */
+  {
+    xsane_set_sensitivity(TRUE);		/* reactivate buttons etc */
+    sane_cancel(xsane.dev); /* stop scanning */
+    xsane_update_histogram(TRUE /* update raw */);
+    xsane_update_param(0);
+  }
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+void xsane_cancel(void)
+{
+  DBG(DBG_proc, "xsane_cancel\n");
+
+  if (!xsane.scanning)
+  {
+    return;
+  }
+
+  sane_cancel(xsane.dev);
+
+  /* we have to make sure that xsane does detect that the scan has been cancled */
+  /* but the select_fd does not make sure that preview_read_image_data is called */
+  /* when the select_fd is closed by the backend, so we have to make sure that */
+  /* preview_read_image_data is called */
+
+  if (xsane.reading_data) /* we are still reading data, set flag for cancel */
+  {
+    xsane.cancel_scan = TRUE;
+  }
+  else /* we are not reading image data, so we have to call it now */
+  {
+    xsane_read_image_data(0, -1, GDK_INPUT_READ);
+  }
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+/* xsane_start_scan is called 3 times in 3 pass scanning mode */
+static void xsane_start_scan(void)
+{
+ SANE_Status status;
+ SANE_Handle dev = xsane.dev;
+ const char *frame_type = 0;
+ char buf[256];
+ int fd;
+ Image_info image_info;
+
+  DBG(DBG_proc, "xsane_start_scan\n");
+
+  while (gtk_events_pending())
+  {
+    gtk_main_iteration();
+  }
+
+  status = sane_start(dev);
+  DBG(DBG_info, "sane_start returned with status %s\n", XSANE_STRSTATUS(status));
+
+  if ((status == SANE_STATUS_NO_DOCS) && (xsane.adf_page_counter>0)) /* ADF out of docs but not first page */
+  {
+    xsane_scan_done(status); /* ok, stop multi image scan */
+    snprintf(buf, sizeof(buf), "%s %d", TEXT_ADF_PAGES_SCANNED, xsane.adf_page_counter);
+    xsane_back_gtk_info(buf, FALSE);
+    xsane.adf_page_counter = 0;
+   return;
+  }
+  else if (status != SANE_STATUS_GOOD) /* error */
+  {
+    xsane_scan_done(status);
+    snprintf(buf, sizeof(buf), "%s %s", ERR_FAILED_START_SCANNER, XSANE_STRSTATUS(status));
+    xsane_back_gtk_error(buf, TRUE);
+    xsane.adf_page_counter = 0;
+   return;
+  }
+
+  status = sane_get_parameters(dev, &xsane.param);
+  if (status != SANE_STATUS_GOOD)
+  {
+    xsane_scan_done(status);
+    snprintf(buf, sizeof(buf), "%s %s", ERR_FAILED_GET_PARAMS, XSANE_STRSTATUS(status));
+    xsane_back_gtk_error(buf, TRUE);
+    xsane.adf_page_counter = 0;
+   return;
+  }
+
+  xsane.depth = xsane.param.depth; /* bit depth for saving, can be changed: 1->8, 16->8 */
+
+  xsane.num_bytes = xsane.param.lines * xsane.param.bytes_per_line;
+  xsane.bytes_read = 0;
+  xsane.expand_lineart_to_grayscale = 0;
+
+  switch (xsane.param.format)
+  {
+    case SANE_FRAME_RGB:	frame_type = "RGB"; break;
+    case SANE_FRAME_RED:	frame_type = "red"; break;
+    case SANE_FRAME_GREEN:	frame_type = "green"; break;
+    case SANE_FRAME_BLUE:	frame_type = "blue"; break;
+    case SANE_FRAME_GRAY:	frame_type = "gray"; break;
+#ifdef SUPPORT_RGBA
+    case SANE_FRAME_RGBA:	frame_type = "RGBA"; break;
+#endif
+    default:			frame_type = "unknown"; break;
+  }
+
+  if ( (xsane.param.depth == 1) && (xsane.preview->rotation) )
+  {
+    xsane.expand_lineart_to_grayscale = 1; /* We want to do transformation with lineart scan, so we save it as grayscale */
+  }
+
+  if ((xsane.xsane_mode == XSANE_VIEWER) && (xsane.param.depth == 1))
+  {
+    xsane.expand_lineart_to_grayscale = 1; /* we are using the viewer, lineart is not supported, so create grayscale */
+  }
+
+  if (!xsane.header_size) /* first pass of multi pass scan or single pass scan */
+  {
+    xsane_create_internal_gamma_tables(); /* create gamma tables that are not supported by scanner */
+
+    /* temporary file is created with permission 0600 in xsane_generate_dummy_filename */
+    if (!xsane_generate_dummy_filename(0)) /* create filename the scanned data is saved to */
+    {
+      /* no temporary file */
+      if (xsane_create_secure_file(xsane.dummy_filename)) /* remove possibly existing symbolic links for security */
+      {
+        snprintf(buf, sizeof(buf), "%s %s %s\n", ERR_DURING_SAVE, ERR_CREATE_SECURE_FILE, xsane.dummy_filename);
+        xsane_scan_done(-1); /* -1 = error */
+        xsane_back_gtk_error(buf, TRUE);
+       return;
+      }
+    }
+
+    xsane.out = fopen(xsane.dummy_filename, "wb"); /* b = binary mode for win32 */
+
+    if (!xsane.out) /* error while opening the dummy_file for writing */
+    {
+      xsane_scan_done(-1); /* -1 = error */
+      DBG(DBG_info, "open of file `%s'failed : %s\n", xsane.dummy_filename, strerror(errno));
+      snprintf(buf, sizeof(buf), "%s `%s': %s", ERR_OPEN_FAILED, xsane.dummy_filename, strerror(errno));
+      xsane_back_gtk_error(buf, TRUE);
+     return;
+    }
+
+    if ( (xsane.expand_lineart_to_grayscale) || (xsane.reduce_16bit_to_8bit) )
+    {
+      xsane.depth = 8;
+    }
+
+    image_info.image_width      = xsane.param.pixels_per_line;
+    image_info.image_height     = xsane.param.lines;
+    image_info.depth            = xsane.depth;
+    image_info.colors           = xsane.xsane_colors;
+
+    image_info.resolution_x     = xsane.resolution_x;
+    image_info.resolution_y     = xsane.resolution_y;
+
+    image_info.gamma            = xsane.gamma;
+    image_info.gamma_red        = xsane.gamma_red;
+    image_info.gamma_green      = xsane.gamma_green;
+    image_info.gamma_blue       = xsane.gamma_blue;
+
+    image_info.brightness       = xsane.brightness;
+    image_info.brightness_red   = xsane.brightness_red;
+    image_info.brightness_green = xsane.brightness_green;
+    image_info.brightness_blue  = xsane.brightness_blue;
+ 
+    image_info.contrast         = xsane.contrast;
+    image_info.contrast_red     = xsane.contrast_red;
+    image_info.contrast_green   = xsane.contrast_green;
+    image_info.contrast_blue    = xsane.contrast_blue;
+ 
+    image_info.threshold        = xsane.threshold;
+
+    xsane_write_pnm_header(xsane.out, &image_info);
+
+    fflush(xsane.out);
+    xsane.header_size = ftell(xsane.out); /* store header size for 3 pass scan */
+  }
+
+  if (xsane.param.format >= SANE_FRAME_RED && xsane.param.format <= SANE_FRAME_BLUE)
+  {
+/* correct this using read_pnm_header */
+    fseek(xsane.out, xsane.header_size + xsane.param.format - SANE_FRAME_RED, SEEK_SET);
+  }
+
+  xsane.pixelcolor = 0;
+
+  snprintf(buf, sizeof(buf), PROGRESS_RECEIVING_FRAME_DATA, _(frame_type));
+  xsane_progress_new(buf, PROGRESS_SCANNING, (GtkSignalFunc) xsane_cancel, NULL);
+
+  while (gtk_events_pending())
+  {
+    gtk_main_iteration();
+  }
+
+  xsane.input_tag = -1;
+
+#ifndef BUGGY_GDK_INPUT_EXCEPTION
+  /* for unix */
+  if ((sane_set_io_mode(dev, SANE_TRUE) == SANE_STATUS_GOOD) && (sane_get_select_fd(dev, &fd) == SANE_STATUS_GOOD))
+  {
+    DBG(DBG_info, "gdk_input_add\n");
+    xsane.input_tag = gdk_input_add(fd, GDK_INPUT_READ | GDK_INPUT_EXCEPTION, xsane_read_image_data, 0);
+  }
+  else
+#else
+  /* for win32 */
+  sane_set_io_mode(dev, SANE_FALSE);
+#endif
+  {
+    xsane_read_image_data(0, -1, GDK_INPUT_READ);
+  }
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+/* Invoked when the scan button is pressed */
+/* or by scan_done if automatic document feeder is selected */
+void xsane_scan_dialog(GtkWidget * widget, gpointer call_data)
+{
+ char buf[256];
+ const SANE_Option_Descriptor *opt;
+
+  DBG(DBG_proc, "xsane_scan_dialog\n");
+
+  xsane.reduce_16bit_to_8bit = preferences.reduce_16bit_to_8bit; /* reduce 16 bit image to 8 bit ? */
+
+  sane_get_parameters(xsane.dev, &xsane.param); /* update xsane.param */
+
+  if ( (xsane.mode == XSANE_STANDALONE) && (xsane.xsane_mode == XSANE_SAVE) )
+  {
+    /* correct length of filename counter if it is shorter than minimum length */
+    if (!xsane.force_filename)
+    {
+      xsane_update_counter_in_filename(&preferences.filename, FALSE, 0, preferences.filename_counter_len);
+      gtk_entry_set_text(GTK_ENTRY(xsane.outputfilename_entry), preferences.filename); 
+    }
+  }
+
+  xsane_define_output_filename(); /* make xsane.output_filename up to date */
+
+  /* test if file exists, may be we have to output an overwrite warning */
+  if (xsane.mode == XSANE_STANDALONE) /* We are running in standalone mode */
+  {
+   char *extension;
+
+    if ( (xsane.xsane_mode == XSANE_SAVE) && (preferences.overwrite_warning) ) /* test if filename already used */
+    {
+     FILE *testfile;
+
+      testfile = fopen(xsane.output_filename, "rb"); /* read binary (b for win32) */
+      if (testfile) /* filename used: skip */
+      {
+       char buf[256];
+
+        fclose(testfile);
+        snprintf(buf, sizeof(buf), WARN_FILE_EXISTS, xsane.output_filename);
+        if (xsane_back_gtk_decision(ERR_HEADER_WARNING, (gchar **) warning_xpm, buf, BUTTON_OVERWRITE, BUTTON_CANCEL, TRUE /* wait */) == FALSE)
+        {
+          return;
+        }
+      }
+    }
+
+    xsane.xsane_output_format = xsane_identify_output_format(xsane.output_filename, &extension);
+
+    if (xsane.xsane_mode == XSANE_SAVE)
+    {
+      if (xsane.xsane_output_format == XSANE_UNKNOWN)
+      {
+        if (extension)
+        {
+          snprintf(buf, sizeof(buf), ERR_UNSUPPORTED_OUTPUT_FORMAT, xsane.param.depth, extension);
+        }
+        else
+        {
+          snprintf(buf, sizeof(buf), "%s", ERR_NO_OUTPUT_FORMAT);
+        }
+        xsane_back_gtk_error(buf, TRUE);
+        return;
+      }
+      else if ( ( ( (xsane.xsane_output_format == XSANE_JPEG) && xsane.param.depth == 16) ||
+                  ( (xsane.xsane_output_format == XSANE_PS)   && xsane.param.depth == 16) ) &&
+                ( !xsane.reduce_16bit_to_8bit) )
+                
+      {
+        snprintf(buf, sizeof(buf), TEXT_REDUCE_16BIT_TO_8BIT);
+        if (xsane_back_gtk_decision(ERR_HEADER_INFO, (gchar **) info_xpm, buf, BUTTON_REDUCE, BUTTON_CANCEL, TRUE /* wait */) == FALSE)
+        {
+          return;
+        }
+        xsane.reduce_16bit_to_8bit = TRUE;
+      }
+      
+#ifdef SUPPORT_RGBA
+      else if ((xsane.xsane_output_format == XSANE_RGBA) && (xsane.param.format != SANE_FRAME_RGBA))
+      {
+        snprintf(buf, sizeof(buf), "No RGBA data format !!!"); /* user selected output format RGBA, scanner uses other format */
+        xsane_back_gtk_error(buf, TRUE);
+        return;
+      }
+#endif
+    }
+#ifdef SUPPORT_RGBA
+    else if (xsane.param.format == SANE_FRAME_RGBA) /* no scanmode but format=rgba */
+    {
+      snprintf(buf, sizeof(buf), "Special format RGBA only supported in scan mode !!!");
+      xsane_back_gtk_error(buf, TRUE);
+      return;
+    }
+#endif
+
+#ifdef SUPPORT_RGBA
+    if (xsane.param.format == SANE_FRAME_RGBA)
+    {
+      if ( (xsane.xsane_output_format != XSANE_RGBA) && (xsane.xsane_output_format != XSANE_PNG) )
+      {
+        snprintf(buf, sizeof(buf), "Image data of type SANE_FRAME_RGBA\ncan only be saved in rgba or png format");
+        xsane_back_gtk_error(buf, TRUE);
+        return;
+      }
+    }
+#endif
+
+    if (xsane.xsane_mode == XSANE_FAX)
+    {
+      mkdir(preferences.fax_project, 7*64 + 0*8 + 0);
+    }
+
+    if (extension)
+    {
+      free(extension);
+    }
+  }
+#ifdef HAVE_LIBGIMP_GIMP_H
+  else	/* We are running in gimp mode */
+  {
+    if ((xsane.param.depth != 1) && (xsane.param.depth != 8)) /* not support bit depth ? */
+    {
+      if (!xsane.reduce_16bit_to_8bit) /* ask if reduce 16 to 8 bit */
+      {
+        if (xsane.param.depth == 16)
+        {
+          snprintf(buf, sizeof(buf), TEXT_GIMP_REDUCE_16BIT_TO_8BIT);
+          if (xsane_back_gtk_decision(ERR_HEADER_INFO, (gchar **) info_xpm, buf, BUTTON_REDUCE, BUTTON_CANCEL, TRUE /* wait */) == FALSE)
+          {
+            return;
+          }
+          xsane.reduce_16bit_to_8bit = TRUE;
+        }
+        else /* unsupported bit depth */
+        {
+          snprintf(buf, sizeof(buf), ERR_GIMP_BAD_DEPTH, xsane.param.depth);
+          xsane_back_gtk_error(buf, TRUE);
+         return;
+        }
+      }
+    }
+  }
+#endif
+
+  if (xsane.dummy_filename) /* no dummy filename defined - necessary if an error occurs */
+  {
+    free(xsane.dummy_filename);
+    xsane.dummy_filename = 0;
+  }
+
+  /* create scanner gamma tables, xsane internal gamma tables are created after sane_start */
+  if ( (xsane.xsane_colors > 1) && /* color scan */
+       xsane.scanner_gamma_color ) /* gamma table for red, green and blue available */
+  {
+   double gamma_red, gamma_green, gamma_blue;
+   int gamma_red_size, gamma_green_size, gamma_blue_size;
+   int gamma_red_max, gamma_green_max, gamma_blue_max;
+
+    /* ok, scanner color gamma function is supported, so we do all conversions about that */
+    /* we do not need any gamma tables while scanning, so we can free them after sending */
+    /* the data to the scanner */
+
+    /* if also gray gamma function is supported, set this to 1.0 to get the right colors */
+    if (xsane.scanner_gamma_gray)
+    {
+     int gamma_gray_size;
+     int gamma_gray_max;
+
+      opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector);
+      gamma_gray_size = opt->size / sizeof(opt->type);
+      gamma_gray_max  = opt->constraint.range->max;
+
+      xsane.gamma_data = malloc(gamma_gray_size  * sizeof(SANE_Int));
+      xsane_create_gamma_curve(xsane.gamma_data, 0, 1.0, 0.0, 0.0, 0.0, 100.0, 1.0, gamma_gray_size, gamma_gray_max);
+      xsane_back_gtk_update_vector(xsane.well_known.gamma_vector, xsane.gamma_data);
+      free(xsane.gamma_data);
+      xsane.gamma_data = 0;
+    }
+
+    opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector_r);
+    gamma_red_size = opt->size / sizeof(opt->type);
+    gamma_red_max  = opt->constraint.range->max;
+
+    opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector_g);
+    gamma_green_size = opt->size / sizeof(opt->type);
+    gamma_green_max  = opt->constraint.range->max;
+
+    opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector_b);
+    gamma_blue_size = opt->size / sizeof(opt->type);
+    gamma_blue_max  = opt->constraint.range->max;
+
+    xsane.gamma_data_red   = malloc(gamma_red_size   * sizeof(SANE_Int));
+    xsane.gamma_data_green = malloc(gamma_green_size * sizeof(SANE_Int));
+    xsane.gamma_data_blue  = malloc(gamma_blue_size  * sizeof(SANE_Int));
+
+    if (xsane.xsane_mode == XSANE_COPY)
+    {
+      gamma_red   = xsane.gamma * xsane.gamma_red   * preferences.printer[preferences.printernr]->gamma * preferences.printer[preferences.printernr]->gamma_red;
+      gamma_green = xsane.gamma * xsane.gamma_green * preferences.printer[preferences.printernr]->gamma * preferences.printer[preferences.printernr]->gamma_green;
+      gamma_blue  = xsane.gamma * xsane.gamma_blue  * preferences.printer[preferences.printernr]->gamma * preferences.printer[preferences.printernr]->gamma_blue;
+    }
+    else
+    {
+      gamma_red   = xsane.gamma * xsane.gamma_red;
+      gamma_green = xsane.gamma * xsane.gamma_green;
+      gamma_blue  = xsane.gamma * xsane.gamma_blue;
+    }
+
+    xsane_create_gamma_curve(xsane.gamma_data_red, xsane.negative != xsane.medium_negative,
+		 	       gamma_red,
+			       xsane.brightness + xsane.brightness_red,
+			       xsane.contrast + xsane.contrast_red,
+                               xsane.medium_shadow_red, xsane.medium_highlight_red, xsane.medium_gamma_red, 
+                               gamma_red_size, gamma_red_max);
+
+    xsane_create_gamma_curve(xsane.gamma_data_green, xsane.negative != xsane.medium_negative,
+			       gamma_green,
+			       xsane.brightness + xsane.brightness_green,
+			       xsane.contrast + xsane.contrast_green,
+                               xsane.medium_shadow_green, xsane.medium_highlight_green, xsane.medium_gamma_green, 
+                               gamma_green_size, gamma_green_max);
+
+    xsane_create_gamma_curve(xsane.gamma_data_blue, xsane.negative != xsane.medium_negative,
+			       gamma_blue,
+			       xsane.brightness + xsane.brightness_blue,
+			       xsane.contrast + xsane.contrast_blue,
+                               xsane.medium_shadow_blue, xsane.medium_highlight_blue, xsane.medium_gamma_blue, 
+                               gamma_blue_size, gamma_blue_max);
+
+    xsane_back_gtk_update_vector(xsane.well_known.gamma_vector_r, xsane.gamma_data_red);
+    xsane_back_gtk_update_vector(xsane.well_known.gamma_vector_g, xsane.gamma_data_green);
+    xsane_back_gtk_update_vector(xsane.well_known.gamma_vector_b, xsane.gamma_data_blue);
+
+    free(xsane.gamma_data_red);
+    free(xsane.gamma_data_green);
+    free(xsane.gamma_data_blue);
+
+    xsane.gamma_data_red   = 0;
+    xsane.gamma_data_green = 0;
+    xsane.gamma_data_blue  = 0;
+  }
+  else if (xsane.scanner_gamma_gray) /* only scanner gray gamma function available or grayscale scan */
+  {
+   /* ok, the scanner only supports gray gamma function */
+   /* if we are doing a grayscale scan everyting is ok, */
+   /* for a color scan the software has to do the gamma correction set by the component slider */
+
+   double gamma;
+   int gamma_gray_size;
+   int gamma_gray_max;
+
+    opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector);
+    gamma_gray_size = opt->size / sizeof(opt->type);
+    gamma_gray_max  = opt->constraint.range->max;
+
+    if (xsane.xsane_mode == XSANE_COPY)
+    {
+      gamma = xsane.gamma * preferences.printer[preferences.printernr]->gamma;
+    }
+    else
+    {
+      gamma = xsane.gamma;
+    }
+
+    xsane.gamma_data = malloc(gamma_gray_size * sizeof(SANE_Int));
+
+    if (xsane.xsane_colors > 1) /* color scan */
+    {
+      xsane_create_gamma_curve(xsane.gamma_data, xsane.negative,
+                               gamma, xsane.brightness, xsane.contrast,
+                               0.0, 100.0, 1.0, /* medium correction is done by xsane internal gamma correction */
+                               gamma_gray_size, gamma_gray_max);
+    }
+    else
+    {
+      xsane_create_gamma_curve(xsane.gamma_data, xsane.negative != xsane.medium_negative,
+                               gamma, xsane.brightness, xsane.contrast,
+                               xsane.medium_shadow_gray, xsane.medium_highlight_gray, xsane.medium_gamma_gray, 
+                               gamma_gray_size, gamma_gray_max);
+    }
+
+    xsane_back_gtk_update_vector(xsane.well_known.gamma_vector, xsane.gamma_data);
+    free(xsane.gamma_data);
+    xsane.gamma_data = 0;
+  }
+
+  xsane_clear_histogram(&xsane.histogram_raw);
+  xsane_clear_histogram(&xsane.histogram_enh);    
+  xsane_set_sensitivity(FALSE);
+
+  while (gtk_events_pending())
+  {
+    gtk_main_iteration();
+  }
+
+  xsane.reading_data = FALSE;
+
+  xsane.scanning = TRUE; /* set marker that scan has been initiated */
+
+  xsane_start_scan();
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+static void xsane_create_internal_gamma_tables(void)
+{
+ int size, maxval;
+
+  size = (int) pow(2, xsane.param.depth);
+  maxval = size-1;
+
+  if (xsane.xsane_colors > 1) /* color scan */
+  {
+    if ( (!xsane.scanner_gamma_color) && (xsane.scanner_gamma_gray) )
+    {
+      /* we have to create color gamma table for software conversion */
+	/* but we only have to use color slider values, because gray slider value */
+	/* is used by scanner gray gamma */
+
+     double gamma_red, gamma_green, gamma_blue;
+
+      DBG(DBG_info, "creating xsane internal color gamma tables with size %d\n", size);
+
+      xsane.gamma_data_red   = malloc(size * sizeof(SANE_Int));
+      xsane.gamma_data_green = malloc(size * sizeof(SANE_Int));
+      xsane.gamma_data_blue  = malloc(size * sizeof(SANE_Int));
+
+      if (xsane.xsane_mode == XSANE_COPY)
+      {
+        gamma_red   = xsane.gamma_red   * preferences.printer[preferences.printernr]->gamma_red;
+        gamma_green = xsane.gamma_green * preferences.printer[preferences.printernr]->gamma_green;
+        gamma_blue  = xsane.gamma_blue  * preferences.printer[preferences.printernr]->gamma_blue;
+      }
+      else
+      {
+        gamma_red   = xsane.gamma_red;
+        gamma_green = xsane.gamma_green;
+        gamma_blue  = xsane.gamma_blue;
+      }
+    
+      xsane_create_gamma_curve(xsane.gamma_data_red, xsane.medium_negative,
+                               gamma_red, xsane.brightness_red, xsane.contrast_red,
+                               xsane.medium_shadow_red, xsane.medium_highlight_red, xsane.medium_gamma_red, 
+                               size, maxval);
+
+      xsane_create_gamma_curve(xsane.gamma_data_green, xsane.medium_negative,
+                               gamma_green, xsane.brightness_green, xsane.contrast_green,
+                               xsane.medium_shadow_green, xsane.medium_highlight_green, xsane.medium_gamma_green, 
+                               size, maxval);
+
+      xsane_create_gamma_curve(xsane.gamma_data_blue, xsane.medium_negative,
+                               gamma_blue, xsane.brightness_blue, xsane.contrast_blue,
+                               xsane.medium_shadow_blue, xsane.medium_highlight_blue, xsane.medium_gamma_blue, 
+                               size, maxval);
+
+      /* gamma tables are freed after scan */
+    }
+    else if ( (!xsane.scanner_gamma_color) && (!xsane.scanner_gamma_gray) ) /* no scanner gamma table */
+    {
+     double gamma_red, gamma_green, gamma_blue;
+      /* ok, we have to combin gray and color slider values */
+
+      DBG(DBG_info, "creating xsane internal complete gamma tables with size %d\n", size);
+
+      xsane.gamma_data_red   = malloc(size * sizeof(SANE_Int));
+      xsane.gamma_data_green = malloc(size * sizeof(SANE_Int));
+      xsane.gamma_data_blue  = malloc(size * sizeof(SANE_Int));
+
+      if (xsane.xsane_mode == XSANE_COPY)
+      {
+        gamma_red   = xsane.gamma * xsane.gamma_red   * preferences.printer[preferences.printernr]->gamma * preferences.printer[preferences.printernr]->gamma_red;
+        gamma_green = xsane.gamma * xsane.gamma_green * preferences.printer[preferences.printernr]->gamma * preferences.printer[preferences.printernr]->gamma_green;
+        gamma_blue  = xsane.gamma * xsane.gamma_blue  * preferences.printer[preferences.printernr]->gamma * preferences.printer[preferences.printernr]->gamma_blue;
+      }
+      else
+      {
+        gamma_red   = xsane.gamma * xsane.gamma_red;
+        gamma_green = xsane.gamma * xsane.gamma_green;
+        gamma_blue  = xsane.gamma * xsane.gamma_blue;
+      }
+
+      xsane_create_gamma_curve(xsane.gamma_data_red, xsane.negative != xsane.medium_negative,
+                               gamma_red,
+                               xsane.brightness + xsane.brightness_red,
+                               xsane.contrast + xsane.contrast_red,
+                               xsane.medium_shadow_red, xsane.medium_highlight_red, xsane.medium_gamma_red, 
+                               size, maxval);
+
+      xsane_create_gamma_curve(xsane.gamma_data_green, xsane.negative != xsane.medium_negative,
+                               gamma_green,
+                               xsane.brightness + xsane.brightness_green,
+                               xsane.contrast + xsane.contrast_green,
+                               xsane.medium_shadow_green, xsane.medium_highlight_green, xsane.medium_gamma_green, 
+                               size, maxval);
+
+      xsane_create_gamma_curve(xsane.gamma_data_blue, xsane.negative != xsane.medium_negative,
+                               gamma_blue,
+                               xsane.brightness + xsane.brightness_blue,
+                               xsane.contrast + xsane.contrast_blue,
+                               xsane.medium_shadow_blue, xsane.medium_highlight_blue, xsane.medium_gamma_blue, 
+                               size, maxval);
+
+      /* gamma tables are freed after scan */
+    }
+  }
+  else /* grayscale scan */
+  {
+    if (!xsane.scanner_gamma_gray) /* no gray scanner gamma table */
+    {
+     double gamma;
+
+      DBG(DBG_info, "creating xsane internal gray gamma table with size %d\n", size);
+
+      if (xsane.xsane_mode == XSANE_COPY)
+      {
+        gamma = xsane.gamma * preferences.printer[preferences.printernr]->gamma;
+      }
+      else
+      {
+        gamma = xsane.gamma;
+      }
+
+      xsane.gamma_data = malloc(size * sizeof(SANE_Int));
+      xsane_create_gamma_curve(xsane.gamma_data, xsane.negative != xsane.medium_negative,
+                               gamma, xsane.brightness, xsane.contrast,
+                               xsane.medium_shadow_gray, xsane.medium_highlight_gray, xsane.medium_gamma_gray, 
+                               size, maxval);
+
+      /* gamma table is freed after scan */
+    }
+  }
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+