diff options
Diffstat (limited to 'backend/dc25.c')
| -rw-r--r-- | backend/dc25.c | 2760 |
1 files changed, 2760 insertions, 0 deletions
diff --git a/backend/dc25.c b/backend/dc25.c new file mode 100644 index 0000000..2c9e78c --- /dev/null +++ b/backend/dc25.c @@ -0,0 +1,2760 @@ +/*************************************************************************** + * SANE - Scanner Access Now Easy. + + dc25.c + + $Id$ + + This file (C) 1998 Peter Fales + + This file is part of the SANE 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., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA. + + As a special exception, the authors of SANE give permission for + additional uses of the libraries contained in this release of SANE. + + The exception is that, if you link a SANE library with other files + to produce an executable, this does not by itself cause the + resulting executable to be covered by the GNU General Public + License. Your use of that executable is in no way restricted on + account of linking the SANE library code into it. + + This exception does not, however, invalidate any other reasons why + the executable file might be covered by the GNU General Public + License. + + If you submit changes to SANE to the maintainers to be included in + a subsequent release, you agree by submitting the changes that + those changes may be distributed with this exception intact. + + If you write modifications of your own for SANE, it is your choice + whether to permit this exception to apply to your modifications. + If you do not wish that, delete this exception notice. + + *************************************************************************** + + This file implements a SANE backend for the Kodak DC-25 (and + probably the DC-20) digital cameras. THIS IS EXTREMELY ALPHA CODE! + USE AT YOUR OWN RISK!! + + (feedback to: dc25-devel@fales-lorenz.net) + + This backend is based heavily on the dc20ctrl package by Ugo + Paternostro <paterno@dsi.unifi.it>. I've attached his header below: + + *************************************************************************** + + * Copyright (C) 1998 Ugo Paternostro <paterno@dsi.unifi.it> + * + * This file is part of the dc20ctrl package. The complete package can be + * downloaded from: + * http://aguirre.dsi.unifi.it/~paterno/binaries/dc20ctrl.tar.gz + * + * This package is derived from the dc20 package, built by Karl Hakimian + * <hakimian@aha.com> that you can find it at ftp.eecs.wsu.edu in the + * /pub/hakimian directory. The complete URL is: + * ftp://ftp.eecs.wsu.edu/pub/hakimian/dc20.tar.gz + * + * This package also includes a sligthly modified version of the Comet to ppm + * conversion routine written by YOSHIDA Hideki <hideki@yk.rim.or.jp> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published + * 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 "../include/sane/config.h" + +#include <stdlib.h> +#include <string.h> +#include <stdio.h> +#include <unistd.h> +#include <fcntl.h> +#include <limits.h> + +#include "../include/sane/sane.h" +#include "../include/sane/sanei.h" +#include "../include/sane/saneopts.h" + +#define BACKEND_NAME dc25 +#include "../include/sane/sanei_backend.h" + +#include "dc25.h" + +#ifndef PATH_MAX +# define PATH_MAX 1024 +#endif + +#define MAGIC (void *)0xab730324 +#define DC25_CONFIG_FILE "dc25.conf" +#define THUMBSIZE ( (CameraInfo.model == 0x25 ) ? 14400 : 5120 ) + +static SANE_Bool is_open = 0; + +static SANE_Byte dc25_opt_image_number = 1; /* Image to load */ +static SANE_Bool dc25_opt_thumbnails; /* Load thumbnails */ +static SANE_Bool dc25_opt_snap; /* Take new picture */ +static SANE_Bool dc25_opt_lowres; /* Use low resoluiton */ +#define DC25_OPT_CONTRAST_DEFAULT 1.6 + /* Contrast enhancement */ +static SANE_Fixed dc25_opt_contrast = SANE_FIX (DC25_OPT_CONTRAST_DEFAULT); +#define DC25_OPT_GAMMA_DEFAULT 4.5 + /* Gamma correction (10x) */ +static SANE_Fixed dc25_opt_gamma = SANE_FIX (DC25_OPT_GAMMA_DEFAULT); +static SANE_Bool dc25_opt_erase; /* Erase all after download */ +static SANE_Bool dc25_opt_erase_one; /* Erase one after download */ +static SANE_Bool dumpinquiry; + +static SANE_Int info_flags; + +static int tfd; /* Camera File Descriptor */ +static char tty_name[PATH_MAX]; +#define DEF_TTY_NAME "/dev/ttyS0" + +static speed_t tty_baud = DEFAULT_TTY_BAUD; +static char *tmpname; +static char tmpnamebuf[] = "/tmp/dc25XXXXXX"; + +static Dc20Info *dc20_info; +static Dc20Info CameraInfo; + +static SANE_Byte contrast_table[256]; + +static struct pixmap *pp; + +static const SANE_Range percentage_range = { + -100 << SANE_FIXED_SCALE_SHIFT, /* minimum */ + 100 << SANE_FIXED_SCALE_SHIFT, /* maximum */ + 0 << SANE_FIXED_SCALE_SHIFT /* quantization */ +}; + +static const SANE_Range contrast_range = { + 0 << SANE_FIXED_SCALE_SHIFT, /* minimum */ + 3 << SANE_FIXED_SCALE_SHIFT, /* maximum */ + 16384 /* quantization ~ 0.025 */ +}; + +static const SANE_Range gamma_range = { + 0 << SANE_FIXED_SCALE_SHIFT, /* minimum */ + 10 << SANE_FIXED_SCALE_SHIFT, /* maximum */ + 16384 /* quantization ~ 0.025 */ +}; + +static SANE_Range image_range = { + 0, + 14, + 0 +}; + +static SANE_Option_Descriptor sod[] = { + { + SANE_NAME_NUM_OPTIONS, + SANE_TITLE_NUM_OPTIONS, + SANE_DESC_NUM_OPTIONS, + SANE_TYPE_INT, + SANE_UNIT_NONE, + sizeof (SANE_Word), + SANE_CAP_SOFT_DETECT, + SANE_CONSTRAINT_NONE, + {NULL} + } + , + +#define D25_OPT_IMAGE_SELECTION 1 + { + "", + "Image Selection", + "Selection of the image to load.", + SANE_TYPE_GROUP, + SANE_UNIT_NONE, + 0, + 0, + SANE_CONSTRAINT_NONE, + {NULL} + } + , + +#define DC25_OPT_IMAGE_NUMBER 2 + { + "image", + "Image Number", + "Select Image Number to load from camera", + SANE_TYPE_INT, + SANE_UNIT_NONE, + 4, + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT, + SANE_CONSTRAINT_RANGE, + {(SANE_String_Const *) & image_range} /* this is ANSI conformant! */ + } + , + +#define DC25_OPT_THUMBS 3 + { + "thumbs", + "Load Thumbnail", + "Load the image as thumbnail.", + SANE_TYPE_BOOL, + SANE_UNIT_NONE, + sizeof (SANE_Word), + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT, + SANE_CONSTRAINT_NONE, + {NULL} + } + , +#define DC25_OPT_SNAP 4 + { + "snap", + "Snap new picture", + "Take new picture and download it", + SANE_TYPE_BOOL, + SANE_UNIT_NONE, + sizeof (SANE_Word), + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_ADVANCED, + SANE_CONSTRAINT_NONE, + {NULL} + } + , +#define DC25_OPT_LOWRES 5 + { + "lowres", + "Low Resolution", + "New pictures taken in low resolution", + SANE_TYPE_BOOL, + SANE_UNIT_NONE, + sizeof (SANE_Word), + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE | + SANE_CAP_ADVANCED, + SANE_CONSTRAINT_NONE, + {NULL} + } + , + +#define DC25_OPT_ERASE 6 + { + "erase", + "Erase", + "Erase all pictures after downloading", + SANE_TYPE_BOOL, + SANE_UNIT_NONE, + sizeof (SANE_Word), + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT, + SANE_CONSTRAINT_NONE, + {NULL} + } + , + +#define DC25_OPT_ERASE_ONE 7 + { + "erase-one", + "Erase One", + "Erase downloaded picture after downloading", + SANE_TYPE_BOOL, + SANE_UNIT_NONE, + sizeof (SANE_Word), + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT, + SANE_CONSTRAINT_NONE, + {NULL} + } + , + +#define DC25_OPT_ENHANCE 8 + { + "", + "Image Parameters", + "Modifications to image parameters", + SANE_TYPE_GROUP, + SANE_UNIT_NONE, + 0, + 0, + SANE_CONSTRAINT_NONE, + {NULL} + } + , + +#define DC25_OPT_CONTRAST 9 + { + "contrast", + "Contrast Adjustment", + "Values > 1 enhance contrast", + SANE_TYPE_FIXED, + SANE_UNIT_NONE, + sizeof (SANE_Word), + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT, + SANE_CONSTRAINT_RANGE, + {(const SANE_String_Const *) &contrast_range} /* this is ANSI conformant! */ + }, + +#define DC25_OPT_GAMMA 10 + { + "gamma", + "Gamma Adjustment", + "Larger values make image darker", + SANE_TYPE_FIXED, + SANE_UNIT_NONE, + sizeof (SANE_Word), + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT, + SANE_CONSTRAINT_RANGE, + {(const SANE_String_Const *) &gamma_range} /* this is ANSI conformant! */ + }, + +#define DC25_OPT_DEFAULT 11 + { + "default-enhancements", + "Defaults", + "Set default values for enhancement controls (i.e. contrast).", + SANE_TYPE_BUTTON, + SANE_UNIT_NONE, + 0, + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT, + SANE_CONSTRAINT_NONE, + {NULL} + } +}; + +static SANE_Parameters parms = { + SANE_FRAME_RGB, + 1, + 500, /* Number of bytes returned per scan line: */ + 500, /* Number of pixels per scan line. */ + 373, /* Number of lines for the current scan. */ + 8, /* Number of bits per sample. */ +}; + + + + +static unsigned char init_pck[] = INIT_PCK; + +/* + * List of speeds to try to establish connection with the camera. + * Check 9600 first, as it's the speed the camera comes up in, then + * 115200, as that is the one most likely to be configured from a + * previous run + */ +static struct pkt_speed speeds[] = { {B9600, {0x96, 0x00}}, +#ifdef B115200 +{B115200, {0x11, 0x52}}, +#endif +#ifdef B57600 +{B57600, {0x57, 0x60}}, +#endif +{B38400, {0x38, 0x40}}, +{B19200, {0x19, 0x20}}, +}; +#define NUM_OF_SPEEDS ((int)(sizeof(speeds) / sizeof(struct pkt_speed))) + +static struct termios tty_orig; + +static int +send_pck (int fd, unsigned char *pck) +{ + int n; + unsigned char r; + + /* + * Not quite sure why we need this, but the program works a whole + * lot better (at least on the DC25) with this short delay. + */ +#ifdef HAVE_USLEEP + usleep (10); +#else + sleep (1); +#endif + if (write (fd, (char *) pck, 8) != 8) + { + DBG (2, "send_pck: error: write returned -1\n"); + return -1; + } + + if ((n = read (fd, (char *) &r, 1)) != 1) + { + DBG (2, "send_pck: error: read returned -1\n"); + return -1; + } + + return (r == 0xd1) ? 0 : -1; +} + +static int +init_dc20 (char *device, speed_t speed) +{ + struct termios tty_new; + int speed_index; + + DBG (1, "DC-20/25 Backend 05/07/01\n"); + + for (speed_index = 0; speed_index < NUM_OF_SPEEDS; speed_index++) + { + if (speeds[speed_index].baud == speed) + { + init_pck[2] = speeds[speed_index].pkt_code[0]; + init_pck[3] = speeds[speed_index].pkt_code[1]; + break; + } + } + + if (init_pck[2] == 0) + { + DBG (2, "unsupported baud rate.\n"); + return -1; + } + + /* + Open device file. + */ + if ((tfd = open (device, O_RDWR)) == -1) + { + DBG (2, "init_dc20: error: could not open %s for read/write\n", device); + return -1; + } + /* + Save old device information to restore when we are done. + */ + if (tcgetattr (tfd, &tty_orig) == -1) + { + DBG (2, "init_dc20: error: could not get attributes\n"); + return -1; + } + + memcpy ((char *) &tty_new, (char *) &tty_orig, sizeof (struct termios)); + /* + We need the device to be raw. 8 bits even parity on 9600 baud to start. + */ +#ifdef HAVE_CFMAKERAW + cfmakeraw (&tty_new); +#else + tty_new.c_lflag &= ~(ICANON | ECHO | ISIG); +#endif + tty_new.c_oflag &= ~CSTOPB; + tty_new.c_cflag |= PARENB; + tty_new.c_cflag &= ~PARODD; + tty_new.c_cc[VMIN] = 0; + tty_new.c_cc[VTIME] = 50; + cfsetospeed (&tty_new, B9600); + cfsetispeed (&tty_new, B9600); + + if (tcsetattr (tfd, TCSANOW, &tty_new) == -1) + { + DBG (2, "init_dc20: error: could not set attributes\n"); + return -1; + } + + if (send_pck (tfd, init_pck) == -1) + { + /* + * The camera always powers up at 9600, so we try + * that first. However, it may be already set to + * a different speed. Try the entries in the table: + */ + + for (speed_index = NUM_OF_SPEEDS - 1; speed_index > 0; speed_index--) + { + DBG (3, "init_dc20: changing speed to %d\n", + (int) speeds[speed_index].baud); + + cfsetospeed (&tty_new, speeds[speed_index].baud); + cfsetispeed (&tty_new, speeds[speed_index].baud); + + if (tcsetattr (tfd, TCSANOW, &tty_new) == -1) + { + DBG (2, "init_dc20: error: could not set attributes\n"); + return -1; + } + if (send_pck (tfd, init_pck) != -1) + break; + } + + if (speed_index == 0) + { + tcsetattr (tfd, TCSANOW, &tty_orig); + DBG (2, "init_dc20: error: no suitable baud rate\n"); + return -1; + } + } + /* + Set speed to requested speed. Also, make a long timeout (we need this for + erase and shoot operations) + */ + tty_new.c_cc[VTIME] = 150; + cfsetospeed (&tty_new, speed); + cfsetispeed (&tty_new, speed); + + if (tcsetattr (tfd, TCSANOW, &tty_new) == -1) + { + DBG (2, "init_dc20: error: could not set attributes\n"); + return -1; + } + + return tfd; +} + +static void +close_dc20 (int fd) +{ + DBG (127, "close_dc20() called\n"); + /* + * Put the camera back to 9600 baud + */ + + init_pck[2] = speeds[0].pkt_code[0]; + init_pck[3] = speeds[0].pkt_code[1]; + if (send_pck (fd, init_pck) == -1) + { + DBG (4, "close_dc20: error: could not set attributes\n"); + } + + /* + Restore original device settings. + */ + if (tcsetattr (fd, TCSANOW, &tty_orig) == -1) + { + DBG (4, "close_dc20: error: could not set attributes\n"); + } + + if (close (fd) == -1) + { + DBG (4, "close_dc20: error: could not close device\n"); + } +} + +static unsigned char info_pck[] = INFO_PCK; + +static Dc20Info * +get_info (int fd) +{ + unsigned char buf[256]; + + if (send_pck (fd, info_pck) == -1) + { + DBG (2, "get_info: error: send_pck returned -1\n"); + return NULL; + } + + DBG (9, "get_info: read info packet\n"); + + if (read_data (fd, buf, 256) == -1) + { + DBG (2, "get_info: error: read_data returned -1\n"); + return NULL; + } + + if (end_of_data (fd) == -1) + { + DBG (2, "get_info: error: end_of_data returned -1\n"); + return NULL; + } + + CameraInfo.model = buf[1]; + CameraInfo.ver_major = buf[2]; + CameraInfo.ver_minor = buf[3]; + CameraInfo.pic_taken = buf[8] << 8 | buf[9]; + if (CameraInfo.model == 0x25) + { + + /* Not sure where the previous line came from. All the + * information I have says that even on the DC20 the number of + * standard res pics is in byte 17 and the number of high res pics + * is in byte 19. This is definitely true on my DC25. + */ + CameraInfo.pic_taken = buf[17] + buf[19]; + } + + image_range.max = CameraInfo.pic_taken; + image_range.min = CameraInfo.pic_taken ? 1 : 0; + + CameraInfo.pic_left = buf[10] << 8 | buf[11]; + + if (CameraInfo.model == 0x25) + { + /* Not sure where the previous line came from. All the + * information I have says that even on the DC20 the number of + * standard res pics left is in byte 23 and the number of high res + * pics left is in byte 21. It seems to me that the conservative + * approach is to report the number of high res pics left. + */ + CameraInfo.pic_left = buf[21]; + } + CameraInfo.flags.low_res = buf[23]; + + if (CameraInfo.model == 0x25) + { + /* Not sure where the previous line came from. All the + * information I have says that even on the DC20 the low_res + * byte is 11. + */ + CameraInfo.flags.low_res = buf[11]; + } + CameraInfo.flags.low_batt = buf[29]; + + return &CameraInfo; +} + +static int +read_data (int fd, unsigned char *buf, int sz) +{ + unsigned char ccsum; + unsigned char rcsum; + unsigned char c; + int retries = 0; + int n; + int r = 0; + int i; + + while (retries++ < 5) + { + + /* + * If this is not the first time through, then it must be + * a retry - signal the camera that we didn't like what + * we got. In either case, start filling the packet + */ + if (retries != 1) + { + + DBG (2, "Attempt retry %d\n", retries); + c = 0xe3; + if (write (fd, (char *) &c, 1) != 1) + { + DBG (2, "read_data: error: write ack\n"); + return -1; + } + + } + + for (n = 0; n < sz && (r = read (fd, (char *) &buf[n], sz - n)) > 0; + n += r) + ; + + if (r <= 0) + { + DBG (2, "read_data: error: read returned -1\n"); + continue; + } + + if (n < sz || read (fd, &rcsum, 1) != 1) + { + DBG (2, "read_data: error: buffer underrun or no checksum\n"); + continue; + } + + for (i = 0, ccsum = 0; i < n; i++) + ccsum ^= buf[i]; + + if (ccsum != rcsum) + { + DBG (2, "read_data: error: bad checksum (%02x != %02x)\n", rcsum, + ccsum); + continue; + } + + /* If we got this far, then the packet is OK */ + break; + } + + c = 0xd2; + + if (write (fd, (char *) &c, 1) != 1) + { + DBG (2, "read_data: error: write ack\n"); + return -1; + } + + return 0; +} + +static int +end_of_data (int fd) +{ + char c; + + if (read (fd, &c, 1) != 1) + { + DBG (2, "end_of_data: error: read returned -1\n"); + return -1; + } + + if (c != 0) + { + DBG (2, "end_of_data: error: bad EOD from camera (%02x)\n", + (unsigned) c); + return -1; + } + + return 0; +} + +#include <math.h> + +#define BIDIM_ARRAY(name, x, y, width) (name[((x) + ((y) * (width)))]) + +/* + * These definitions depend on the resolution of the image + */ + +#define MY_LOW_RIGHT_MARGIN 6 + +/* + * These definitions are constant with resolution + */ + +#define MY_LEFT_MARGIN 2 + +#define NET_COLUMNS (columns - MY_LEFT_MARGIN - right_margin) +#define NET_LINES (HEIGHT - TOP_MARGIN - BOTTOM_MARGIN) +#define NET_PIXELS (NET_COLUMNS * NET_LINES) + + +#define SCALE 64 +#define SMAX (256 * SCALE - 1) +#define HORIZONTAL_INTERPOLATIONS 3 +#define HISTOGRAM_STEPS 4096 + +#define RFACTOR 0.64 +#define GFACTOR 0.58 +#define BFACTOR 1.00 +#define RINTENSITY 0.476 +#define GINTENSITY 0.299 +#define BINTENSITY 0.175 + +#define SATURATION 1.0 +#define NORM_PERCENTAGE 3 + +static int columns = HIGH_WIDTH, + right_margin = HIGH_RIGHT_MARGIN, camera_header_size = HIGH_CAMERA_HEADER; +static int low_i = -1, high_i = -1, norm_percentage = NORM_PERCENTAGE; +static float saturation = SATURATION, + rfactor = RFACTOR, gfactor = GFACTOR, bfactor = BFACTOR; + +static void +set_initial_interpolation (const unsigned char ccd[], + short horizontal_interpolation[]) +{ + int column, line; + for (line = 0; line < HEIGHT; line++) + { + BIDIM_ARRAY (horizontal_interpolation, MY_LEFT_MARGIN, line, columns) = + BIDIM_ARRAY (ccd, MY_LEFT_MARGIN + 1, line, columns) * SCALE; + BIDIM_ARRAY (horizontal_interpolation, columns - right_margin - 1, line, + columns) = + BIDIM_ARRAY (ccd, columns - right_margin - 2, line, columns) * SCALE; + for (column = MY_LEFT_MARGIN + 1; column < columns - right_margin - 1; + column++) + { + BIDIM_ARRAY (horizontal_interpolation, column, line, columns) = + (BIDIM_ARRAY (ccd, column - 1, line, columns) + + BIDIM_ARRAY (ccd, column + 1, line, columns)) * (SCALE / 2); + } + } +} + +static void +interpolate_horizontally (const unsigned char ccd[], + short horizontal_interpolation[]) +{ + int column, line, i, initial_column; + for (line = TOP_MARGIN - 1; line < HEIGHT - BOTTOM_MARGIN + 1; line++) + { + for (i = 0; i < HORIZONTAL_INTERPOLATIONS; i++) + { + for (initial_column = MY_LEFT_MARGIN + 1; + initial_column <= MY_LEFT_MARGIN + 2; initial_column++) + { + for (column = initial_column; + column < columns - right_margin - 1; column += 2) + { + BIDIM_ARRAY (horizontal_interpolation, column, line, + columns) = + ((float) BIDIM_ARRAY (ccd, column - 1, line, columns) / + BIDIM_ARRAY (horizontal_interpolation, column - 1, line, + columns) + (float) BIDIM_ARRAY (ccd, + column + 1, + line, + columns) / + BIDIM_ARRAY (horizontal_interpolation, column + 1, line, + columns)) * BIDIM_ARRAY (ccd, column, line, + columns) * (SCALE * + SCALE / + 2) + + 0.5; + } + } + } + } +} + +static void +interpolate_vertically (const unsigned char ccd[], + const short horizontal_interpolation[], + short red[], short green[], short blue[]) +{ + int column, line; + for (line = TOP_MARGIN; line < HEIGHT - BOTTOM_MARGIN; line++) + { + for (column = MY_LEFT_MARGIN; column < columns - right_margin; column++) + { + int r2gb, g2b, rg2, rgb2, r, g, b; + int this_ccd = BIDIM_ARRAY (ccd, column, line, columns) * SCALE; + int up_ccd = BIDIM_ARRAY (ccd, column, line - 1, columns) * SCALE; + int down_ccd = BIDIM_ARRAY (ccd, column, line + 1, columns) * SCALE; + int this_horizontal_interpolation = + BIDIM_ARRAY (horizontal_interpolation, column, line, columns); + int this_intensity = this_ccd + this_horizontal_interpolation; + int up_intensity = + BIDIM_ARRAY (horizontal_interpolation, column, line - 1, + columns) + up_ccd; + int down_intensity = + BIDIM_ARRAY (horizontal_interpolation, column, line + 1, + columns) + down_ccd; + int this_vertical_interpolation; + + /* + * PSF: I don't understand all this code, but I've found pictures + * where up_intensity or down_intensity are zero, resulting in a + * divide by zero error. It looks like this only happens when + * up_ccd or down_ccd are also zero, so we just set the intensity + * value to non-zero to prevent the error. + */ + if (down_ccd == 0) + DBG (10, "down_ccd==0 at %d,%d\n", line, column); + if (up_ccd == 0) + DBG (10, "up_ccd==0 at %d,%d\n", line, column); + if (down_intensity == 0) + { + DBG (9, "Found down_intensity==0 at %d,%d down_ccd=%d\n", line, + column, down_ccd); + down_intensity = 1; + } + if (up_intensity == 0) + { + DBG (9, "Found up_intensity==0 at %d,%d up_ccd=%d\n", line, + column, up_ccd); + up_intensity = 1; + } + + if (line == TOP_MARGIN) + { + this_vertical_interpolation = + (float) down_ccd / down_intensity * this_intensity + 0.5; + } + else if (line == HEIGHT - BOTTOM_MARGIN - 1) + { + this_vertical_interpolation = + (float) up_ccd / up_intensity * this_intensity + 0.5; + } + else + { + this_vertical_interpolation = + ((float) up_ccd / up_intensity + + (float) down_ccd / down_intensity) * this_intensity / 2.0 + + 0.5; + } + if (line & 1) + { + if (column & 1) + { + r2gb = this_ccd; + g2b = this_horizontal_interpolation; + rg2 = this_vertical_interpolation; + r = (2 * (r2gb - g2b) + rg2) / 5; + g = (rg2 - r) / 2; + b = g2b - 2 * g; + } + else + { + g2b = this_ccd; + r2gb = this_horizontal_interpolation; + rgb2 = this_vertical_interpolation; + r = (3 * r2gb - g2b - rgb2) / 5; + g = 2 * r - r2gb + g2b; + b = g2b - 2 * g; + } + } + else + { + if (column & 1) + { + rg2 = this_ccd; + rgb2 = this_horizontal_interpolation; + r2gb = this_vertical_interpolation; + b = (3 * rgb2 - r2gb - rg2) / 5; + g = (rgb2 - r2gb + rg2 - b) / 2; + r = rg2 - 2 * g; + } + else + { + rgb2 = this_ccd; + rg2 = this_horizontal_interpolation; + g2b = this_vertical_interpolation; + b = (g2b - 2 * (rg2 - rgb2)) / 5; + g = (g2b - b) / 2; + r = rg2 - 2 * g; + } + } + if (r < 0) + r = 0; + if (g < 0) + g = 0; + if (b < 0) + b = 0; + BIDIM_ARRAY (red, column, line, columns) = r; + BIDIM_ARRAY (green, column, line, columns) = g; + BIDIM_ARRAY (blue, column, line, columns) = b; + } + } +} + +static void +adjust_color_and_saturation (short red[], short green[], short blue[]) +{ + int line, column; + int r_min = SMAX, g_min = SMAX, b_min = SMAX; + int r_max = 0, g_max = 0, b_max = 0; + int r_sum = 0, g_sum = 0, b_sum = 0; + float sqr_saturation = sqrt (saturation); + for (line = TOP_MARGIN; line < HEIGHT - BOTTOM_MARGIN; line++) + { + for (column = MY_LEFT_MARGIN; column < columns - right_margin; column++) + { + float r = BIDIM_ARRAY (red, column, line, columns) * rfactor; + float g = BIDIM_ARRAY (green, column, line, columns) * gfactor; + float b = BIDIM_ARRAY (blue, column, line, columns) * bfactor; + if (saturation != 1.0) + { + float *min, *mid, *max, new_intensity; + float intensity = + r * RINTENSITY + g * GINTENSITY + b * BINTENSITY; + if (r > g) + { + if (r > b) + { + max = &r; + if (g > b) + { + min = &b; + mid = &g; + } + else + { + min = &g; + mid = &b; + } + } + else + { + min = &g; + mid = &r; + max = &b; + } + } + else + { + if (g > b) + { + max = &g; + if (r > b) + { + min = &b; + mid = &r; + } + else + { + min = &r; + mid = &b; + } + } + else + { + min = &r; + mid = &g; + max = &b; + } + } + *mid = *min + sqr_saturation * (*mid - *min); + *max = *min + saturation * (*max - *min); + new_intensity = + r * RINTENSITY + g * GINTENSITY + b * BINTENSITY; + r *= intensity / new_intensity; + g *= intensity / new_intensity; + b *= intensity / new_intensity; + } + r += 0.5; + g += 0.5; + b += 0.5; + if (r_min > r) + r_min = r; + if (g_min > g) + g_min = g; + if (b_min > b) + b_min = b; + if (r_max < r) + r_max = r; + if (g_max < g) + g_max = g; + if (b_max < b) + b_max = b; + r_sum += r; + g_sum += g; + b_sum += b; + BIDIM_ARRAY (red, column, line, columns) = r; + BIDIM_ARRAY (green, column, line, columns) = g; + BIDIM_ARRAY (blue, column, line, columns) = b; + } + } +} + +static int +min3 (int x, int y, int z) +{ + return (x < y ? (x < z ? x : z) : (y < z ? y : z)); +} + +static int +max3 (int x, int y, int z) +{ + return (x > y ? (x > z ? x : z) : (y > z ? y : z)); +} + +static void +determine_limits (const short red[], + const short green[], + const short blue[], int *low_i_ptr, int *high_i_ptr) +{ + unsigned int histogram[HISTOGRAM_STEPS + 1]; + int column, line, i, s; + int low_i = *low_i_ptr, high_i = *high_i_ptr; + int max_i = 0; + for (line = TOP_MARGIN; line < HEIGHT - BOTTOM_MARGIN; line++) + { + for (column = MY_LEFT_MARGIN; column < columns - right_margin; column++) + { + i = max3 (BIDIM_ARRAY (red, column, line, columns), + BIDIM_ARRAY (green, column, line, columns), + BIDIM_ARRAY (blue, column, line, columns)); + if (i > max_i) + max_i = i; + } + } + if (low_i == -1) + { + for (i = 0; i <= HISTOGRAM_STEPS; i++) + histogram[i] = 0; + for (line = TOP_MARGIN; line < HEIGHT - BOTTOM_MARGIN; line++) + { + for (column = MY_LEFT_MARGIN; column < columns - right_margin; + column++) + { + i = min3 (BIDIM_ARRAY (red, column, line, columns), + BIDIM_ARRAY (green, column, line, columns), + BIDIM_ARRAY (blue, column, line, columns)); + histogram[i * HISTOGRAM_STEPS / max_i]++; + } + } + for (low_i = 0, s = 0; + low_i <= HISTOGRAM_STEPS && s < NET_PIXELS * norm_percentage / 100; + low_i++) + { + s += histogram[low_i]; + } + low_i = (low_i * max_i + HISTOGRAM_STEPS / 2) / HISTOGRAM_STEPS; + *low_i_ptr = low_i; + } + if (high_i == -1) + { + for (i = 0; i <= HISTOGRAM_STEPS; i++) + histogram[i] = 0; + for (line = TOP_MARGIN; line < HEIGHT - BOTTOM_MARGIN; line++) + { + for (column = MY_LEFT_MARGIN; column < columns - right_margin; + column++) + { + i = max3 (BIDIM_ARRAY (red, column, line, columns), + BIDIM_ARRAY (green, column, line, columns), + BIDIM_ARRAY (blue, column, line, columns)); + histogram[i * HISTOGRAM_STEPS / max_i]++; + } + } + for (high_i = HISTOGRAM_STEPS, s = 0; + high_i >= 0 && s < NET_PIXELS * norm_percentage / 100; high_i--) + { + s += histogram[high_i]; + } + high_i = (high_i * max_i + HISTOGRAM_STEPS / 2) / HISTOGRAM_STEPS; + *high_i_ptr = high_i; + } +/* +if (verbose) printf ("%s: determine_limits: low_i = %d, high_i = %d\n", __progname, low_i, high_i); +*/ +} + +/* + * The original dc20ctrl program used a default gamma of 0.35, but I thougt + * 0.45 looks better. In addition, since xscanimage seems to always force + * a resolution of 0.1, I multiply everything by 10 and make the default + * 4.5. + */ + +static unsigned char * +make_gamma_table (int range) +{ + int i; + double factor = + pow (256.0, 1.0 / (SANE_UNFIX (dc25_opt_gamma) / 10.0)) / range; + unsigned char *gamma_table; + if ((gamma_table = malloc (range * sizeof (unsigned char))) == NULL) + { + DBG (1, "make_gamma_table: can't allocate memory for gamma table\n"); + return NULL; + } + for (i = 0; i < range; i++) + { + int g = + pow ((double) i * factor, (SANE_UNFIX (dc25_opt_gamma) / 10.0)) + 0.5; +/* + if (verbose) fprintf (stderr, "%s: make_gamma_table: gamma[%4d] = %3d\n", __progname, i, g); +*/ + if (g > 255) + g = 255; + gamma_table[i] = g; + } + return gamma_table; +} + +static int +lookup_gamma_table (int i, int low_i, int high_i, + const unsigned char gamma_table[]) +{ + if (i <= low_i) + return 0; + if (i >= high_i) + return 255; + return gamma_table[i - low_i]; +} + +static int +output_rgb (const short red[], + const short green[], + const short blue[], int low_i, int high_i, struct pixmap *pp) +{ + int r_min = 255, g_min = 255, b_min = 255; + int r_max = 0, g_max = 0, b_max = 0; + int r_sum = 0, g_sum = 0, b_sum = 0; + int column, line; + unsigned char *gamma_table = make_gamma_table (high_i - low_i); + + if (gamma_table == NULL) + { + DBG (10, "output_rgb: error: cannot make gamma table\n"); + return -1; + } + + for (line = TOP_MARGIN; line < HEIGHT - BOTTOM_MARGIN; line++) + { + for (column = MY_LEFT_MARGIN; column < columns - right_margin; column++) + { + int r = + lookup_gamma_table (BIDIM_ARRAY (red, column, line, columns), + low_i, high_i, gamma_table); + int g = + lookup_gamma_table (BIDIM_ARRAY (green, column, line, columns), + low_i, high_i, gamma_table); + int b = + lookup_gamma_table (BIDIM_ARRAY (blue, column, line, columns), + low_i, high_i, gamma_table); + if (r > 255) + r = 255; + else if (r < 0) + r = 0; + if (g > 255) + g = 255; + else if (g < 0) + g = 0; + if (b > 255) + b = 255; + else if (b < 0) + b = 0; + set_pixel_rgb (pp, column - MY_LEFT_MARGIN, line - TOP_MARGIN, r, g, + b); + if (r_min > r) + r_min = r; + if (g_min > g) + g_min = g; + if (b_min > b) + b_min = b; + if (r_max < r) + r_max = r; + if (g_max < g) + g_max = g; + if (b_max < b) + b_max = b; + r_sum += r; + g_sum += g; + b_sum += b; + } + } + free (gamma_table); +/* + { + fprintf (stderr, "%s: output_rgb: r: min = %d, max = %d, ave = %d\n", __progname, r_min, r_max, r_sum / NET_PIXELS); + fprintf (stderr, "%s: output_rgb: g: min = %d, max = %d, ave = %d\n", __progname, g_min, g_max, g_sum / NET_PIXELS); + fprintf (stderr, "%s: output_rgb: b: min = %d, max = %d, ave = %d\n", __progname, b_min, b_max, b_sum / NET_PIXELS); + } +*/ + return 0; +} + +static int +comet_to_pixmap (unsigned char *pic, struct pixmap *pp) +{ + unsigned char *ccd; + short *horizontal_interpolation, *red, *green, *blue; + int retval = 0; + + if (pic == NULL) + { + DBG (1, "cmttoppm: error: no input image\n"); + return -1; + } + + if (pic[4] == 0x01) + { + /* Low resolution mode */ + columns = LOW_WIDTH; + right_margin = MY_LOW_RIGHT_MARGIN; + camera_header_size = LOW_CAMERA_HEADER; + } + else + { + /* High resolution mode */ + columns = HIGH_WIDTH; + right_margin = HIGH_RIGHT_MARGIN; + camera_header_size = HIGH_CAMERA_HEADER; + } + ccd = pic + camera_header_size; + + if ((horizontal_interpolation = + malloc (sizeof (short) * HEIGHT * columns)) == NULL) + { + DBG (1, + "cmttoppm: error: not enough memory for horizontal_interpolation\n"); + return -1; + } + + + if ((red = malloc (sizeof (short) * HEIGHT * columns)) == NULL) + { + DBG (1, "error: not enough memory for red\n"); + return -1; + } + + if ((green = malloc (sizeof (short) * HEIGHT * columns)) == NULL) + { + DBG (1, "error: not enough memory for green\n"); + return -1; + } + + if ((blue = malloc (sizeof (short) * HEIGHT * columns)) == NULL) + { + DBG (1, "error: not enough memory for blue\n"); + return -1; + } + + /* Decode raw CCD data to RGB */ + set_initial_interpolation (ccd, horizontal_interpolation); + interpolate_horizontally (ccd, horizontal_interpolation); + interpolate_vertically (ccd, horizontal_interpolation, red, green, blue); + + adjust_color_and_saturation (red, green, blue); + + /* Determine lower and upper limit using histogram */ + if (low_i == -1 || high_i == -1) + { + determine_limits (red, green, blue, &low_i, &high_i); + } + + /* Output pixmap structure */ + retval = output_rgb (red, green, blue, low_i, high_i, pp); + + return retval; +} + +static int +convert_pic (char *base_name, int format) +{ + FILE *ifp; + unsigned char pic[MAX_IMAGE_SIZE]; + int res, image_size, image_width, net_width, camera_header, components; + struct pixmap *pp2; + + DBG (127, "convert_pic() called\n"); + + /* + * Read the image in memory + */ + + if ((ifp = fopen (base_name, "rb")) == NULL) + { + DBG (10, "convert_pic: error: cannot open %s for reading\n", base_name); + return -1; + } + + if (fread (pic, COMET_HEADER_SIZE, 1, ifp) != 1) + { + DBG (10, "convert_pic: error: cannot read COMET header\n"); + fclose (ifp); + return -1; + } + + if (strncmp ((char *) pic, COMET_MAGIC, sizeof (COMET_MAGIC)) != 0) + { + DBG (10, "convert_pic: error: file %s is not in COMET format\n", + base_name); + fclose (ifp); + return -1; + } + + if (fread (pic, LOW_CAMERA_HEADER, 1, ifp) != 1) + { + DBG (10, "convert_pic: error: cannot read camera header\n"); + fclose (ifp); + return -1; + } + + res = pic[4]; + if (res == 0) + { + /* + * We just read a LOW_CAMERA_HEADER block, so resync with the + * HIGH_CAMERA_HEADER length by reading once more one of this. + */ + if (fread (pic + LOW_CAMERA_HEADER, LOW_CAMERA_HEADER, 1, ifp) != 1) + { + DBG (10, + "convert_pic: error: cannot resync with high resolution header\n"); + fclose (ifp); + return -1; + } + } + + if (fread (pic + CAMERA_HEADER (res), WIDTH (res), HEIGHT, ifp) != HEIGHT) + { + DBG (9, "convert_pic: error: cannot read picture\n"); + fclose (ifp); + return -1; + } + + fclose (ifp); + + /* + * Setup image size with resolution + */ + + image_size = IMAGE_SIZE (res); + image_width = WIDTH (res); + net_width = image_width - LEFT_MARGIN - RIGHT_MARGIN (res); + camera_header = CAMERA_HEADER (res); + components = (format & SAVE_24BITS) ? 3 : 1; + + /* + * Convert the image to 24 bits + */ + + if ((pp = + alloc_pixmap (net_width - 1, HEIGHT - BOTTOM_MARGIN - 1, + components)) == NULL) + { + DBG (1, "convert_pic: error: alloc_pixmap\n"); + return -1; + } + + comet_to_pixmap (pic, pp); + + if (format & SAVE_ADJASPECT) + { + /* + * Strech image + */ + + if (res) + pp2 = alloc_pixmap (320, HEIGHT - BOTTOM_MARGIN - 1, components); + else + pp2 = alloc_pixmap (net_width - 1, 373, components); + + if (pp2 == NULL) + { + DBG (2, "convert_pic: error: alloc_pixmap\n"); + free_pixmap (pp); + return -1; + } + + if (res) + zoom_x (pp, pp2); + else + zoom_y (pp, pp2); + + free_pixmap (pp); + pp = pp2; + pp2 = NULL; + + } + + return 0; +} + +#define PGM_EXT "pgm" +#define PPM_EXT "ppm" + +#define RED 0.30 +#define GREEN 0.59 +#define BLUE 0.11 + +#define RED_OFFSET 0 +#define GREEN_OFFSET 1 +#define BLUE_OFFSET 2 + +#define GET_COMP(pp, x, y, c) (pp->planes[((x) + (y)*pp->width)*pp->components + (c)]) + +#define GET_R(pp, x, y) (GET_COMP(pp, x, y, RED_OFFSET)) +#define GET_G(pp, x, y) (GET_COMP(pp, x, y, GREEN_OFFSET)) +#define GET_B(pp, x, y) (GET_COMP(pp, x, y, BLUE_OFFSET)) + +static struct pixmap * +alloc_pixmap (int x, int y, int d) +{ + struct pixmap *result = NULL; + + if (d == 1 || d == 3) + { + if (x > 0) + { + if (y > 0) + { + if ((result = malloc (sizeof (struct pixmap))) != NULL) + { + result->width = x; + result->height = y; + result->components = d; + if (!(result->planes = malloc (x * y * d))) + { + DBG (10, + "alloc_pixmap: error: not enough memory for bitplanes\n"); + free (result); + result = NULL; + } + } + else + DBG (10, + "alloc_pixmap: error: not enough memory for pixmap\n"); + } + else + DBG (10, "alloc_pixmap: error: y is out of range\n"); + } + else + DBG (10, "alloc_pixmap: error: x is out of range\n"); + } + else + DBG (10, "alloc_pixmap: error: cannot handle %d components\n", d); + + return result; +} + +static void +free_pixmap (struct pixmap *p) +{ + if (p) + { + free (p->planes); + free (p); + } +} + +static int +set_pixel_rgb (struct pixmap *p, int x, int y, unsigned char r, + unsigned char g, unsigned char b) +{ + int result = 0; + + if (p) + { + if (x >= 0 && x < p->width) + { + if (y >= 0 && y < p->height) + { + if (p->components == 1) + { + GET_R (p, x, y) = RED * r + GREEN * g + BLUE * b; + } + else + { + GET_R (p, x, y) = r; + GET_G (p, x, y) = g; + GET_B (p, x, y) = b; + } + } + else + { + DBG (10, "set_pixel_rgb: error: y out of range\n"); + result = -1; + } + } + else + { + DBG (10, "set_pixel_rgb: error: x out of range\n"); + result = -1; + } + } + + return result; +} + +static int +zoom_x (struct pixmap *source, struct pixmap *dest) +{ + int result = 0, dest_col, row, component, src_index; + float ratio, src_ptr, delta; + unsigned char src_component; + + if (source && dest) + { + /* + * We could think of resizing a pixmap and changing the number of + * components at the same time. Maybe this will be implemented later. + */ + if (source->height == dest->height + && source->components == dest->components) + { + if (source->width < dest->width) + { + ratio = ((float) source->width / (float) dest->width); + + for (src_ptr = 0, dest_col = 0; dest_col < dest->width; + src_ptr += ratio, dest_col++) + { + /* + * dest[dest_col] = source[(int)src_ptr] + + * (source[((int)src_ptr) + 1] - source[(int)src_ptr]) + * * (src_ptr - (int)src_ptr); + */ + src_index = (int) src_ptr; + delta = src_ptr - src_index; + + for (row = 0; row < source->height; row++) + { + for (component = 0; component < source->components; + component++) + { + src_component = + GET_COMP (source, src_index, row, component); + + GET_COMP (dest, dest_col, row, component) = + src_component + + (GET_COMP (source, src_index + 1, row, + component) - src_component) * delta; + } + } + } + } + else + { + DBG (10, "zoom_x: error: can only zoom out\n"); + result = -1; + } + } + else + { + DBG (10, "zoom_x: error: incompatible pixmaps\n"); + result = -1; + } + } + + return result; +} + +static int +zoom_y (struct pixmap *source, struct pixmap *dest) +{ + int result = 0, dest_row, column, component, src_index; + float ratio, src_ptr, delta; + unsigned char src_component; + + if (source && dest) + { + /* + * We could think of resizing a pixmap and changing the number of + * components at the same time. Maybe this will be implemented later. + */ + if (source->width == dest->width + && source->components == dest->components) + { + if (source->height < dest->height) + { + ratio = ((float) source->height / (float) dest->height); + + for (src_ptr = 0, dest_row = 0; dest_row < dest->height; + src_ptr += ratio, dest_row++) + { + /* + * dest[dest_row] = source[(int)src_ptr] + + * (source[((int)src_ptr) + 1] - source[(int)src_ptr]) + * * (src_ptr - (int)src_ptr); + */ + src_index = (int) src_ptr; + delta = src_ptr - src_index; + + for (column = 0; column < source->width; column++) + { + for (component = 0; component < source->components; + component++) + { + src_component = + GET_COMP (source, column, src_index, component); + + GET_COMP (dest, column, dest_row, component) = + src_component + + (GET_COMP (source, column, src_index + 1, + component) - src_component) * delta; + } + } + } + } + else + { + DBG (10, "zoom_y: error: can only zoom out\n"); + result = -1; + } + } + else + { + DBG (10, "zoom_y: error: incompatible pixmaps\n"); + result = -1; + } + } + + return result; +} + +static unsigned char shoot_pck[] = SHOOT_PCK; + +static int +shoot (int fd) +{ + struct termios tty_temp, tty_old; + int result = 0; + + DBG (127, "shoot() called\n"); + + if (write (fd, (char *) shoot_pck, 8) != 8) + { + DBG (3, "shoot: error: write error\n"); + return -1; + } + + if (CameraInfo.model != 0x25) + { + /* + * WARNING: now we set the serial port to 9600 baud! + */ + + if (tcgetattr (fd, &tty_old) == -1) + { + DBG (3, "shoot: error: could not get attributes\n"); + return -1; + } + + memcpy ((char *) &tty_temp, (char *) &tty_old, sizeof (struct termios)); + + cfsetispeed (&tty_temp, B9600); + cfsetospeed (&tty_temp, B9600); + + /* + * Apparently there is a bug in the DC20 where the response to + * the shoot request is always at 9600. The DC25 does not have + * this bug, so we skip this block. + */ + if (tcsetattr (fd, TCSANOW, &tty_temp) == -1) + { + DBG (3, "shoot: error: could not set attributes\n"); + return -1; + } + } + + if (read (fd, (char *) &result, 1) != 1) + { + DBG (3, "shoot: error: read returned -1\n"); + result = -1; + } + else + { + result = (result == 0xD1) ? 0 : -1; + } + + if (CameraInfo.model != 0x25) + { + /* + * We reset the serial to its original speed. + * We can skip this on the DC25 also. + */ + if (tcsetattr (fd, TCSANOW, &tty_old) == -1) + { + DBG (3, "shoot: error: could not reset attributes\n"); + result = -1; + } + } + + if (result == 0) + { + if (CameraInfo.model == 0x25) + { + /* + * If we don't put this in, the next read will time out + * and return failure. Does the DC-20 need it too? + */ + sleep (3); + } + if (end_of_data (fd) == -1) + { + DBG (3, "shoot: error: end_of_data returned -1\n"); + result = -1; + } + } + + return result; +} + + +static unsigned char erase_pck[] = ERASE_PCK; + +static int +erase (int fd) +{ + int count = 0; + + DBG (127, "erase() called for image %d\n", dc25_opt_image_number); + erase_pck[3] = dc25_opt_image_number; + if (dc25_opt_erase) + { + erase_pck[3] = 0; + } + + if (send_pck (fd, erase_pck) == -1) + { + DBG (3, "erase: error: send_pck returned -1\n"); + return -1; + } + + if (CameraInfo.model == 0x25) + { + /* + * This block may really apply to the DC20 also, but since I + * don't have one, it's hard to say for sure. On the DC25, erase + * takes long enought that the read may timeout without returning + * any data before the erase is complete. We let this happen + * up to 4 times, then give up. + */ + while (count < 4) + { + if (end_of_data (fd) == -1) + { + count++; + } + else + { + break; + } + } + if (count == 4) + { + DBG (3, "erase: error: end_of_data returned -1\n"); + return -1; + } + } + else + { /* Assume DC-20 */ + + if (end_of_data (fd) == -1) + { + DBG (3, "erase: error: end_of_data returned -1\n"); + return -1; + } + } + + return 0; +} + +static unsigned char res_pck[] = RES_PCK; + +static int +change_res (int fd, unsigned char res) +{ + DBG (127, "change_res called\n"); + if (res != 0 && res != 1) + { + DBG (3, "change_res: error: unsupported resolution\n"); + return -1; + } + + res_pck[2] = res; + + if (send_pck (fd, res_pck) == -1) + { + DBG (4, "change_res: error: send_pck returned -1\n"); + } + + if (end_of_data (fd) == -1) + { + DBG (4, "change_res: error: end_of_data returned -1\n"); + } + return 0; +} + +SANE_Status +sane_init (SANE_Int * version_code, SANE_Auth_Callback UNUSEDARG authorize) +{ + char dev_name[PATH_MAX], *p; + size_t len; + FILE *fp; + int baud; + + strcpy (tty_name, DEF_TTY_NAME); + + DBG_INIT (); + + if (version_code) + *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0); + + fp = sanei_config_open (DC25_CONFIG_FILE); + + DBG (127, + "sane_init() $Id$\n"); + + if (!fp) + { + /* default to /dev/ttyS0 instead of insisting on config file */ + DBG (1, "sane_init: missing config file '%s'\n", DC25_CONFIG_FILE); + } + else + { + while (sanei_config_read (dev_name, sizeof (dev_name), fp)) + { + dev_name[sizeof (dev_name) - 1] = '\0'; + DBG (20, "sane_init: config- %s", dev_name); + + if (dev_name[0] == '#') + continue; /* ignore line comments */ + len = strlen (dev_name); + if (!len) + continue; /* ignore empty lines */ + if (strncmp (dev_name, "port=", 5) == 0) + { + p = strchr (dev_name, '/'); + if (p) + { + strcpy (tty_name, p); + } + DBG (20, "Config file port=%s\n", tty_name); + } + else if (strncmp (dev_name, "baud=", 5) == 0) + { + baud = atoi (&dev_name[5]); + switch (baud) + { + case 9600: + tty_baud = B9600; + break; + case 19200: + tty_baud = B19200; + break; + case 38400: + tty_baud = B38400; + break; +#ifdef B57600 + case 57600: + tty_baud = B57600; + break; +#endif +#ifdef B115200 + case 115200: + tty_baud = B115200; + break; +#endif + default: + DBG (20, "Unknown baud=%d\n", baud); + tty_baud = DEFAULT_TTY_BAUD; + break; + } + DBG (20, "Config file baud=%lu\n", (u_long) tty_baud); + } + else if (strcmp (dev_name, "dumpinquiry") == 0) + { + dumpinquiry = SANE_TRUE; + } + } + fclose (fp); + } + + if ((tfd = init_dc20 (tty_name, tty_baud)) == -1) + { + return SANE_STATUS_INVAL; + } + + if ((dc20_info = get_info (tfd)) == NULL) + { + DBG (2, "error: could not get info\n"); + close_dc20 (tfd); + return SANE_STATUS_INVAL; + } + + if (dumpinquiry) + { + DBG (0, "\nCamera information:\n~~~~~~~~~~~~~~~~~\n\n"); + DBG (0, "Model...........: DC%x\n", dc20_info->model); + DBG (0, "Firmware version: %d.%d\n", dc20_info->ver_major, + dc20_info->ver_minor); + DBG (0, "Pictures........: %d/%d\n", dc20_info->pic_taken, + dc20_info->pic_taken + dc20_info->pic_left); + DBG (0, "Resolution......: %s\n", + dc20_info->flags.low_res ? "low" : "high"); + DBG (0, "Battery state...: %s\n", + dc20_info->flags.low_batt ? "low" : "good"); + } + + if (CameraInfo.pic_taken == 0) + { +/* + sod[DC25_OPT_IMAGE_NUMBER].cap |= SANE_CAP_INACTIVE; +*/ + image_range.min = 0; + dc25_opt_image_number = 0; + + } + else + { +/* + sod[DC25_OPT_IMAGE_NUMBER].cap &= ~SANE_CAP_INACTIVE; +*/ + image_range.min = 1; + } + + return SANE_STATUS_GOOD; +} + +void +sane_exit (void) +{ +} + +/* Device select/open/close */ + +static const SANE_Device dev[] = { + { + "0", + "Kodak", + "DC-25", + "still camera"}, +}; + +SANE_Status +sane_get_devices (const SANE_Device *** device_list, + SANE_Bool UNUSEDARG local_only) +{ + static const SANE_Device *devlist[] = { + dev + 0, 0 + }; + + DBG (127, "sane_get_devices called\n"); + + if (dc20_info == NULL) + { + return SANE_STATUS_INVAL; + } + *device_list = devlist; + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_open (SANE_String_Const devicename, SANE_Handle * handle) +{ + int i; + + DBG (127, "sane_open for device %s\n", devicename); + if (!devicename[0]) + { + i = 0; + } + else + { + for (i = 0; i < NELEMS (dev); ++i) + { + if (strcmp (devicename, dev[i].name) == 0) + { + break; + } + } + } + + if (i >= NELEMS (dev)) + { + return SANE_STATUS_INVAL; + } + + if (is_open) + { + return SANE_STATUS_DEVICE_BUSY; + } + + is_open = 1; + *handle = MAGIC; + + if (dc20_info == NULL) + { + DBG (1, "No device info\n"); + } + + if (tmpname == NULL) + { + tmpname = tmpnamebuf; + if (mktemp (tmpname) == NULL) + { + DBG (1, "Unable to make temp file %s\n", tmpname); + return SANE_STATUS_INVAL; + } + } + + DBG (3, "sane_open: pictures taken=%d\n", dc20_info->pic_taken); + + return SANE_STATUS_GOOD; +} + +void +sane_close (SANE_Handle handle) +{ + DBG (127, "sane_close called\n"); + if (handle == MAGIC) + is_open = 0; + + if (pp) + { + free_pixmap (pp); + pp = NULL; + } + + close_dc20 (tfd); + + DBG (127, "sane_close returning\n"); +} + +const SANE_Option_Descriptor * +sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) +{ + if (handle != MAGIC || !is_open) + return NULL; /* wrong device */ + if (option < 0 || option >= NELEMS (sod)) + return NULL; + return &sod[option]; +} + +SANE_Status +sane_control_option (SANE_Handle handle, SANE_Int option, + SANE_Action action, void *value, SANE_Int * info) +{ + SANE_Int myinfo = info_flags; + SANE_Status status; + + info_flags = 0; + + DBG (127, "control_option(handle=%p,opt=%s,act=%s,val=%p,info=%p)\n", + handle, sod[option].title, + (action == + SANE_ACTION_SET_VALUE ? "SET" : (action == + SANE_ACTION_GET_VALUE ? "GET" : + "SETAUTO")), value, (void *)info); + + if (handle != MAGIC || !is_open) + return SANE_STATUS_INVAL; /* Unknown handle ... */ + + if (option < 0 || option >= NELEMS (sod)) + return SANE_STATUS_INVAL; /* Unknown option ... */ + + switch (action) + { + case SANE_ACTION_SET_VALUE: + status = sanei_constrain_value (sod + option, value, &myinfo); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "Constraint error in control_option\n"); + return status; + } + + switch (option) + { + case DC25_OPT_IMAGE_NUMBER: + dc25_opt_image_number = *(SANE_Word *) value; +/* myinfo |= SANE_INFO_RELOAD_OPTIONS; */ + break; + + case DC25_OPT_THUMBS: + dc25_opt_thumbnails = !!*(SANE_Word *) value; + myinfo |= SANE_INFO_RELOAD_PARAMS; + + if (dc25_opt_thumbnails) + { + /* + * DC20 thumbnail are 80x60 grayscale, DC25 + * thumbnails are color. + */ + parms.format = + (CameraInfo.model == 0x25) ? SANE_FRAME_RGB : SANE_FRAME_GRAY; + parms.bytes_per_line = 80 * 3; + parms.pixels_per_line = 80; + parms.lines = 60; + } + else + { + parms.format = SANE_FRAME_RGB; + if (dc20_info->flags.low_res) + { + parms.bytes_per_line = 320 * 3; + parms.pixels_per_line = 320; + parms.lines = 243; + } + else + { + parms.bytes_per_line = 500 * 3; + parms.pixels_per_line = 500; + parms.lines = 373; + } + } + break; + + case DC25_OPT_SNAP: + dc25_opt_snap = !!*(SANE_Word *) value; + myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + if (dc25_opt_snap) + { + sod[DC25_OPT_LOWRES].cap &= ~SANE_CAP_INACTIVE; + } + else + { + sod[DC25_OPT_LOWRES].cap |= SANE_CAP_INACTIVE; + } + break; + + case DC25_OPT_LOWRES: + dc25_opt_lowres = !!*(SANE_Word *) value; + myinfo |= SANE_INFO_RELOAD_PARAMS; + + if (!dc25_opt_thumbnails) + { + + parms.format = SANE_FRAME_RGB; + + if (dc20_info->flags.low_res) + { + parms.bytes_per_line = 320 * 3; + parms.pixels_per_line = 320; + parms.lines = 243; + } + else + { + parms.bytes_per_line = 500 * 3; + parms.pixels_per_line = 500; + parms.lines = 373; + } + + } + break; + + case DC25_OPT_CONTRAST: + dc25_opt_contrast = *(SANE_Word *) value; + break; + + case DC25_OPT_GAMMA: + dc25_opt_gamma = *(SANE_Word *) value; + break; + + case DC25_OPT_ERASE: + dc25_opt_erase = !!*(SANE_Word *) value; + + /* + * erase and erase_one are mutually exclusive. If + * this one is turned on, the other must be off + */ + if (dc25_opt_erase && dc25_opt_erase_one) + { + dc25_opt_erase_one = SANE_FALSE; + myinfo |= SANE_INFO_RELOAD_OPTIONS; + } + break; + + case DC25_OPT_ERASE_ONE: + dc25_opt_erase_one = !!*(SANE_Word *) value; + + /* + * erase and erase_one are mutually exclusive. If + * this one is turned on, the other must be off + */ + if (dc25_opt_erase_one && dc25_opt_erase) + { + dc25_opt_erase = SANE_FALSE; + myinfo |= SANE_INFO_RELOAD_OPTIONS; + } + break; + + case DC25_OPT_DEFAULT: + + dc25_opt_contrast = SANE_FIX (DC25_OPT_CONTRAST_DEFAULT); + dc25_opt_gamma = SANE_FIX (DC25_OPT_GAMMA_DEFAULT); + myinfo |= SANE_INFO_RELOAD_OPTIONS; + break; + + default: + return SANE_STATUS_INVAL; + } + break; + + case SANE_ACTION_GET_VALUE: + switch (option) + { + case 0: + *(SANE_Word *) value = NELEMS (sod); + break; + + case DC25_OPT_IMAGE_NUMBER: + *(SANE_Word *) value = dc25_opt_image_number; + break; + + case DC25_OPT_THUMBS: + *(SANE_Word *) value = dc25_opt_thumbnails; + break; + + case DC25_OPT_SNAP: + *(SANE_Word *) value = dc25_opt_snap; + break; + + case DC25_OPT_LOWRES: + *(SANE_Word *) value = dc25_opt_lowres; + break; + + case DC25_OPT_CONTRAST: + *(SANE_Word *) value = dc25_opt_contrast; + break; + + case DC25_OPT_GAMMA: + *(SANE_Word *) value = dc25_opt_gamma; + break; + + case DC25_OPT_ERASE: + *(SANE_Word *) value = dc25_opt_erase; + break; + + case DC25_OPT_ERASE_ONE: + *(SANE_Word *) value = dc25_opt_erase_one; + break; + + default: + return SANE_STATUS_INVAL; + } + break; + + case SANE_ACTION_SET_AUTO: + switch (option) + { +#if 0 + case DC25_OPT_CONTRAST: + dc25_opt_contrast = SANE_FIX (DC25_OPT_CONTRAST_DEFAULT); + break; + + case DC25_OPT_GAMMA: + dc25_opt_gamma = SANE_FIX (DC25_OPT_GAMMA_DEFAULT); + break; +#endif + + default: + return SANE_STATUS_UNSUPPORTED; /* We are DUMB */ + } + } + + if (info) + *info = myinfo; + + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_get_parameters (SANE_Handle handle, SANE_Parameters * params) +{ + int rc = SANE_STATUS_GOOD; + + DBG (127, "sane_get_params called\n"); + + if (handle != MAGIC || !is_open) + rc = SANE_STATUS_INVAL; /* Unknown handle ... */ + + + *params = parms; + return rc; +} + +static unsigned char thumb_pck[] = THUMBS_PCK; + +static unsigned char pic_pck[] = PICS_PCK; + +static int bytes_in_buffer; +static int bytes_read_from_buffer; +static SANE_Byte buffer[1024]; +static int total_bytes_read; +static SANE_Bool started = SANE_FALSE; +static int outbytes; + +SANE_Status +sane_start (SANE_Handle handle) +{ + int n, i; + FILE *f; + + DBG (127, "sane_start called, handle=%lx\n", (u_long) handle); + + if (handle != MAGIC || !is_open || + (dc25_opt_image_number == 0 && dc25_opt_snap == SANE_FALSE)) + return SANE_STATUS_INVAL; /* Unknown handle ... */ + + if (started) + { + return SANE_STATUS_EOF; + } + + if (dc25_opt_snap) + { + + /* + * Don't allow picture unless there is room in the + * camera. + */ + if (CameraInfo.pic_left == 0) + { + DBG (3, "No room to store new picture\n"); + return SANE_STATUS_INVAL; + } + + /* + * DC-20 can only change resolution when camer is empty. + * DC-25 can do it any time. + */ + if (CameraInfo.model != 0x20 || CameraInfo.pic_taken == 0) + { + if (change_res (tfd, dc25_opt_lowres) == -1) + { + DBG (1, "Failed to set resolution\n"); + return SANE_STATUS_INVAL; + } + } + + /* + * Not sure why this delay is needed, but it seems to help: + */ +#ifdef HAVE_USLEEP + usleep (10); +#else + sleep (1); +#endif + if (shoot (tfd) == -1) + { + DBG (1, "Failed to snap new picture\n"); + return SANE_STATUS_INVAL; + } + else + { + info_flags |= SANE_INFO_RELOAD_OPTIONS; + CameraInfo.pic_taken++; + CameraInfo.pic_left--; + dc25_opt_image_number = CameraInfo.pic_taken; + if (image_range.min == 0) + image_range.min = 1; + image_range.max++; + sod[DC25_OPT_IMAGE_NUMBER].cap &= ~SANE_CAP_INACTIVE; + } + } + + if (dc25_opt_thumbnails) + { + + /* + * For thumbnails, we can do things right where we + * start the download, and grab the first block + * from the camera. The reamining blocks will be + * fetched as necessary by sane_read(). + */ + thumb_pck[3] = (unsigned char) dc25_opt_image_number; + + if (send_pck (tfd, thumb_pck) == -1) + { + DBG (4, "sane_start: error: send_pck returned -1\n"); + return SANE_STATUS_INVAL; + } + + if (read_data (tfd, buffer, 1024) == -1) + { + DBG (4, "sane_start: read_data failed\n"); + return SANE_STATUS_INVAL; + } + + /* + * DC20 thumbnail are 80x60 grayscale, DC25 + * thumbnails are color. + */ + parms.format = + (CameraInfo.model == 0x25) ? SANE_FRAME_RGB : SANE_FRAME_GRAY; + parms.bytes_per_line = 80 * 3; /* 80 pixels, 3 colors */ + parms.pixels_per_line = 80; + parms.lines = 60; + + bytes_in_buffer = 1024; + bytes_read_from_buffer = 0; + + } + else + { + /* + * We do something a little messy, and violates the SANE + * philosophy. However, since it is fairly tricky to + * convert the DC2x "comet" files on the fly, we read in + * the entire data stream in sane_open(), and use convert_pic + * to convert it to an in-memory pixpmap. Then when + * sane_read() is called, we fill the requests from + * memory. A good project for me (or some kind volunteer) + * would be to rewrite this and move the actual download + * to sane_read(). However, one argument for keeping it + * this way is that the data comes down pretty fast, and + * it helps to dedicate the processor to this task. We + * might get serial port overruns if we try to do other + * things at the same time. + * + * Also, as a side note, I was constantly getting serial + * port overruns on a 90MHz pentium until I used hdparm + * to set the "-u1" flag on the system drives. + */ + int fd; + + fd = open (tmpname, O_CREAT | O_EXCL | O_WRONLY, 0600); + if (fd == -1) + { + DBG (0, "Unable to open tmp file\n"); + return SANE_STATUS_INVAL; + } + f = fdopen (fd, "wb"); + if (f == NULL) + { + DBG (0, "Unable to fdopen tmp file\n"); + return SANE_STATUS_INVAL; + } + + strcpy ((char *) buffer, COMET_MAGIC); + fwrite (buffer, 1, COMET_HEADER_SIZE, f); + + pic_pck[3] = (unsigned char) dc25_opt_image_number; + + if (send_pck (tfd, pic_pck) == -1) + { + DBG (4, "sane_start: error: send_pck returned -1\n"); + return SANE_STATUS_INVAL; + } + + if (read_data (tfd, buffer, 1024) == -1) + { + DBG (5, "sane_start: read_data failed\n"); + return SANE_STATUS_INVAL; + } + + if (buffer[4] == 0) + { /* hi-res image */ + DBG (5, "sane_start: hi-res image\n"); + n = 122; + + parms.bytes_per_line = 500 * 3; /* 3 colors */ + parms.pixels_per_line = 500; + parms.lines = 373; + + bytes_in_buffer = 1024; + bytes_read_from_buffer = 0; + } + else + { + n = 61; + DBG (5, "sane_start: low-res image\n"); + + parms.bytes_per_line = 320 * 3; /* 3 Colors */ + parms.pixels_per_line = 320; + parms.lines = 243; + + bytes_in_buffer = 1024; + bytes_read_from_buffer = 0; + } + + + fwrite (buffer, 1, 1024, f); + + for (i = 1; i < n; i++) + { + if (read_data (tfd, buffer, 1024) == -1) + { + DBG (5, "sane_start: read_data failed\n"); + return SANE_STATUS_INVAL; + } + fwrite (buffer, 1, 1024, f); + } + + if (end_of_data (tfd) == -1) + { + fclose (f); + DBG (4, "sane_open: end_of_data error\n"); + return SANE_STATUS_INVAL; + } + else + { + fclose (f); + if (convert_pic (tmpname, SAVE_ADJASPECT | SAVE_24BITS) == -1) + { + DBG (3, "sane_open: unable to convert\n"); + return SANE_STATUS_INVAL; + } + unlink (tmpname); + outbytes = 0; + } + } + + started = SANE_TRUE; + total_bytes_read = 0; + + return SANE_STATUS_GOOD; +} + + +SANE_Status +sane_read (SANE_Handle UNUSEDARG handle, SANE_Byte * data, + SANE_Int max_length, SANE_Int * length) +{ + DBG (127, "sane_read called, maxlen=%d\n", max_length); + + if ( ! started ) { + return SANE_STATUS_INVAL; + } + + if (dc25_opt_thumbnails) + { + if (total_bytes_read == THUMBSIZE) + { + if (dc25_opt_erase || dc25_opt_erase_one) + { + + if (erase (tfd) == -1) + { + DBG (1, "Failed to erase memory\n"); + return SANE_STATUS_INVAL; + } + + dc25_opt_erase = SANE_FALSE; + dc25_opt_erase_one = SANE_FALSE; + info_flags |= SANE_INFO_RELOAD_OPTIONS; + + if (get_info (tfd) == NULL) + { + DBG (2, "error: could not get info\n"); + close_dc20 (tfd); + return SANE_STATUS_INVAL; + } + DBG (10, "Call get_info!, image range=%d,%d\n", image_range.min, + image_range.max); + } + return SANE_STATUS_EOF; + } + + *length = 0; + if (!(bytes_in_buffer - bytes_read_from_buffer)) + { + if (read_data (tfd, buffer, 1024) == -1) + { + DBG (5, "sane_read: read_data failed\n"); + return SANE_STATUS_INVAL; + } + bytes_in_buffer = 1024; + bytes_read_from_buffer = 0; + } + + while (bytes_read_from_buffer < bytes_in_buffer && + max_length && total_bytes_read < THUMBSIZE) + { + *data++ = buffer[bytes_read_from_buffer++]; + (*length)++; + max_length--; + total_bytes_read++; + } + + if (total_bytes_read == THUMBSIZE) + { + if (end_of_data (tfd) == -1) + { + DBG (4, "sane_read: end_of_data error\n"); + return SANE_STATUS_INVAL; + } + else + { + return SANE_STATUS_GOOD; + } + } + else + { + return SANE_STATUS_GOOD; + } + } + else + { + int i; + int filesize = parms.bytes_per_line * parms.lines; + + /* + * If outbytes is zero, then this is the first time + * we've been called, so update the contrast table. + * The formula is something I came up with that has the + * following prooperties: + * 1) It's a smooth curve that provides the effect I wanted + * (bright pixels are made brighter, dim pixels are made + * dimmer) + * 2) The contrast parameter can be adjusted to provide + * different amounts of contrast. + * 3) A parameter of 1.0 can be used to pass the data + * through unchanged (but values around 1.75 look + * a lot better + */ + if (outbytes == 0) + { + double d; + double cont = SANE_UNFIX (dc25_opt_contrast); + + for (i = 0; i < 256; i++) + { + d = (i * 2.0) / 255 - 1.0; + d = + ((-pow (1 - d, cont)) + 1) * (d >= + 0) + (((pow (d + 1, cont)) - + 1)) * (d < 0); + contrast_table[i] = (d * 127.5) + 127.5; +/* + fprintf (stderr,"%03d %03d\n",i,contrast_table[i]); +*/ + } + } + + /* We're done, so return EOF */ + if (outbytes >= filesize) + { + free_pixmap (pp); + pp = NULL; + + if (dc25_opt_erase || dc25_opt_erase_one) + { + if (erase (tfd) == -1) + { + DBG (1, "Failed to erase memory\n"); + return SANE_STATUS_INVAL; + } + } + + if (get_info (tfd) == NULL) + { + DBG (2, "error: could not get info\n"); + close_dc20 (tfd); + return SANE_STATUS_INVAL; + } + DBG (10, "Call get_info!, image range=%d,%d\n", image_range.min, + image_range.max); + + get_info (tfd); + + *length=0; + + return SANE_STATUS_EOF; + } + + if (max_length > filesize - outbytes) + { + *length = filesize - outbytes; + } + else + { + *length = max_length; + } + + memcpy (data, pp->planes + outbytes, *length); + outbytes += *length; + + + for (i = 0; i < *length; i++) + { + data[i] = contrast_table[data[i]]; + } + + return SANE_STATUS_GOOD; + + } +} + +void +sane_cancel (SANE_Handle UNUSEDARG handle) +{ + DBG (127, "sane_cancel() called\n"); + started = SANE_FALSE; +} + +SANE_Status +sane_set_io_mode (SANE_Handle UNUSEDARG handle, + SANE_Bool UNUSEDARG non_blocking) +{ + /* sane_set_io_mode() is only valid during a scan */ + if (started) + { + if (non_blocking == SANE_FALSE) + { + return SANE_STATUS_GOOD; + } + else + { + return SANE_STATUS_UNSUPPORTED; + } + } + else + { + /* We aren't currently scanning */ + return SANE_STATUS_INVAL; + } +} + +SANE_Status +sane_get_select_fd (SANE_Handle UNUSEDARG handle, SANE_Int UNUSEDARG * fd) +{ + return SANE_STATUS_UNSUPPORTED; +} |