summaryrefslogtreecommitdiff
path: root/backend/dmc.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/dmc.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/dmc.c')
-rw-r--r--backend/dmc.c1404
1 files changed, 1404 insertions, 0 deletions
diff --git a/backend/dmc.c b/backend/dmc.c
new file mode 100644
index 0000000..96f9186
--- /dev/null
+++ b/backend/dmc.c
@@ -0,0 +1,1404 @@
+/* sane - Scanner Access Now Easy.
+ Copyright (C) 1998 David F. Skoll
+ Heavily based on "hp.c" driver for HP Scanners, by
+ David Mosberger-Tang.
+
+ 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 Polaroid Digital
+ Microscope Camera. */
+
+/* $Id$ */
+
+#include "../include/sane/config.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include "../include/_stdint.h"
+
+#include "../include/sane/sane.h"
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei_scsi.h"
+
+#define BACKEND_NAME dmc
+#include "../include/sane/sanei_backend.h"
+
+#ifndef PATH_MAX
+# define PATH_MAX 1024
+#endif
+
+#include "../include/sane/sanei_config.h"
+#define DMC_CONFIG_FILE "dmc.conf"
+
+#include "dmc.h"
+
+/* A linked-list of attached devices and handles */
+static DMC_Device *FirstDevice = NULL;
+static DMC_Camera *FirstHandle = NULL;
+static int NumDevices = 0;
+
+static SANE_String_Const ValidModes[] = { "Full frame", "Viewfinder",
+ "Raw", "Thumbnail",
+ "Super-Resolution",
+ NULL };
+
+static SANE_String_Const ValidBalances[] = { "Daylight", "Incandescent",
+ "Fluorescent", NULL };
+
+static SANE_Word ValidASAs[] = { 3, 25, 50, 100 };
+
+/* Convert between 32-us ticks and milliseconds */
+#define MS_TO_TICKS(x) (((x) * 1000 + 16) / 32)
+#define TICKS_TO_MS(x) (((x) * 32) / 1000)
+
+/* Macros for stepping along the raw lines for super-resolution mode
+ They are very ugly because they handle boundary conditions at
+ the edges of the image. Yuck... */
+
+#define PREV_RED(i) (((i)/3)*3)
+#define NEXT_RED(i) (((i) >= BYTES_PER_RAW_LINE-3) ? BYTES_PER_RAW_LINE-3 : \
+ PREV_RED(i)+3)
+#define PREV_GREEN(i) ((i)<1 ? 1 : PREV_RED((i)-1)+1)
+#define NEXT_GREEN(i) ((i)<1 ? 1 : ((i) >= BYTES_PER_RAW_LINE-2) ? \
+ BYTES_PER_RAW_LINE-2 : PREV_GREEN(i)+3)
+#define PREV_BLUE(i) ((i)<2 ? 2 : PREV_RED((i)-2)+2)
+#define NEXT_BLUE(i) ((i)<2 ? 2 : ((i) >= BYTES_PER_RAW_LINE-1) ? \
+ BYTES_PER_RAW_LINE-1 : PREV_BLUE(i)+3)
+
+#define ADVANCE_COEFF(i) (((i)==1) ? 3 : (i)-1);
+
+/**********************************************************************
+//%FUNCTION: DMCRead
+//%ARGUMENTS:
+// fd -- file descriptor
+// typecode -- data type code
+// qualifier -- data type qualifier
+// maxlen -- tranfer length
+// buf -- buffer to store data in
+// len -- set to actual length of data
+//%RETURNS:
+// A SANE status code
+//%DESCRIPTION:
+// Reads the particular data selected by typecode and qualifier
+// *********************************************************************/
+static SANE_Status
+DMCRead(int fd, unsigned int typecode, unsigned int qualifier,
+ SANE_Byte *buf, size_t maxlen, size_t *len)
+{
+ uint8_t readCmd[10];
+ SANE_Status status;
+
+ readCmd[0] = 0x28;
+ readCmd[1] = 0;
+ readCmd[2] = typecode;
+ readCmd[3] = 0;
+ readCmd[4] = (qualifier >> 8) & 0xFF;
+ readCmd[5] = qualifier & 0xFF;
+ readCmd[6] = (maxlen >> 16) & 0xFF;
+ readCmd[7] = (maxlen >> 8) & 0xFF;
+ readCmd[8] = maxlen & 0xFF;
+ readCmd[9] = 0;
+ DBG(3, "DMCRead: typecode=%x, qualifier=%x, maxlen=%lu\n",
+ typecode, qualifier, (u_long) maxlen);
+
+ *len = maxlen;
+ status = sanei_scsi_cmd(fd, readCmd, sizeof(readCmd), buf, len);
+ DBG(3, "DMCRead: Read %lu bytes\n", (u_long) *len);
+ return status;
+}
+
+/**********************************************************************
+//%FUNCTION: DMCWrite
+//%ARGUMENTS:
+// fd -- file descriptor
+// typecode -- data type code
+// qualifier -- data type qualifier
+// maxlen -- tranfer length
+// buf -- buffer to store data in
+//%RETURNS:
+// A SANE status code
+//%DESCRIPTION:
+// Writes the particular data selected by typecode and qualifier
+// *********************************************************************/
+static SANE_Status
+DMCWrite(int fd, unsigned int typecode, unsigned int qualifier,
+ SANE_Byte *buf, size_t maxlen)
+{
+ uint8_t *writeCmd;
+ SANE_Status status;
+
+ writeCmd = malloc(maxlen + 10);
+ if (!writeCmd) return SANE_STATUS_NO_MEM;
+
+ writeCmd[0] = 0x2A;
+ writeCmd[1] = 0;
+ writeCmd[2] = typecode;
+ writeCmd[3] = 0;
+ writeCmd[4] = (qualifier >> 8) & 0xFF;
+ writeCmd[5] = qualifier & 0xFF;
+ writeCmd[6] = (maxlen >> 16) & 0xFF;
+ writeCmd[7] = (maxlen >> 8) & 0xFF;
+ writeCmd[8] = maxlen & 0xFF;
+ writeCmd[9] = 0;
+ memcpy(writeCmd+10, buf, maxlen);
+
+ DBG(3, "DMCWrite: typecode=%x, qualifier=%x, maxlen=%lu\n",
+ typecode, qualifier, (u_long) maxlen);
+
+ status = sanei_scsi_cmd(fd, writeCmd, 10+maxlen, NULL, NULL);
+ free(writeCmd);
+ return status;
+}
+
+/**********************************************************************
+//%FUNCTION: DMCAttach
+//%ARGUMENTS:
+// devname -- name of device file to open
+// devp -- a DMC_Device structure which we fill in if it's not NULL.
+//%RETURNS:
+// SANE_STATUS_GOOD -- We have a Polaroid DMC attached and all looks good.
+// SANE_STATUS_INVAL -- There's a problem.
+//%DESCRIPTION:
+// Verifies that a Polaroid DMC is attached. Sets up device options in
+// DMC_Device structure.
+// *********************************************************************/
+#define INQ_LEN 255
+static SANE_Status
+DMCAttach(char const *devname, DMC_Device **devp)
+{
+ DMC_Device *dev;
+ SANE_Status status;
+ int fd;
+ size_t size;
+ char result[INQ_LEN];
+
+ uint8_t exposureCalculationResults[16];
+ uint8_t userInterfaceSettings[16];
+
+ static uint8_t const inquiry[] =
+ { 0x12, 0x00, 0x00, 0x00, INQ_LEN, 0x00 };
+
+ static uint8_t const test_unit_ready[] =
+ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+ static uint8_t const no_viewfinder[] =
+ { 0xC6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+ /* If we're already attached, do nothing */
+
+ for (dev = FirstDevice; dev; dev = dev->next) {
+ if (!strcmp(dev->sane.name, devname)) {
+ if (devp) *devp = dev;
+ return SANE_STATUS_GOOD;
+ }
+ }
+
+ DBG(3, "DMCAttach: opening `%s'\n", devname);
+ status = sanei_scsi_open(devname, &fd, 0, 0);
+ if (status != SANE_STATUS_GOOD) {
+ DBG(1, "DMCAttach: open failed (%s)\n", sane_strstatus(status));
+ return status;
+ }
+
+ DBG(3, "DMCAttach: sending INQUIRY\n");
+ size = sizeof(result);
+ status = sanei_scsi_cmd(fd, inquiry, sizeof(inquiry), result, &size);
+ if (status != SANE_STATUS_GOOD || size < 32) {
+ if (status == SANE_STATUS_GOOD) status = SANE_STATUS_INVAL;
+ DBG(1, "DMCAttach: inquiry failed (%s)\n", sane_strstatus(status));
+ sanei_scsi_close(fd);
+ return status;
+ }
+
+ /* Verify that we have a Polaroid DMC */
+
+ if (result[0] != 6 ||
+ strncmp(result+8, "POLAROID", 8) ||
+ strncmp(result+16, "DMC ", 8)) {
+ sanei_scsi_close(fd);
+ DBG(1, "DMCAttach: Device does not look like a Polaroid DMC\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ DBG(3, "DMCAttach: sending TEST_UNIT_READY\n");
+ status = sanei_scsi_cmd(fd, test_unit_ready, sizeof(test_unit_ready),
+ NULL, NULL);
+ if (status != SANE_STATUS_GOOD) {
+ DBG(1, "DMCAttach: test unit ready failed (%s)\n",
+ sane_strstatus(status));
+ sanei_scsi_close(fd);
+ return status;
+ }
+
+ /* Read current ASA and shutter speed settings */
+ status = DMCRead(fd, 0x87, 0x4, exposureCalculationResults,
+ sizeof(exposureCalculationResults), &size);
+ if (status != SANE_STATUS_GOOD ||
+ size < sizeof(exposureCalculationResults)) {
+ DBG(1, "DMCAttach: Couldn't read exposure calculation results (%s)\n",
+ sane_strstatus(status));
+ sanei_scsi_close(fd);
+ if (status == SANE_STATUS_GOOD) status = SANE_STATUS_IO_ERROR;
+ return status;
+ }
+
+ /* Read current white balance settings */
+ status = DMCRead(fd, 0x82, 0x0, userInterfaceSettings,
+ sizeof(userInterfaceSettings), &size);
+ if (status != SANE_STATUS_GOOD ||
+ size < sizeof(userInterfaceSettings)) {
+ DBG(1, "DMCAttach: Couldn't read user interface settings (%s)\n",
+ sane_strstatus(status));
+ sanei_scsi_close(fd);
+ if (status == SANE_STATUS_GOOD) status = SANE_STATUS_IO_ERROR;
+ return status;
+ }
+
+ /* Shut off viewfinder mode */
+ status = sanei_scsi_cmd(fd, no_viewfinder, sizeof(no_viewfinder),
+ NULL, NULL);
+ if (status != SANE_STATUS_GOOD) {
+ sanei_scsi_close(fd);
+ return status;
+ }
+ sanei_scsi_close(fd);
+
+ DBG(3, "DMCAttach: Looks like we have a Polaroid DMC\n");
+
+ dev = malloc(sizeof(*dev));
+ if (!dev) return SANE_STATUS_NO_MEM;
+ memset(dev, 0, sizeof(*dev));
+
+ dev->sane.name = strdup(devname);
+ dev->sane.vendor = "Polaroid";
+ dev->sane.model = "DMC";
+ dev->sane.type = "still camera";
+ dev->next = FirstDevice;
+ dev->whiteBalance = userInterfaceSettings[5];
+ if (dev->whiteBalance > WHITE_BALANCE_FLUORESCENT) {
+ dev->whiteBalance = WHITE_BALANCE_FLUORESCENT;
+ }
+
+ /* Bright Eyes documentation gives these as shutter speed ranges (ms) */
+ /* dev->shutterSpeedRange.min = 8; */
+ /* dev->shutterSpeedRange.max = 320; */
+
+ /* User's manual says these are shutter speed ranges (ms) */
+ dev->shutterSpeedRange.min = 8;
+ dev->shutterSpeedRange.max = 1000;
+ dev->shutterSpeedRange.quant = 2;
+ dev->shutterSpeed =
+ (exposureCalculationResults[10] << 8) +
+ exposureCalculationResults[11];
+
+ /* Convert from ticks to ms */
+ dev->shutterSpeed = TICKS_TO_MS(dev->shutterSpeed);
+
+ dev->asa = exposureCalculationResults[13];
+ if (dev->asa > ASA_100) dev->asa = ASA_100;
+ dev->asa = ValidASAs[dev->asa + 1];
+ FirstDevice = dev;
+ NumDevices++;
+ if (devp) *devp = dev;
+ return SANE_STATUS_GOOD;
+}
+
+/**********************************************************************
+//%FUNCTION: ValidateHandle
+//%ARGUMENTS:
+// handle -- a handle for an opened camera
+//%RETURNS:
+// A validated pointer to the camera or NULL if handle is not valid.
+// *********************************************************************/
+static DMC_Camera *
+ValidateHandle(SANE_Handle handle)
+{
+ DMC_Camera *c;
+ for (c = FirstHandle; c; c = c->next) {
+ if (c == handle) return c;
+ }
+ DBG(1, "ValidateHandle: invalid handle %p\n", handle);
+ return NULL;
+}
+
+/**********************************************************************
+//%FUNCTION: DMCInitOptions
+//%ARGUMENTS:
+// c -- a DMC camera device
+//%RETURNS:
+// SANE_STATUS_GOOD -- OK
+// SANE_STATUS_INVAL -- There's a problem.
+//%DESCRIPTION:
+// Initializes the options in the DMC_Camera structure
+// *********************************************************************/
+static SANE_Status
+DMCInitOptions(DMC_Camera *c)
+{
+ int i;
+
+ /* Image is initially 801x600 */
+ c->tl_x_range.min = 0;
+ c->tl_x_range.max = c->tl_x_range.min;
+ c->tl_x_range.quant = 1;
+ c->tl_y_range.min = 0;
+ c->tl_y_range.max = c->tl_y_range.min;
+ c->tl_y_range.quant = 1;
+
+ c->br_x_range.min = 800;
+ c->br_x_range.max = c->br_x_range.min;
+ c->br_x_range.quant = 1;
+ c->br_y_range.min = 599;
+ c->br_y_range.max = c->br_y_range.min;
+ c->br_y_range.quant = 1;
+
+ memset(c->opt, 0, sizeof(c->opt));
+ memset(c->val, 0, sizeof(c->val));
+
+ for (i=0; i<NUM_OPTIONS; i++) {
+ c->opt[i].type = SANE_TYPE_INT;
+ c->opt[i].size = sizeof(SANE_Word);
+ c->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ c->opt[i].unit = SANE_UNIT_NONE;
+ }
+
+ c->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
+ c->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
+ c->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
+ c->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
+ c->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
+ c->opt[OPT_NUM_OPTS].constraint_type = SANE_CONSTRAINT_NONE;
+ c->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
+
+ c->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
+ c->opt[OPT_GEOMETRY_GROUP].name = "";
+ c->opt[OPT_GEOMETRY_GROUP].title = "Geometry";
+ c->opt[OPT_GEOMETRY_GROUP].desc = "";
+ c->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
+ c->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+ /* top-left x */
+ c->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
+ c->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
+ c->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
+ c->opt[OPT_TL_X].type = SANE_TYPE_INT;
+ c->opt[OPT_TL_X].unit = SANE_UNIT_PIXEL;
+ c->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+ c->opt[OPT_TL_X].constraint.range = &c->tl_x_range;
+ c->val[OPT_TL_X].w = c->tl_x_range.min;
+
+ /* top-left y */
+ c->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
+ c->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
+ c->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
+ c->opt[OPT_TL_Y].type = SANE_TYPE_INT;
+ c->opt[OPT_TL_Y].unit = SANE_UNIT_PIXEL;
+ c->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+ c->opt[OPT_TL_Y].constraint.range = &c->tl_y_range;
+ c->val[OPT_TL_Y].w = c->tl_y_range.min;
+
+ /* bottom-right x */
+ c->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
+ c->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
+ c->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
+ c->opt[OPT_BR_X].type = SANE_TYPE_INT;
+ c->opt[OPT_BR_X].unit = SANE_UNIT_PIXEL;
+ c->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+ c->opt[OPT_BR_X].constraint.range = &c->br_x_range;
+ c->val[OPT_BR_X].w = c->br_x_range.min;
+
+ /* bottom-right y */
+ c->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
+ c->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
+ c->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
+ c->opt[OPT_BR_Y].type = SANE_TYPE_INT;
+ c->opt[OPT_BR_Y].unit = SANE_UNIT_PIXEL;
+ c->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+ c->opt[OPT_BR_Y].constraint.range = &c->br_y_range;
+ c->val[OPT_BR_Y].w = c->br_y_range.min;
+
+ c->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
+ c->opt[OPT_MODE_GROUP].name = "";
+ c->opt[OPT_MODE_GROUP].title = "Imaging Mode";
+ c->opt[OPT_MODE_GROUP].desc = "";
+ c->opt[OPT_MODE_GROUP].cap = SANE_CAP_ADVANCED;
+ c->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+ c->opt[OPT_IMAGE_MODE].name = "imagemode";
+ c->opt[OPT_IMAGE_MODE].title = "Image Mode";
+ c->opt[OPT_IMAGE_MODE].desc = "Selects image mode: 800x600 full frame, 270x201 viewfinder mode, 1599x600 \"raw\" image, 80x60 thumbnail image or 1599x1200 \"super-resolution\" image";
+ c->opt[OPT_IMAGE_MODE].type = SANE_TYPE_STRING;
+ c->opt[OPT_IMAGE_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ c->opt[OPT_IMAGE_MODE].constraint.string_list = ValidModes;
+ c->opt[OPT_IMAGE_MODE].size = 16;
+ c->val[OPT_IMAGE_MODE].s = "Full frame";
+
+ c->opt[OPT_ASA].name = "asa";
+ c->opt[OPT_ASA].title = "ASA Setting";
+ c->opt[OPT_ASA].desc = "Equivalent ASA setting";
+ c->opt[OPT_ASA].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+ c->opt[OPT_ASA].constraint.word_list = ValidASAs;
+ c->val[OPT_ASA].w = c->hw->asa;
+
+ c->opt[OPT_SHUTTER_SPEED].name = "shutterspeed";
+ c->opt[OPT_SHUTTER_SPEED].title = "Shutter Speed (ms)";
+ c->opt[OPT_SHUTTER_SPEED].desc = "Shutter Speed in milliseconds";
+ c->opt[OPT_SHUTTER_SPEED].constraint_type = SANE_CONSTRAINT_RANGE;
+ c->opt[OPT_SHUTTER_SPEED].constraint.range = &c->hw->shutterSpeedRange;
+ c->val[OPT_SHUTTER_SPEED].w = c->hw->shutterSpeed;
+
+ c->opt[OPT_WHITE_BALANCE].name = "whitebalance";
+ c->opt[OPT_WHITE_BALANCE].title = "White Balance";
+ c->opt[OPT_WHITE_BALANCE].desc = "Selects white balance";
+ c->opt[OPT_WHITE_BALANCE].type = SANE_TYPE_STRING;
+ c->opt[OPT_WHITE_BALANCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ c->opt[OPT_WHITE_BALANCE].constraint.string_list = ValidBalances;
+ c->opt[OPT_WHITE_BALANCE].size = 16;
+ c->val[OPT_WHITE_BALANCE].s = (SANE_String) ValidBalances[c->hw->whiteBalance];
+
+ return SANE_STATUS_GOOD;
+}
+
+/**********************************************************************
+//%FUNCTION: DMCSetMode
+//%ARGUMENTS:
+// c -- a DMC camera device
+// mode -- Imaging mode
+//%RETURNS:
+// SANE_STATUS_GOOD -- OK
+// SANE_STATUS_INVAL -- There's a problem.
+//%DESCRIPTION:
+// Sets the camera's imaging mode.
+// *********************************************************************/
+static SANE_Status
+DMCSetMode(DMC_Camera *c, int mode)
+{
+ switch(mode) {
+ case IMAGE_MFI:
+ c->tl_x_range.min = 0;
+ c->tl_x_range.max = c->tl_x_range.max;
+ c->tl_y_range.min = 0;
+ c->tl_y_range.max = c->tl_y_range.max;
+ c->br_x_range.min = 800;
+ c->br_x_range.max = c->br_x_range.max;
+ c->br_y_range.min = 599;
+ c->br_y_range.max = c->br_y_range.max;
+ break;
+ case IMAGE_VIEWFINDER:
+ c->tl_x_range.min = 0;
+ c->tl_x_range.max = c->tl_x_range.max;
+ c->tl_y_range.min = 0;
+ c->tl_y_range.max = c->tl_y_range.max;
+ c->br_x_range.min = 269;
+ c->br_x_range.max = c->br_x_range.max;
+ c->br_y_range.min = 200;
+ c->br_y_range.max = c->br_y_range.max;
+ break;
+ case IMAGE_RAW:
+ c->tl_x_range.min = 0;
+ c->tl_x_range.max = c->tl_x_range.max;
+ c->tl_y_range.min = 0;
+ c->tl_y_range.max = c->tl_y_range.max;
+ c->br_x_range.min = 1598;
+ c->br_x_range.max = c->br_x_range.max;
+ c->br_y_range.min = 599;
+ c->br_y_range.max = c->br_y_range.max;
+ break;
+ case IMAGE_THUMB:
+ c->tl_x_range.min = 0;
+ c->tl_x_range.max = c->tl_x_range.max;
+ c->tl_y_range.min = 0;
+ c->tl_y_range.max = c->tl_y_range.max;
+ c->br_x_range.min = 79;
+ c->br_x_range.max = c->br_x_range.max;
+ c->br_y_range.min = 59;
+ c->br_y_range.max = c->br_y_range.max;
+ break;
+ case IMAGE_SUPER_RES:
+ c->tl_x_range.min = 0;
+ c->tl_x_range.max = c->tl_x_range.max;
+ c->tl_y_range.min = 0;
+ c->tl_y_range.max = c->tl_y_range.max;
+ c->br_x_range.min = 1598;
+ c->br_x_range.max = c->br_x_range.max;
+ c->br_y_range.min = 1199;
+ c->br_y_range.max = c->br_y_range.max;
+ break;
+ default:
+ return SANE_STATUS_INVAL;
+ }
+ c->imageMode = mode;
+ c->val[OPT_TL_X].w = c->tl_x_range.min;
+ c->val[OPT_TL_Y].w = c->tl_y_range.min;
+ c->val[OPT_BR_X].w = c->br_x_range.min;
+ c->val[OPT_BR_Y].w = c->br_y_range.min;
+ return SANE_STATUS_GOOD;
+}
+
+/**********************************************************************
+//%FUNCTION: DMCCancel
+//%ARGUMENTS:
+// c -- a DMC camera device
+//%RETURNS:
+// SANE_STATUS_CANCELLED
+//%DESCRIPTION:
+// Cancels DMC image acquisition
+// *********************************************************************/
+static SANE_Status
+DMCCancel(DMC_Camera *c)
+{
+ if (c->fd >= 0) {
+ sanei_scsi_close(c->fd);
+ c->fd = -1;
+ }
+ return SANE_STATUS_CANCELLED;
+}
+
+/**********************************************************************
+//%FUNCTION: DMCSetASA
+//%ARGUMENTS:
+// fd -- SCSI file descriptor
+// asa -- the ASA to set
+//%RETURNS:
+// A sane status value
+//%DESCRIPTION:
+// Sets the equivalent ASA setting of the camera.
+// *********************************************************************/
+static SANE_Status
+DMCSetASA(int fd, unsigned int asa)
+{
+ uint8_t exposureCalculationResults[16];
+ SANE_Status status;
+ size_t len;
+ int i;
+
+ DBG(3, "DMCSetAsa: %d\n", asa);
+ for (i=1; i<=ASA_100+1; i++) {
+ if (asa == (unsigned int) ValidASAs[i]) break;
+ }
+
+ if (i > ASA_100+1) return SANE_STATUS_INVAL;
+
+ status = DMCRead(fd, 0x87, 0x4, exposureCalculationResults,
+ sizeof(exposureCalculationResults), &len);
+ if (status != SANE_STATUS_GOOD) return status;
+ if (len < sizeof(exposureCalculationResults)) return SANE_STATUS_IO_ERROR;
+
+ exposureCalculationResults[13] = (uint8_t) i - 1;
+
+ return DMCWrite(fd, 0x87, 0x4, exposureCalculationResults,
+ sizeof(exposureCalculationResults));
+}
+
+/**********************************************************************
+//%FUNCTION: DMCSetWhiteBalance
+//%ARGUMENTS:
+// fd -- SCSI file descriptor
+// mode -- white balance mode
+//%RETURNS:
+// A sane status value
+//%DESCRIPTION:
+// Sets the equivalent ASA setting of the camera.
+// *********************************************************************/
+static SANE_Status
+DMCSetWhiteBalance(int fd, int mode)
+{
+ uint8_t userInterfaceSettings[16];
+ SANE_Status status;
+ size_t len;
+
+ DBG(3, "DMCSetWhiteBalance: %d\n", mode);
+ status = DMCRead(fd, 0x82, 0x0, userInterfaceSettings,
+ sizeof(userInterfaceSettings), &len);
+ if (status != SANE_STATUS_GOOD) return status;
+ if (len < sizeof(userInterfaceSettings)) return SANE_STATUS_IO_ERROR;
+
+ userInterfaceSettings[5] = (uint8_t) mode;
+
+ return DMCWrite(fd, 0x82, 0x0, userInterfaceSettings,
+ sizeof(userInterfaceSettings));
+}
+
+/**********************************************************************
+//%FUNCTION: DMCSetShutterSpeed
+//%ARGUMENTS:
+// fd -- SCSI file descriptor
+// speed -- shutter speed in ms
+//%RETURNS:
+// A sane status value
+//%DESCRIPTION:
+// Sets the shutter speed of the camera
+// *********************************************************************/
+static SANE_Status
+DMCSetShutterSpeed(int fd, unsigned int speed)
+{
+ uint8_t exposureCalculationResults[16];
+ SANE_Status status;
+ size_t len;
+
+ DBG(3, "DMCSetShutterSpeed: %u\n", speed);
+ /* Convert from ms to ticks */
+ speed = MS_TO_TICKS(speed);
+
+ status = DMCRead(fd, 0x87, 0x4, exposureCalculationResults,
+ sizeof(exposureCalculationResults), &len);
+ if (status != SANE_STATUS_GOOD) return status;
+ if (len < sizeof(exposureCalculationResults)) return SANE_STATUS_IO_ERROR;
+
+ exposureCalculationResults[10] = (speed >> 8) & 0xFF;
+ exposureCalculationResults[11] = speed & 0xFF;
+
+ return DMCWrite(fd, 0x87, 0x4, exposureCalculationResults,
+ sizeof(exposureCalculationResults));
+}
+
+/**********************************************************************
+//%FUNCTION: DMCReadTwoSuperResolutionLines
+//%ARGUMENTS:
+// c -- DMC Camera
+// buf -- where to put output.
+// lastLine -- if true, these are the last two lines in the super-resolution
+// image to read.
+//%RETURNS:
+// Nothing
+//%DESCRIPTION:
+// Reads a single "raw" line from the camera (if needed) and constructs
+// two "super-resolution" output lines in "buf"
+// *********************************************************************/
+static SANE_Status
+DMCReadTwoSuperResolutionLines(DMC_Camera *c, SANE_Byte *buf, int lastLine)
+{
+ SANE_Status status;
+ size_t len;
+
+ SANE_Byte *output, *prev;
+ int redCoeff, greenCoeff, blueCoeff;
+ int red, green, blue;
+ int i;
+
+ if (c->nextRawLineValid) {
+ memcpy(c->currentRawLine, c->nextRawLine, BYTES_PER_RAW_LINE);
+ } else {
+ status = DMCRead(c->fd, 0x00, IMAGE_RAW,
+ c->currentRawLine, BYTES_PER_RAW_LINE, &len);
+ if (status != SANE_STATUS_GOOD) return status;
+ }
+ if (!lastLine) {
+ status = DMCRead(c->fd, 0x00, IMAGE_RAW,
+ c->nextRawLine, BYTES_PER_RAW_LINE, &len);
+ if (status != SANE_STATUS_GOOD) return status;
+ c->nextRawLineValid = 1;
+ }
+
+ redCoeff = 3;
+ greenCoeff = 1;
+ blueCoeff = 2;
+
+ /* Do the first super-resolution line */
+ output = buf;
+ for (i=0; i<BYTES_PER_RAW_LINE; i++) {
+ red = redCoeff * c->currentRawLine[PREV_RED(i)] +
+ (3-redCoeff) * c->currentRawLine[NEXT_RED(i)];
+ green = greenCoeff * c->currentRawLine[PREV_GREEN(i)] +
+ (3-greenCoeff) * c->currentRawLine[NEXT_GREEN(i)];
+ blue = blueCoeff * c->currentRawLine[PREV_BLUE(i)] +
+ (3-blueCoeff) * c->currentRawLine[NEXT_BLUE(i)];
+ *output++ = red/3;
+ *output++ = green/3;
+ *output++ = blue/3;
+ redCoeff = ADVANCE_COEFF(redCoeff);
+ greenCoeff = ADVANCE_COEFF(greenCoeff);
+ blueCoeff = ADVANCE_COEFF(blueCoeff);
+ }
+
+ /* Do the next super-resolution line and interpolate vertically */
+ if (lastLine) {
+ memcpy(buf+BYTES_PER_RAW_LINE*3, buf, BYTES_PER_RAW_LINE*3);
+ return SANE_STATUS_GOOD;
+ }
+ redCoeff = 3;
+ greenCoeff = 1;
+ blueCoeff = 2;
+
+ prev = buf;
+ for (i=0; i<BYTES_PER_RAW_LINE; i++) {
+ red = redCoeff * c->nextRawLine[PREV_RED(i)] +
+ (3-redCoeff) * c->nextRawLine[NEXT_RED(i)];
+ green = greenCoeff * c->nextRawLine[PREV_GREEN(i)] +
+ (3-greenCoeff) * c->nextRawLine[NEXT_GREEN(i)];
+ blue = blueCoeff * c->nextRawLine[PREV_BLUE(i)] +
+ (3-blueCoeff) * c->nextRawLine[NEXT_BLUE(i)];
+ *output++ = (red/3 + *prev++) / 2;
+ *output++ = (green/3 + *prev++) / 2;
+ *output++ = (blue/3 + *prev++) / 2;
+ redCoeff = ADVANCE_COEFF(redCoeff);
+ greenCoeff = ADVANCE_COEFF(greenCoeff);
+ blueCoeff = ADVANCE_COEFF(blueCoeff);
+ }
+ return SANE_STATUS_GOOD;
+}
+
+/***********************************************************************
+//%FUNCTION: attach_one (static function)
+//%ARGUMENTS:
+// dev -- device to attach
+//%RETURNS:
+// SANE_STATUS_GOOD
+//%DESCRIPTION:
+// tries to attach a device found by sanei_config_attach_matching_devices
+// *********************************************************************/
+static SANE_Status
+attach_one (const char *dev)
+{
+ DMCAttach (dev, 0);
+ return SANE_STATUS_GOOD;
+}
+
+/**********************************************************************
+//%FUNCTION: sane_init
+//%ARGUMENTS:
+// version_code -- pointer to where we stick our version code
+// authorize -- authorization function
+//%RETURNS:
+// A sane status value
+//%DESCRIPTION:
+// Initializes DMC sane system.
+// *********************************************************************/
+SANE_Status
+sane_init(SANE_Int *version_code, SANE_Auth_Callback authorize)
+{
+ char dev_name[PATH_MAX];
+ size_t len;
+ FILE *fp;
+
+ authorize = authorize;
+
+ DBG_INIT();
+ if (version_code) {
+ *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0);
+ }
+
+ fp = sanei_config_open(DMC_CONFIG_FILE);
+ if (!fp) {
+ /* default to /dev/camera instead of insisting on config file */
+ if (DMCAttach ("/dev/camera", NULL) != SANE_STATUS_GOOD) {
+ /* OK, try /dev/scanner */
+ DMCAttach("/dev/scanner", NULL);
+ }
+ return SANE_STATUS_GOOD;
+ }
+
+ while (sanei_config_read (dev_name, sizeof (dev_name), fp)) {
+ if (dev_name[0] == '#') { /* ignore line comments */
+ continue;
+ }
+ len = strlen (dev_name);
+
+ if (!len) continue; /* ignore empty lines */
+
+ sanei_config_attach_matching_devices(dev_name, attach_one);
+ }
+ fclose (fp);
+ return SANE_STATUS_GOOD;
+}
+
+/**********************************************************************
+//%FUNCTION: sane_exit
+//%ARGUMENTS:
+// None
+//%RETURNS:
+// Nothing
+//%DESCRIPTION:
+// Cleans up all the SANE information
+// *********************************************************************/
+void
+sane_exit(void)
+{
+ DMC_Device *dev, *next;
+
+ /* Close all handles */
+ while(FirstHandle) {
+ sane_close(FirstHandle);
+ }
+
+ /* Free all devices */
+ dev = FirstDevice;
+ while(dev) {
+ next = dev->next;
+ free((char *) dev->sane.model);
+ free(dev);
+ dev = next;
+ }
+}
+
+/**********************************************************************
+//%FUNCTION: sane_get_devices
+//%ARGUMENTS:
+// device_list -- set to allocated list of devices
+// local_only -- ignored
+//%RETURNS:
+// A SANE status
+//%DESCRIPTION:
+// Returns a list of all known DMC devices
+// *********************************************************************/
+SANE_Status
+sane_get_devices(SANE_Device const ***device_list, SANE_Bool local_only)
+{
+ static SANE_Device const **devlist = 0;
+ DMC_Device *dev;
+ int i = 0;
+
+ local_only = local_only;
+
+ if (devlist) free(devlist);
+ devlist = malloc((NumDevices+1) * sizeof(devlist[0]));
+ if (!devlist) return SANE_STATUS_NO_MEM;
+
+ for (dev=FirstDevice; dev; dev = dev->next) {
+ devlist[i++] = &dev->sane;
+ }
+ devlist[i] = NULL;
+
+ if (device_list) *device_list = devlist;
+
+ return SANE_STATUS_GOOD;
+}
+
+/**********************************************************************
+//%FUNCTION: sane_open
+//%ARGUMENTS:
+// name -- name of device to open
+// handle -- set to a handle for the opened device
+//%RETURNS:
+// A SANE status
+//%DESCRIPTION:
+// Opens a DMC camera device
+// *********************************************************************/
+SANE_Status
+sane_open(SANE_String_Const name, SANE_Handle *handle)
+{
+ SANE_Status status;
+ DMC_Device *dev;
+ DMC_Camera *c;
+
+ /* If we're given a device name, search for it */
+ if (*name) {
+ for (dev = FirstDevice; dev; dev = dev->next) {
+ if (!strcmp(dev->sane.name, name)) {
+ break;
+ }
+ }
+ if (!dev) {
+ status = DMCAttach(name, &dev);
+ if (status != SANE_STATUS_GOOD) return status;
+ }
+ } else {
+ dev = FirstDevice;
+ }
+
+ if (!dev) return SANE_STATUS_INVAL;
+
+ c = malloc(sizeof(*c));
+ if (!c) return SANE_STATUS_NO_MEM;
+
+ memset(c, 0, sizeof(*c));
+
+ c->fd = -1;
+ c->hw = dev;
+ c->readBuffer = NULL;
+ c->readPtr = NULL;
+ c->imageMode = IMAGE_MFI;
+ c->inViewfinderMode = 0;
+ c->nextRawLineValid = 0;
+
+ DMCInitOptions(c);
+
+ c->next = FirstHandle;
+ FirstHandle = c;
+ if (handle) *handle = c;
+ return SANE_STATUS_GOOD;
+}
+
+/**********************************************************************
+//%FUNCTION: sane_close
+//%ARGUMENTS:
+// handle -- handle of device to close
+//%RETURNS:
+// A SANE status
+//%DESCRIPTION:
+// Closes a DMC camera device
+// *********************************************************************/
+void
+sane_close(SANE_Handle handle)
+{
+ DMC_Camera *prev, *c;
+ prev = NULL;
+ for (c = FirstHandle; c; c = c->next) {
+ if (c == handle) break;
+ prev = c;
+ }
+ if (!c) {
+ DBG(1, "close: invalid handle %p\n", handle);
+ return;
+ }
+ DMCCancel(c);
+
+ if (prev) prev->next = c->next;
+ else FirstHandle = c->next;
+
+ if (c->readBuffer) {
+ free(c->readBuffer);
+ }
+ free(c);
+}
+
+/**********************************************************************
+//%FUNCTION: sane_get_option_descriptor
+//%ARGUMENTS:
+// handle -- handle of device
+// option -- option number to retrieve
+//%RETURNS:
+// An option descriptor or NULL on error
+// *********************************************************************/
+SANE_Option_Descriptor const *
+sane_get_option_descriptor(SANE_Handle handle, SANE_Int option)
+{
+ DMC_Camera *c = ValidateHandle(handle);
+ if (!c) return NULL;
+
+ if ((unsigned) option >= NUM_OPTIONS) return NULL;
+ return c->opt + option;
+}
+
+/**********************************************************************
+//%FUNCTION: sane_control_option
+//%ARGUMENTS:
+// handle -- handle of device
+// option -- option number to retrieve
+// action -- what to do with the option
+// val -- value to set option to
+// info -- returned info flags
+//%RETURNS:
+// SANE status
+//%DESCRIPTION:
+// Sets or queries option values
+// *********************************************************************/
+SANE_Status
+sane_control_option(SANE_Handle handle, SANE_Int option,
+ SANE_Action action, void *val, SANE_Int *info)
+{
+ DMC_Camera *c;
+ SANE_Word cap;
+ SANE_Status status;
+ int i;
+
+ if (info) *info = 0;
+
+ c = ValidateHandle(handle);
+ if (!c) return SANE_STATUS_INVAL;
+
+ if (c->fd >= 0) return SANE_STATUS_DEVICE_BUSY;
+
+ if (option >= NUM_OPTIONS) return SANE_STATUS_INVAL;
+
+ cap = c->opt[option].cap;
+ if (!SANE_OPTION_IS_ACTIVE(cap)) return SANE_STATUS_INVAL;
+
+ if (action == SANE_ACTION_GET_VALUE) {
+ switch(c->opt[option].type) {
+ case SANE_TYPE_INT:
+ * (SANE_Int *) val = c->val[option].w;
+ return SANE_STATUS_GOOD;
+
+ case SANE_TYPE_STRING:
+ strcpy(val, c->val[option].s);
+ return SANE_STATUS_GOOD;
+
+ default:
+ DBG(3, "impossible option type!\n");
+ return SANE_STATUS_INVAL;
+ }
+ }
+
+ if (action == SANE_ACTION_SET_AUTO) {
+ return SANE_STATUS_UNSUPPORTED;
+ }
+
+ switch(option) {
+ case OPT_IMAGE_MODE:
+ for (i=0; i<NUM_IMAGE_MODES; i++) {
+ if (!strcmp(val, ValidModes[i])) {
+ status = DMCSetMode(c, i);
+ c->val[OPT_IMAGE_MODE].s = (SANE_String) ValidModes[i];
+ if (info) *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+ return SANE_STATUS_GOOD;
+ }
+ }
+ break;
+ case OPT_WHITE_BALANCE:
+ for (i=0; i<=WHITE_BALANCE_FLUORESCENT; i++) {
+ if (!strcmp(val, ValidBalances[i])) {
+ c->val[OPT_WHITE_BALANCE].s = (SANE_String) ValidBalances[i];
+ return SANE_STATUS_GOOD;
+ }
+ }
+ break;
+ case OPT_ASA:
+ for (i=1; i<= ASA_100+1; i++) {
+ if (* ((SANE_Int *) val) == ValidASAs[i]) {
+ c->val[OPT_ASA].w = ValidASAs[i];
+ return SANE_STATUS_GOOD;
+ }
+ }
+ break;
+ case OPT_SHUTTER_SPEED:
+ if (* (SANE_Int *) val < c->hw->shutterSpeedRange.min ||
+ * (SANE_Int *) val > c->hw->shutterSpeedRange.max) {
+ return SANE_STATUS_INVAL;
+ }
+ c->val[OPT_SHUTTER_SPEED].w = * (SANE_Int *) val;
+ /* Do any roundoff */
+ c->val[OPT_SHUTTER_SPEED].w =
+ TICKS_TO_MS(MS_TO_TICKS(c->val[OPT_SHUTTER_SPEED].w));
+ if (c->val[OPT_SHUTTER_SPEED].w != * (SANE_Int *) val) {
+ if (info) *info |= SANE_INFO_INEXACT;
+ }
+
+ return SANE_STATUS_GOOD;
+
+ default:
+ /* Should really be INVAL, but just bit-bucket set requests... */
+ return SANE_STATUS_GOOD;
+ }
+
+ return SANE_STATUS_INVAL;
+}
+
+/**********************************************************************
+//%FUNCTION: sane_get_parameters
+//%ARGUMENTS:
+// handle -- handle of device
+// params -- set to device parameters
+//%RETURNS:
+// SANE status
+//%DESCRIPTION:
+// Returns parameters for current or next image.
+// *********************************************************************/
+SANE_Status
+sane_get_parameters(SANE_Handle handle, SANE_Parameters *params)
+{
+ DMC_Camera *c = ValidateHandle(handle);
+ if (!c) return SANE_STATUS_INVAL;
+
+ if (c->fd < 0) {
+ int width, height;
+ memset(&c->params, 0, sizeof(c->params));
+
+ width = c->val[OPT_BR_X].w - c->val[OPT_TL_X].w;
+ height = c->val[OPT_BR_Y].w - c->val[OPT_TL_Y].w;
+ c->params.pixels_per_line = width + 1;
+ c->params.lines = height+1;
+ c->params.depth = 8;
+ c->params.last_frame = SANE_TRUE;
+ switch(c->imageMode) {
+ case IMAGE_SUPER_RES:
+ case IMAGE_MFI:
+ case IMAGE_THUMB:
+ c->params.format = SANE_FRAME_RGB;
+ c->params.bytes_per_line = c->params.pixels_per_line * 3;
+ break;
+ case IMAGE_RAW:
+ case IMAGE_VIEWFINDER:
+ c->params.format = SANE_FRAME_GRAY;
+ c->params.bytes_per_line = c->params.pixels_per_line;
+ break;
+ }
+ }
+ if (params) *params = c->params;
+ return SANE_STATUS_GOOD;
+}
+
+/**********************************************************************
+//%FUNCTION: sane_start
+//%ARGUMENTS:
+// handle -- handle of device
+//%RETURNS:
+// SANE status
+//%DESCRIPTION:
+// Starts acquisition
+// *********************************************************************/
+SANE_Status
+sane_start(SANE_Handle handle)
+{
+ static uint8_t const acquire[] =
+ { 0xC1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+ static uint8_t const viewfinder[] =
+ { 0xCB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+ static uint8_t const no_viewfinder[] =
+ { 0xC6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+ DMC_Camera *c = ValidateHandle(handle);
+ SANE_Status status;
+ int i;
+
+ if (!c) return SANE_STATUS_INVAL;
+
+ /* If we're already open, barf -- not sure this is the best status */
+ if (c->fd >= 0) return SANE_STATUS_DEVICE_BUSY;
+
+ /* Get rid of old read buffers */
+ if (c->readBuffer) {
+ free(c->readBuffer);
+ c->readBuffer = NULL;
+ c->readPtr = NULL;
+ }
+
+ c->nextRawLineValid = 0;
+
+ /* Refresh parameter list */
+ status = sane_get_parameters(c, NULL);
+ if (status != SANE_STATUS_GOOD) return status;
+
+ status = sanei_scsi_open(c->hw->sane.name, &c->fd, NULL, NULL);
+ if (status != SANE_STATUS_GOOD) {
+ c->fd = -1;
+ DBG(1, "DMC: Open of `%s' failed: %s\n",
+ c->hw->sane.name, sane_strstatus(status));
+ return status;
+ }
+
+ /* Set ASA and shutter speed if they're no longer current */
+ if (c->val[OPT_ASA].w != c->hw->asa) {
+ status = DMCSetASA(c->fd, c->val[OPT_ASA].w);
+ if (status != SANE_STATUS_GOOD) {
+ DMCCancel(c);
+ return status;
+ }
+ c->hw->asa = c->val[OPT_ASA].w;
+ }
+
+ if ((unsigned int) c->val[OPT_SHUTTER_SPEED].w != c->hw->shutterSpeed) {
+ status = DMCSetShutterSpeed(c->fd, c->val[OPT_SHUTTER_SPEED].w);
+ if (status != SANE_STATUS_GOOD) {
+ DMCCancel(c);
+ return status;
+ }
+ c->hw->shutterSpeed = c->val[OPT_SHUTTER_SPEED].w;
+ }
+
+ /* Set white balance mode if needed */
+ for (i=0; i<=WHITE_BALANCE_FLUORESCENT; i++) {
+ if (!strcmp(ValidBalances[i], c->val[OPT_WHITE_BALANCE].s)) {
+ if (i != c->hw->whiteBalance) {
+ status = DMCSetWhiteBalance(c->fd, i);
+ if (status != SANE_STATUS_GOOD) {
+ DMCCancel(c);
+ return status;
+ }
+ c->hw->whiteBalance = i;
+ }
+ }
+ }
+
+ /* Flip into viewfinder mode if needed */
+ if (c->imageMode == IMAGE_VIEWFINDER && !c->inViewfinderMode) {
+ status = sanei_scsi_cmd(c->fd, viewfinder, sizeof(viewfinder),
+ NULL, NULL);
+ if (status != SANE_STATUS_GOOD) {
+ DMCCancel(c);
+ return status;
+ }
+ c->inViewfinderMode = 1;
+ }
+
+ /* Flip out of viewfinder mode if needed */
+ if (c->imageMode != IMAGE_VIEWFINDER && c->inViewfinderMode) {
+ status = sanei_scsi_cmd(c->fd, no_viewfinder, sizeof(no_viewfinder),
+ NULL, NULL);
+ if (status != SANE_STATUS_GOOD) {
+ DMCCancel(c);
+ return status;
+ }
+ c->inViewfinderMode = 0;
+ }
+
+
+ status = sanei_scsi_cmd(c->fd, acquire, sizeof(acquire), NULL, NULL);
+ if (status != SANE_STATUS_GOOD) {
+ DMCCancel(c);
+ return status;
+ }
+ c->bytes_to_read = c->params.bytes_per_line * c->params.lines;
+ return SANE_STATUS_GOOD;
+}
+
+/**********************************************************************
+//%FUNCTION: sane_read
+//%ARGUMENTS:
+// handle -- handle of device
+// buf -- destination for data
+// max_len -- maximum amount of data to store
+// len -- set to actual amount of data stored.
+//%RETURNS:
+// SANE status
+//%DESCRIPTION:
+// Reads image data from the camera
+// *********************************************************************/
+SANE_Status
+sane_read(SANE_Handle handle, SANE_Byte *buf, SANE_Int max_len, SANE_Int *len)
+{
+ SANE_Status status;
+ DMC_Camera *c = ValidateHandle(handle);
+ size_t size;
+ SANE_Int i;
+
+ if (!c) return SANE_STATUS_INVAL;
+
+ if (c->fd < 0) return SANE_STATUS_INVAL;
+
+ if (c->bytes_to_read == 0) {
+ if (c->readBuffer) {
+ free(c->readBuffer);
+ c->readBuffer = NULL;
+ c->readPtr = NULL;
+ }
+ DMCCancel(c);
+ return SANE_STATUS_EOF;
+ }
+
+ if (max_len == 0) {
+ return SANE_STATUS_GOOD;
+ }
+
+ if (c->imageMode == IMAGE_SUPER_RES) {
+ /* We have to read *two* complete rows... */
+ max_len = (max_len / (2*c->params.bytes_per_line)) *
+ (2*c->params.bytes_per_line);
+ /* If user is trying to read less than two complete lines, fail */
+ if (max_len == 0) return SANE_STATUS_INVAL;
+ if ((unsigned int) max_len > c->bytes_to_read) max_len = c->bytes_to_read;
+ for (i=0; i<max_len; i += 2*c->params.bytes_per_line) {
+ c->bytes_to_read -= 2*c->params.bytes_per_line;
+ status = DMCReadTwoSuperResolutionLines(c, buf+i,
+ !c->bytes_to_read);
+ if (status != SANE_STATUS_GOOD) return status;
+ }
+ *len = max_len;
+ return SANE_STATUS_GOOD;
+ }
+
+ if (c->imageMode == IMAGE_MFI || c->imageMode == IMAGE_RAW) {
+ /* We have to read complete rows... */
+ max_len = (max_len / c->params.bytes_per_line) * c->params.bytes_per_line;
+
+ /* If user is trying to read less than one complete row, fail */
+ if (max_len == 0) return SANE_STATUS_INVAL;
+ if ((unsigned int) max_len > c->bytes_to_read) max_len = c->bytes_to_read;
+ c->bytes_to_read -= (unsigned int) max_len;
+ status = DMCRead(c->fd, 0x00, c->imageMode, buf, max_len, &size);
+ *len = size;
+ return status;
+ }
+
+ if ((unsigned int) max_len > c->bytes_to_read) max_len = c->bytes_to_read;
+ if (c->readPtr) {
+ *len = max_len;
+ memcpy(buf, c->readPtr, max_len);
+ c->readPtr += max_len;
+ c->bytes_to_read -= max_len;
+ return SANE_STATUS_GOOD;
+ }
+
+ /* Fill the read buffer completely */
+ c->readBuffer = malloc(c->bytes_to_read);
+ if (!c->readBuffer) return SANE_STATUS_NO_MEM;
+ c->readPtr = c->readBuffer;
+ status = DMCRead(c->fd, 0x00, c->imageMode, (SANE_Byte *) c->readBuffer,
+ c->bytes_to_read, &size);
+ *len = size;
+ if (status != SANE_STATUS_GOOD) return status;
+ if ((unsigned int) *len != c->bytes_to_read) return SANE_STATUS_IO_ERROR;
+
+ /* Now copy */
+ *len = max_len;
+ memcpy(buf, c->readPtr, max_len);
+ c->readPtr += max_len;
+ c->bytes_to_read -= max_len;
+ return SANE_STATUS_GOOD;
+}
+
+/**********************************************************************
+//%FUNCTION: sane_cancel
+//%ARGUMENTS:
+// handle -- handle of device
+//%RETURNS:
+// Nothing
+//%DESCRIPTION:
+// A quick cancellation of the scane
+// *********************************************************************/
+void
+sane_cancel (SANE_Handle handle)
+{
+ DMC_Camera *c = ValidateHandle(handle);
+ if (!c) return;
+
+ DMCCancel(c);
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+ handle = handle;
+ non_blocking = non_blocking;
+
+ return SANE_STATUS_UNSUPPORTED;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle handle, SANE_Int *fd)
+{
+ handle = handle;
+ fd = fd;
+
+ return SANE_STATUS_UNSUPPORTED;
+}