summaryrefslogtreecommitdiff
path: root/backend/hp3900_rts8822.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/hp3900_rts8822.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/hp3900_rts8822.c')
-rw-r--r--backend/hp3900_rts8822.c15123
1 files changed, 15123 insertions, 0 deletions
diff --git a/backend/hp3900_rts8822.c b/backend/hp3900_rts8822.c
new file mode 100644
index 0000000..9c8deaa
--- /dev/null
+++ b/backend/hp3900_rts8822.c
@@ -0,0 +1,15123 @@
+/* HP Scanjet 3900 series - RTS8822 Core
+
+ Copyright (C) 2005-2013 Jonathan Bravo Lopez <jkdsoft@gmail.com>
+
+ 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 code is still a bit ugly due to it's the result of applying
+ reverse engineering techniques to windows driver. So at this
+ moment what you see is exactly what windows driver does.
+ And so many global vars exist that will be erased when driver
+ is entirely debugged. There are some variables with unknown
+ purpose. So they have no meaning name in form v+address. I
+ hope to change their names when driver is debugged completely.
+*/
+
+#ifndef RTS8822_CORE
+
+#define RTS8822_CORE
+
+#define GetTickCount() (time(0) * 1000)
+#define min(A,B) (((A)<(B)) ? (A) : (B))
+#define max(A,B) (((A)>(B)) ? (A) : (B))
+#define PIXEL_TO_MM(_pixel_, _dpi_) ((_pixel_) * 25.4 / (_dpi_))
+#define MM_TO_PIXEL(_mm_, _dpi_) ((_mm_) * (_dpi_) / 25.4)
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h> /* bzero() */
+#include <time.h> /* clock() */
+#include <math.h> /* truncf() */
+#include <ctype.h> /* tolower() */
+#include <unistd.h> /* usleep() */
+#include <sys/types.h>
+
+#include "hp3900_types.c"
+#include "hp3900_debug.c"
+#include "hp3900_config.c"
+#include "hp3900_usb.c"
+
+/*-------------------- Exported function headers --------------------*/
+
+#ifdef developing
+static SANE_Int hp4370_prueba (struct st_device *dev);
+static void prueba (SANE_Byte * a);
+void shadingtest1 (struct st_device *dev, SANE_Byte * Regs,
+ struct st_calibration *myCalib);
+static SANE_Int Calib_test (struct st_device *dev, SANE_Byte * Regs,
+ struct st_calibration *myCalib,
+ struct st_scanparams *scancfg);
+static SANE_Int Calib_BlackShading_jkd (struct st_device *dev,
+ SANE_Byte * Regs,
+ struct st_calibration *myCalib,
+ struct st_scanparams *scancfg);
+#endif
+
+/*static void show_diff(struct st_device *dev, SANE_Byte *original);*/
+
+/* functions to allocate and free space for a device */
+static struct st_device *RTS_Alloc (void);
+static void RTS_Free (struct st_device *dev);
+
+/* Scanner level commands */
+static SANE_Int RTS_Scanner_Init (struct st_device *dev);
+static SANE_Int RTS_Scanner_SetParams (struct st_device *dev,
+ struct params *param);
+static SANE_Int RTS_Scanner_StartScan (struct st_device *dev);
+static void RTS_Scanner_StopScan (struct st_device *dev, SANE_Int wait);
+static void RTS_Scanner_End (struct st_device *dev);
+
+/* loading configuration functions */
+static SANE_Int Load_Buttons (struct st_device *dev);
+static SANE_Int Load_Chipset (struct st_device *dev);
+static SANE_Int Load_Config (struct st_device *dev);
+static SANE_Int Load_Constrains (struct st_device *dev);
+static SANE_Int Load_Motor (struct st_device *dev);
+static SANE_Int Load_MotorCurves (struct st_device *dev);
+static SANE_Int Load_Motormoves (struct st_device *dev);
+static SANE_Int Load_Scanmodes (struct st_device *dev);
+static SANE_Int Load_Sensor (struct st_device *dev);
+static SANE_Int Load_Timings (struct st_device *dev);
+
+/* freeing configuration functions */
+static void Free_Buttons (struct st_device *dev);
+static void Free_Chipset (struct st_device *dev);
+static void Free_Config (struct st_device *dev);
+static void Free_Constrains (struct st_device *dev);
+static void Free_Motor (struct st_device *dev);
+static void Free_MotorCurves (struct st_device *dev);
+static void Free_Motormoves (struct st_device *dev);
+static void Free_Scanmodes (struct st_device *dev);
+static void Free_Sensor (struct st_device *dev);
+static void Free_Timings (struct st_device *dev);
+static void Free_Vars (void);
+
+/* Functions to manage data */
+static SANE_Byte data_bitget (SANE_Byte * address, SANE_Int mask);
+static void data_bitset (SANE_Byte * address, SANE_Int mask, SANE_Byte data);
+static SANE_Int data_lsb_get (SANE_Byte * address, SANE_Int size);
+static void data_lsb_set (SANE_Byte * address, SANE_Int data, SANE_Int size);
+static void data_msb_set (SANE_Byte * address, SANE_Int data, SANE_Int size);
+static void data_wide_bitset (SANE_Byte * address, SANE_Int mask,
+ SANE_Int data);
+static SANE_Int data_swap_endianess (SANE_Int address, SANE_Int size);
+
+static SANE_Int Device_get (SANE_Int product, SANE_Int vendor);
+
+/* Chipset related commands */
+static SANE_Int Chipset_ID (struct st_device *dev);
+static SANE_Int Chipset_Name (struct st_device *dev, char *name,
+ SANE_Int size);
+static SANE_Int Chipset_Reset (struct st_device *dev);
+
+/* Initializing functions */
+static SANE_Int Init_Registers (struct st_device *dev);
+static SANE_Int Init_USBData (struct st_device *dev);
+static SANE_Int Init_Vars (void);
+
+/* scanmode functions */
+static SANE_Int Scanmode_fitres (struct st_device *dev, SANE_Int scantype,
+ SANE_Int colormode, SANE_Int resolution);
+static SANE_Int Scanmode_maxres (struct st_device *dev, SANE_Int scantype,
+ SANE_Int colormode);
+static SANE_Int Scanmode_minres (struct st_device *dev, SANE_Int scantype,
+ SANE_Int colormode);
+
+/* Chipset management useful commands*/
+static SANE_Int RTS_USBType (struct st_device *dev);
+static SANE_Byte RTS_Sensor_Type (USB_Handle usb_handle);
+static void RTS_DebugInit (void);
+static SANE_Int RTS_Enable_CCD (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Int channels);
+
+/* DMA management commands */
+static SANE_Int RTS_DMA_Cancel (struct st_device *dev);
+static SANE_Int RTS_DMA_CheckType (struct st_device *dev, SANE_Byte * Regs);
+static SANE_Int RTS_DMA_Enable_Read (struct st_device *dev, SANE_Int dmacs,
+ SANE_Int size, SANE_Int options);
+static SANE_Int RTS_DMA_Enable_Write (struct st_device *dev, SANE_Int dmacs,
+ SANE_Int size, SANE_Int options);
+static SANE_Int RTS_DMA_Read (struct st_device *dev, SANE_Int dmacs,
+ SANE_Int options, SANE_Int size,
+ SANE_Byte * buffer);
+static SANE_Int RTS_DMA_Reset (struct st_device *dev);
+static SANE_Int RTS_DMA_SetType (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Byte ramtype);
+static SANE_Int RTS_DMA_WaitReady (struct st_device *dev, SANE_Int msecs);
+static SANE_Int RTS_DMA_Write (struct st_device *dev, SANE_Int dmacs,
+ SANE_Int options, SANE_Int size,
+ SANE_Byte * buffer);
+
+/* EEPROM management commands */
+static SANE_Int RTS_EEPROM_ReadByte (USB_Handle usb_handle, SANE_Int address,
+ SANE_Byte * data);
+static SANE_Int RTS_EEPROM_ReadInteger (USB_Handle usb_handle,
+ SANE_Int address, SANE_Int * data);
+static SANE_Int RTS_EEPROM_ReadWord (USB_Handle usb_handle, SANE_Int address,
+ SANE_Int * data);
+static SANE_Int RTS_EEPROM_WriteBuffer (USB_Handle usb_handle,
+ SANE_Int address, SANE_Byte * data,
+ SANE_Int size);
+static SANE_Int RTS_EEPROM_WriteByte (USB_Handle usb_handle, SANE_Int address,
+ SANE_Byte data);
+static SANE_Int RTS_EEPROM_WriteInteger (USB_Handle usb_handle,
+ SANE_Int address, SANE_Int data);
+static SANE_Int RTS_EEPROM_WriteWord (USB_Handle usb_handle, SANE_Int address,
+ SANE_Int data);
+
+static SANE_Int RTS_Execute (struct st_device *dev);
+static SANE_Int RTS_Warm_Reset (struct st_device *dev);
+static SANE_Byte RTS_IsExecuting (struct st_device *dev, SANE_Byte * Regs);
+
+static SANE_Int RTS_GetScanmode (struct st_device *dev, SANE_Int scantype,
+ SANE_Int colormode, SANE_Int resolution);
+static SANE_Int RTS_GetImage (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg,
+ struct st_gain_offset *gain_offset,
+ SANE_Byte * buffer,
+ struct st_calibration *myCalib,
+ SANE_Int options, SANE_Int gainmode);
+static SANE_Int RTS_GetImage_GetBuffer (struct st_device *dev, double dSize,
+ SANE_Byte * buffer,
+ double *transferred);
+static SANE_Int RTS_GetImage_Read (struct st_device *dev, SANE_Byte * buffer,
+ struct st_scanparams *myvar,
+ struct st_hwdconfig *hwdcfg);
+
+static SANE_Int RTS_isTmaAttached (struct st_device *dev);
+
+/* functions to wait for a process tp finish */
+static SANE_Int RTS_WaitInitEnd (struct st_device *dev, SANE_Int msecs);
+static SANE_Int RTS_WaitScanEnd (struct st_device *dev, SANE_Int msecs);
+
+/* functions to read/write control registers */
+static SANE_Int RTS_ReadRegs (USB_Handle usb_handle, SANE_Byte * buffer);
+static SANE_Int RTS_WriteRegs (USB_Handle usb_handle, SANE_Byte * buffer);
+
+/* functions to manage the scan counter */
+static SANE_Int RTS_ScanCounter_Inc (struct st_device *dev);
+static SANE_Int RTS_ScanCounter_Get (struct st_device *dev);
+
+/* functions to setup control registers */
+static SANE_Int RTS_Setup (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *myvar,
+ struct st_hwdconfig *hwdcfg,
+ struct st_gain_offset *gain_offset);
+static void RTS_Setup_Arrangeline (struct st_device *dev,
+ struct st_hwdconfig *hwdcfg,
+ SANE_Int colormode);
+static void RTS_Setup_Channels (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg,
+ SANE_Int mycolormode);
+static void RTS_Setup_Coords (SANE_Byte * Regs, SANE_Int iLeft, SANE_Int iTop,
+ SANE_Int width, SANE_Int height);
+static SANE_Int RTS_Setup_Depth (SANE_Byte * Regs,
+ struct st_scanparams *scancfg,
+ SANE_Int mycolormode);
+static void RTS_Setup_Exposure_Times (SANE_Byte * Regs,
+ struct st_scanparams *scancfg,
+ struct st_scanmode *sm);
+static void RTS_Setup_GainOffset (SANE_Byte * Regs,
+ struct st_gain_offset *gain_offset);
+static void RTS_Setup_Gamma (SANE_Byte * Regs, struct st_hwdconfig *lowcfg);
+static SANE_Int RTS_Setup_Line_Distances (struct st_device *dev,
+ SANE_Byte * Regs,
+ struct st_scanparams *scancfg,
+ struct st_hwdconfig *hwdcfg,
+ SANE_Int mycolormode,
+ SANE_Int arrangeline);
+static SANE_Int RTS_Setup_Motor (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *myvar,
+ SANE_Int somevalue);
+static void RTS_Setup_RefVoltages (struct st_device *dev, SANE_Byte * Regs);
+static void RTS_Setup_SensorTiming (struct st_device *dev, SANE_Int mytiming,
+ SANE_Byte * Regs);
+static void RTS_Setup_Shading (SANE_Byte * Regs,
+ struct st_scanparams *scancfg,
+ struct st_hwdconfig *hwdcfg,
+ SANE_Int bytes_per_line);
+
+static SANE_Int Scan_Start (struct st_device *dev);
+
+static void SetLock (USB_Handle usb_handle, SANE_Byte * Regs,
+ SANE_Byte Enable);
+static SANE_Int fn3330 (struct st_device *dev, SANE_Byte * Regs,
+ struct st_cal2 *calbuffers,
+ SANE_Int sensorchannelcolor, SANE_Int * tablepos,
+ SANE_Int data);
+static SANE_Int fn3560 (USHORT * table, struct st_cal2 *calbuffers,
+ SANE_Int * tablepos);
+static SANE_Int fn3730 (struct st_device *dev, struct st_cal2 *calbuffers,
+ SANE_Byte * Regs, USHORT * table,
+ SANE_Int sensorchannelcolor, SANE_Int data);
+
+static SANE_Int Reading_CreateBuffers (struct st_device *dev);
+static SANE_Int Reading_DestroyBuffers (struct st_device *dev);
+static SANE_Int Reading_BufferSize_Get (struct st_device *dev,
+ SANE_Byte channels_per_dot,
+ SANE_Int channel_size);
+static SANE_Int Reading_BufferSize_Notify (struct st_device *dev,
+ SANE_Int data, SANE_Int size);
+static SANE_Int Reading_Wait (struct st_device *dev,
+ SANE_Byte Channels_per_dot,
+ SANE_Byte Channel_size, SANE_Int size,
+ SANE_Int * last_amount, SANE_Int seconds,
+ SANE_Byte op);
+
+static SANE_Int Read_Image (struct st_device *dev, SANE_Int buffer_size,
+ SANE_Byte * buffer, SANE_Int * transferred);
+static SANE_Int Read_ResizeBlock (struct st_device *dev, SANE_Byte * buffer,
+ SANE_Int buffer_size,
+ SANE_Int * transferred);
+static SANE_Int Read_Block (struct st_device *dev, SANE_Int buffer_size,
+ SANE_Byte * buffer, SANE_Int * transferred);
+static SANE_Int Read_NonColor_Block (struct st_device *dev,
+ SANE_Byte * buffer, SANE_Int buffer_size,
+ SANE_Byte ColorMode,
+ SANE_Int * transferred);
+
+/* Ref functions */
+static SANE_Int Refs_Analyze_Pattern (struct st_scanparams *scancfg,
+ SANE_Byte * scanned_pattern,
+ SANE_Int * ler1, SANE_Int ler1order,
+ SANE_Int * ser1, SANE_Int ser1order);
+static SANE_Int Refs_Counter_Inc (struct st_device *dev);
+static SANE_Byte Refs_Counter_Load (struct st_device *dev);
+static SANE_Int Refs_Counter_Save (struct st_device *dev, SANE_Byte data);
+static SANE_Int Refs_Detect (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Int resolution_x, SANE_Int resolution_y,
+ SANE_Int * x, SANE_Int * y);
+static SANE_Int Refs_Load (struct st_device *dev, SANE_Int * x, SANE_Int * y);
+static SANE_Int Refs_Save (struct st_device *dev, SANE_Int left_leading,
+ SANE_Int start_pos);
+static SANE_Int Refs_Set (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *myscan);
+
+/* Coordinates' constrains functions */
+static SANE_Int Constrains_Check (struct st_device *dev, SANE_Int Resolution,
+ SANE_Int scantype,
+ struct st_coords *mycoords);
+static struct st_coords *Constrains_Get (struct st_device *dev,
+ SANE_Byte scantype);
+
+/* Gain and offset functions */
+static SANE_Int GainOffset_Clear (struct st_device *dev);
+static SANE_Int GainOffset_Get (struct st_device *dev);
+static SANE_Int GainOffset_Save (struct st_device *dev, SANE_Int * offset,
+ SANE_Byte * gain);
+static SANE_Int GainOffset_Counter_Inc (struct st_device *dev,
+ SANE_Int * arg1);
+static SANE_Byte GainOffset_Counter_Load (struct st_device *dev);
+static SANE_Int GainOffset_Counter_Save (struct st_device *dev,
+ SANE_Byte data);
+
+/* Gamma functions*/
+static SANE_Int Gamma_AllocTable (SANE_Byte * table);
+static SANE_Int Gamma_Apply (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg,
+ struct st_hwdconfig *hwdcfg,
+ struct st_gammatables *mygamma);
+static void Gamma_FreeTables (void);
+static SANE_Int Gamma_SendTables (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Byte * gammatable, SANE_Int size);
+static SANE_Int Gamma_GetTables (struct st_device *dev,
+ SANE_Byte * Gamma_buffer);
+
+/* Lamp functions */
+static SANE_Byte Lamp_GetGainMode (struct st_device *dev, SANE_Int resolution,
+ SANE_Byte scantype);
+static void Lamp_SetGainMode (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Int resolution, SANE_Byte gainmode);
+static SANE_Int Lamp_PWM_DutyCycle_Get (struct st_device *dev,
+ SANE_Int * data);
+static SANE_Int Lamp_PWM_DutyCycle_Set (struct st_device *dev,
+ SANE_Int duty_cycle);
+static SANE_Int Lamp_PWM_Setup (struct st_device *dev, SANE_Int lamp);
+static SANE_Int Lamp_PWM_use (struct st_device *dev, SANE_Int enable);
+static SANE_Int Lamp_PWM_CheckStable (struct st_device *dev,
+ SANE_Int resolution, SANE_Int lamp);
+static SANE_Int Lamp_PWM_Save (struct st_device *dev, SANE_Int fixedpwm);
+static SANE_Int Lamp_PWM_SaveStatus (struct st_device *dev, SANE_Byte status);
+static SANE_Int Lamp_Status_Get (struct st_device *dev, SANE_Byte * flb_lamp,
+ SANE_Byte * tma_lamp);
+static SANE_Int Lamp_Status_Set (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Int turn_on, SANE_Int lamp);
+static SANE_Int Lamp_Status_Timer_Set (struct st_device *dev,
+ SANE_Int minutes);
+static SANE_Int Lamp_Warmup (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Int lamp, SANE_Int resolution);
+
+/* Head related functions */
+static SANE_Int Head_IsAtHome (struct st_device *dev, SANE_Byte * Regs);
+static SANE_Int Head_ParkHome (struct st_device *dev, SANE_Int bWait,
+ SANE_Int movement);
+static SANE_Int Head_Relocate (struct st_device *dev, SANE_Int speed,
+ SANE_Int direction, SANE_Int ypos);
+
+/* Motor functions */
+static SANE_Byte *Motor_AddStep (SANE_Byte * steps, SANE_Int * bwriten,
+ SANE_Int step);
+static SANE_Int Motor_Change (struct st_device *dev, SANE_Byte * buffer,
+ SANE_Byte value);
+static SANE_Int Motor_GetFromResolution (SANE_Int resolution);
+static SANE_Int Motor_Move (struct st_device *dev, SANE_Byte * Regs,
+ struct st_motormove *mymotor,
+ struct st_motorpos *mtrpos);
+static void Motor_Release (struct st_device *dev);
+static SANE_Int Motor_Setup_Steps (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Int mysetting);
+static SANE_Int Motor_Curve_Equal (struct st_device *dev,
+ SANE_Int motorsetting, SANE_Int direction,
+ SANE_Int curve1, SANE_Int curve2);
+static void Motor_Curve_Free (struct st_motorcurve **motorcurves,
+ SANE_Int * mtc_count);
+static struct st_curve *Motor_Curve_Get (struct st_device *dev,
+ SANE_Int motorcurve,
+ SANE_Int direction, SANE_Int itype);
+static struct st_motorcurve **Motor_Curve_Parse (SANE_Int * mtc_count,
+ SANE_Int * buffer);
+
+/* Functions to arrange scanned lines */
+static SANE_Int Arrange_Colour (struct st_device *dev, SANE_Byte * buffer,
+ SANE_Int buffer_size, SANE_Int * transferred);
+static SANE_Int Arrange_Compose (struct st_device *dev, SANE_Byte * buffer,
+ SANE_Int buffer_size,
+ SANE_Int * transferred);
+static SANE_Int Arrange_NonColour (struct st_device *dev, SANE_Byte * buffer,
+ SANE_Int buffer_size,
+ SANE_Int * transferred);
+
+/* Composing RGB triplet functions */
+static void Triplet_Gray (SANE_Byte * pPointer1, SANE_Byte * pPointer2,
+ SANE_Byte * buffer, SANE_Int channels_count);
+static void Triplet_Lineart (SANE_Byte * pPointer1, SANE_Byte * pPointer2,
+ SANE_Byte * buffer, SANE_Int channels_count);
+static void Triplet_Compose_Order (struct st_device *dev, SANE_Byte * pRed,
+ SANE_Byte * pGreen, SANE_Byte * pBlue,
+ SANE_Byte * buffer, SANE_Int dots);
+static void Triplet_Compose_HRes (SANE_Byte * pPointer1,
+ SANE_Byte * pPointer2,
+ SANE_Byte * pPointer3,
+ SANE_Byte * pPointer4,
+ SANE_Byte * pPointer5,
+ SANE_Byte * pPointer6, SANE_Byte * buffer,
+ SANE_Int Width);
+static void Triplet_Compose_LRes (SANE_Byte * pRed, SANE_Byte * pGreen,
+ SANE_Byte * pBlue, SANE_Byte * buffer,
+ SANE_Int dots);
+static void Triplet_Colour_Order (struct st_device *dev, SANE_Byte * pRed,
+ SANE_Byte * pGreen, SANE_Byte * pBlue,
+ SANE_Byte * buffer, SANE_Int Width);
+static void Triplet_Colour_HRes (SANE_Byte * pRed1, SANE_Byte * pGreen1,
+ SANE_Byte * pBlue1, SANE_Byte * pRed2,
+ SANE_Byte * pGreen2, SANE_Byte * pBlue2,
+ SANE_Byte * buffer, SANE_Int Width);
+static void Triplet_Colour_LRes (SANE_Int Width, SANE_Byte * Buffer,
+ SANE_Byte * pChannel1, SANE_Byte * pChannel2,
+ SANE_Byte * pChannel3);
+
+/* Timing functions */
+static SANE_Int Timing_SetLinearImageSensorClock (SANE_Byte * Regs,
+ struct st_cph *cph);
+
+/* Functions used to resize retrieved image */
+static SANE_Int Resize_Start (struct st_device *dev, SANE_Int * transferred);
+static SANE_Int Resize_CreateBuffers (struct st_device *dev, SANE_Int size1,
+ SANE_Int size2, SANE_Int size3);
+static SANE_Int Resize_DestroyBuffers (struct st_device *dev);
+static SANE_Int Resize_Increase (SANE_Byte * to_buffer,
+ SANE_Int to_resolution, SANE_Int to_width,
+ SANE_Byte * from_buffer,
+ SANE_Int from_resolution,
+ SANE_Int from_width, SANE_Int myresize_mode);
+static SANE_Int Resize_Decrease (SANE_Byte * to_buffer,
+ SANE_Int to_resolution, SANE_Int to_width,
+ SANE_Byte * from_buffer,
+ SANE_Int from_resolution,
+ SANE_Int from_width, SANE_Int myresize_mode);
+
+/* Scanner buttons support */
+static SANE_Int Buttons_Count (struct st_device *dev);
+static SANE_Int Buttons_Enable (struct st_device *dev);
+static SANE_Int Buttons_Order (struct st_device *dev, SANE_Int mask);
+static SANE_Int Buttons_Status (struct st_device *dev);
+static SANE_Int Buttons_Released (struct st_device *dev);
+
+/* Calibration functions */
+static SANE_Int Calib_CreateBuffers (struct st_device *dev,
+ struct st_calibration *buffer,
+ SANE_Int my14b4);
+static SANE_Int Calib_CreateFixedBuffers (void);
+static void Calib_FreeBuffers (struct st_calibration *caltables);
+static void Calib_LoadCut (struct st_device *dev,
+ struct st_scanparams *scancfg, SANE_Int scantype,
+ struct st_calibration_config *calibcfg);
+static SANE_Int Calib_AdcGain (struct st_device *dev,
+ struct st_calibration_config *calibcfg,
+ SANE_Int arg2, SANE_Int gainmode);
+static SANE_Int Calib_AdcOffsetRT (struct st_device *dev,
+ struct st_calibration_config *calibcfg,
+ SANE_Int value);
+static SANE_Int Calib_BlackShading (struct st_device *dev,
+ struct st_calibration_config *calibcfg,
+ struct st_calibration *myCalib,
+ SANE_Int gainmode);
+static SANE_Int Calib_BWShading (struct st_calibration_config *calibcfg,
+ struct st_calibration *myCalib,
+ SANE_Int gainmode);
+static SANE_Int Calib_WhiteShading_3 (struct st_device *dev,
+ struct st_calibration_config *calibcfg,
+ struct st_calibration *myCalib,
+ SANE_Int gainmode);
+static void Calibrate_Free (struct st_cal2 *calbuffers);
+static SANE_Int Calibrate_Malloc (struct st_cal2 *calbuffers,
+ SANE_Byte * Regs,
+ struct st_calibration *myCalib,
+ SANE_Int somelength);
+static SANE_Int Calib_ReadTable (struct st_device *dev, SANE_Byte * table,
+ SANE_Int size, SANE_Int data);
+static SANE_Int Calib_WriteTable (struct st_device *dev, SANE_Byte * table,
+ SANE_Int size, SANE_Int data);
+static SANE_Int Calib_LoadConfig (struct st_device *dev,
+ struct st_calibration_config *calibcfg,
+ SANE_Int scantype, SANE_Int resolution,
+ SANE_Int bitmode);
+static SANE_Int Calib_PAGain (struct st_device *dev,
+ struct st_calibration_config *calibcfg,
+ SANE_Int gainmode);
+static SANE_Int Calibration (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg,
+ struct st_calibration *myCalib, SANE_Int value);
+
+/* function for white shading correction */
+static SANE_Int WShading_Calibrate (struct st_device *dev, SANE_Byte * Regs,
+ struct st_calibration *myCalib,
+ struct st_scanparams *scancfg);
+static void WShading_Emulate (SANE_Byte * buffer, SANE_Int * chnptr,
+ SANE_Int size, SANE_Int depth);
+
+/* functions for shading calibration */
+static SANE_Int Shading_apply (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *myvar,
+ struct st_calibration *myCalib);
+static SANE_Int Shading_black_apply (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Int channels,
+ struct st_calibration *myCalib,
+ struct st_cal2 *calbuffers);
+static SANE_Int Shading_white_apply (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Int channels,
+ struct st_calibration *myCalib,
+ struct st_cal2 *calbuffers);
+
+/* Spread-Spectrum Clock Generator functions */
+static SANE_Int SSCG_Enable (struct st_device *dev);
+
+static void Split_into_12bit_channels (SANE_Byte * destino,
+ SANE_Byte * fuente, SANE_Int size);
+static SANE_Int Scan_Read_BufferA (struct st_device *dev,
+ SANE_Int buffer_size, SANE_Int arg2,
+ SANE_Byte * pBuffer,
+ SANE_Int * bytes_transfered);
+
+static SANE_Int Bulk_Operation (struct st_device *dev, SANE_Byte op,
+ SANE_Int buffer_size, SANE_Byte * buffer,
+ SANE_Int * transfered);
+static SANE_Int Get_PAG_Value (SANE_Byte scantype, SANE_Byte color);
+static SANE_Int GetOneLineInfo (struct st_device *dev, SANE_Int resolution,
+ SANE_Int * maximus, SANE_Int * minimus,
+ double *average);
+
+static SANE_Int Load_StripCoords (SANE_Int scantype, SANE_Int * ypos,
+ SANE_Int * xpos);
+
+/*static SANE_Int Free_Fixed_CalBuffer(void);*/
+static SANE_Int SetMultiExposure (struct st_device *dev, SANE_Byte * Regs);
+
+static void Set_E950_Mode (struct st_device *dev, SANE_Byte mode);
+
+static SANE_Int LoadImagingParams (struct st_device *dev, SANE_Int inifile);
+
+static SANE_Int SetScanParams (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg,
+ struct st_hwdconfig *hwdcfg);
+static SANE_Int IsScannerLinked (struct st_device *dev);
+
+static SANE_Int Read_FE3E (struct st_device *dev, SANE_Byte * destino);
+
+static double get_shrd (double value, SANE_Int desp);
+static char get_byte (double value);
+/*static SANE_Int RTS8822_GetRegisters(SANE_Byte *buffer);*/
+
+/* ----------------- Implementation ------------------*/
+
+static void
+RTS_Free (struct st_device *dev)
+{
+ /* this function frees space of devices's variable */
+
+ if (dev != NULL)
+ {
+ /* next function shouldn't be necessary but I can NOT assure that other
+ programmers will call Free_Config before this function */
+ Free_Config (dev);
+
+ if (dev->init_regs != NULL)
+ free (dev->init_regs);
+
+ if (dev->Resize != NULL)
+ free (dev->Resize);
+
+ if (dev->Reading != NULL)
+ free (dev->Reading);
+
+ if (dev->scanning != NULL)
+ free (dev->scanning);
+
+ if (dev->status != NULL)
+ free (dev->status);
+
+ free (dev);
+ }
+}
+
+static struct st_device *
+RTS_Alloc ()
+{
+ /* this function allocates space for device's variable */
+
+ struct st_device *dev = NULL;
+
+ dev = malloc (sizeof (struct st_device));
+ if (dev != NULL)
+ {
+ SANE_Int rst = OK;
+
+ bzero (dev, sizeof (struct st_device));
+
+ /* initial registers */
+ dev->init_regs = malloc (sizeof (SANE_Byte) * RT_BUFFER_LEN);
+ if (dev->init_regs != NULL)
+ bzero (dev->init_regs, sizeof (SANE_Byte) * RT_BUFFER_LEN);
+ else
+ rst = ERROR;
+
+ if (rst == OK)
+ {
+ dev->scanning = malloc (sizeof (struct st_scanning));
+ if (dev->scanning != NULL)
+ bzero (dev->scanning, sizeof (struct st_scanning));
+ else
+ rst = ERROR;
+ }
+
+ if (rst == OK)
+ {
+ dev->Reading = malloc (sizeof (struct st_readimage));
+ if (dev->Reading != NULL)
+ bzero (dev->Reading, sizeof (struct st_readimage));
+ else
+ rst = ERROR;
+ }
+
+ if (rst == OK)
+ {
+ dev->Resize = malloc (sizeof (struct st_resize));
+ if (dev->Resize != NULL)
+ bzero (dev->Resize, sizeof (struct st_resize));
+ else
+ rst = ERROR;
+ }
+
+ if (rst == OK)
+ {
+ dev->status = malloc (sizeof (struct st_status));
+ if (dev->status != NULL)
+ bzero (dev->status, sizeof (struct st_status));
+ else
+ rst = ERROR;
+ }
+
+ /* if something fails, free space */
+ if (rst != OK)
+ {
+ RTS_Free (dev);
+ dev = NULL;
+ }
+ }
+
+ return dev;
+}
+
+static void
+RTS_Scanner_End (struct st_device *dev)
+{
+ Gamma_FreeTables ();
+ Free_Config (dev);
+ Free_Vars ();
+}
+
+static SANE_Int
+Device_get (SANE_Int product, SANE_Int vendor)
+{
+ return cfg_device_get (product, vendor);
+}
+
+static SANE_Int
+RTS_Scanner_Init (struct st_device *dev)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "> RTS_Scanner_Init:\n");
+ DBG (DBG_FNC, "> Backend version: %s\n", BACKEND_VRSN);
+
+ rst = ERROR;
+
+ /* gets usb type of this scanner if it's not already set by user */
+ if (RTS_Debug->usbtype == -1)
+ RTS_Debug->usbtype = RTS_USBType (dev);
+
+ if (RTS_Debug->usbtype != ERROR)
+ {
+ DBG (DBG_FNC, " -> Chipset model ID: %i\n", Chipset_ID (dev));
+
+ Chipset_Reset (dev);
+
+ if (Load_Config (dev) == OK)
+ {
+ if (IsScannerLinked (dev) == OK)
+ {
+ Set_E950_Mode (dev, 0);
+ Gamma_AllocTable (NULL);
+ rst = OK;
+ }
+ else
+ Free_Config (dev);
+ }
+ }
+
+ return rst;
+}
+
+static SANE_Int
+RTS_WriteRegs (USB_Handle usb_handle, SANE_Byte * buffer)
+{
+ SANE_Int rst = ERROR;
+
+ if (buffer != NULL)
+ rst =
+ Write_Buffer (usb_handle, 0xe800, buffer,
+ RT_BUFFER_LEN * sizeof (SANE_Byte));
+
+ return rst;
+}
+
+static SANE_Int
+RTS_ReadRegs (USB_Handle usb_handle, SANE_Byte * buffer)
+{
+ SANE_Int rst = ERROR;
+
+ if (buffer != NULL)
+ rst =
+ Read_Buffer (usb_handle, 0xe800, buffer,
+ RT_BUFFER_LEN * sizeof (SANE_Byte));
+
+ return rst;
+}
+
+static void
+SetLock (USB_Handle usb_handle, SANE_Byte * Regs, SANE_Byte Enable)
+{
+ SANE_Byte lock;
+
+ DBG (DBG_FNC, "+ SetLock(*Regs, Enable=%i):\n", Enable);
+
+ if (Regs == NULL)
+ {
+ if (Read_Byte (usb_handle, 0xee00, &lock) != OK)
+ lock = 0;
+ }
+ else
+ lock = Regs[0x600];
+
+ if (Enable == FALSE)
+ lock &= 0xfb;
+ else
+ lock |= 4;
+
+ if (Regs != NULL)
+ Regs[0x600] = lock;
+
+ Write_Byte (usb_handle, 0xee00, lock);
+
+ DBG (DBG_FNC, "- SetLock\n");
+}
+
+static void
+Set_E950_Mode (struct st_device *dev, SANE_Byte mode)
+{
+ SANE_Int data;
+
+ DBG (DBG_FNC, "+ Set_E950_Mode(mode=%i):\n", mode);
+
+ if (Read_Word (dev->usb_handle, 0xe950, &data) == OK)
+ {
+ data = (mode == 0) ? data & 0xffbf : data | 0x40;
+ Write_Word (dev->usb_handle, 0xe950, data);
+ }
+
+ DBG (DBG_FNC, "- Set_E950_Mode\n");
+}
+
+static struct st_curve *
+Motor_Curve_Get (struct st_device *dev, SANE_Int motorcurve,
+ SANE_Int direction, SANE_Int itype)
+{
+ struct st_curve *rst = NULL;
+
+ if (dev != NULL)
+ {
+ if ((dev->mtrsetting != NULL) && (motorcurve < dev->mtrsetting_count))
+ {
+ struct st_motorcurve *mtc = dev->mtrsetting[motorcurve];
+
+ if (mtc != NULL)
+ {
+ if ((mtc->curve != NULL) && (mtc->curve_count > 0))
+ {
+ struct st_curve *crv;
+ SANE_Int a = 0;
+
+ while (a < mtc->curve_count)
+ {
+ /* get each curve */
+ crv = mtc->curve[a];
+ if (crv != NULL)
+ {
+ /* check direction and type */
+ if ((crv->crv_speed == direction)
+ && (crv->crv_type == itype))
+ {
+ /* found ! */
+ rst = crv;
+ break;
+ }
+ }
+ a++;
+ }
+ }
+ }
+ }
+ }
+
+ return rst;
+}
+
+static SANE_Int
+Motor_Curve_Equal (struct st_device *dev, SANE_Int motorsetting,
+ SANE_Int direction, SANE_Int curve1, SANE_Int curve2)
+{
+ /* compares two curves of the same direction
+ returns TRUE if both buffers are equal */
+
+ SANE_Int rst = FALSE;
+ struct st_curve *crv1 =
+ Motor_Curve_Get (dev, motorsetting, direction, curve1);
+ struct st_curve *crv2 =
+ Motor_Curve_Get (dev, motorsetting, direction, curve2);
+
+ if ((crv1 != NULL) && (crv2 != NULL))
+ {
+ if (crv1->step_count == crv2->step_count)
+ {
+ rst = TRUE;
+
+ if (crv1->step_count > 0)
+ {
+ SANE_Int a = 0;
+
+ while ((a < crv1->step_count) && (rst == TRUE))
+ {
+ rst = (crv1->step[a] == crv2->step[a]) ? TRUE : FALSE;
+ a++;
+ }
+ }
+ }
+ }
+
+ return rst;
+}
+
+static struct st_motorcurve **
+Motor_Curve_Parse (SANE_Int * mtc_count, SANE_Int * buffer)
+{
+ /* this function parses motorcurve buffer to get all motor settings */
+ struct st_motorcurve **rst = NULL;
+
+ *mtc_count = 0;
+
+ if (buffer != NULL)
+ {
+ /* phases:
+ -1 : null phase
+ 0 :
+ -3 : initial config
+ */
+ struct st_motorcurve *mtc = NULL;
+ SANE_Int phase;
+
+ phase = -1;
+ while (*buffer != -1)
+ {
+ if (*buffer == -2)
+ {
+ /* end of motorcurve */
+ /* complete any openned phase */
+ /* close phase */
+ phase = -1;
+ }
+ else
+ {
+ /* step */
+ if (phase == -1)
+ {
+ /* new motorcurve */
+ phase = 0;
+ mtc =
+ (struct st_motorcurve *)
+ malloc (sizeof (struct st_motorcurve));
+ if (mtc != NULL)
+ {
+ *mtc_count += 1;
+ rst =
+ realloc (rst,
+ sizeof (struct st_motorcurve **) *
+ *mtc_count);
+ if (rst != NULL)
+ {
+ rst[*mtc_count - 1] = mtc;
+ memset (mtc, 0, sizeof (struct st_motorcurve));
+ phase = -3; /* initial config */
+ }
+ else
+ {
+ /* memory error */
+ *mtc_count = 0;
+ break;
+ }
+ }
+ else
+ break; /* some error */
+ }
+
+ if (mtc != NULL)
+ {
+ switch (phase)
+ {
+ case -3: /* initial config */
+ mtc->mri = *(buffer);
+ mtc->msi = *(buffer + 1);
+ mtc->skiplinecount = *(buffer + 2);
+ mtc->motorbackstep = *(buffer + 3);
+ buffer += 3;
+
+ phase = -4;
+ break;
+
+ case -4:
+ /**/
+ {
+ /* create new step curve */
+ struct st_curve *curve =
+ malloc (sizeof (struct st_curve));
+ if (curve != NULL)
+ {
+ /* add to step curve list */
+ mtc->curve =
+ (struct st_curve **) realloc (mtc->curve,
+ sizeof (struct
+ st_curve
+ **) *
+ (mtc->
+ curve_count +
+ 1));
+ if (mtc->curve != NULL)
+ {
+ mtc->curve_count++;
+ mtc->curve[mtc->curve_count - 1] = curve;
+
+ memset (curve, 0, sizeof (struct st_curve));
+ /* read crv speed and type */
+ curve->crv_speed = *buffer;
+ curve->crv_type = *(buffer + 1);
+ buffer += 2;
+
+ /* get length of step buffer */
+ while (*(buffer + curve->step_count) != 0)
+ curve->step_count++;
+
+ if (curve->step_count > 0)
+ {
+ /* allocate step buffer */
+ curve->step =
+ (SANE_Int *) malloc (sizeof (SANE_Int) *
+ curve->step_count);
+ if (curve->step != NULL)
+ {
+ memcpy (curve->step, buffer,
+ sizeof (SANE_Int) *
+ curve->step_count);
+ buffer += curve->step_count;
+ }
+ else
+ curve->step_count = 0;
+ }
+ }
+ else
+ {
+ mtc->curve_count = 0;
+ free (curve);
+ }
+ }
+ else
+ break;
+ }
+ break;
+ }
+ }
+ }
+ buffer++;
+ }
+ }
+
+ return rst;
+}
+
+static void
+Motor_Curve_Free (struct st_motorcurve **motorcurves, SANE_Int * mtc_count)
+{
+ if ((motorcurves != NULL) && (mtc_count != NULL))
+ {
+ struct st_motorcurve *mtc;
+ struct st_curve *curve;
+
+ while (*mtc_count > 0)
+ {
+ mtc = motorcurves[*mtc_count - 1];
+ if (mtc != NULL)
+ {
+ if (mtc->curve != NULL)
+ {
+ while (mtc->curve_count > 0)
+ {
+ curve = mtc->curve[mtc->curve_count - 1];
+ if (curve != NULL)
+ {
+ if (curve->step != NULL)
+ free (curve->step);
+
+ free (curve);
+ }
+ mtc->curve_count--;
+ }
+ }
+ free (mtc);
+ }
+ *mtc_count -= 1;
+ }
+
+ free (motorcurves);
+ }
+}
+
+static SANE_Byte
+RTS_Sensor_Type (USB_Handle usb_handle)
+{
+ /*
+ Returns sensor type
+ 01 = CCD
+ 00 = CIS
+ */
+
+ SANE_Int a, b, c;
+ SANE_Byte rst;
+
+ DBG (DBG_FNC, "+ RTS_Sensor_Type:\n");
+
+ a = b = c = 0;
+
+ /* Save data first */
+ Read_Word (usb_handle, 0xe950, &a);
+ Read_Word (usb_handle, 0xe956, &b);
+
+ /* Enables GPIO 0xe950 writing directly 0x13ff */
+ Write_Word (usb_handle, 0xe950, 0x13ff);
+ /* Sets GPIO 0xe956 writing 0xfcf0 */
+ Write_Word (usb_handle, 0xe956, 0xfcf0);
+ /* Makes a sleep of 200 ms */
+ usleep (1000 * 200);
+ /* Get GPIO 0xe968 */
+ Read_Word (usb_handle, 0xe968, &c);
+ /* Restore data */
+ Write_Word (usb_handle, 0xe950, a);
+ Write_Word (usb_handle, 0xe956, b);
+
+ rst = ((_B1 (c) & 1) == 0) ? CCD_SENSOR : CIS_SENSOR;
+
+ DBG (DBG_FNC, "- RTS_Sensor_Type: %s\n",
+ (rst == CCD_SENSOR) ? "CCD" : "CIS");
+
+ return rst;
+}
+
+static void
+Free_Scanmodes (struct st_device *dev)
+{
+ DBG (DBG_FNC, "> Free_Scanmodes\n");
+
+ if (dev->scanmodes != NULL)
+ {
+ if (dev->scanmodes_count > 0)
+ {
+ SANE_Int a;
+ for (a = 0; a < dev->scanmodes_count; a++)
+ if (dev->scanmodes[a] != NULL)
+ free (dev->scanmodes[a]);
+ }
+
+ free (dev->scanmodes);
+ dev->scanmodes = NULL;
+ }
+
+ dev->scanmodes_count = 0;
+}
+
+static SANE_Int
+Load_Scanmodes (struct st_device *dev)
+{
+ SANE_Int rst = OK;
+ SANE_Int a, b;
+ struct st_scanmode reg, *mode;
+
+ DBG (DBG_FNC, "> Load_Scanmodes\n");
+
+ if ((dev->scanmodes != NULL) || (dev->scanmodes_count > 0))
+ Free_Scanmodes (dev);
+
+ a = 0;
+ while ((cfg_scanmode_get (dev->sensorcfg->type, a, &reg) == OK)
+ && (rst == OK))
+ {
+ mode = (struct st_scanmode *) malloc (sizeof (struct st_scanmode));
+ if (mode != NULL)
+ {
+ memcpy (mode, &reg, sizeof (struct st_scanmode));
+
+ for (b = 0; b < 3; b++)
+ {
+ if (mode->mexpt[b] == 0)
+ {
+ mode->mexpt[b] = mode->ctpc;
+ if (mode->multiexposure != 1)
+ mode->expt[b] = mode->ctpc;
+ }
+ }
+
+ mode->ctpc = ((mode->ctpc + 1) * mode->multiexposure) - 1;
+
+ dev->scanmodes =
+ (struct st_scanmode **) realloc (dev->scanmodes,
+ (dev->scanmodes_count +
+ 1) *
+ sizeof (struct st_scanmode **));
+ if (dev->scanmodes != NULL)
+ {
+ dev->scanmodes[dev->scanmodes_count] = mode;
+ dev->scanmodes_count++;
+ }
+ else
+ rst = ERROR;
+ }
+ else
+ rst = ERROR;
+
+ a++;
+ }
+
+ if (rst == ERROR)
+ Free_Scanmodes (dev);
+
+ DBG (DBG_FNC, " -> Found %i scanmodes\n", dev->scanmodes_count);
+ dbg_scanmodes (dev);
+
+ return rst;
+}
+
+static void
+Free_Config (struct st_device *dev)
+{
+ DBG (DBG_FNC, "+ Free_Config\n");
+
+ /* free buttons */
+ Free_Buttons (dev);
+
+ /* free motor general configuration */
+ Free_Motor (dev);
+
+ /* free sensor main configuration */
+ Free_Sensor (dev);
+
+ /* free ccd sensor timing tables */
+ Free_Timings (dev);
+
+ /* free motor curves */
+ Free_MotorCurves (dev);
+
+ /* free motor movements */
+ Free_Motormoves (dev);
+
+ /* free scan modes */
+ Free_Scanmodes (dev);
+
+ /* free constrains */
+ Free_Constrains (dev);
+
+ /* free chipset configuration */
+ Free_Chipset (dev);
+
+ DBG (DBG_FNC, "- Free_Config\n");
+}
+
+static void
+Free_Chipset (struct st_device *dev)
+{
+ DBG (DBG_FNC, "> Free_Chipset\n");
+
+ if (dev->chipset != NULL)
+ {
+ if (dev->chipset->name != NULL)
+ free (dev->chipset->name);
+
+ free (dev->chipset);
+ dev->chipset = NULL;
+ }
+}
+
+static SANE_Int
+Load_Chipset (struct st_device *dev)
+{
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "> Load_Chipset\n");
+
+ if (dev->chipset != NULL)
+ Free_Chipset (dev);
+
+ dev->chipset = malloc (sizeof (struct st_chip));
+ if (dev->chipset != NULL)
+ {
+ SANE_Int model;
+
+ bzero (dev->chipset, sizeof (struct st_chip));
+
+ /* get chipset model of selected scanner */
+ model = cfg_chipset_model_get (RTS_Debug->dev_model);
+
+ /* get configuration for selected chipset */
+ rst = cfg_chipset_get (model, dev->chipset);
+ }
+
+ /* if rst == ERROR may be related to allocating space for chipset name */
+
+ return rst;
+}
+
+static SANE_Int
+Load_Config (struct st_device *dev)
+{
+ DBG (DBG_FNC, "+ Load_Config\n");
+
+ /* load chipset configuration */
+ Load_Chipset (dev);
+
+ /* load scanner's buttons */
+ Load_Buttons (dev);
+
+ /* load scanner area constrains */
+ Load_Constrains (dev);
+
+ /* load motor general configuration */
+ Load_Motor (dev);
+
+ /* load sensor main configuration */
+ Load_Sensor (dev);
+
+ if (dev->sensorcfg->type == -1)
+ /* get sensor from gpio */
+ dev->sensorcfg->type = RTS_Sensor_Type (dev->usb_handle);
+
+ /* load ccd sensor timing tables */
+ Load_Timings (dev);
+
+ /* load motor curves */
+ Load_MotorCurves (dev);
+
+ /* load motor movements */
+ Load_Motormoves (dev);
+
+ /* load scan modes */
+ Load_Scanmodes (dev);
+
+ /* deprecated */
+ if (dev->sensorcfg->type == CCD_SENSOR)
+ /* ccd */ usbfile =
+ (RTS_Debug->usbtype == USB20) ? T_RTINIFILE : T_USB1INIFILE;
+ else /* cis */
+ usbfile = (RTS_Debug->usbtype == USB20) ? S_RTINIFILE : S_USB1INIFILE;
+
+ scantype = ST_NORMAL;
+
+ pwmlamplevel = get_value (SCAN_PARAM, PWMLAMPLEVEL, 1, usbfile);
+
+ arrangeline2 = get_value (SCAN_PARAM, ARRANGELINE, FIX_BY_HARD, usbfile);
+
+ shadingbase = get_value (TRUE_GRAY_PARAM, SHADINGBASE, 3, usbfile);
+ shadingfact[0] = get_value (TRUE_GRAY_PARAM, SHADINGFACT1, 1, usbfile);
+ shadingfact[1] = get_value (TRUE_GRAY_PARAM, SHADINGFACT2, 1, usbfile);
+ shadingfact[2] = get_value (TRUE_GRAY_PARAM, SHADINGFACT3, 1, usbfile);
+
+ LoadImagingParams (dev, usbfile);
+
+ DBG (DBG_FNC, "- Load_Config\n");
+
+ return OK;
+}
+
+static SANE_Int
+LoadImagingParams (struct st_device *dev, SANE_Int inifile)
+{
+ DBG (DBG_FNC, "> LoadImagingParams(inifile='%i'):\n", inifile);
+
+ scan.startpos = get_value (SCAN_PARAM, STARTPOS, 0, inifile);
+ scan.leftleading = get_value (SCAN_PARAM, LEFTLEADING, 0, inifile);
+ arrangeline = get_value (SCAN_PARAM, ARRANGELINE, FIX_BY_HARD, inifile);
+ compression = get_value (SCAN_PARAM, COMPRESSION, 0, inifile);
+
+ /* get default gain and offset values */
+ cfg_gainoffset_get (dev->sensorcfg->type, default_gain_offset);
+
+ linedarlampoff = get_value (CALI_PARAM, LINEDARLAMPOFF, 0, inifile);
+
+ pixeldarklevel = get_value (CALI_PARAM, PIXELDARKLEVEL, 0x00ffff, inifile);
+
+ binarythresholdh = get_value (PLATFORM, BINARYTHRESHOLDH, 0x80, inifile);
+ binarythresholdl = get_value (PLATFORM, BINARYTHRESHOLDL, 0x7f, inifile);
+
+ return OK;
+}
+
+static SANE_Int
+Arrange_Colour (struct st_device *dev, SANE_Byte * buffer,
+ SANE_Int buffer_size, SANE_Int * transferred)
+{
+ /*
+ 05F0FA78 04EC00D8 /CALL to Assumed StdFunc2 from hpgt3970.04EC00D3
+ 05F0FA7C 05D10048 |Arg1 = 05D10048
+ 05F0FA80 0000F906 \Arg2 = 0000F906
+ */
+ SANE_Int mydistance;
+ SANE_Int Lines_Count;
+ SANE_Int space;
+ SANE_Int rst = OK;
+ SANE_Int c;
+ struct st_scanning *scn;
+
+ DBG (DBG_FNC, "> Arrange_Colour(*buffer, buffer_size=%i, *transferred)\n",
+ buffer_size);
+
+ /* this is just to make code more legible */
+ scn = dev->scanning;
+
+ if (scn->imagebuffer == NULL)
+ {
+ if (dev->sensorcfg->type == CCD_SENSOR)
+ mydistance =
+ (dev->sensorcfg->line_distance * scan2.resolution_y) /
+ dev->sensorcfg->resolution;
+ else
+ mydistance = 0;
+
+ /*aafa */
+ if (mydistance != 0)
+ {
+ scn->bfsize =
+ (scn->arrange_hres ==
+ TRUE) ? scn->arrange_sensor_evenodd_dist : 0;
+ scn->bfsize = (scn->bfsize + (mydistance * 2) + 1) * line_size;
+ }
+ else
+ scn->bfsize = line_size * 2;
+
+ /*ab3c */
+ space =
+ (((scn->bfsize / line_size) * bytesperline) >
+ scn->bfsize) ? (scn->bfsize / line_size) *
+ bytesperline : scn->bfsize;
+
+ scn->imagebuffer = (SANE_Byte *) malloc (space * sizeof (SANE_Byte));
+ if (scn->imagebuffer == NULL)
+ return ERROR;
+
+ scn->imagepointer = scn->imagebuffer;
+
+ if (Read_Block (dev, scn->bfsize, scn->imagebuffer, transferred) != OK)
+ return ERROR;
+
+ scn->arrange_orderchannel = FALSE;
+ scn->channel_size = (scan2.depth == 8) ? 1 : 2;
+
+ /* Calculate channel displacements */
+ for (c = CL_RED; c <= CL_BLUE; c++)
+ {
+ if (mydistance == 0)
+ {
+ /*ab9b */
+ if (scn->arrange_hres == FALSE)
+ {
+ if ((((dev->sensorcfg->line_distance * scan2.resolution_y) *
+ 2) / dev->sensorcfg->resolution) == 1)
+ scn->arrange_orderchannel = TRUE;
+
+ if (scn->arrange_orderchannel == TRUE)
+ scn->desp[c] =
+ ((dev->sensorcfg->rgb_order[c] / 2) * line_size) +
+ (scn->channel_size * c);
+ else
+ scn->desp[c] = scn->channel_size * c;
+ }
+ }
+ else
+ {
+ /*ac32 */
+ scn->desp[c] =
+ (dev->sensorcfg->rgb_order[c] * (mydistance * line_size)) +
+ (scn->channel_size * c);
+
+ if (scn->arrange_hres == TRUE)
+ {
+ scn->desp1[c] = scn->desp[c];
+ scn->desp2[c] =
+ ((scn->channel_size * 3) + scn->desp[c]) +
+ (scn->arrange_sensor_evenodd_dist * line_size);
+ }
+ }
+ }
+
+ /*ace2 */
+ for (c = CL_RED; c <= CL_BLUE; c++)
+ {
+ if (scn->arrange_hres == TRUE)
+ {
+ scn->pColour2[c] = scn->imagebuffer + scn->desp2[c];
+ scn->pColour1[c] = scn->imagebuffer + scn->desp1[c];
+ }
+ else
+ scn->pColour[c] = scn->imagebuffer + scn->desp[c];
+ }
+ }
+
+ /*ad91 */
+ Lines_Count = buffer_size / line_size;
+ while (Lines_Count > 0)
+ {
+ if (scn->arrange_orderchannel == FALSE)
+ {
+ if (scn->arrange_hres == TRUE)
+ Triplet_Colour_HRes (scn->pColour1[CL_RED],
+ scn->pColour1[CL_GREEN],
+ scn->pColour1[CL_BLUE],
+ scn->pColour2[CL_RED],
+ scn->pColour2[CL_GREEN],
+ scn->pColour2[CL_BLUE], buffer,
+ line_size / (scn->channel_size * 3));
+ else
+ Triplet_Colour_LRes (line_size / (scn->channel_size * 3), buffer,
+ scn->pColour[CL_RED], scn->pColour[CL_GREEN],
+ scn->pColour[CL_BLUE]);
+ }
+ else
+ Triplet_Colour_Order (dev, scn->pColour[CL_RED],
+ scn->pColour[CL_GREEN], scn->pColour[CL_BLUE],
+ buffer, line_size / (scn->channel_size * 3));
+
+ scn->arrange_size -= bytesperline;
+ if (scn->arrange_size < 0)
+ v15bc--;
+
+ buffer += line_size;
+
+ Lines_Count--;
+ if (Lines_Count == 0)
+ {
+ if ((scn->arrange_size | v15bc) == 0)
+ return OK;
+ }
+
+ if (Read_Block (dev, line_size, scn->imagepointer, transferred) ==
+ ERROR)
+ return ERROR;
+
+ /* Update displacements */
+ for (c = CL_RED; c <= CL_BLUE; c++)
+ {
+ if (scn->arrange_hres == TRUE)
+ {
+ /*aeb7 */
+ scn->desp2[c] = (scn->desp2[c] + line_size) % scn->bfsize;
+ scn->desp1[c] = (scn->desp1[c] + line_size) % scn->bfsize;
+
+ scn->pColour2[c] = scn->imagebuffer + scn->desp2[c];
+ scn->pColour1[c] = scn->imagebuffer + scn->desp1[c];
+ }
+ else
+ {
+ /*af86 */
+ scn->desp[c] = (scn->desp[c] + line_size) % scn->bfsize;
+ scn->pColour[c] = scn->imagebuffer + scn->desp[c];
+ }
+ }
+
+ /*aff3 */
+ scn->imagepointer += line_size;
+ if (scn->imagepointer >= (scn->imagebuffer + scn->bfsize))
+ scn->imagepointer = scn->imagebuffer;
+ }
+
+ return rst;
+}
+
+static SANE_Int
+RTS_Scanner_SetParams (struct st_device *dev, struct params *param)
+{
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "+ RTS_Scanner_SetParams:\n");
+ DBG (DBG_FNC, "-> param->resolution_x=%i\n", param->resolution_x);
+ DBG (DBG_FNC, "-> param->resolution_y=%i\n", param->resolution_y);
+ DBG (DBG_FNC, "-> param->left =%i\n", param->coords.left);
+ DBG (DBG_FNC, "-> param->width =%i\n", param->coords.width);
+ DBG (DBG_FNC, "-> param->top =%i\n", param->coords.top);
+ DBG (DBG_FNC, "-> param->height =%i\n", param->coords.height);
+ DBG (DBG_FNC, "-> param->colormode =%s\n",
+ dbg_colour (param->colormode));
+ DBG (DBG_FNC, "-> param->scantype =%s\n",
+ dbg_scantype (param->scantype));
+ DBG (DBG_FNC, "-> param->depth =%i\n", param->depth);
+ DBG (DBG_FNC, "-> param->channel =%i\n", param->channel);
+
+ /* validate area size to scan */
+ if ((param->coords.width != 0) && (param->coords.height != 0))
+ {
+ SANE_Byte mybuffer[1];
+ struct st_hwdconfig hwdcfg;
+
+ /* setting coordinates */
+ memcpy (&scan.coord, &param->coords, sizeof (struct st_coords));
+
+ /* setting resolution */
+ scan.resolution_x = param->resolution_x;
+ scan.resolution_y = param->resolution_y;
+
+ /* setting colormode and depth */
+ scan.colormode = param->colormode;
+ scan.depth = (param->colormode == CM_LINEART) ? 8 : param->depth;
+
+ /* setting color channel for non color scans */
+ scan.channel = _B0 (param->channel);
+
+ arrangeline = FIX_BY_HARD;
+ if ((scan.resolution_x == 2400) || ((scan.resolution_x == 4800)))
+ {
+ if (scan.colormode != CM_COLOR)
+ {
+ if (scan.colormode == CM_GRAY)
+ {
+ if (scan.channel == 3)
+ arrangeline = FIX_BY_SOFT;
+ }
+ }
+ else
+ arrangeline = FIX_BY_SOFT;
+ }
+
+ /* setting scan type */
+ if ((param->scantype > 0) && (param->scantype < 4))
+ scan.scantype = param->scantype;
+ else
+ scan.scantype = ST_NORMAL;
+
+ /* setting scanner lamp */
+ data_bitset (&dev->init_regs[0x146], 0x40,
+ ((dev->sensorcfg->type == CIS_SENSOR) ? 0 : 1));
+
+ /* turn on appropiate lamp */
+ if (scan.scantype == ST_NORMAL)
+ Lamp_Status_Set (dev, NULL, TRUE, FLB_LAMP);
+ else
+ Lamp_Status_Set (dev, NULL, TRUE, TMA_LAMP);
+
+ mybuffer[0] = 0;
+ if (RTS_IsExecuting (dev, mybuffer) == FALSE)
+ RTS_WriteRegs (dev->usb_handle, dev->init_regs);
+
+ if (scan.depth == 16)
+ compression = FALSE;
+
+ /* resetting low level config */
+ bzero (&hwdcfg, sizeof (struct st_hwdconfig));
+
+ /* setting low level config */
+ hwdcfg.scantype = scan.scantype;
+ hwdcfg.calibrate = mybuffer[0];
+ hwdcfg.arrangeline = arrangeline; /*1 */
+ hwdcfg.highresolution = (scan.resolution_x > 1200) ? TRUE : FALSE;
+ hwdcfg.sensorevenodddistance = dev->sensorcfg->evenodd_distance;
+
+ SetScanParams (dev, dev->init_regs, &scan, &hwdcfg);
+
+ scan.shadinglength =
+ (((scan.sensorresolution * 17) / 2) + 3) & 0xfffffffc;
+
+ rst = OK;
+ }
+
+ DBG (DBG_FNC, "- RTS_Scanner_SetParams: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+SetScanParams (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg, struct st_hwdconfig *hwdcfg)
+{
+ struct st_coords mycoords;
+ SANE_Int mycolormode;
+ SANE_Int myvalue;
+ SANE_Int mymode;
+ SANE_Int channel_size;
+ SANE_Int channel_count;
+ SANE_Int dots_per_block;
+ SANE_Int aditional_dots;
+
+ DBG (DBG_FNC, "+ SetScanParams:\n");
+ dbg_ScanParams (scancfg);
+ dbg_hwdcfg (hwdcfg);
+
+ bzero (&mycoords, sizeof (struct st_coords));
+ /* Copy scancfg to scan2 */
+ memcpy (&scan2, scancfg, sizeof (struct st_scanparams));
+
+ mycolormode = scancfg->colormode;
+ myvalue = scancfg->colormode;
+ scantype = hwdcfg->scantype;
+
+ if (scancfg->colormode == CM_LINEART)
+ scan2.depth = 8;
+
+ if ((scancfg->colormode != CM_COLOR) && (scancfg->channel == 3)) /*channel = 0x00 */
+ {
+ if (scancfg->colormode == CM_GRAY)
+ {
+ mycolormode = (hwdcfg->arrangeline != FIX_BY_SOFT) ? 3 : CM_COLOR;
+ }
+ else
+ mycolormode = 3;
+ myvalue = mycolormode;
+ }
+
+ dev->Resize->resolution_x = scancfg->resolution_x;
+ dev->Resize->resolution_y = scancfg->resolution_y;
+
+ mymode = RTS_GetScanmode (dev, hwdcfg->scantype, myvalue, scancfg->resolution_x); /*0x0b */
+ if (mymode == -1)
+ {
+ /* Non supported resolution. We will resize image after scanning */
+ SANE_Int fitres;
+
+ fitres =
+ Scanmode_fitres (dev, hwdcfg->scantype, scancfg->colormode,
+ scancfg->resolution_x);
+ if (fitres != -1)
+ {
+ /* supported resolution found */
+ dev->Resize->type = RSZ_DECREASE;
+ }
+ else
+ {
+ dev->Resize->type = RSZ_INCREASE;
+ fitres =
+ Scanmode_maxres (dev, hwdcfg->scantype, scancfg->colormode);
+ }
+
+ scan2.resolution_x = fitres;
+ scan2.resolution_y = fitres;
+
+ mymode =
+ RTS_GetScanmode (dev, hwdcfg->scantype, myvalue, scan2.resolution_x);
+ if (mymode == -1)
+ return ERROR;
+
+ imageheight = scancfg->coord.height;
+ dev->Resize->towidth = scancfg->coord.width;
+
+ /* Calculate coords for new resolution */
+ mycoords.left =
+ (scan2.resolution_x * scancfg->coord.left) /
+ dev->Resize->resolution_x;
+ mycoords.width =
+ (scan2.resolution_x * scancfg->coord.width) /
+ dev->Resize->resolution_x;
+ mycoords.top =
+ (scan2.resolution_y * scancfg->coord.top) / dev->Resize->resolution_y;
+ mycoords.height =
+ ((scan2.resolution_y * scancfg->coord.height) /
+ dev->Resize->resolution_y) + 2;
+
+ switch (scan2.colormode)
+ {
+ case CM_GRAY:
+ if ((dev->scanmodes[mymode]->samplerate == PIXEL_RATE)
+ && (mycolormode != 3))
+ dev->Resize->towidth *= 2;
+
+ channel_size = (scan2.depth == 8) ? 1 : 2;
+ dev->Resize->mode = (scan2.depth == 8) ? RSZ_GRAYL : RSZ_GRAYH;
+ dev->Resize->bytesperline = dev->Resize->towidth * channel_size;
+ break;
+ case CM_LINEART:
+ if (dev->scanmodes[mymode]->samplerate == PIXEL_RATE)
+ dev->Resize->towidth *= 2;
+
+ dev->Resize->mode = RSZ_LINEART;
+ dev->Resize->bytesperline = (dev->Resize->towidth + 7) / 8;
+ break;
+ default: /*CM_COLOR */
+ channel_count = 3;
+ channel_size = (scan2.depth == 8) ? 1 : 2;
+ dev->Resize->mode = (scan2.depth == 8) ? RSZ_COLOURL : RSZ_COLOURH;
+ dev->Resize->bytesperline =
+ scancfg->coord.width * (channel_count * channel_size);
+ break;
+ }
+ }
+ else
+ {
+ /* Supported scanmode */
+ dev->Resize->type = RSZ_NONE;
+ scan2.resolution_x = scancfg->resolution_x;
+ scan2.resolution_y = scancfg->resolution_y;
+ mycoords.left = scancfg->coord.left;
+ mycoords.top = scancfg->coord.top;
+ mycoords.width = scancfg->coord.width;
+ mycoords.height = scancfg->coord.height;
+ }
+
+ scancfg->timing = dev->scanmodes[mymode]->timing;
+
+ scan2.sensorresolution = dev->timings[scancfg->timing]->sensorresolution;
+ if ((scantype > 0) && (scantype < 5))
+ scan2.shadinglength =
+ (((scan2.sensorresolution * 17) / 2) + 3) & 0xfffffffc;
+
+ scancfg->sensorresolution = scan2.sensorresolution;
+ scancfg->shadinglength = scan2.shadinglength;
+
+ dev->scanning->arrange_compression = ((mycolormode != CM_LINEART)
+ && (scan2.depth <=
+ 8)) ? hwdcfg->compression : FALSE;
+
+ if ((arrangeline2 == FIX_BY_HARD) || (mycolormode == CM_LINEART))
+ arrangeline2 = mycolormode; /*¿? */
+ else if ((mycolormode == CM_GRAY) && (hwdcfg->highresolution == FALSE))
+ arrangeline2 = 0;
+
+ if (hwdcfg->highresolution == FALSE)
+ {
+ /* resolution < 1200 dpi */
+ dev->scanning->arrange_hres = FALSE;
+ dev->scanning->arrange_sensor_evenodd_dist = 0;
+ }
+ else
+ {
+ /* resolution > 1200 dpi */
+ dev->scanning->arrange_hres = TRUE;
+ dev->scanning->arrange_sensor_evenodd_dist =
+ hwdcfg->sensorevenodddistance;
+ }
+
+ /* with must be adjusted to fit in the dots count per block */
+ aditional_dots = 0;
+ if (mycolormode != CM_LINEART)
+ {
+ dots_per_block = ((scan2.resolution_x > 2400)
+ && (scancfg->samplerate == PIXEL_RATE)) ? 8 : 4;
+
+ /* fit width */
+ if ((mycoords.width % dots_per_block) != 0)
+ {
+ aditional_dots = dots_per_block - (mycoords.width % dots_per_block);
+ mycoords.width += aditional_dots;
+ }
+ }
+ else
+ {
+ /* Lineart */
+ dots_per_block = 32 - (mycoords.width & 0x1f);
+ if (dots_per_block < 32)
+ {
+ mycoords.width += dots_per_block;
+ aditional_dots = (dots_per_block / 8);
+ }
+ }
+
+ DBG (DBG_FNC, " -> dots_per_block: %i\n", dots_per_block);
+ DBG (DBG_FNC, " -> aditional_dots: %i\n", aditional_dots);
+
+ if (mycolormode == CM_LINEART)
+ {
+ bytesperline =
+ (dev->scanmodes[mymode]->samplerate ==
+ PIXEL_RATE) ? mycoords.width / 4 : mycoords.width / 8;
+ imagewidth3 = bytesperline;
+ lineart_width = bytesperline * 8;
+ line_size = bytesperline - aditional_dots;
+ dev->Resize->fromwidth = line_size * 8;
+ }
+ else
+ {
+ /*4510 */
+ switch (mycolormode)
+ {
+ case CM_COLOR:
+ channel_count = 3;
+ break;
+ case 3:
+ channel_count = 1;
+ break;
+ case CM_GRAY:
+ channel_count = (dev->scanmodes[mymode]->samplerate == PIXEL_RATE) ? 2 : 1; /*1 */
+ break;
+ }
+
+ channel_size = (scan2.depth == 8) ? 1 : 2;
+ bytesperline = mycoords.width * (channel_count * channel_size);
+ imagewidth3 = bytesperline / channel_count;
+ lineart_width = imagewidth3 / channel_size;
+ line_size =
+ bytesperline - (aditional_dots * (channel_count * channel_size));
+ dev->Resize->fromwidth = line_size / (channel_count * channel_size);
+ }
+
+ imagesize = mycoords.height * bytesperline;
+ v15b4 = 0;
+ dev->scanning->arrange_size = imagesize;
+ v15bc = 0;
+
+ /* set resolution ratio */
+ data_bitset (&Regs[0xc0], 0x1f,
+ scancfg->sensorresolution / scancfg->resolution_x);
+
+ scancfg->coord.left = mycoords.left;
+ scancfg->coord.top = mycoords.top;
+ scancfg->coord.width = mycoords.width;
+ scancfg->coord.height = mycoords.height;
+ scancfg->resolution_x = scan2.resolution_x;
+ scancfg->resolution_y = scan2.resolution_y;
+
+ myvalue =
+ (dev->Resize->type == RSZ_NONE) ? line_size : dev->Resize->bytesperline;
+ scancfg->bytesperline = bytesperline;
+
+ scancfg->v157c = myvalue;
+
+ if (scan.colormode != CM_COLOR)
+ {
+ if (mycolormode == CM_COLOR)
+ scancfg->v157c = (scancfg->v157c / 3);
+ }
+
+ if (scan.colormode == CM_LINEART)
+ {
+ if (mycolormode == 3)
+ {
+ scancfg->v157c = (scancfg->v157c + 7) / 8;
+ scancfg->bytesperline = (scancfg->bytesperline + 7) / 8;
+ }
+ }
+
+ DBG (DBG_FNC, "- SetScanParams:\n");
+
+ return OK;
+}
+
+static SANE_Int
+GainOffset_Counter_Save (struct st_device *dev, SANE_Byte data)
+{
+ SANE_Int rst = OK;
+
+ DBG (DBG_FNC, "> GainOffset_Counter_Save(data=%i):\n", data);
+
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ {
+ data = min (data, 0x0f);
+ rst = RTS_EEPROM_WriteByte (dev->usb_handle, 0x0077, data);
+ }
+
+ return rst;
+}
+
+static SANE_Int
+GainOffset_Counter_Inc (struct st_device *dev, SANE_Int * arg1)
+{
+ SANE_Byte count;
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ GainOffset_Counter_Inc:\n");
+
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ {
+ count = GainOffset_Counter_Load (dev);
+ if ((count >= 0x0f) || (GainOffset_Get (dev) != OK))
+ {
+ offset[CL_BLUE] = offset[CL_GREEN] = offset[CL_RED] = 0;
+ gain[CL_BLUE] = gain[CL_GREEN] = gain[CL_RED] = 0;
+ count = 0;
+ }
+ else
+ {
+ count++;
+ if (arg1 != NULL)
+ *arg1 = 1;
+ }
+
+ rst = GainOffset_Counter_Save (dev, count);
+ }
+ else
+ rst = OK;
+
+ DBG (DBG_FNC, "- GainOffset_Counter_Inc: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+GainOffset_Get (struct st_device *dev)
+{
+ SANE_Int a, data, rst;
+ SANE_Byte checksum;
+
+ DBG (DBG_FNC, "+ GainOffset_Get:\n");
+
+ checksum = 0;
+
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ {
+ /* get current checksum */
+ if (RTS_EEPROM_ReadByte (dev->usb_handle, 0x76, &checksum) == OK)
+ {
+ rst = OK;
+
+ /* read gain and offset values from EEPROM */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ if (RTS_EEPROM_ReadWord (dev->usb_handle, 0x70 + (2 * a), &data)
+ == ERROR)
+ {
+ rst = ERROR;
+ break;
+ }
+ else
+ offset[a] = data;
+ }
+
+ /* check checksum */
+ checksum =
+ _B0 (checksum + offset[CL_GREEN] + offset[CL_BLUE] +
+ offset[CL_RED]);
+ }
+ else
+ rst = ERROR;
+ }
+ else
+ rst = ERROR;
+
+ /* extract gain and offset values */
+ if ((rst == OK) && (checksum == 0x5b))
+ {
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ gain[a] = (offset[a] >> 9) & 0x1f;
+ offset[a] &= 0x01ff;
+ }
+ }
+ else
+ {
+ /* null values, let's reset them */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ gain[a] = 0;
+ offset[a] = 0;
+ }
+
+ rst = ERROR;
+ }
+
+ DBG (DBG_FNC,
+ "-> Preview gainR=%i, gainG=%i, gainB=%i, offsetR=%i, offsetG=%i, offsetB=%i\n",
+ gain[CL_RED], gain[CL_GREEN], gain[CL_BLUE], offset[CL_RED],
+ offset[CL_GREEN], offset[CL_BLUE]);
+
+ DBG (DBG_FNC, "- GainOffset_Get: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Scanmode_maxres (struct st_device *dev, SANE_Int scantype, SANE_Int colormode)
+{
+ /* returns position in scanmodes table where data fits with given arguments */
+ SANE_Int rst = 0;
+ SANE_Int a;
+ struct st_scanmode *reg;
+
+ for (a = 0; a < dev->scanmodes_count; a++)
+ {
+ reg = dev->scanmodes[a];
+ if (reg != NULL)
+ {
+ if ((reg->scantype == scantype) && (reg->colormode == colormode))
+ rst = max (rst, reg->resolution); /* found ! */
+ }
+ }
+
+ if (rst == 0)
+ {
+ /* There isn't any mode for these arguments.
+ Most devices doesn't support specific setup to scan in lineart mode
+ so they use gray colormode. Lets check this case */
+ if (colormode == CM_LINEART)
+ rst = Scanmode_maxres (dev, scantype, CM_GRAY);
+ }
+
+ DBG (DBG_FNC, "> Scanmode_maxres(scantype=%s, colormode=%s): %i\n",
+ dbg_scantype (scantype), dbg_colour (colormode), rst);
+
+ return rst;
+}
+
+static SANE_Int
+Scanmode_minres (struct st_device *dev, SANE_Int scantype, SANE_Int colormode)
+{
+ /* returns position in scanmodes table where data fits with given arguments */
+ SANE_Int rst, a;
+ struct st_scanmode *reg;
+
+ rst = Scanmode_maxres (dev, scantype, colormode);
+
+ for (a = 0; a < dev->scanmodes_count; a++)
+ {
+ reg = dev->scanmodes[a];
+ if (reg != NULL)
+ {
+ if ((reg->scantype == scantype) && (reg->colormode == colormode))
+ rst = min (rst, reg->resolution); /* found ! */
+ }
+ }
+
+ if (rst == 0)
+ {
+ /* There isn't any mode for these arguments.
+ Most devices doesn't support specific setup to scan in lineart mode
+ so they use gray colormode. Lets check this case */
+ if (colormode == CM_LINEART)
+ rst = Scanmode_minres (dev, scantype, CM_GRAY);
+ }
+
+ DBG (DBG_FNC, "> Scanmode_minres(scantype=%s, colormode=%s): %i\n",
+ dbg_scantype (scantype), dbg_colour (colormode), rst);
+
+ return rst;
+}
+
+static SANE_Int
+Scanmode_fitres (struct st_device *dev, SANE_Int scantype, SANE_Int colormode,
+ SANE_Int resolution)
+{
+ /* returns a supported resolution */
+ SANE_Int rst;
+ SANE_Int a, nullres;
+ struct st_scanmode *reg;
+
+ nullres = Scanmode_maxres (dev, scantype, colormode) + 1;
+ rst = nullres;
+
+ for (a = 0; a < dev->scanmodes_count; a++)
+ {
+ reg = dev->scanmodes[a];
+ if (reg != NULL)
+ {
+ if ((reg->scantype == scantype) && (reg->colormode == colormode))
+ {
+ if ((reg->resolution < rst) && (resolution <= reg->resolution))
+ rst = reg->resolution;
+ }
+ }
+ }
+
+ if (rst == nullres)
+ {
+ /* There isn't any mode for these arguments.
+ Most devices doesn't support specific setup to scan in lineart mode
+ so they use gray colormode. Lets check this case */
+ if (colormode != CM_LINEART)
+ {
+ /* at this point, given resolution is bigger than maximum supported resolution */
+ rst = -1;
+ }
+ else
+ rst = Scanmode_minres (dev, scantype, CM_GRAY);
+ }
+
+ DBG (DBG_FNC,
+ "> Scanmode_fitres(scantype=%s, colormode=%s, resolution=%i): %i\n",
+ dbg_scantype (scantype), dbg_colour (colormode), resolution, rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_GetScanmode (struct st_device *dev, SANE_Int scantype, SANE_Int colormode,
+ SANE_Int resolution)
+{
+ /* returns position in scanmodes table where data fits with given arguments */
+ SANE_Int rst = -1;
+ SANE_Int a;
+ struct st_scanmode *reg;
+
+ for (a = 0; a < dev->scanmodes_count; a++)
+ {
+ reg = dev->scanmodes[a];
+ if (reg != NULL)
+ {
+ if ((reg->scantype == scantype) && (reg->colormode == colormode)
+ && (reg->resolution == resolution))
+ {
+ /* found ! */
+ rst = a;
+ break;
+ }
+ }
+ }
+
+ if (rst == -1)
+ {
+ /* There isn't any mode for these arguments.
+ May be given resolution isn't supported by chipset.
+ Most devices doesn't support specific setup to scan in lineart mode
+ so they use gray colormode. Lets check this case */
+ if ((colormode == CM_LINEART) || (colormode == 3))
+ rst = RTS_GetScanmode (dev, scantype, CM_GRAY, resolution);
+ }
+
+ DBG (DBG_FNC,
+ "> RTS_GetScanmode(scantype=%s, colormode=%s, resolution=%i): %i\n",
+ dbg_scantype (scantype), dbg_colour (colormode), resolution, rst);
+
+ return rst;
+}
+
+static void
+Free_Motor (struct st_device *dev)
+{
+ /* this function releases space for stepper motor */
+
+ DBG (DBG_FNC, "> Free_Motor\n");
+
+ if (dev->motorcfg != NULL)
+ {
+ free (dev->motorcfg);
+ dev->motorcfg = NULL;
+ }
+}
+
+static SANE_Int
+Load_Motor (struct st_device *dev)
+{
+ /* this function loads general configuration for motor */
+
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "> Load_Motor\n");
+
+ if (dev->motorcfg != NULL)
+ Free_Motor (dev);
+
+ dev->motorcfg = malloc (sizeof (struct st_motorcfg));
+ if (dev->motorcfg != NULL)
+ {
+ rst = cfg_motor_get (dev->motorcfg);
+ dbg_motorcfg (dev->motorcfg);
+ }
+
+ return rst;
+}
+
+static void
+Free_Sensor (struct st_device *dev)
+{
+ /* this function releases space for ccd sensor */
+
+ DBG (DBG_FNC, "> Free_Sensor\n");
+
+ if (dev->sensorcfg != NULL)
+ {
+ free (dev->sensorcfg);
+ dev->sensorcfg = NULL;
+ }
+}
+
+static void
+Free_Buttons (struct st_device *dev)
+{
+ /* this function releases space for buttons */
+
+ DBG (DBG_FNC, "> Free_Buttons\n");
+
+ if (dev->buttons != NULL)
+ {
+ free (dev->buttons);
+ dev->buttons = NULL;
+ }
+}
+
+static SANE_Int
+Load_Buttons (struct st_device *dev)
+{
+ /* this function loads configuration for ccd sensor */
+
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "> Load_Buttons\n");
+
+ if (dev->buttons != NULL)
+ Free_Buttons (dev);
+
+ dev->buttons = malloc (sizeof (struct st_buttons));
+ if (dev->buttons != NULL)
+ {
+ rst = cfg_buttons_get (dev->buttons);
+ dbg_buttons (dev->buttons);
+ }
+
+ return rst;
+}
+
+static SANE_Int
+Load_Sensor (struct st_device *dev)
+{
+ /* this function loads configuration for ccd sensor */
+
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "> Load_Sensor\n");
+
+ if (dev->sensorcfg != NULL)
+ Free_Sensor (dev);
+
+ dev->sensorcfg = malloc (sizeof (struct st_sensorcfg));
+ if (dev->sensorcfg != NULL)
+ {
+ rst = cfg_sensor_get (dev->sensorcfg);
+ dbg_sensor (dev->sensorcfg);
+ }
+
+ return rst;
+}
+
+static void
+Free_Timings (struct st_device *dev)
+{
+ /* this function frees all ccd sensor timing tables */
+ DBG (DBG_FNC, "> Free_Timings\n");
+
+ if (dev->timings != NULL)
+ {
+ if (dev->timings_count > 0)
+ {
+ SANE_Int a;
+ for (a = 0; a < dev->timings_count; a++)
+ if (dev->timings[a] != NULL)
+ free (dev->timings[a]);
+
+ dev->timings_count = 0;
+ }
+
+ free (dev->timings);
+ dev->timings = NULL;
+ }
+}
+
+static SANE_Int
+Load_Timings (struct st_device *dev)
+{
+ SANE_Int rst = OK;
+ SANE_Int a;
+ struct st_timing reg, *tmg;
+
+ DBG (DBG_FNC, "> Load_Timings\n");
+
+ if (dev->timings != NULL)
+ Free_Timings (dev);
+
+ a = 0;
+
+ while ((cfg_timing_get (dev->sensorcfg->type, a, &reg) == OK)
+ && (rst == OK))
+ {
+ tmg = (struct st_timing *) malloc (sizeof (struct st_timing));
+ if (tmg != NULL)
+ {
+ memcpy (tmg, &reg, sizeof (struct st_timing));
+
+ dev->timings_count++;
+ dev->timings =
+ (struct st_timing **) realloc (dev->timings,
+ sizeof (struct st_timing **) *
+ dev->timings_count);
+ if (dev->timings == NULL)
+ {
+ rst = ERROR;
+ dev->timings_count = 0;
+ }
+ else
+ dev->timings[dev->timings_count - 1] = tmg;
+ }
+ else
+ rst = ERROR;
+
+ a++;
+ }
+
+ if (rst == ERROR)
+ Free_Timings (dev);
+
+ DBG (DBG_FNC, " -> Found %i timing registers\n", dev->timings_count);
+
+ return rst;
+}
+
+static SANE_Int
+IsScannerLinked (struct st_device *dev)
+{
+ SANE_Int var2;
+ SANE_Byte lamp;
+
+ DBG (DBG_FNC, "+ IsScannerLinked:\n");
+
+ Read_FE3E (dev, &v1619);
+ Init_USBData (dev);
+ scan.scantype = ST_NORMAL;
+
+ RTS_WaitInitEnd (dev, 0x30000);
+
+ lamp = FLB_LAMP;
+
+ /* Comprobar si es la primera conexión con el escaner */
+ if (Read_Word (dev->usb_handle, 0xe829, &var2) == OK)
+ {
+ SANE_Int firstconnection;
+
+#ifdef STANDALONE
+ firstconnection = TRUE;
+#else
+ firstconnection = (var2 == 0) ? TRUE : FALSE;
+#endif
+
+ if (firstconnection == TRUE)
+ {
+ /* primera conexión */
+ SANE_Byte flb_lamp, tma_lamp;
+
+ flb_lamp = 0;
+ tma_lamp = 0;
+ Lamp_Status_Get (dev, &flb_lamp, &tma_lamp);
+
+ if ((flb_lamp == 0) && (tma_lamp != 0))
+ lamp = TMA_LAMP;
+
+ /*Clear GainOffset count */
+ GainOffset_Clear (dev);
+ GainOffset_Counter_Save (dev, 0);
+
+ /* Clear AutoRef count */
+ Refs_Counter_Save (dev, 0);
+
+ Buttons_Enable (dev);
+ Lamp_Status_Timer_Set (dev, 13);
+ }
+ else
+ lamp = (_B0 (var2) == 0) ? FLB_LAMP : TMA_LAMP;
+ }
+
+ if (RTS_Warm_Reset (dev) != OK)
+ return ERROR;
+
+ Head_ParkHome (dev, TRUE, dev->motorcfg->parkhomemotormove);
+
+ Lamp_Status_Timer_Set (dev, 13);
+
+ /* Use fixed pwm? */
+ if (RTS_Debug->use_fixed_pwm != FALSE)
+ {
+ Lamp_PWM_Save (dev, cfg_fixedpwm_get (dev->sensorcfg->type, ST_NORMAL));
+ /* Lets enable using fixed pwm */
+ Lamp_PWM_SaveStatus (dev, TRUE);
+ }
+
+ Lamp_PWM_Setup (dev, lamp);
+
+ DBG (DBG_FNC, "- IsScannerLinked:\n");
+
+ return OK;
+}
+
+static SANE_Int
+Lamp_PWM_SaveStatus (struct st_device *dev, SANE_Byte status)
+{
+ SANE_Byte mypwm;
+ SANE_Int rst = OK;
+
+ DBG (DBG_FNC, "+ Lamp_PWM_SaveStatus(status=%i):\n", status);
+
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ {
+ rst = ERROR;
+
+ if (RTS_EEPROM_ReadByte (dev->usb_handle, 0x007b, &mypwm) == OK)
+ {
+ mypwm = (status == FALSE) ? mypwm & 0x7f : mypwm | 0x80;
+
+ if (RTS_EEPROM_WriteByte (dev->usb_handle, 0x007b, mypwm) == OK)
+ rst = OK;
+ }
+ }
+
+ DBG (DBG_FNC, "- Lamp_PWM_SaveStatus: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Lamp_PWM_Save (struct st_device *dev, SANE_Int fixedpwm)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ Lamp_PWM_Save(fixedpwm=%i):\n", fixedpwm);
+
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ rst =
+ RTS_EEPROM_WriteByte (dev->usb_handle, 0x7b, ((fixedpwm << 2) | 0x80));
+ else
+ rst = OK;
+
+ DBG (DBG_FNC, "- Lamp_PWM_Save: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Lamp_PWM_Setup (struct st_device *dev, SANE_Int lamp)
+{
+ SANE_Int rst = OK;
+
+ DBG (DBG_FNC, "+ Lamp_PWM_Setup(lamp=%s):\n",
+ (lamp == FLB_LAMP) ? "FLB_LAMP" : "TMA_LAMP");
+
+ if (Lamp_PWM_use (dev, 1) == OK)
+ {
+ SANE_Int fixedpwm, currentpwd;
+
+ currentpwd = 0;
+ fixedpwm =
+ cfg_fixedpwm_get (dev->sensorcfg->type,
+ (lamp == FLB_LAMP) ? ST_NORMAL : ST_TA);
+
+ if (Lamp_PWM_DutyCycle_Get (dev, &currentpwd) == OK)
+ {
+ /* set duty cycle if current one is different */
+ if (currentpwd != fixedpwm)
+ rst = Lamp_PWM_DutyCycle_Set (dev, fixedpwm);
+ }
+ else
+ rst = Lamp_PWM_DutyCycle_Set (dev, fixedpwm);
+ }
+
+ DBG (DBG_FNC, "- Lamp_PWM_Setup: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Lamp_PWM_DutyCycle_Get (struct st_device *dev, SANE_Int * data)
+{
+ SANE_Byte a;
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "+ Lamp_PWM_DutyCycle_Get:\n");
+
+ if (Read_Byte (dev->usb_handle, 0xe948, &a) == OK)
+ {
+ *data = a & 0x3f;
+ rst = OK;
+ }
+
+ DBG (DBG_FNC, "- Lamp_PWM_DutyCycle_Get = %i: %i\n", *data, rst);
+
+ return rst;
+}
+
+static SANE_Int
+Lamp_PWM_DutyCycle_Set (struct st_device *dev, SANE_Int duty_cycle)
+{
+ SANE_Byte *Regs;
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ Lamp_PWM_DutyCycle_Set(duty_cycle=%i):\n", duty_cycle);
+
+ rst = ERROR;
+
+ Regs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
+ if (Regs != NULL)
+ {
+ if (RTS_ReadRegs (dev->usb_handle, Regs) == OK)
+ {
+ data_bitset (&Regs[0x148], 0x3f, duty_cycle);
+
+ if (pwmlamplevel == 0)
+ {
+ data_bitset (&Regs[0x148], 0x40, 0);
+ Regs[0x1e0] |= ((duty_cycle >> 1) & 0x40);
+ }
+
+ data_bitset (&dev->init_regs[0x148], 0x7f, Regs[0x148]);
+ data_bitset (&dev->init_regs[0x1e0], 0x3f, Regs[0x1e0]);
+
+ Write_Byte (dev->usb_handle, 0xe948, Regs[0x0148]);
+
+ rst = Write_Byte (dev->usb_handle, 0xe9e0, Regs[0x01e0]);
+ }
+
+ free (Regs);
+ }
+
+ DBG (DBG_FNC, "- Lamp_PWM_DutyCycle_Set: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Head_ParkHome (struct st_device *dev, SANE_Int bWait, SANE_Int movement)
+{
+ SANE_Int rst = ERROR;
+ SANE_Byte *Regs;
+
+ DBG (DBG_FNC, "+ Head_ParkHome(bWait=%i, movement=%i):\n", bWait, movement);
+
+ Regs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
+ if (Regs != NULL)
+ {
+ rst = OK;
+
+ memcpy (Regs, dev->init_regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+
+ /* Lets wait if it's required when is already executing */
+ if (bWait != FALSE)
+ {
+ if (RTS_WaitScanEnd (dev, 0x3a98) != OK)
+ {
+ DBG (DBG_FNC, " -> Head_ParkHome: RTS_WaitScanEnd Timeout\n");
+ rst = ERROR; /* timeout */
+ }
+ }
+ else
+ {
+ if (RTS_IsExecuting (dev, Regs) == FALSE)
+ {
+ DBG (DBG_FNC,
+ " -> Head_ParkHome: RTS_IsExecuting = 0, exiting function\n");
+ rst = ERROR; /* if NOT executing */
+ }
+ }
+
+ /* Check if lamp is at home */
+ if ((rst == OK) && (Head_IsAtHome (dev, Regs) == FALSE))
+ {
+ struct st_motormove mymotor;
+ struct st_motorpos mtrpos;
+
+ DBG (DBG_FNC,
+ "-> Head_ParkHome: Lamp is not at home, lets move\n");
+
+ /* it isn't */
+ dev->status->parkhome = TRUE;
+
+ if ((movement != -1) && (movement < dev->motormove_count))
+ {
+ memcpy (&mymotor, dev->motormove[movement],
+ sizeof (struct st_motormove));
+ }
+ else
+ {
+ /* debug this code. Shouldn't have any relationship with offsets */
+ if (default_gain_offset->edcg2[CL_BLUE] < 4)
+ mymotor.scanmotorsteptype =
+ default_gain_offset->edcg2[CL_BLUE];
+
+ mymotor.ctpc = default_gain_offset->odcg2[1];
+ mymotor.systemclock = default_gain_offset->edcg2[1]; /*? */
+ }
+
+ mtrpos.options = MTR_ENABLED | MTR_BACKWARD;
+ mtrpos.v12e448 = 0x01;
+ mtrpos.v12e44c = 0x00;
+ mtrpos.coord_y = 0x4e20;
+
+ Motor_Move (dev, Regs, &mymotor, &mtrpos);
+
+ /* Should we wait? */
+ if (bWait != FALSE)
+ rst = RTS_WaitScanEnd (dev, 15000);
+
+ dev->status->parkhome = FALSE;
+ }
+
+ free (Regs);
+ }
+
+ DBG (DBG_FNC, "- Head_ParkHome: %i:\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Motor_Move (struct st_device *dev, SANE_Byte * Regs,
+ struct st_motormove *mymotor, struct st_motorpos *mtrpos)
+{
+ SANE_Byte *cpRegs;
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ Motor_Move:\n");
+
+ rst = ERROR;
+
+ cpRegs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
+ if (cpRegs != NULL)
+ {
+ SANE_Int data, v12dcf8, coord_y, step_type;
+
+ memcpy (cpRegs, Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+ v12dcf8 = 0;
+
+ /* resolution = 1 dpi */
+ data_bitset (&cpRegs[0xc0], 0x1f, 1); /*---xxxxx*/
+
+ /* set motor step type */
+ data_bitset (&cpRegs[0xd9], 0x70, mymotor->scanmotorsteptype); /*-xxx----*/
+
+ /* set motor direction (polarity) */
+ data_bitset (&cpRegs[0xd9], 0x80, mtrpos->options >> 3); /*e------- */
+
+ /* next value doesn't seem to have any effect */
+ data_bitset (&cpRegs[0xd9], 0x0f, mtrpos->options); /*----efgh*/
+
+ /* 0 enable/1 disable motor */
+ data_bitset (&cpRegs[0xdd], 0x80, mtrpos->options >> 4); /*d------- */
+
+ /* next value doesn't seem to have any effect */
+ data_bitset (&cpRegs[0xdd], 0x40, mtrpos->options >> 4); /*-d------*/
+
+ switch (mymotor->scanmotorsteptype)
+ {
+ case STT_OCT:
+ step_type = 8;
+ break;
+ case STT_QUART:
+ step_type = 4;
+ break;
+ case STT_HALF:
+ step_type = 2;
+ break;
+ case STT_FULL:
+ step_type = 1;
+ break;
+ default:
+ step_type = 0;
+ break; /* shouldn't be used */
+ }
+
+ coord_y = (mtrpos->coord_y * step_type) & 0xffff;
+ if (coord_y < 2)
+ coord_y = 2;
+
+ /* Sets dummyline to 1 */
+ data_bitset (&cpRegs[0xd6], 0xf0, 1);
+
+ /* set step_size - 1 */
+ cpRegs[0xe0] = 0;
+
+ cpRegs[0x01] &= 0xf9;
+ cpRegs[0x01] |= (mtrpos->v12e448 & 1) << 2;
+
+ /* set dummy scan */
+ data_bitset (&cpRegs[0x01], 0x10, 1); /*---x----*/
+
+ /* set samplerate */
+ data_bitset (&cpRegs[0x1cf], 0x40, PIXEL_RATE); /*-x------*/
+
+ /* unknown data */
+ data_bitset (&cpRegs[0x1cf], 0x80, 1); /*x------- */
+
+ /* sets one chanel per color */
+ data_bitset (&cpRegs[0x12], 0x3f, 0); /* channel */
+ data_bitset (&cpRegs[0x12], 0xc0, 1); /* 1 channel */
+
+ /* timing cnpp */
+ data_bitset (&cpRegs[0x96], 0x3f, 0x0b); /*--001011*/
+
+ /* set systemclock */
+ data_bitset (&cpRegs[0x00], 0x0f, mymotor->systemclock); /*----xxxx*/
+
+ /* set last step of accurve.smearing table to 2 */
+ data_lsb_set (&cpRegs[0xe4], 2, 3);
+
+ /* set last step of deccurve.scanbufferfull table to 16 */
+ data_lsb_set (&Regs[0xea], 0x10, 3);
+
+ /* set last step of deccurve.normalscan table to 16 */
+ data_lsb_set (&Regs[0xed], 0x10, 3);
+
+ /* set last step of deccurve.smearing table to 16 */
+ data_lsb_set (&Regs[0xf0], 0x10, 3);
+
+ /* set last step of deccurve.parkhome table to 16 */
+ data_lsb_set (&Regs[0xf3], 0x10, 3);
+
+ /* set msi */
+ cpRegs[0xda] = 2;
+ cpRegs[0xdd] &= 0xfc;
+
+ /* set if motor has motorcurves */
+ data_bitset (&cpRegs[0xdf], 0x10,
+ ((mymotor->motorcurve != -1) ? 1 : 0));
+
+ if (mymotor->motorcurve != -1)
+ {
+ struct st_curve *crv;
+
+ /* set last step of accurve.normalscan table */
+ crv =
+ Motor_Curve_Get (dev, mymotor->motorcurve, ACC_CURVE,
+ CRV_NORMALSCAN);
+ if (crv != NULL)
+ data_lsb_set (&cpRegs[0xe1], crv->step[crv->step_count - 1], 3);
+
+ DBG (DBG_FNC, " -> Setting up stepper motor using motorcurve %i\n",
+ mymotor->motorcurve);
+ v12dcf8 = Motor_Setup_Steps (dev, cpRegs, mymotor->motorcurve);
+
+ /* set step_size - 1 */
+ cpRegs[0xe0] = 0;
+
+ crv =
+ Motor_Curve_Get (dev, mymotor->motorcurve, DEC_CURVE,
+ CRV_NORMALSCAN);
+ if (crv != NULL)
+ coord_y -= (v12dcf8 + crv->step_count);
+
+ /* set line exposure time */
+ data_lsb_set (&cpRegs[0x30], mymotor->ctpc, 3);
+
+ /* set last step of accurve.smearing table */
+ data_lsb_set (&cpRegs[0xe4], 0, 3);
+ }
+ else
+ {
+ /* Setting some motor step */
+ SANE_Int some_step;
+
+ switch (Regs[0x00] & 0x0f)
+ {
+ case 0x00:
+ some_step = 0x00895440;
+ break; /* 3 x 0x2DC6C0 */
+ case 0x08:
+ case 0x01:
+ some_step = 0x00b71b00;
+ break; /* 4 x 0x2DC6C0 */
+ case 0x02:
+ some_step = 0x0112a880;
+ break; /* 6 x 0x2DC6C0 */
+ case 0x0a:
+ case 0x03:
+ some_step = 0x016e3600;
+ break; /* 8 x 0x2DC6C0 */
+ case 0x04:
+ some_step = 0x02255100;
+ break; /* 12 x 0x2DC6C0 */
+ case 0x0c:
+ some_step = 0x02dc6c00;
+ break; /* 16 x 0x2DC6C0 */
+ case 0x05:
+ some_step = 0x044aa200;
+ break; /* 24 x 0x2DC6C0 */
+ case 0x0d:
+ some_step = 0x05b8d800;
+ break; /* 32 x 0x2DC6C0 */
+
+ case 0x09:
+ some_step = 0x00f42400;
+ break;
+ case 0x0b:
+ some_step = 0x01e84800;
+ break; /* = case 9 * 2 */
+ default:
+ some_step = 0x0478f7f8;
+ break;
+ }
+
+ /* divide by timing.cnpp */
+ some_step /= ((cpRegs[0x96] & 0x3f) + 1);
+ if (mymotor->ctpc > 0)
+ some_step /= mymotor->ctpc;
+
+ /* set line exposure time */
+ data_lsb_set (&cpRegs[0x30], some_step, 3);
+
+ /* set last step of accurve.normalscan table */
+ data_lsb_set (&cpRegs[0xe1], some_step, 3);
+ }
+
+ /* Setting coords */
+ RTS_Setup_Coords (cpRegs, 100, coord_y - 1, 800, 1);
+
+ /* enable head movement */
+ data_bitset (&cpRegs[0xd8], 0x80, 1);
+
+ /* release motor before executing */
+ Motor_Release (dev);
+
+ RTS_Warm_Reset (dev);
+
+ /* action! */
+ data = RTS_WriteRegs (dev->usb_handle, cpRegs);
+ if (data == OK)
+ RTS_Execute (dev);
+
+ /* wait 10 seconds */
+ RTS_WaitScanEnd (dev, 10000);
+
+ rst = (data != OK) ? v12dcf8 : RTS_WaitScanEnd (dev, 20000);
+
+ free (cpRegs);
+ }
+
+ DBG (DBG_FNC, "- Motor_Move: %i\n", rst);
+
+ return rst;
+}
+
+static void
+Free_Motormoves (struct st_device *dev)
+{
+ DBG (DBG_FNC, "> Free_Motormoves\n");
+
+ if (dev->motormove != NULL)
+ {
+ SANE_Int a;
+ struct st_motormove *ms;
+
+ for (a = 0; a < dev->motormove_count; a++)
+ {
+ ms = dev->motormove[a];
+ if (ms != NULL)
+ free (ms);
+ }
+
+ free (dev->motormove);
+ dev->motormove = NULL;
+ }
+
+ dev->motormove_count = 0;
+}
+
+static void
+Free_MotorCurves (struct st_device *dev)
+{
+ DBG (DBG_FNC, "> Free_MotorCurves\n");
+ if (dev->mtrsetting != NULL)
+ Motor_Curve_Free (dev->mtrsetting, &dev->mtrsetting_count);
+
+ dev->mtrsetting = NULL;
+ dev->mtrsetting_count = 0;
+}
+
+static SANE_Int
+Load_MotorCurves (struct st_device *dev)
+{
+ SANE_Int rst = ERROR;
+ SANE_Int *mtc = NULL;
+
+ if (dev->mtrsetting != NULL)
+ Free_MotorCurves (dev);
+
+ DBG (DBG_FNC, "> Load_MotorCurves\n");
+
+ /* get motor setttings buffer for this device */
+ mtc = cfg_motorcurve_get ();
+ if (mtc != NULL)
+ {
+ /* parse buffer to get all motorcurves */
+ dev->mtrsetting = Motor_Curve_Parse (&dev->mtrsetting_count, mtc);
+ if (dev->mtrsetting != NULL)
+ rst = OK;
+ }
+
+ if (rst != ERROR)
+ {
+ DBG (DBG_FNC, " -> Found %i motor settings\n", dev->mtrsetting_count);
+ dbg_motorcurves (dev);
+ }
+ else
+ DBG (DBG_ERR, "- Load_MotorCurves error!!\n");
+
+ return rst;
+}
+
+static SANE_Int
+Load_Motormoves (struct st_device *dev)
+{
+ SANE_Int rst = OK;
+ SANE_Int a;
+ struct st_motormove reg, *mm;
+
+ DBG (DBG_FNC, "> Load_Motormoves\n");
+
+ /* if there is already any movement loaded let's free it */
+ if (dev->motormove != NULL)
+ Free_Motormoves (dev);
+
+ a = 0;
+ while ((cfg_motormove_get (dev->sensorcfg->type, a, &reg) != ERROR)
+ && (rst == OK))
+ {
+ dev->motormove_count++;
+ dev->motormove =
+ (struct st_motormove **) realloc (dev->motormove,
+ sizeof (struct st_motormove **) *
+ dev->motormove_count);
+ if (dev->motormove != NULL)
+ {
+ mm = (struct st_motormove *) malloc (sizeof (struct st_motormove));
+ if (mm != NULL)
+ {
+ memcpy (mm, &reg, sizeof (struct st_motormove));
+ dev->motormove[dev->motormove_count - 1] = mm;
+ }
+ else
+ rst = ERROR;
+ }
+ else
+ rst = ERROR;
+
+ a++;
+ }
+
+ if (rst == ERROR)
+ Free_Motormoves (dev);
+
+ DBG (DBG_FNC, " -> Found %i motormoves\n", dev->motormove_count);
+ dbg_motormoves (dev);
+
+ return rst;
+}
+
+static SANE_Byte *
+Motor_AddStep (SANE_Byte * steps, SANE_Int * bwriten, SANE_Int step)
+{
+ steps = (SANE_Byte *) realloc (steps, sizeof (SANE_Byte) * (*bwriten + 3));
+ if (steps != NULL)
+ {
+ data_msb_set (&steps[*bwriten], step, 3);
+ *bwriten += 3;
+ }
+ else
+ *bwriten = 0;
+
+ return steps;
+}
+
+static SANE_Int
+Motor_Setup_Steps (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Int mysetting)
+{
+ SANE_Int varx10, cont, last_acc_step, varx20, stepbuffer_size,
+ mystep, bwriten;
+ SANE_Int myvar, var1, myvalor, mybwriten;
+ struct st_curve *mycurve;
+ SANE_Byte *steps;
+
+ DBG (DBG_FNC, "+ Motor_Setup_Steps(*Regs, motorsetting=%i):\n", mysetting);
+
+ varx10 = 0;
+ cont = 0;
+ varx20 = 0;
+ stepbuffer_size = (v15f8 << 4) & 0xffff;
+ steps = NULL;
+ bwriten = 0;
+ deccurvecount = 0;
+ acccurvecount = 0;
+ last_acc_step = 0;
+
+ /* mycurve points to acc normalscan steps table */
+ mycurve = Motor_Curve_Get (dev, mysetting, ACC_CURVE, CRV_NORMALSCAN);
+
+ if (mycurve != NULL)
+ {
+ /* acccurvecount has the number of steps in acc normalscan table */
+ acccurvecount = mycurve->step_count;
+
+ /* get last acccurve step from acc.normalscan step table */
+ last_acc_step = data_lsb_get (&Regs[0xe1], 3);
+
+ /* sets pointer to acc.normalscan step table */
+ data_wide_bitset (&Regs[0xf6], 0x3fff, stepbuffer_size);
+
+ /* Separate each step in three bytes */
+ if (mycurve->step_count > 0)
+ for (cont = 0; cont < mycurve->step_count; cont++)
+ {
+ mystep = mycurve->step[cont];
+ if (mystep <= last_acc_step)
+ {
+ acccurvecount = cont;
+ break;
+ }
+ varx20 += mystep + 1;
+ steps = Motor_AddStep (steps, &bwriten, mystep);
+ }
+ }
+
+ if (acccurvecount == 0)
+ {
+ /* Write one step (last_acc_step + 0x01) to buffer */
+ acccurvecount++;
+ varx20 += (last_acc_step + 1) + 1;
+ steps = Motor_AddStep (steps, &bwriten, last_acc_step + 1);
+ }
+
+ /* write another step (last_acc_step) */
+ acccurvecount++;
+ varx20 += last_acc_step + 1;
+ steps = Motor_AddStep (steps, &bwriten, last_acc_step);
+
+ /* get line exposure time */
+ myvar = data_lsb_get (&Regs[0x30], 3) + 1;
+
+ var1 = (varx20 + myvar - 1) / myvar;
+ var1 = ((var1 * myvar) + mycurve->step[0] - varx20) - 0x0d;
+ if (steps != NULL)
+ data_msb_set (&steps[0], var1, 3);
+
+ /* dec.scanbufferfull step table */
+ /* set pointer to next table */
+ stepbuffer_size += (acccurvecount * 3);
+ data_wide_bitset (&Regs[0xf8], 0x3fff, stepbuffer_size);
+
+ /* set last step of deccurve.scanbufferfull table */
+ mycurve = Motor_Curve_Get (dev, mysetting, DEC_CURVE, CRV_BUFFERFULL);
+ deccurvecount = mycurve->step_count;
+ data_lsb_set (&Regs[0xea], mycurve->step[mycurve->step_count - 1], 3);
+
+ /* write another step mycurve->step_count,cont,last_acc_step */
+ deccurvecount++;
+ steps = Motor_AddStep (steps, &bwriten, last_acc_step);
+
+ /* Separate each step in three bytes */
+ if (mycurve->step_count > 1)
+ for (cont = 0; cont < (mycurve->step_count - 1); cont++)
+ {
+ mystep = mycurve->step[cont];
+ if (mystep > last_acc_step)
+ steps = Motor_AddStep (steps, &bwriten, mystep);
+ else
+ deccurvecount--;
+ }
+
+ myvalor = dev->mtrsetting[mysetting]->motorbackstep;
+ if (myvalor > 0)
+ {
+ SANE_Int step_size = _B0 (Regs[0xe0]) + 1;
+
+ myvalor = ((myvalor - deccurvecount) - acccurvecount) + 2;
+ varx10 = myvalor;
+ myvalor /= step_size;
+ myvalor *= step_size;
+ var1 = mycurve->step[mycurve->step_count - 1]; /* last deccurve step */
+ if (last_acc_step >= var1)
+ var1 = last_acc_step + 1;
+ deccurvecount += (varx10 - myvalor);
+ myvalor = varx10 - myvalor;
+ }
+ else
+ myvalor = varx10;
+
+ if (myvalor > 0)
+ for (cont = myvalor; cont > 0; cont--)
+ steps = Motor_AddStep (steps, &bwriten, var1 - 1);
+
+ /* write another step , bwriten tiene 4b */
+ steps = Motor_AddStep (steps, &bwriten, var1);
+
+ /* acc.smearing step table */
+ if (Motor_Curve_Get (dev, mysetting, ACC_CURVE, CRV_SMEARING) != NULL)
+ {
+ /* acc.smearing curve enabled */
+ if (Motor_Curve_Equal
+ (dev, mysetting, ACC_CURVE, CRV_SMEARING, CRV_NORMALSCAN) == TRUE)
+ {
+ /* acc.smearing pointer points to acc.normalscan table */
+ data_wide_bitset (&Regs[0xfa], 0x3fff,
+ data_lsb_get (&Regs[0xf6], 2));
+ /* last step of acc.smearing table is the same as acc.normalscan */
+ data_lsb_set (&Regs[0xe4], data_lsb_get (&Regs[0xe1], 3), 3);
+ }
+ else
+ {
+ /* set pointer to next step table */
+ stepbuffer_size += (deccurvecount * 3);
+ data_wide_bitset (&Regs[0xfa], 0x3fff, stepbuffer_size);
+
+ /* set last step of acc.smearing table */
+ mycurve = Motor_Curve_Get (dev, mysetting, ACC_CURVE, CRV_SMEARING);
+ if (mycurve != NULL)
+ {
+ smearacccurvecount = mycurve->step_count;
+ data_lsb_set (&Regs[0xe4],
+ mycurve->step[mycurve->step_count - 1], 3);
+
+ /* generate acc.smearing table */
+ if (mycurve->step_count > 0)
+ for (cont = 0; cont < mycurve->step_count; cont++)
+ steps =
+ Motor_AddStep (steps, &bwriten, mycurve->step[cont]);
+ }
+ }
+ }
+ else
+ {
+ /* acc.smearing curve disabled */
+ data_wide_bitset (&Regs[0xfa], 0x3fff, 0);
+ }
+
+ /* dec.smearing */
+ if (Motor_Curve_Get (dev, mysetting, DEC_CURVE, CRV_SMEARING) != NULL)
+ {
+ /* dec.smearing curve enabled */
+ if (Motor_Curve_Equal
+ (dev, mysetting, DEC_CURVE, CRV_SMEARING, CRV_BUFFERFULL) == TRUE)
+ {
+ /* dec.smearing pointer points to dec.scanbufferfull table */
+ data_wide_bitset (&Regs[0x00fc], 0x3fff,
+ data_lsb_get (&Regs[0x00f8], 2));
+ /* last step of dec.smearing table is the same as dec.scanbufferfull */
+ data_lsb_set (&Regs[0x00f0], data_lsb_get (&Regs[0x00ea], 3), 3);
+ }
+ else
+ {
+ /* set pointer to next step table */
+ if (mycurve != NULL)
+ stepbuffer_size += (mycurve->step_count * 3);
+ data_wide_bitset (&Regs[0xfc], 0x3fff, stepbuffer_size);
+
+ /* set last step of dec.smearing table */
+ mycurve = Motor_Curve_Get (dev, mysetting, DEC_CURVE, CRV_SMEARING);
+ if (mycurve != NULL)
+ {
+ smeardeccurvecount = mycurve->step_count;
+ data_lsb_set (&Regs[0xf0],
+ mycurve->step[mycurve->step_count - 1], 3);
+
+ /* generate dec.smearing table */
+ if (mycurve->step_count > 0)
+ for (cont = 0; cont < mycurve->step_count; cont++)
+ steps =
+ Motor_AddStep (steps, &bwriten, mycurve->step[cont]);
+ }
+ }
+ }
+ else
+ {
+ /* dec.smearing curve disabled */
+ data_wide_bitset (&Regs[0x00fc], 0x3fff, 0);
+ }
+
+ /* dec.normalscan */
+ if (Motor_Curve_Get (dev, mysetting, DEC_CURVE, CRV_NORMALSCAN) != NULL)
+ {
+ /* dec.normalscan enabled */
+ if (Motor_Curve_Equal
+ (dev, mysetting, DEC_CURVE, CRV_NORMALSCAN, CRV_BUFFERFULL) == TRUE)
+ {
+ /* dec.normalscan pointer points to dec.scanbufferfull table */
+ data_wide_bitset (&Regs[0xfe], 0x3fff,
+ data_lsb_get (&Regs[0xf8], 2));
+ /* last step of dec.normalscan table is the same as dec.scanbufferfull */
+ data_lsb_set (&Regs[0xed], data_lsb_get (&Regs[0xea], 3), 3);
+ }
+ else
+ if (Motor_Curve_Equal
+ (dev, mysetting, DEC_CURVE, CRV_NORMALSCAN, CRV_SMEARING) == TRUE)
+ {
+ /* dec.normalscan pointer points to dec.smearing table */
+ data_wide_bitset (&Regs[0xfe], 0x3fff,
+ data_lsb_get (&Regs[0xfc], 2));
+ /* last step of dec.normalscan table is the same as dec.smearing */
+ data_lsb_set (&Regs[0xed], data_lsb_get (&Regs[0xf0], 3), 3);
+ }
+ else
+ {
+ /* set pointer to next step table */
+ if (mycurve != NULL)
+ stepbuffer_size += (mycurve->step_count * 3);
+ data_wide_bitset (&Regs[0xfe], 0x3fff, stepbuffer_size);
+
+ /* set last step of dec.normalscan table */
+ mycurve =
+ Motor_Curve_Get (dev, mysetting, DEC_CURVE, CRV_NORMALSCAN);
+ if (mycurve != NULL)
+ {
+ data_lsb_set (&Regs[0xed],
+ mycurve->step[mycurve->step_count - 1], 3);
+
+ /* generate dec.normalscan table */
+ if (mycurve->step_count > 0)
+ for (cont = 0; cont < mycurve->step_count; cont++)
+ steps =
+ Motor_AddStep (steps, &bwriten, mycurve->step[cont]);
+ }
+ }
+ }
+ else
+ {
+ /* dec.normalscan disabled */
+ data_wide_bitset (&Regs[0xfe], 0x3fff, 0);
+ }
+
+ /* acc.parkhome */
+ if (Motor_Curve_Get (dev, mysetting, ACC_CURVE, CRV_PARKHOME) != NULL)
+ {
+ /* parkhome curve enabled */
+
+ if (Motor_Curve_Equal
+ (dev, mysetting, ACC_CURVE, CRV_PARKHOME, CRV_NORMALSCAN) == TRUE)
+ {
+ /* acc.parkhome pointer points to acc.normalscan table */
+ data_wide_bitset (&Regs[0x100], 0x3fff,
+ data_lsb_get (&Regs[0xf6], 2));
+
+ /* last step of acc.parkhome table is the same as acc.normalscan */
+ data_lsb_set (&Regs[0xe7], data_lsb_get (&Regs[0xe1], 3), 3);
+ }
+ else
+ if (Motor_Curve_Equal
+ (dev, mysetting, ACC_CURVE, CRV_PARKHOME, CRV_SMEARING) == TRUE)
+ {
+ /* acc.parkhome pointer points to acc.smearing table */
+ data_wide_bitset (&Regs[0x100], 0x3fff,
+ data_lsb_get (&Regs[0xfa], 2));
+ /* last step of acc.parkhome table is the same as acc.smearing */
+ data_lsb_set (&Regs[0xe7], data_lsb_get (&Regs[0xe4], 3), 3);
+ }
+ else
+ {
+ /* set pointer to next step table */
+ if (mycurve != NULL)
+ stepbuffer_size += (mycurve->step_count * 3);
+ data_wide_bitset (&Regs[0x100], 0x3fff, stepbuffer_size);
+
+ /* set last step of acc.parkhome table */
+ mycurve = Motor_Curve_Get (dev, mysetting, ACC_CURVE, CRV_PARKHOME);
+ if (mycurve != NULL)
+ {
+ data_lsb_set (&Regs[0xe7],
+ mycurve->step[mycurve->step_count - 1], 3);
+
+ /* generate acc.parkhome table */
+ if (mycurve->step_count > 0)
+ for (cont = 0; cont < mycurve->step_count; cont++)
+ steps =
+ Motor_AddStep (steps, &bwriten, mycurve->step[cont]);
+ }
+ }
+ }
+ else
+ {
+ /* parkhome curve is disabled */
+ /* acc.parkhome pointer points to 0 */
+ data_wide_bitset (&Regs[0x100], 0x3fff, 0);
+ data_lsb_set (&Regs[0xe7], 16, 3);
+ }
+
+ /* dec.parkhome */
+ if (Motor_Curve_Get (dev, mysetting, DEC_CURVE, CRV_PARKHOME) != NULL)
+ {
+ /* parkhome curve enabled */
+ if (Motor_Curve_Equal
+ (dev, mysetting, DEC_CURVE, CRV_PARKHOME, CRV_BUFFERFULL) == TRUE)
+ {
+ /* dec.parkhome pointer points to dec.scanbufferfull table */
+ data_wide_bitset (&Regs[0x102], 0x3fff,
+ data_lsb_get (&Regs[0xf8], 2));
+ /* last step of dec.parkhome table is the same as dec.scanbufferfull */
+ data_lsb_set (&Regs[0xf3], data_lsb_get (&Regs[0xe4], 3), 3);
+ }
+ else
+ if (Motor_Curve_Equal
+ (dev, mysetting, DEC_CURVE, CRV_PARKHOME, CRV_SMEARING) == TRUE)
+ {
+ /* dec.parkhome pointer points to dec.smearing table */
+ data_wide_bitset (&Regs[0x102], 0x3fff,
+ data_lsb_get (&Regs[0xfe], 2));
+ /* last step of dec.parkhome table is the same as dec.smearing */
+ data_lsb_set (&Regs[0xf3], data_lsb_get (&Regs[0xf0], 3), 3);
+ }
+ else
+ if (Motor_Curve_Equal
+ (dev, mysetting, DEC_CURVE, CRV_PARKHOME, CRV_NORMALSCAN) == TRUE)
+ {
+ /* dec.parkhome pointer points to dec.normalscan table */
+ data_wide_bitset (&Regs[0x102], 0x3fff,
+ data_lsb_get (&Regs[0xfe], 2));
+ /* last step of dec.parkhome table is the same as dec.normalscan */
+ data_lsb_set (&Regs[0xf3], data_lsb_get (&Regs[0xed], 3), 3);
+ }
+ else
+ {
+ /* set pointer to next step table */
+ if (mycurve != NULL)
+ stepbuffer_size += (mycurve->step_count * 3);
+ data_wide_bitset (&Regs[0x102], 0x3fff, stepbuffer_size);
+
+ /* set last step of dec.parkhome table */
+ mycurve = Motor_Curve_Get (dev, mysetting, DEC_CURVE, CRV_PARKHOME);
+ if (mycurve != NULL)
+ {
+ data_lsb_set (&Regs[0xf3],
+ mycurve->step[mycurve->step_count - 1], 3);
+
+ /* generate dec.parkhome table */
+ if (mycurve->step_count > 0)
+ for (cont = 0; cont < mycurve->step_count; cont++)
+ steps =
+ Motor_AddStep (steps, &bwriten, mycurve->step[cont]);
+ }
+ }
+ }
+ else
+ {
+ /* parkhome curve is disabled */
+
+ /* dec.parkhome pointer points to 0 */
+ data_wide_bitset (&Regs[0x102], 0x3fff, 0);
+ data_lsb_set (&Regs[0xf3], 16, 3);
+ }
+
+ mybwriten = bwriten & 0x8000000f;
+ if (mybwriten < 0)
+ mybwriten = ((mybwriten - 1) | 0xfffffff0) + 1;
+
+ if (mybwriten != 0)
+ bwriten = (((bwriten & 0xffff) >> 0x04) + 1) << 0x04;
+ bwriten = bwriten & 0xffff;
+
+ /* display table */
+ DBG (DBG_FNC, " -> Direction Type Offset Last step\n");
+ DBG (DBG_FNC, " -> --------- -------------- ------ ---------\n");
+ DBG (DBG_FNC, " -> ACC_CURVE CRV_NORMALSCAN %6i %6i\n",
+ data_lsb_get (&Regs[0x0f6], 2) & 0x3fff, data_lsb_get (&Regs[0x0e1],
+ 3));
+ DBG (DBG_FNC, " -> ACC_CURVE CRV_SMEARING %6i %6i\n",
+ data_lsb_get (&Regs[0x0fa], 2) & 0x3fff, data_lsb_get (&Regs[0x0e4],
+ 3));
+ DBG (DBG_FNC, " -> ACC_CURVE CRV_PARKHOME %6i %6i\n",
+ data_lsb_get (&Regs[0x100], 2) & 0x3fff, data_lsb_get (&Regs[0x0e7],
+ 3));
+ DBG (DBG_FNC, " -> DEC_CURVE CRV_NORMALSCAN %6i %6i\n",
+ data_lsb_get (&Regs[0x0fe], 2) & 0x3fff, data_lsb_get (&Regs[0x0ed],
+ 3));
+ DBG (DBG_FNC, " -> DEC_CURVE CRV_SMEARING %6i %6i\n",
+ data_lsb_get (&Regs[0x0fc], 2) & 0x3fff, data_lsb_get (&Regs[0x0f0],
+ 3));
+ DBG (DBG_FNC, " -> DEC_CURVE CRV_PARKHOME %6i %6i\n",
+ data_lsb_get (&Regs[0x102], 2) & 0x3fff, data_lsb_get (&Regs[0x0f3],
+ 3));
+ DBG (DBG_FNC, " -> DEC_CURVE CRV_BUFFERFULL %6i %6i\n",
+ data_lsb_get (&Regs[0x0f8], 2) & 0x3fff, data_lsb_get (&Regs[0x0ea],
+ 3));
+
+ RTS_Warm_Reset (dev);
+
+ /* send motor steps */
+ if (steps != NULL)
+ {
+ if (bwriten > 0)
+ {
+ /* lock */
+ SetLock (dev->usb_handle, Regs, TRUE);
+
+ /* send steps */
+ RTS_DMA_Write (dev, 0x0000, v15f8, bwriten, steps);
+
+ /* unlock */
+ SetLock (dev->usb_handle, Regs, FALSE);
+ }
+
+ free (steps);
+ }
+
+ DBG (DBG_FNC, "- Motor_Setup_Steps: %i\n", acccurvecount);
+
+ return acccurvecount;
+}
+
+static SANE_Int
+Lamp_PWM_use (struct st_device *dev, SANE_Int enable)
+{
+ SANE_Byte a, b;
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "+ Lamp_PWM_use(enable=%i):\n", enable);
+
+ if (Read_Byte (dev->usb_handle, 0xe948, &a) == OK)
+ {
+ if (Read_Byte (dev->usb_handle, 0xe9e0, &b) == OK)
+ {
+ if (enable != 0)
+ {
+ if (pwmlamplevel != 0x00)
+ {
+ b |= 0x80;
+ dev->init_regs[0x01e0] &= 0x3f;
+ dev->init_regs[0x01e0] |= 0x80;
+ }
+ else
+ {
+ a |= 0x40;
+ b &= 0x3f;
+ dev->init_regs[0x0148] |= 0x40;
+ dev->init_regs[0x01e0] &= 0x3f;
+ }
+ }
+ else
+ {
+ b &= 0x7f;
+ a &= 0xbf;
+ }
+
+ if (Write_Byte (dev->usb_handle, 0xe948, a) == OK)
+ rst = Write_Byte (dev->usb_handle, 0xe9e0, b);
+ }
+ }
+
+ DBG (DBG_FNC, "- Lamp_PWM_use: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+SSCG_Enable (struct st_device *dev)
+{
+ SANE_Int rst;
+ SANE_Int sscg;
+ SANE_Byte data1, data2;
+ SANE_Int enable, mode, clock;
+
+ DBG (DBG_FNC, "+ SSCG_Enable:\n");
+
+ rst = cfg_sscg_get (&enable, &mode, &clock);
+
+ if (rst == OK)
+ {
+ if ((Read_Byte (dev->usb_handle, 0xfe3a, &data1) == OK)
+ && (Read_Byte (dev->usb_handle, 0xfe39, &data2) == OK))
+ {
+ if (enable != FALSE)
+ {
+ /* clock values: 0=0.25%; 1=0.50%; 2=0.75%; 3=1.00% */
+ data2 = (mode == 0) ? data2 & 0x7f : data2 | 0x80;
+
+ sscg = (data1 & 0xf3) | (((clock & 0x03) | 0x04) << 0x02);
+ sscg = (sscg << 8) | data2;
+ }
+ else
+ sscg = ((data1 & 0xef) << 8) | _B0 (data2);
+
+ rst = Write_Word (dev->usb_handle, 0xfe39, sscg);
+ }
+ else
+ rst = ERROR;
+ }
+
+ DBG (DBG_FNC, "- SSCG_Enable: %i\n", rst);
+
+ return rst;
+}
+
+static void
+RTS_Setup_RefVoltages (struct st_device *dev, SANE_Byte * Regs)
+{
+ /* this function sets top, midle and bottom reference voltages */
+
+ DBG (DBG_FNC, "> RTS_Setup_RefVoltages\n");
+
+ if (Regs != NULL)
+ {
+ SANE_Byte vrts, vrms, vrbs;
+
+ cfg_refvoltages_get (dev->sensorcfg->type, &vrts, &vrms, &vrbs);
+
+ /* Top Reference Voltage */
+ data_bitset (&Regs[0x14], 0xe0, vrts); /*xxx----- */
+
+ /* Middle Reference Voltage */
+ data_bitset (&Regs[0x15], 0xe0, vrms); /*xxx----- */
+
+ /* Bottom Reference Voltage */
+ data_bitset (&Regs[0x16], 0xe0, vrbs); /*xxx----- */
+ }
+}
+
+static SANE_Int
+Init_USBData (struct st_device *dev)
+{
+ SANE_Byte data;
+ SANE_Byte *resource;
+
+ DBG (DBG_FNC, "+ Init_USBData:\n");
+
+ if (Read_Byte (dev->usb_handle, 0xf8ff, &data) != OK)
+ return ERROR;
+
+ data = (data | 1);
+ if (Write_Byte (dev->usb_handle, 0xf8ff, data) != OK)
+ return ERROR;
+
+ if (SSCG_Enable (dev) != OK)
+ return ERROR;
+
+ Init_Registers (dev);
+
+ /* Gamma table size = 0x100 */
+ data_bitset (&dev->init_regs[0x1d0], 0x30, 0x00); /*--00----*/
+
+ /* Set 3 channels_per_dot */
+ data_bitset (&dev->init_regs[0x12], 0xc0, 0x03); /*xx------ */
+
+ /* systemclock */
+ data_bitset (&dev->init_regs[0x00], 0x0f, 0x05); /*----xxxx*/
+
+ /* timing cnpp */
+ data_bitset (&dev->init_regs[0x96], 0x3f, 0x17); /*--xxxxxx*/
+
+ /* set sensor_channel_color_order */
+ data_bitset (&dev->init_regs[0x60a], 0x7f, 0x24); /*-xxxxxxx*/
+
+ /* set crvs */
+ data_bitset (&dev->init_regs[0x10], 0x1f, get_value (SCAN_PARAM, CRVS, 7, usbfile)); /*---xxxxx*/
+
+ /* set reference voltages */
+ RTS_Setup_RefVoltages (dev, dev->init_regs);
+
+ dev->init_regs[0x11] |= 0x10;
+
+ data_bitset (&dev->init_regs[0x26], 0x70, 5); /*-101----*/
+
+ dev->init_regs[0x185] = 0x88;
+ dev->init_regs[0x186] = 0x88;
+
+ /* SDRAM clock */
+ data = get_value (SCAN_PARAM, MCLKIOC, 8, usbfile);
+ data_bitset (&dev->init_regs[0x187], 0x0f, 0x08); /*----xxxx*/
+ data_bitset (&dev->init_regs[0x187], 0xf0, data); /*xxxx---- */
+
+ data--;
+
+ if (data < 7)
+ {
+ switch (data)
+ {
+ case 0:
+ data |= 0xc0;
+ break;
+ case 1:
+ data |= 0xa0;
+ break;
+ case 2:
+ data |= 0xe0;
+ break;
+ case 3:
+ data |= 0x90;
+ break;
+ case 4:
+ data |= 0xd0;
+ break;
+ case 5:
+ data |= 0xb0;
+ break;
+ case 6:
+ data = (data & 0x0f);
+ break;
+ }
+ dev->init_regs[0x187] = _B0 (data);
+ }
+
+ data_bitset (&dev->init_regs[0x26], 0x0f, 0); /*----0000*/
+
+ dev->init_regs[0x27] &= 0x3f;
+ dev->init_regs[0x29] = 0x24;
+ dev->init_regs[0x2a] = 0x10;
+ dev->init_regs[0x150] = 0xff;
+ dev->init_regs[0x151] = 0x13;
+ dev->init_regs[0x156] = 0xf0;
+ dev->init_regs[0x157] = 0xfd;
+
+ if (dev->motorcfg->changemotorcurrent != FALSE)
+ Motor_Change (dev, dev->init_regs, 3);
+
+ dev->init_regs[0xde] = 0;
+ data_bitset (&dev->init_regs[0xdf], 0x0f, 0);
+
+ /* loads motor resource for this dev */
+ resource = cfg_motor_resource_get (&data);
+ if ((resource != NULL) && (data > 1))
+ memcpy (&dev->init_regs[0x104], resource, data);
+
+ /* this bit is set but I don't know its purpose */
+ dev->init_regs[0x01] |= 0x40; /*-1------*/
+
+ dev->init_regs[0x124] = 0x94;
+
+ /* release motor */
+ Motor_Release (dev);
+
+ DBG (DBG_FNC, "- Init_USBData:\n");
+
+ return OK;
+}
+
+static SANE_Int
+Init_Registers (struct st_device *dev)
+{
+ SANE_Int rst = OK;
+
+ DBG (DBG_FNC, "+ Init_Registers:\n");
+
+ /* Lee dev->init_regs */
+ bzero (dev->init_regs, RT_BUFFER_LEN);
+ RTS_ReadRegs (dev->usb_handle, dev->init_regs);
+ Read_FE3E (dev, &v1619);
+
+ if (dev->sensorcfg->type == CCD_SENSOR)
+ {
+ /* CCD sensor */
+ data_bitset (&dev->init_regs[0x11], 0xc0, 0); /*xx------ */
+ data_bitset (&dev->init_regs[0x146], 0x80, 1); /*x------- */
+ data_bitset (&dev->init_regs[0x146], 0x40, 1); /*-x------*/
+
+ }
+ else
+ {
+ /* CIS sensor */
+ data_bitset (&dev->init_regs[0x146], 0x80, 0); /*0------- */
+ data_bitset (&dev->init_regs[0x146], 0x40, 0); /*-0------*/
+ data_bitset (&dev->init_regs[0x11], 0xc0, 2); /*xx------ */
+ data_bitset (&dev->init_regs[0xae], 0x3f, 0x14); /*--xxxxxx*/
+ data_bitset (&dev->init_regs[0xaf], 0x07, 1); /*-----xxx*/
+
+ dev->init_regs[0x9c] = dev->init_regs[0xa2] = dev->init_regs[0xa8] =
+ (RTS_Debug->dev_model != UA4900) ? 1 : 0;
+ dev->init_regs[0x9d] = dev->init_regs[0xa3] = dev->init_regs[0xa9] = 0;
+ dev->init_regs[0x9e] = dev->init_regs[0xa4] = dev->init_regs[0xaa] = 0;
+ dev->init_regs[0x9f] = dev->init_regs[0xa5] = dev->init_regs[0xab] = 0;
+ dev->init_regs[0xa0] = dev->init_regs[0xa6] = dev->init_regs[0xac] = 0;
+ dev->init_regs[0xa1] = dev->init_regs[0xa7] = dev->init_regs[0xad] =
+ (RTS_Debug->dev_model != UA4900) ? 0x80 : 0;
+ }
+
+ /* disable CCD channels */
+ data_bitset (&dev->init_regs[0x10], 0xe0, 0); /*xxx----- */
+ data_bitset (&dev->init_regs[0x13], 0x80, 0); /*x------- */
+
+ /* enable timer to switch off lamp */
+ data_bitset (&dev->init_regs[0x146], 0x10, 1); /*---x----*/
+
+ /* set time to switch off lamp */
+ dev->init_regs[0x147] = 0xff;
+
+ /* set last acccurve step */
+ data_lsb_set (&dev->init_regs[0xe1], 0x2af8, 3);
+
+ /* set msi 0x02 */
+ dev->init_regs[0xda] = 0x02;
+ data_bitset (&dev->init_regs[0xdd], 0x03, 0); /*------xx*/
+
+ /* set binary threshold high and low in little endian */
+ data_lsb_set (&dev->init_regs[0x19e], binarythresholdl, 2);
+ data_lsb_set (&dev->init_regs[0x1a0], binarythresholdh, 2);
+
+
+ data_bitset (&dev->init_regs[0x01], 0x08, 0); /*----x---*/
+ data_bitset (&dev->init_regs[0x16f], 0x40, 0); /*-x------*/
+ dev->init_regs[0x0bf] = (dev->init_regs[0x00bf] & 0xe0) | 0x20;
+ dev->init_regs[0x163] = (dev->init_regs[0x0163] & 0x3f) | 0x40;
+
+ data_bitset (&dev->init_regs[0xd6], 0x0f, 8); /*----xxxx*/
+ data_bitset (&dev->init_regs[0x164], 0x80, 1); /*x------- */
+
+ dev->init_regs[0x0bc] = 0x00;
+ dev->init_regs[0x0bd] = 0x00;
+
+ dev->init_regs[0x165] = (dev->init_regs[0x0165] & 0x3f) | 0x80;
+ dev->init_regs[0x0ed] = 0x10;
+ dev->init_regs[0x0be] = 0x00;
+ dev->init_regs[0x0d5] = 0x00;
+
+ dev->init_regs[0xee] = 0x00;
+ dev->init_regs[0xef] = 0x00;
+ dev->init_regs[0xde] = 0xff;
+
+ /* set bit[4] has_curves = 0 | bit[0..3] unknown = 0 */
+ data_bitset (&dev->init_regs[0xdf], 0x10, 0); /*---x----*/
+ data_bitset (&dev->init_regs[0xdf], 0x0f, 0); /*----xxxx*/
+
+ /* Set motor type */
+ data_bitset (&dev->init_regs[0xd7], 0x80, dev->motorcfg->type); /*x------- */
+
+ if (dev->motorcfg->type == MT_ONCHIP_PWM)
+ {
+ data_bitset (&dev->init_regs[0x14e], 0x10, 1); /*---x----*/
+
+ /* set motorpwmfrequency */
+ data_bitset (&dev->init_regs[0xd7], 0x3f, dev->motorcfg->pwmfrequency); /*--xxxxxx*/
+ }
+
+ dev->init_regs[0x600] &= 0xfb;
+ dev->init_regs[0x1d8] |= 0x08;
+
+ v160c_block_size = 0x04;
+ mem_total = 0x80000;
+
+ /* check and setup installed ram */
+ RTS_DMA_CheckType (dev, dev->init_regs);
+ rst = RTS_DMA_WaitReady (dev, 1500);
+
+ DBG (DBG_FNC, "- Init_Registers: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Read_FE3E (struct st_device *dev, SANE_Byte * destino)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ Read_FE3E:\n");
+
+ rst = ERROR;
+ if (destino != NULL)
+ {
+ SANE_Byte data;
+ if (Read_Byte (dev->usb_handle, 0xfe3e, &data) == 0)
+ {
+ *destino = data;
+ rst = OK;
+ DBG (DBG_FNC, " -> %02x\n", _B0 (data));
+ }
+ }
+
+ DBG (DBG_FNC, "- Read_FE3E: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Head_IsAtHome (struct st_device *dev, SANE_Byte * Regs)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ Head_IsAtHome:\n");
+
+ /* if returns TRUE, lamp is at home. Otherwise it returns FALSE */
+ rst = 0;
+
+ if (Regs != NULL)
+ {
+ SANE_Byte data;
+ if (Read_Byte (dev->usb_handle, 0xe96f, &data) == OK)
+ {
+ Regs[0x16f] = _B0 (data);
+ rst = (data >> 6) & 1;
+ }
+ }
+
+ rst = (rst == 1) ? TRUE : FALSE;
+
+ DBG (DBG_FNC, "- Head_IsAtHome: %s\n", (rst == TRUE) ? "Yes" : "No");
+
+ return rst;
+}
+
+static SANE_Byte
+RTS_IsExecuting (struct st_device *dev, SANE_Byte * Regs)
+{
+ SANE_Byte rst;
+
+ DBG (DBG_FNC, "+ RTS_IsExecuting:\n");
+
+ rst = 0;
+
+ if (Regs != NULL)
+ {
+ SANE_Byte data;
+ if (Read_Byte (dev->usb_handle, 0xe800, &data) == OK)
+ {
+ Regs[0x00] = data;
+ rst = (data >> 7) & 1;
+ }
+ }
+
+ DBG (DBG_FNC, "- RTS_IsExecuting: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_WaitScanEnd (struct st_device *dev, SANE_Int msecs)
+{
+ SANE_Byte data;
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ RTS_WaitScanEnd(msecs=%i):\n", msecs);
+
+ /* returns 0 if ok or timeout
+ returns -1 if fails */
+
+ rst = ERROR;
+
+ if (Read_Byte (dev->usb_handle, 0xe800, &data) == OK)
+ {
+ long ticks = GetTickCount () + msecs;
+ rst = OK;
+ while (((data & 0x80) != 0) && (ticks > GetTickCount ()) && (rst == OK))
+ {
+ rst = Read_Byte (dev->usb_handle, 0xe800, &data);
+ }
+ }
+
+ DBG (DBG_FNC, "- RTS_WaitScanEnd: Ending with rst=%i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_Enable_CCD (struct st_device *dev, SANE_Byte * Regs, SANE_Int channels)
+{
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "+ RTS_Enable_CCD(*Regs, arg2=%i):\n", channels);
+
+ if (Read_Buffer (dev->usb_handle, 0xe810, &Regs[0x10], 4) == OK)
+ {
+ data_bitset (&Regs[0x10], 0xe0, channels); /*xxx----- */
+ data_bitset (&Regs[0x13], 0x80, channels >> 3); /*x------- */
+
+ Write_Buffer (dev->usb_handle, 0xe810, &Regs[0x10], 4);
+ rst = OK;
+ }
+
+ DBG (DBG_FNC, "- RTS_Enable_CCD: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_Warm_Reset (struct st_device *dev)
+{
+ SANE_Byte data;
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ RTS_Warm_Reset:\n");
+
+ rst = ERROR;
+ if (Read_Byte (dev->usb_handle, 0xe800, &data) == OK)
+ {
+ data = (data & 0x3f) | 0x40; /*01------ */
+ if (Write_Byte (dev->usb_handle, 0xe800, data) == OK)
+ {
+ data &= 0xbf; /*-0------*/
+ rst = Write_Byte (dev->usb_handle, 0xe800, data);
+ }
+ }
+
+ DBG (DBG_FNC, "- RTS_Warm_Reset: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Lamp_Status_Timer_Set (struct st_device *dev, SANE_Int minutes)
+{
+ SANE_Byte MyBuffer[2];
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ Lamp_Status_Timer_Set(minutes=%i):\n", minutes);
+
+ MyBuffer[0] = dev->init_regs[0x0146] & 0xef;
+ MyBuffer[1] = dev->init_regs[0x0147];
+
+ if (minutes > 0)
+ {
+ double rst, op2;
+
+ minutes = _B0 (minutes);
+ op2 = 2.682163611980331;
+ MyBuffer[0x00] |= 0x10;
+ rst = (minutes * op2);
+ MyBuffer[0x01] = (SANE_Byte) floor (rst);
+ }
+
+ dev->init_regs[0x147] = MyBuffer[1];
+ dev->init_regs[0x146] =
+ (dev->init_regs[0x146] & 0xef) | (MyBuffer[0] & 0x10);
+
+ rst =
+ Write_Word (dev->usb_handle, 0xe946,
+ (SANE_Int) ((MyBuffer[1] << 8) + MyBuffer[0]));
+
+ DBG (DBG_FNC, "- Lamp_Status_Timer_Set: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Buttons_Enable (struct st_device *dev)
+{
+ SANE_Int data, rst;
+
+ DBG (DBG_FNC, "+ Buttons_Enable:\n");
+
+ if (Read_Word (dev->usb_handle, 0xe958, &data) == OK)
+ {
+ data |= 0x0f;
+ rst = Write_Word (dev->usb_handle, 0xe958, data);
+ }
+ else
+ rst = ERROR;
+
+ DBG (DBG_FNC, "- Buttons_Enable: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Buttons_Count (struct st_device *dev)
+{
+ SANE_Int rst = 0;
+
+ /* This chipset supports up to six buttons */
+
+ if (dev->buttons != NULL)
+ rst = dev->buttons->count;
+
+ DBG (DBG_FNC, "> Buttons_Count: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Buttons_Status (struct st_device *dev)
+{
+ SANE_Int rst = -1;
+ SANE_Byte data;
+
+ DBG (DBG_FNC, "+ Buttons_Status\n");
+
+ /* Each bit is 1 if button is not pressed, and 0 if it is pressed
+ This chipset supports up to six buttons */
+
+ if (Read_Byte (dev->usb_handle, 0xe968, &data) == OK)
+ rst = _B0 (data);
+
+ DBG (DBG_FNC, "- Buttons_Status: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Buttons_Released (struct st_device *dev)
+{
+ SANE_Int rst = -1;
+ SANE_Byte data;
+
+ DBG (DBG_FNC, "+ Buttons_Released\n");
+
+ /* Each bit is 1 if button is released, until reading this register. Then
+ entire register is cleared. This chipset supports up to six buttons */
+
+ if (Read_Byte (dev->usb_handle, 0xe96a, &data) == OK)
+ rst = _B0 (data);
+
+ DBG (DBG_FNC, "- Buttons_Released: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Buttons_Order (struct st_device *dev, SANE_Int mask)
+{
+ /* this is a way to order each button according to its bit in register 0xe968 */
+ SANE_Int rst = -1;
+
+ if (dev->buttons != NULL)
+ {
+ SANE_Int a;
+
+ for (a = 0; a < 6; a++)
+ {
+ if (dev->buttons->mask[a] == mask)
+ {
+ rst = a;
+ break;
+ }
+ }
+ }
+
+ return rst;
+}
+
+static SANE_Int
+GainOffset_Clear (struct st_device *dev)
+{
+ SANE_Int rst = OK;
+
+ DBG (DBG_FNC, "+ GainOffset_Clear:\n");
+
+ /* clear offsets */
+ offset[CL_RED] = offset[CL_GREEN] = offset[CL_BLUE] = 0;
+
+ /* save offsets */
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ {
+ SANE_Int a;
+
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ RTS_EEPROM_WriteWord (dev->usb_handle, 0x70 + (2 * a), 0);
+
+ /* update checksum */
+ rst = RTS_EEPROM_WriteByte (dev->usb_handle, 0x76, 0);
+ }
+
+ DBG (DBG_FNC, "- GainOffset_Clear: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Lamp_Status_Get (struct st_device *dev, SANE_Byte * flb_lamp,
+ SANE_Byte * tma_lamp)
+{
+ /* The only reason that I think windows driver uses two variables to get
+ which lamp is switched on instead of one variable is that some chipset
+ model could have both lamps switched on, so I'm maintaining such var */
+
+ SANE_Int rst = ERROR; /* default */
+
+ DBG (DBG_FNC, "+ Lamp_Status_Get:\n");
+
+ if ((flb_lamp != NULL) && (tma_lamp != NULL))
+ {
+ SANE_Int data1;
+ SANE_Byte data2;
+
+ if (Read_Byte (dev->usb_handle, 0xe946, &data2) == OK)
+ {
+ if (Read_Word (dev->usb_handle, 0xe954, &data1) == OK)
+ {
+ rst = OK;
+
+ *flb_lamp = 0;
+ *tma_lamp = 0;
+
+ switch (dev->chipset->model)
+ {
+ case RTS8822BL_03A:
+ *flb_lamp = ((data2 & 0x40) != 0) ? 1 : 0;
+ *tma_lamp = (((data2 & 0x20) != 0)
+ && ((data1 & 0x10) == 1)) ? 1 : 0;
+ break;
+ default:
+ if ((_B1 (data1) & 0x10) == 0)
+ *flb_lamp = (data2 >> 6) & 1;
+ else
+ *tma_lamp = (data2 >> 6) & 1;
+ break;
+ }
+ }
+ }
+ }
+
+ DBG (DBG_FNC, "- Lamp_Status_Get: rst=%i flb=%i tma=%i\n", rst,
+ _B0 (*flb_lamp), _B0 (*tma_lamp));
+
+ return rst;
+}
+
+static SANE_Int
+RTS_DMA_WaitReady (struct st_device *dev, SANE_Int msecs)
+{
+ SANE_Byte data;
+ SANE_Int rst;
+ long mytime;
+
+ DBG (DBG_FNC, "+ RTS_DMA_WaitReady(msecs=%i):\n", msecs);
+
+ rst = OK;
+ mytime = GetTickCount () + msecs;
+
+ while ((mytime > GetTickCount ()) && (rst == OK))
+ {
+ if (Read_Byte (dev->usb_handle, 0xef09, &data) == OK)
+ {
+ if ((data & 1) == 0)
+ usleep (1000 * 100);
+ else
+ break;
+ }
+ else
+ rst = ERROR;
+ }
+
+ DBG (DBG_FNC, "- RTS_DMA_WaitReady: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_WaitInitEnd (struct st_device *dev, SANE_Int msecs)
+{
+ SANE_Byte data;
+ SANE_Int rst;
+ long mytime;
+
+ DBG (DBG_FNC, "+ RTS_WaitInitEnd(msecs=%i):\n", msecs);
+
+ rst = OK;
+ mytime = GetTickCount () + msecs;
+
+ while ((mytime > GetTickCount ()) && (rst == OK))
+ {
+ if (Read_Byte (dev->usb_handle, 0xf910, &data) == OK)
+ {
+ if ((data & 8) == 0)
+ usleep (1000 * 100);
+ else
+ break;
+ }
+ else
+ rst = ERROR;
+ }
+
+ DBG (DBG_FNC, "- RTS_WaitInitEnd: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Motor_Change (struct st_device *dev, SANE_Byte * buffer, SANE_Byte value)
+{
+ SANE_Int data, rst;
+
+ DBG (DBG_FNC, "+ Motor_Change(*buffer, value=%i):\n", value);
+
+ if (Read_Word (dev->usb_handle, 0xe954, &data) == OK)
+ {
+ data &= 0xcf; /*--00----*/
+ value--;
+ switch (value)
+ {
+ case 2:
+ data |= 0x30;
+ break; /*--11----*/
+ case 1:
+ data |= 0x20;
+ break; /*--10----*/
+ case 0:
+ data |= 0x10;
+ break; /*--01----*/
+ }
+
+ buffer[0x154] = _B0 (data);
+
+ rst = Write_Byte (dev->usb_handle, 0xe954, buffer[0x154]);
+ }
+ else
+ rst = ERROR;
+
+ DBG (DBG_FNC, "- Motor_Change: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_DMA_Read (struct st_device *dev, SANE_Int dmacs, SANE_Int options,
+ SANE_Int size, SANE_Byte * buffer)
+{
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC,
+ "+ RTS_DMA_Read(dmacs=%04x, options=%04x, size=%i., *buffer):\n",
+ dmacs, options, size);
+
+ /* is there any buffer to send? */
+ if ((buffer != NULL) && (size > 0))
+ {
+ /* reset dma */
+ if (RTS_DMA_Reset (dev) == OK)
+ {
+ /* prepare dma to read */
+ if (RTS_DMA_Enable_Read (dev, dmacs, size, options) == OK)
+ {
+ SANE_Int transferred;
+
+ rst =
+ Bulk_Operation (dev, BLK_READ, size, buffer, &transferred);
+ }
+ }
+ }
+
+ DBG (DBG_FNC, "- RTS_DMA_Read(): %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_DMA_Write (struct st_device *dev, SANE_Int dmacs, SANE_Int options,
+ SANE_Int size, SANE_Byte * buffer)
+{
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC,
+ "+ RTS_DMA_Write(dmacs=%04x, options=%04x, size=%i., *buffer):\n",
+ dmacs, options, size);
+
+ /* is there any buffer to send? */
+ if ((buffer != NULL) && (size > 0))
+ {
+ /* reset dma */
+ if (RTS_DMA_Reset (dev) == OK)
+ {
+ /* prepare dma to write */
+ if (RTS_DMA_Enable_Write (dev, dmacs, size, options) == OK)
+ {
+ SANE_Int transferred;
+ SANE_Byte *check_buffer;
+
+ check_buffer = (SANE_Byte *) malloc (size);
+ if (check_buffer != NULL)
+ {
+ /* if some transfer fails we try again until ten times */
+ SANE_Int a;
+ for (a = 10; a > 0; a--)
+ {
+ /* send buffer */
+ Bulk_Operation (dev, BLK_WRITE, size, buffer,
+ &transferred);
+
+ /* prepare dma to read */
+ if (RTS_DMA_Enable_Read (dev, dmacs, size, options) ==
+ OK)
+ {
+ SANE_Int b = 0, diff = FALSE;
+
+ /* read buffer */
+ Bulk_Operation (dev, BLK_READ, size, check_buffer,
+ &transferred);
+
+ /* check buffers */
+ while ((b < size) && (diff == FALSE))
+ {
+ if (buffer[b] == check_buffer[b])
+ b++;
+ else
+ diff = TRUE;
+ }
+
+ /* if buffers are equal we can break loop */
+ if (diff == TRUE)
+ {
+ /* cancel dma */
+ RTS_DMA_Cancel (dev);
+
+ /* prepare dma to write buffer again */
+ if (RTS_DMA_Enable_Write
+ (dev, dmacs, size, options) != OK)
+ break;
+ }
+ else
+ {
+ /* everything went ok */
+ rst = OK;
+ break;
+ }
+ }
+ else
+ break;
+ }
+
+ /* free check buffer */
+ free (check_buffer);
+ }
+ else
+ {
+ /* for some reason it's not posible to allocate space to check
+ sent buffer so we just write data */
+ Bulk_Operation (dev, BLK_WRITE, size, buffer, &transferred);
+ rst = OK;
+ }
+ }
+ }
+ }
+
+ DBG (DBG_FNC, "- RTS_DMA_Write(): %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_DMA_CheckType (struct st_device *dev, SANE_Byte * Regs)
+{
+ /* This function tries to detect what kind of RAM supports chipset */
+ /* Returns a value between 0 and 4. -1 means error */
+
+ SANE_Int rst = -1;
+
+ DBG (DBG_FNC, "+ RTS_DMA_CheckType(*Regs):\n");
+
+ if (Regs != NULL)
+ {
+ SANE_Byte *out_buffer;
+
+ /* define buffer to send */
+ out_buffer = (SANE_Byte *) malloc (sizeof (SANE_Byte) * 2072);
+ if (out_buffer != NULL)
+ {
+ SANE_Byte *in_buffer;
+
+ /* define incoming buffer */
+ in_buffer = (SANE_Byte *) malloc (sizeof (SANE_Byte) * 2072);
+ if (in_buffer != NULL)
+ {
+ SANE_Int a, b, diff;
+
+ /* fill outgoing buffer with a known pattern */
+ b = 0;
+ for (a = 0; a < 2072; a++)
+ {
+ out_buffer[a] = b;
+ b++;
+ if (b == 0x61)
+ b = 0;
+ }
+
+ /* let's send buffer with different ram types and compare
+ incoming buffer until getting the right type */
+
+ for (a = 4; a >= 0; a--)
+ {
+ /* set ram type */
+ if (RTS_DMA_SetType (dev, Regs, a) != OK)
+ break;
+
+ /* wait 1500 miliseconds */
+ if (RTS_DMA_WaitReady (dev, 1500) == OK)
+ {
+ /* reset dma */
+ RTS_DMA_Reset (dev);
+
+ /* write buffer */
+ RTS_DMA_Write (dev, 0x0004, 0x102, 2072, out_buffer);
+
+ /* now read buffer */
+ RTS_DMA_Read (dev, 0x0004, 0x102, 2072, in_buffer);
+
+ /* check buffers */
+ b = 0;
+ diff = FALSE;
+ while ((b < 2072) && (diff == FALSE))
+ {
+ if (out_buffer[b] == in_buffer[b])
+ b++;
+ else
+ diff = TRUE;
+ }
+
+ /* if buffers are equal */
+ if (diff == FALSE)
+ {
+ SANE_Int data = 0;
+
+ /* buffers are equal so we've found the right ram type */
+ memset (out_buffer, 0, 0x20);
+ for (b = 0; b < 0x20; b += 2)
+ out_buffer[b] = b;
+
+ /* write buffer */
+ if (RTS_DMA_Write
+ (dev, 0x0004, 0x0000, 0x20, out_buffer) == OK)
+ {
+ SANE_Int c = 0;
+ diff = TRUE;
+
+ do
+ {
+ c++;
+ for (b = 1; b < 0x20; b += 2)
+ out_buffer[b] = c;
+
+ if (RTS_DMA_Write
+ (dev, 0x0004, (_B0 (c) << 0x11) >> 0x04,
+ 0x20, out_buffer) == OK)
+ {
+ if (RTS_DMA_Read
+ (dev, 0x0004, 0x0000, 0x20,
+ in_buffer) == OK)
+ {
+ b = 0;
+ diff = FALSE;
+ while ((b < 0x20)
+ && (diff == FALSE))
+ {
+ if (out_buffer[b] ==
+ in_buffer[b])
+ b++;
+ else
+ diff = TRUE;
+ }
+
+ if (diff == FALSE)
+ data = c << 7;
+ }
+ }
+ }
+ while ((c < 0x80) && (diff == TRUE));
+ }
+
+ switch (data)
+ {
+ case 16384:
+ Regs[0x708] &= 0x1f;
+ Regs[0x708] |= 0x80;
+ break;
+ case 8192:
+ Regs[0x708] &= 0x1f;
+ Regs[0x708] |= 0x60;
+ break;
+ case 4096:
+ Regs[0x708] &= 0x1f;
+ Regs[0x708] |= 0x40;
+ break;
+ case 2048:
+ Regs[0x708] &= 0x1f;
+ Regs[0x708] |= 0x20;
+ break;
+ case 1024:
+ Regs[0x708] &= 0x1f;
+ data = 0x200;
+ break;
+ case 128:
+ Regs[0x708] &= 0x1f;
+ break;
+ }
+
+ DBG (DBG_FNC, " -> data1 = 0x%08x\n",
+ (data * 4) * 1024);
+ DBG (DBG_FNC, " -> data2 = 0x%08x\n", data * 1024);
+ DBG (DBG_FNC, " -> type = 0x%04x\n",
+ Regs[0x708] >> 5);
+
+ RTS_DMA_SetType (dev, Regs, Regs[0x708] >> 5);
+
+ rst = OK;
+ break;
+ }
+ }
+ else
+ break;
+ }
+
+ free (in_buffer);
+ }
+
+ free (out_buffer);
+ }
+ }
+
+ DBG (DBG_FNC, "- RTS_DMA_CheckType(): %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_DMA_SetType (struct st_device *dev, SANE_Byte * Regs, SANE_Byte ramtype)
+{
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "+ RTS_DMA_SetType(*Regs, ramtype=%i):\n", ramtype);
+
+ if (Regs != NULL)
+ {
+ data_bitset (&Regs[0x708], 0x08, 0); /*----0---*/
+
+ if (Write_Byte (dev->usb_handle, 0xef08, Regs[0x708]) == OK)
+ {
+ data_bitset (&Regs[0x708], 0xe0, ramtype);
+
+ if (Write_Byte (dev->usb_handle, 0xef08, Regs[0x708]) == OK)
+ {
+ data_bitset (&Regs[0x708], 0x08, 1); /*----1---*/
+ rst = Write_Byte (dev->usb_handle, 0xef08, Regs[0x708]);
+ }
+ }
+ }
+
+ DBG (DBG_FNC, "- RTS_DMA_SetType: %i\n", rst);
+
+ return rst;
+}
+
+static void
+Motor_Release (struct st_device *dev)
+{
+ SANE_Byte data = 0;
+
+ DBG (DBG_FNC, "+ Motor_Release:\n");
+
+ if (Read_Byte (dev->usb_handle, 0xe8d9, &data) == OK)
+ {
+ data |= 4;
+ Write_Byte (dev->usb_handle, 0xe8d9, data);
+ }
+
+ DBG (DBG_FNC, "- Motor_Release:\n");
+}
+
+static SANE_Byte
+GainOffset_Counter_Load (struct st_device *dev)
+{
+ SANE_Byte data = 0x0f;
+
+ DBG (DBG_FNC, "+ GainOffset_Counter_Load:\n");
+
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ if (RTS_EEPROM_ReadByte (dev->usb_handle, 0x77, &data) != OK)
+ data = 0x0f;
+
+ DBG (DBG_FNC, "- GainOffset_Counter_Load: %i\n", _B0 (data));
+
+ return data;
+}
+
+static SANE_Int
+RTS_Execute (struct st_device *dev)
+{
+ SANE_Byte e813, e800;
+ SANE_Int ret;
+
+ DBG (DBG_FNC, "+ RTS_Execute:\n");
+
+ e813 = 0;
+ e800 = 0;
+ ret = ERROR;
+
+ if (Read_Byte (dev->usb_handle, 0xe800, &e800) == OK)
+ {
+ if (Read_Byte (dev->usb_handle, 0xe813, &e813) == OK)
+ {
+ e813 &= 0xbf;
+ if (Write_Byte (dev->usb_handle, 0xe813, e813) == OK)
+ {
+ e800 |= 0x40;
+ if (Write_Byte (dev->usb_handle, 0xe800, e800) == OK)
+ {
+ e813 |= 0x40;
+ if (Write_Byte (dev->usb_handle, 0xe813, e813) == OK)
+ {
+ e800 &= 0xbf;
+ if (Write_Byte (dev->usb_handle, 0xe800, e800) == OK)
+ {
+ usleep (1000 * 100);
+ e800 |= 0x80;
+ ret = Write_Byte (dev->usb_handle, 0xe800, e800);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ DBG (DBG_FNC, "- RTS_Execute: %i\n", ret);
+
+ return ret;
+}
+
+static SANE_Int
+RTS_isTmaAttached (struct st_device *dev)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ RTS_isTmaAttached:\n");
+
+ /* returns 0 if Tma is attached. Otherwise 1 */
+ if (Read_Word (dev->usb_handle, 0xe968, &rst) == OK)
+ {
+ rst = ((_B1 (rst) & 2) != 0) ? FALSE : TRUE;
+ }
+ else
+ rst = TRUE;
+
+ DBG (DBG_FNC, "- RTS_isTmaAttached: %s\n", (rst == TRUE) ? "Yes" : "No");
+
+ return rst;
+}
+
+static SANE_Int
+Gamma_AllocTable (SANE_Byte * table)
+{
+ SANE_Int C;
+ SANE_Int rst = OK;
+
+ hp_gamma->depth = 8;
+
+ for (C = 0; C < 3; C++)
+ if (hp_gamma->table[C] == NULL)
+ hp_gamma->table[C] = malloc (sizeof (SANE_Byte) * 256);
+
+ if ((hp_gamma->table[CL_RED] != NULL) &&
+ (hp_gamma->table[CL_GREEN] != NULL) &&
+ (hp_gamma->table[CL_BLUE] != NULL))
+ {
+ /* All tables allocated */
+ for (C = 0; C < 256; C++)
+ {
+ if ((table != NULL) && (RTS_Debug->EnableGamma == TRUE))
+ {
+ /* fill gamma tables with user defined values */
+ hp_gamma->table[CL_RED][C] = table[C];
+ hp_gamma->table[CL_GREEN][C] = table[0x100 + C];
+ hp_gamma->table[CL_BLUE][C] = table[0x200 + C];
+ }
+ else
+ {
+ hp_gamma->table[CL_RED][C] = C;
+ hp_gamma->table[CL_GREEN][C] = C;
+ hp_gamma->table[CL_BLUE][C] = C;
+ }
+ }
+
+ /* Locate threshold of bw */
+ for (C = 0; C < 256; C++)
+ if (hp_gamma->table[CL_RED][C] != 0)
+ break;
+
+ bw_threshold = C - 1;
+ }
+ else
+ {
+ /* Some alloc failed */
+ rst = ERROR;
+
+ Gamma_FreeTables ();
+ }
+
+ DBG (DBG_FNC, "> Gamma_AllocTable: %i >> bw_threshold = %i\n", rst,
+ bw_threshold);
+
+ return rst;
+}
+
+static SANE_Int
+Gamma_Apply (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg, struct st_hwdconfig *hwdcfg,
+ struct st_gammatables *mygamma)
+{
+ SANE_Int rst = OK;
+
+ DBG (DBG_FNC, "+ Gamma_Apply(*Regs, *scancfg, *hwdcfg, *mygamma):\n");
+ dbg_ScanParams (scancfg);
+
+ if (hwdcfg->use_gamma_tables == FALSE)
+ {
+ DBG (DBG_FNC, "-> Gamma tables are not used\n");
+
+ v1600 = NULL;
+ v1604 = NULL;
+ v1608 = NULL;
+ }
+ else
+ {
+ /*390b */
+ SANE_Int table_size, buffersize, c;
+ SANE_Byte channels, *gammabuffer;
+
+ DBG (DBG_FNC, "-> Using gamma tables\n");
+
+ /* get channels count */
+ channels = 3; /* default */
+
+ if (scancfg->colormode != CM_COLOR)
+ {
+ if (scancfg->channel != 3)
+ {
+ if (scancfg->colormode != 3)
+ channels = (scancfg->samplerate == PIXEL_RATE) ? 2 : 1;
+ }
+ }
+
+ /* get size for gamma tables */
+ switch (mygamma->depth & 0x0c)
+ {
+ case 0:
+ table_size = 0x100 + (mygamma->depth & 1);
+ break;
+ case 4:
+ table_size = 0x400 + (mygamma->depth & 1);
+ break;
+ case 8:
+ table_size = 0x1000 + (mygamma->depth & 1);
+ break;
+ default:
+ table_size = 2;
+ break;
+ }
+
+ /* allocate space for gamma buffer */
+ buffersize = table_size * channels;
+ gammabuffer = (SANE_Byte *) malloc (buffersize * sizeof (SANE_Byte));
+ if (gammabuffer != NULL)
+ {
+ /* update gamma pointers for each channel */
+ v1600 = (SANE_Byte *) & mygamma->table[CL_RED];
+ v1604 = (SANE_Byte *) & mygamma->table[CL_GREEN];
+ v1608 = (SANE_Byte *) & mygamma->table[CL_BLUE];
+
+ /* include gamma tables into one buffer */
+ for (c = 0; c < channels; c++)
+ memcpy (gammabuffer + (c * table_size), mygamma->table[c],
+ table_size);
+
+ /* send gamma buffer to scanner */
+ Write_Byte (dev->usb_handle, 0xee0b, Regs[0x060b] & 0xaf);
+ rst = Gamma_SendTables (dev, Regs, gammabuffer, buffersize);
+ Write_Byte (dev->usb_handle, 0xee0b, Regs[0x060b]);
+
+ /* free gamma buffer */
+ free (gammabuffer);
+ }
+ else
+ rst = ERROR;
+ }
+
+ return rst;
+}
+
+static SANE_Int
+Refs_Analyze_Pattern (struct st_scanparams *scancfg,
+ SANE_Byte * scanned_pattern, SANE_Int * ler1,
+ SANE_Int ler1order, SANE_Int * ser1, SANE_Int ser1order)
+{
+ SANE_Int buffersize, xpos, ypos, coord, cnt, chn_size, dist, rst;
+ double *color_sum, *color_dif, diff_max;
+ SANE_Int vector[3];
+
+ DBG (DBG_FNC,
+ "+ Refs_Analyze_Pattern(depth=%i, width=%i, height=%i, *scanned_pattern, *ler1, ler1order=%i, *ser1, ser1order=%i)\n",
+ scancfg->depth, scancfg->coord.width, scancfg->coord.height, ler1order,
+ ser1order);
+
+ rst = ERROR; /* by default */
+ dist = 5; /* distance to compare */
+ chn_size = (scancfg->depth > 8) ? 2 : 1;
+ buffersize = max (scancfg->coord.width, scancfg->coord.height);
+
+ color_sum = (double *) malloc (sizeof (double) * buffersize);
+ if (color_sum != NULL)
+ {
+ color_dif = (double *) malloc (sizeof (double) * buffersize);
+ if (color_dif != NULL)
+ {
+ /*-------- 1st SER -------- */
+ coord = 1;
+
+ if ((scancfg->coord.width - dist) > 1)
+ {
+ /* clear buffers */
+ bzero (color_sum, sizeof (double) * buffersize);
+ bzero (color_dif, sizeof (double) * buffersize);
+
+ for (xpos = 0; xpos < scancfg->coord.width; xpos++)
+ {
+ for (ypos = 0; ypos < 20; ypos++)
+ color_sum[xpos] +=
+ data_lsb_get (scanned_pattern +
+ (scancfg->coord.width * ypos) + xpos,
+ chn_size);
+ }
+
+ diff_max =
+ (ser1order !=
+ 0) ? color_sum[0] - color_sum[1] : color_sum[1] -
+ color_sum[0];
+ color_dif[0] = diff_max;
+ cnt = 1;
+
+ do
+ {
+ color_dif[cnt] =
+ (ser1order !=
+ 0) ? color_sum[cnt] - color_sum[cnt +
+ dist] : color_sum[cnt +
+ dist] -
+ color_sum[cnt];
+
+ if ((color_dif[cnt] >= 0) && (color_dif[cnt] > diff_max))
+ {
+ /*d4df */
+ diff_max = color_dif[cnt];
+ if (abs (color_dif[cnt] - color_dif[cnt - 1]) >
+ abs (color_dif[coord] - color_dif[coord - 1]))
+ coord = cnt;
+ }
+
+ cnt++;
+ }
+ while (cnt < (scancfg->coord.width - dist));
+ }
+
+ vector[0] = coord + dist;
+
+ /*-------- 1st LER -------- */
+ coord = 1;
+
+ if ((scancfg->coord.height - dist) > 1)
+ {
+ /* clear buffers */
+ bzero (color_sum, sizeof (double) * buffersize);
+ bzero (color_dif, sizeof (double) * buffersize);
+
+ for (ypos = 0; ypos < scancfg->coord.height; ypos++)
+ {
+ for (xpos = vector[0]; xpos < scancfg->coord.width - dist;
+ xpos++)
+ color_sum[ypos] +=
+ data_lsb_get (scanned_pattern +
+ (scancfg->coord.width * ypos) + xpos,
+ chn_size);
+ }
+
+ diff_max =
+ (ler1order !=
+ 0) ? color_sum[0] - color_sum[1] : color_sum[1] -
+ color_sum[0];
+ color_dif[0] = diff_max;
+
+ cnt = 1;
+
+ do
+ {
+ color_dif[cnt] =
+ (ler1order !=
+ 0) ? color_sum[cnt] - color_sum[cnt +
+ dist] : color_sum[cnt +
+ dist] -
+ color_sum[cnt];
+
+ if ((color_dif[cnt] >= 0) && (color_dif[cnt] > diff_max))
+ {
+ diff_max = color_dif[cnt];
+ if (abs (color_dif[cnt] - color_dif[cnt - 1]) >
+ abs (color_dif[coord] - color_dif[coord - 1]))
+ coord = cnt;
+ }
+
+ cnt++;
+ }
+ while (cnt < (scancfg->coord.height - dist));
+ }
+
+ vector[1] = coord + dist;
+
+ /*-------- 1st LER -------- */
+ if ((scancfg->coord.width - dist) > 1)
+ {
+ /* clear buffers */
+ bzero (color_sum, sizeof (double) * buffersize);
+ bzero (color_dif, sizeof (double) * buffersize);
+
+ for (xpos = 0; xpos < scancfg->coord.width; xpos++)
+ {
+ for (ypos = coord + 4; ypos < scancfg->coord.height; ypos++)
+ color_sum[xpos] +=
+ data_lsb_get (scanned_pattern +
+ (scancfg->coord.width * ypos) + xpos,
+ chn_size);
+ }
+
+ diff_max =
+ (ser1order !=
+ 0) ? color_sum[0] - color_sum[1] : color_sum[1] -
+ color_sum[0];
+ color_dif[0] = diff_max;
+ cnt = 1;
+
+ do
+ {
+ color_dif[cnt] =
+ (ser1order !=
+ 0) ? color_sum[cnt] - color_sum[cnt +
+ dist] : color_sum[cnt +
+ dist] -
+ color_sum[cnt];
+
+ if ((color_dif[cnt] >= 0) && (color_dif[cnt] > diff_max))
+ {
+ diff_max = color_dif[cnt];
+ if (abs (color_dif[cnt] - color_dif[cnt - 1]) >
+ abs (color_dif[coord] - color_dif[coord - 1]))
+ coord = cnt;
+ }
+
+ cnt++;
+ }
+ while (cnt < (scancfg->coord.width - dist));
+ }
+
+ vector[2] = coord + dist;
+
+ /* save image */
+ if (RTS_Debug->SaveCalibFile != FALSE)
+ dbg_autoref (scancfg, scanned_pattern, vector[0], vector[2],
+ vector[1]);
+
+ /* assign values detected */
+ if (ser1 != NULL)
+ *ser1 = vector[2];
+
+ if (ler1 != NULL)
+ *ler1 = vector[1];
+
+ /* show values */
+ DBG (DBG_FNC, " -> Vectors found: x1=%i, x2=%i, y=%i\n", vector[0],
+ vector[2], vector[1]);
+
+ rst = OK;
+
+ free (color_dif);
+ }
+
+ free (color_sum);
+ }
+
+ DBG (DBG_FNC, "- Refs_Analyze_Pattern: %i\n", rst);
+
+ return rst;
+}
+
+static double
+get_shrd (double value, SANE_Int desp)
+{
+ if (desp <= 0x40)
+ return value / pow (2, desp);
+ else
+ return 0;
+}
+
+static char
+get_byte (double value)
+{
+ unsigned int data;
+ double temp;
+
+ if (value > 0xffffffff)
+ {
+ temp = floor (get_shrd (value, 0x20));
+ temp *= pow (2, 32);
+ value -= temp;
+ }
+
+ data = (unsigned int) value;
+
+ data = _B0 (data);
+
+ return data;
+}
+
+static SANE_Int
+Timing_SetLinearImageSensorClock (SANE_Byte * Regs, struct st_cph *cph)
+{
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC,
+ "+ Timing_SetLinearImageSensorClock(SANE_Byte *Regs, struct st_cph *cph)\n");
+
+ dbg_sensorclock (cph);
+
+ if ((Regs != NULL) && (cph != NULL))
+ {
+ Regs[0x00] = get_byte (cph->p1);
+ Regs[0x01] = get_byte (get_shrd (cph->p1, 0x08));
+ Regs[0x02] = get_byte (get_shrd (cph->p1, 0x10));
+ Regs[0x03] = get_byte (get_shrd (cph->p1, 0x18));
+
+ Regs[0x04] &= 0x80;
+ Regs[0x04] |= ((get_byte (get_shrd (cph->p1, 0x20))) & 0x0f);
+ Regs[0x04] |= ((cph->ps & 1) << 6);
+ Regs[0x04] |= ((cph->ge & 1) << 5);
+ Regs[0x04] |= ((cph->go & 1) << 4);
+
+ Regs[0x05] = get_byte (cph->p2);
+ Regs[0x06] = get_byte (get_shrd (cph->p2, 0x08));
+ Regs[0x07] = get_byte (get_shrd (cph->p2, 0x10));
+ Regs[0x08] = get_byte (get_shrd (cph->p2, 0x18));
+ Regs[0x09] &= 0xf0;
+ Regs[0x09] |= ((get_byte (get_shrd (cph->p2, 0x20))) & 0x0f);
+
+ rst = OK;
+ }
+
+ DBG (DBG_FNC, "- Timing_SetLinearImageSensorClock: %i\n", rst);
+
+ return rst;
+}
+
+static void
+RTS_Setup_SensorTiming (struct st_device *dev, SANE_Int mytiming,
+ SANE_Byte * Regs)
+{
+ DBG (DBG_FNC, "+ RTS_Setup_SensorTiming(mytiming=%i, *Regs):\n", mytiming);
+
+ if ((Regs != NULL) && (mytiming < dev->timings_count))
+ {
+ struct st_timing *mt = dev->timings[mytiming];
+
+ if (mt != NULL)
+ {
+ dbg_timing (mt);
+
+ /* Correlated-Double-Sample 1 & 2 */
+ data_bitset (&Regs[0x92], 0x3f, mt->cdss[0]);
+ data_bitset (&Regs[0x93], 0x3f, mt->cdsc[0]);
+ data_bitset (&Regs[0x94], 0x3f, mt->cdss[1]);
+ data_bitset (&Regs[0x95], 0x3f, mt->cdsc[1]);
+
+ data_bitset (&Regs[0x96], 0x3f, mt->cnpp);
+
+ /* Linear image sensor transfer gates */
+ data_bitset (&Regs[0x45], 0x80, mt->cvtrp[0]);
+ data_bitset (&Regs[0x45], 0x40, mt->cvtrp[1]);
+ data_bitset (&Regs[0x45], 0x20, mt->cvtrp[2]);
+
+ data_bitset (&Regs[0x45], 0x1f, mt->cvtrfpw);
+ data_bitset (&Regs[0x46], 0x1f, mt->cvtrbpw);
+
+ data_lsb_set (&Regs[0x47], mt->cvtrw, 1);
+
+ data_lsb_set (&Regs[0x84], mt->cphbp2s, 3);
+ data_lsb_set (&Regs[0x87], mt->cphbp2e, 3);
+
+ data_lsb_set (&Regs[0x8a], mt->clamps, 3);
+ data_lsb_set (&Regs[0x8d], mt->clampe, 3);
+
+ if (dev->chipset->model == RTS8822L_02A)
+ {
+ if (mt->clampe == -1)
+ data_lsb_set (&Regs[0x8d], mt->cphbp2e, 3);
+ }
+
+ Regs[0x97] = get_byte (mt->adcclkp[0]);
+ Regs[0x98] = get_byte (get_shrd (mt->adcclkp[0], 0x08));
+ Regs[0x99] = get_byte (get_shrd (mt->adcclkp[0], 0x10));
+ Regs[0x9a] = get_byte (get_shrd (mt->adcclkp[0], 0x18));
+ Regs[0x9b] &= 0xf0;
+ Regs[0x9b] |= ((get_byte (get_shrd (mt->adcclkp[0], 0x20))) & 0x0f);
+
+ Regs[0xc1] = get_byte (mt->adcclkp[1]);
+ Regs[0xc2] = get_byte (get_shrd (mt->adcclkp[1], 0x08));
+ Regs[0xc3] = get_byte (get_shrd (mt->adcclkp[1], 0x10));
+ Regs[0xc4] = get_byte (get_shrd (mt->adcclkp[1], 0x18));
+ Regs[0xc5] &= 0xe0;
+ Regs[0xc5] |= ((get_byte (get_shrd (mt->adcclkp[1], 0x20))) & 0x0f);
+
+ /* bit(4) = bit(0) */
+ Regs[0xc5] |= ((mt->adcclkp2e & 1) << 4);
+
+ Timing_SetLinearImageSensorClock (&Regs[0x48], &mt->cph[0]);
+ Timing_SetLinearImageSensorClock (&Regs[0x52], &mt->cph[1]);
+ Timing_SetLinearImageSensorClock (&Regs[0x5c], &mt->cph[2]);
+ Timing_SetLinearImageSensorClock (&Regs[0x66], &mt->cph[3]);
+ Timing_SetLinearImageSensorClock (&Regs[0x70], &mt->cph[4]);
+ Timing_SetLinearImageSensorClock (&Regs[0x7a], &mt->cph[5]);
+ }
+ }
+}
+
+static SANE_Int
+Motor_GetFromResolution (SANE_Int resolution)
+{
+ SANE_Int ret;
+
+ ret = 3;
+ if (RTS_Debug->usbtype != USB11)
+ {
+ if (scan.scantype != ST_NORMAL)
+ {
+ /* scantype is ST_NEG or ST_TA */
+ if (resolution >= 600)
+ ret = 0;
+ }
+ else if (resolution >= 1200)
+ ret = 0;
+ }
+ else if (resolution >= 600)
+ ret = 0;
+
+ DBG (DBG_FNC, "> Motor_GetFromResolution(resolution=%i): %i\n", resolution,
+ ret);
+
+ return ret;
+}
+
+static SANE_Int
+SetMultiExposure (struct st_device *dev, SANE_Byte * Regs)
+{
+ SANE_Int iValue, myctpc;
+
+ DBG (DBG_FNC, "> SetMultiExposure:\n");
+
+ /* set motor has no curves */
+ data_bitset (&Regs[0xdf], 0x10, 0); /*---0----*/
+
+ /* select case systemclock */
+ switch (Regs[0x00] & 0x0f)
+ {
+ case 0x00:
+ iValue = 0x00895440;
+ break; /* 3 x 0x2DC6C0 */
+ case 0x08:
+ case 0x01:
+ iValue = 0x00b71b00;
+ break; /* 4 x 0x2DC6C0 */
+ case 0x02:
+ iValue = 0x0112a880;
+ break; /* 6 x 0x2DC6C0 */
+ case 0x0a:
+ case 0x03:
+ iValue = 0x016e3600;
+ break; /* 8 x 0x2DC6C0 */
+ case 0x04:
+ iValue = 0x02255100;
+ break; /* 12 x 0x2DC6C0 */
+ case 0x0c:
+ iValue = 0x02dc6c00;
+ break; /* 16 x 0x2DC6C0 */
+ case 0x05:
+ iValue = 0x044aa200;
+ break; /* 24 x 0x2DC6C0 */
+ case 0x0d:
+ iValue = 0x05b8d800;
+ break; /* 32 x 0x2DC6C0 */
+
+ case 0x09:
+ iValue = 0x00f42400;
+ break;
+ case 0x0b:
+ iValue = 0x01e84800;
+ break; /* = case 9 * 2 */
+ default:
+ iValue = 0x0478f7f8;
+ break;
+ }
+
+ /* divide by timing.cnpp */
+ iValue /= ((Regs[0x96] & 0x3f) + 1);
+ iValue /= dev->motorcfg->basespeedpps;
+
+ /* get line exposure time */
+ myctpc = data_lsb_get (&Regs[0x30], 3) + 1;
+
+ DBG (DBG_FNC, "CTPC -- SetMultiExposure -- 1 =%i\n", myctpc);
+
+ /* if last step of accurve.normalscan table is lower than iValue ... */
+ if (data_lsb_get (&Regs[0xe1], 3) < iValue)
+ {
+ SANE_Int traget;
+ SANE_Int step_size = _B0 (Regs[0xe0]) + 1;
+
+ /* set exposure time [RED] if zero */
+ if (data_lsb_get (&Regs[0x36], 3) == 0)
+ data_lsb_set (&Regs[0x36], myctpc - 1, 3);
+
+ /* set exposure time [GREEN] if zero */
+ if (data_lsb_get (&Regs[0x3c], 3) == 0)
+ data_lsb_set (&Regs[0x3c], myctpc - 1, 3);
+
+ /* set exposure time [BLUE] if zero */
+ if (data_lsb_get (&Regs[0x42], 3) == 0)
+ data_lsb_set (&Regs[0x42], myctpc - 1, 3);
+
+ iValue = (iValue + 1) * step_size;
+
+ /* update line exposure time */
+ traget = (((myctpc + iValue - 1) / myctpc) * myctpc);
+ data_lsb_set (&Regs[0x30], traget - 1, 3);
+
+ traget = (traget / step_size) - 1;
+ data_lsb_set (&Regs[0x00e1], traget, 3);
+ }
+
+ /* 8300 */
+ return OK;
+}
+
+static SANE_Int
+data_lsb_get (SANE_Byte * address, SANE_Int size)
+{
+ SANE_Int ret = 0;
+ if ((address != NULL) && (size > 0) && (size < 5))
+ {
+ SANE_Int a;
+ SANE_Byte b;
+ size--;
+ for (a = size; a >= 0; a--)
+ {
+ b = address[a];
+ ret = (ret << 8) + b;
+ }
+ }
+ return ret;
+}
+
+static SANE_Byte
+data_bitget (SANE_Byte * address, SANE_Int mask)
+{
+ SANE_Int desp = 0;
+
+ if (mask & 1);
+ else if (mask & 2)
+ desp = 1;
+ else if (mask & 4)
+ desp = 2;
+ else if (mask & 8)
+ desp = 3;
+ else if (mask & 16)
+ desp = 4;
+ else if (mask & 32)
+ desp = 5;
+ else if (mask & 64)
+ desp = 6;
+ else if (mask & 128)
+ desp = 7;
+
+ return (*address & mask) >> desp;
+}
+
+static void
+data_bitset (SANE_Byte * address, SANE_Int mask, SANE_Byte data)
+{
+ /* This function fills mask bits of just a byte with bits given in data */
+ if (mask & 1);
+ else if (mask & 2)
+ data <<= 1;
+ else if (mask & 4)
+ data <<= 2;
+ else if (mask & 8)
+ data <<= 3;
+ else if (mask & 16)
+ data <<= 4;
+ else if (mask & 32)
+ data <<= 5;
+ else if (mask & 64)
+ data <<= 6;
+ else if (mask & 128)
+ data <<= 7;
+
+ *address = (*address & (0xff - mask)) | (data & mask);
+}
+
+static void
+data_wide_bitset (SANE_Byte * address, SANE_Int mask, SANE_Int data)
+{
+ /* Setting bytes bit per bit
+ mask is 4 bytes size
+ Example:
+ data = 0111010111
+ mask = 00000000 11111111 11000000 00000000
+ rst = 00000000 01110101 11000000 00000000 */
+
+ SANE_Int mymask, started = FALSE;
+
+ if ((address != NULL) && (mask != 0))
+ {
+ while (mask != 0)
+ {
+ mymask = _B0 (mask);
+
+ if (started == FALSE)
+ {
+ if (mymask != 0)
+ {
+ SANE_Int a, myvalue;
+
+ for (a = 0; a < 8; a++)
+ if ((mymask & (1 << a)) != 0)
+ break;
+
+ myvalue = _B0 (data << a);
+ myvalue >>= a;
+ data_bitset (address, mymask, myvalue);
+ data >>= (8 - a);
+ started = TRUE;
+ }
+ }
+ else
+ {
+ data_bitset (address, mymask, _B0 (data));
+ data >>= 8;
+ }
+
+ address++;
+ mask >>= 8;
+ }
+ }
+}
+
+
+static void
+data_lsb_set (SANE_Byte * address, SANE_Int data, SANE_Int size)
+{
+ if ((address != NULL) && (size > 0) && (size < 5))
+ {
+ SANE_Int a;
+ for (a = 0; a < size; a++)
+ {
+ address[a] = _B0 (data);
+ data >>= 8;
+ }
+ }
+}
+
+static void
+data_msb_set (SANE_Byte * address, SANE_Int data, SANE_Int size)
+{
+ if ((address != NULL) && (size > 0) && (size < 5))
+ {
+ SANE_Int a;
+
+ for (a = size - 1; a >= 0; a--)
+ {
+ address[a] = _B0 (data);
+ data >>= 8;
+ }
+ }
+}
+
+static SANE_Int
+data_swap_endianess (SANE_Int address, SANE_Int size)
+{
+ SANE_Int rst = 0;
+
+ if ((size > 0) && (size < 5))
+ {
+ SANE_Int a;
+
+ for (a = 0; a < size; a++)
+ {
+ rst = (rst << 8) | _B0 (address);
+ address >>= 8;
+ }
+ }
+
+ return rst;
+}
+
+static void
+Lamp_SetGainMode (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Int resolution, SANE_Byte gainmode)
+{
+ DBG (DBG_FNC, "> Lamp_SetGainMode(*Regs, resolution=%i, gainmode=%i):\n",
+ resolution, gainmode);
+
+ if (dev->chipset->model == RTS8822L_02A)
+ {
+ /* hp4370 */
+ SANE_Int data1, data2;
+
+ data1 = data_lsb_get (&Regs[0x154], 2) & 0xfe7f;
+ data2 = data_lsb_get (&Regs[0x156], 2);
+
+ switch (resolution)
+ {
+ case 4800:
+ data2 |= 0x40;
+ data1 &= 0xffbf;
+ break;
+ case 100:
+ case 150:
+ case 200:
+ case 300:
+ case 600:
+ case 1200:
+ case 2400:
+ data1 |= 0x40;
+ data2 &= 0xffbf;
+ break;
+ }
+
+ data_lsb_set (&Regs[0x154], data1, 2);
+ data_lsb_set (&Regs[0x156], data2, 2);
+ }
+ else
+ {
+ /* hp3970 hp4070 ua4900 */
+ SANE_Int data;
+
+ data = data_lsb_get (&Regs[0x154], 2) & 0xfe7f;
+ data = (gainmode == FALSE) ? data | 0x0040 : data & 0xffbf;
+
+ switch (resolution)
+ {
+ case 100:
+ case 200:
+ case 300:
+ case 600:
+ data |= 0x0100;
+ break;
+ case 2400:
+ data |= 0x0180;
+ break;
+ case 1200:
+ if (dev->sensorcfg->type == CIS_SENSOR)
+ data |= 0x80;
+ else if (dev->sensorcfg->type == CCD_SENSOR)
+ data |= 0x0180;
+ break;
+ }
+
+ data_lsb_set (&Regs[0x0154], data, 2);
+ }
+}
+
+static SANE_Int
+RTS_Scanner_StartScan (struct st_device *dev)
+{
+ SANE_Int rst = ERROR; /* default */
+ SANE_Int data;
+
+ DBG (DBG_FNC, "+ RTS_Scanner_StartScan():\n");
+
+ v14b4 = 1; /* TEMPORAL */
+ data = 0;
+ Lamp_PWM_DutyCycle_Get (dev, &data);
+ data = _B0 (data);
+
+ DBG (DBG_FNC, "-> Pwm used = %i\n", data);
+
+ /*
+ windows driver saves pwm used, in file usbfile
+ Section [SCAN_PARAM], field PwmUsed
+ */
+
+ dev->status->cancel = FALSE;
+
+ if (Scan_Start (dev) == OK)
+ {
+ SANE_Int transferred;
+
+ rst = OK;
+
+ if (dev->scanning->imagebuffer != NULL)
+ {
+ free (dev->scanning->imagebuffer);
+ dev->scanning->imagebuffer = NULL;
+ }
+
+ SetLock (dev->usb_handle, NULL, (scan2.depth == 16) ? FALSE : TRUE);
+
+ /* Reservamos los buffers necesarios para leer la imagen */
+ Reading_CreateBuffers (dev);
+
+ if (dev->Resize->type != RSZ_NONE)
+ Resize_Start (dev, &transferred); /* 6729 */
+
+ RTS_ScanCounter_Inc (dev);
+ }
+
+ DBG (DBG_FNC, "- RTS_Scanner_StartScan: %i\n", rst);
+
+ return rst;
+}
+
+static void
+Triplet_Gray (SANE_Byte * pPointer1, SANE_Byte * pPointer2,
+ SANE_Byte * buffer, SANE_Int channels_count)
+{
+ /*
+ pPointer1 = FAB8
+ pPointer2 = FABC
+ buffer = FAC0
+ channels_count = FAC4
+ */
+
+ SANE_Int value;
+ SANE_Int channel_size;
+
+ DBG (DBG_FNC,
+ "> Triplet_Gray(*pPointer1, *pPointer2, *buffer, channels_count=%i)\n",
+ channels_count);
+
+ channel_size = (scan2.depth > 8) ? 2 : 1;
+ channels_count = channels_count / 2;
+
+ while (channels_count > 0)
+ {
+ value = data_lsb_get (pPointer1, channel_size);
+ data_lsb_set (buffer, value, channel_size);
+
+ value = data_lsb_get (pPointer2, channel_size);
+ data_lsb_set (buffer + channel_size, value, channel_size);
+
+ pPointer1 += 2 * channel_size;
+ pPointer2 += 2 * channel_size;
+ buffer += 2 * channel_size;
+
+ channels_count--;
+ }
+}
+
+static void
+Triplet_Lineart (SANE_Byte * pPointer1, SANE_Byte * pPointer2,
+ SANE_Byte * buffer, SANE_Int channels_count)
+{
+ /* Composing colour in lineart mode */
+
+ SANE_Int dots_count = 0;
+ SANE_Int channel;
+ SANE_Byte mask;
+ SANE_Byte value;
+ SANE_Int C;
+
+ DBG (DBG_FNC,
+ "> Triplet_Lineart(*pPointer1, *pPointer2, *buffer, channels_count=%i)\n",
+ channels_count);
+
+ if (channels_count > 0)
+ {
+ dots_count = (channels_count + 1) / 2;
+ while (dots_count > 0)
+ {
+ mask = 0x80;
+ channel = 2;
+ do
+ {
+ value = 0;
+ for (C = 4; C > 0; C--)
+ {
+ value =
+ (value << 2) +
+ (((*pPointer2 & mask) << 1) | (*pPointer1 & mask));
+ mask = mask >> 1;
+ }
+ *buffer = value;
+ buffer++;
+ channel--;
+ }
+ while (channel > 0);
+ pPointer2 += 2;
+ pPointer1 += 2;
+ dots_count--;
+ }
+ }
+}
+
+static SANE_Int
+Arrange_NonColour (struct st_device *dev, SANE_Byte * buffer,
+ SANE_Int buffer_size, SANE_Int * transferred)
+{
+ /*
+ buffer : fadc
+ buffer_size : fae0
+ */
+
+ SANE_Int lines_count = 0; /* ebp */
+ SANE_Int channels_count = 0; /* fadc pisa buffer */
+ SANE_Int rst = ERROR;
+ struct st_scanning *scn;
+
+ DBG (DBG_FNC,
+ "+ Arrange_NonColour(*buffer, buffer_size=%i, *transferred):\n",
+ buffer_size);
+
+ /* this is just to make code more legible */
+ scn = dev->scanning;
+
+ if (scn->imagebuffer == NULL)
+ {
+ if ((scn->arrange_hres == TRUE) || (scan2.colormode == CM_LINEART))
+ {
+ scn->bfsize = (scn->arrange_sensor_evenodd_dist + 1) * line_size;
+ scn->imagebuffer =
+ (SANE_Byte *) malloc (scn->bfsize * sizeof (SANE_Byte));
+ if (scn->imagebuffer != NULL)
+ {
+ if (Read_Block (dev, scn->bfsize, scn->imagebuffer, transferred)
+ == OK)
+ {
+ scn->channel_size = (scan2.depth == 8) ? 1 : 2;
+ scn->desp1[CL_RED] = 0;
+ scn->desp2[CL_RED] =
+ scn->channel_size +
+ (scn->arrange_sensor_evenodd_dist * line_size);
+ scn->pColour2[CL_RED] =
+ scn->imagebuffer + scn->desp2[CL_RED];
+ scn->pColour1[CL_RED] =
+ scn->imagebuffer + scn->desp1[CL_RED];
+ rst = OK;
+ }
+ }
+ }
+ }
+ else
+ rst = OK;
+
+ /* b0f4 */
+ if (rst == OK)
+ {
+ scn->imagepointer = scn->imagebuffer;
+ lines_count = buffer_size / line_size;
+ channels_count = line_size / scn->channel_size;
+ while (lines_count > 0)
+ {
+ if (scan2.colormode == CM_LINEART)
+ Triplet_Lineart (scn->pColour1[CL_RED], scn->pColour2[CL_RED],
+ buffer, channels_count);
+ else
+ Triplet_Gray (scn->pColour1[CL_RED], scn->pColour2[CL_RED],
+ buffer, channels_count);
+
+ buffer += line_size;
+ scn->arrange_size -= bytesperline;
+
+ lines_count--;
+ if (lines_count == 0)
+ {
+ if ((scn->arrange_size | v15bc) == 0)
+ break;
+ }
+
+ rst = Read_Block (dev, line_size, scn->imagepointer, transferred);
+ if (rst != OK)
+ break;
+
+ if (scn->arrange_hres == TRUE)
+ {
+ scn->desp2[CL_RED] =
+ (line_size + scn->desp2[CL_RED]) % scn->bfsize;
+ scn->desp1[CL_RED] =
+ (line_size + scn->desp1[CL_RED]) % scn->bfsize;
+
+ scn->pColour2[CL_RED] = scn->imagebuffer + scn->desp2[CL_RED];
+ scn->pColour1[CL_RED] = scn->imagebuffer + scn->desp1[CL_RED];
+ }
+
+ /* b21d */
+ scn->imagepointer += line_size;
+ if (scn->imagepointer >= (scn->imagebuffer + scn->bfsize))
+ scn->imagepointer = scn->imagebuffer;
+ }
+ }
+
+ /* 2246 */
+
+ DBG (DBG_FNC, "- Arrange_NonColour(*transferred=%i): %i\n", *transferred,
+ rst);
+
+ return rst;
+}
+
+static SANE_Int
+Resize_Decrease (SANE_Byte * to_buffer, SANE_Int to_resolution,
+ SANE_Int to_width, SANE_Byte * from_buffer,
+ SANE_Int from_resolution, SANE_Int from_width,
+ SANE_Int myresize_mode)
+{
+ /*
+ to_buffer = FAC8 = 0x236200
+ to_resolution = FACC = 0x4b
+ to_width = FAD0 = 0x352
+ from_buffer = FAD4 = 0x235460
+ from_resolution = FAD8 = 0x64
+ from_width = FADC = 0x46d
+ myresize_mode = FAE0 = 1
+ */
+
+ SANE_Int rst = ERROR;
+ SANE_Int channels = 0; /* fac8 */
+ SANE_Int depth = 0; /* fae0 */
+ SANE_Int color[3] = { 0, 0, 0 }; /* fab8 | fabc | fac0 */
+ SANE_Int to_pos = 0; /* fad4 */
+ SANE_Int rescont = 0;
+ SANE_Int from_pos = 0; /* fab4 */
+ SANE_Int C;
+ SANE_Int smres = 0; /* fab0 */
+ SANE_Int value;
+ SANE_Int channel_size;
+
+ to_resolution = to_resolution & 0xffff;
+ from_resolution = from_resolution & 0xffff;
+
+ DBG (DBG_FNC,
+ "+ Resize_Decrease(*to_buffer, to_resolution=%i, to_width=%i, *from_buffer, from_resolution=%i, from_width=%i, myresize_mode=%i):\n",
+ to_resolution, to_width, from_resolution, from_width, myresize_mode);
+
+ if (myresize_mode != RSZ_LINEART)
+ {
+ switch (myresize_mode)
+ {
+ case RSZ_GRAYL:
+ channels = 1;
+ depth = 8;
+ break;
+ case RSZ_COLOURL:
+ channels = 3;
+ depth = 8;
+ break;
+ case RSZ_COLOURH:
+ channels = 3;
+ depth = 16;
+ break;
+ case RSZ_GRAYH:
+ channels = 1;
+ depth = 16;
+ break;
+ }
+
+ channel_size = (depth > 8) ? 2 : 1;
+ to_pos = 0;
+ rescont = 0;
+
+ while (to_pos < to_width)
+ {
+ from_pos++;
+ if (from_pos > from_width)
+ from_buffer -= (((depth + 7) / 8) * channels);
+
+ rescont += to_resolution;
+ if (rescont < from_resolution)
+ {
+ /* Adds 3 color channel values */
+ for (C = 0; C < channels; C++)
+ {
+ color[C] +=
+ data_lsb_get (from_buffer, channel_size) * to_resolution;
+ from_buffer += channel_size;
+ }
+ }
+ else
+ {
+ /* fc3c */
+ to_pos++;
+ smres = to_resolution - (rescont - from_resolution);
+ for (C = 0; C < channels; C++)
+ {
+ value =
+ ((data_lsb_get (from_buffer, channel_size) * smres) +
+ color[C]) / from_resolution;
+ data_lsb_set (to_buffer, value, channel_size);
+ color[C] =
+ data_lsb_get (from_buffer,
+ channel_size) * (rescont - from_resolution);
+
+ to_buffer += channel_size;
+ from_buffer += channel_size;
+ }
+ rescont -= from_resolution;
+ }
+ }
+
+ rst = OK;
+ }
+ else
+ {
+ /* fd60 */
+ SANE_Int bit, pos, desp, rescont2;
+
+ *to_buffer = 0;
+ bit = 0;
+ pos = 0;
+ desp = 0;
+ rescont = 0;
+ rescont2 = 0;
+ if (to_width > 0)
+ {
+ do
+ {
+ if (bit == 8)
+ {
+ /* fda6 */
+ bit = 0;
+ to_buffer++;
+ *to_buffer = 0;
+ }
+
+ rescont += to_resolution;
+ if (rescont < from_resolution)
+ {
+ if ((*from_buffer & (0x80 >> desp)) != 0)
+ rescont2 += to_resolution;
+ }
+ else
+ {
+ /*fdd5 */
+ pos++;
+ rescont -= from_resolution;
+ if ((*from_buffer & (0x80 >> desp)) != 0)
+ /*fdee */
+ rescont2 += (to_resolution - rescont);
+ if (rescont2 > (to_resolution / 2))
+ /* fe00 */
+ *to_buffer = _B0 (*to_buffer | (0x80 >> bit));
+ rescont2 =
+ ((*from_buffer & (0x80 >> desp)) != 0) ? rescont : 0;
+ bit++;
+ }
+
+ /* fe2f */
+ desp++;
+ if (desp == 8)
+ {
+ desp = 0;
+ from_buffer++;
+ }
+ }
+ while (pos < to_width);
+ }
+ else
+ rst = OK;
+ }
+
+ DBG (DBG_FNC, "- Resize_Decrease: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Resize_Increase (SANE_Byte * to_buffer, SANE_Int to_resolution,
+ SANE_Int to_width, SANE_Byte * from_buffer,
+ SANE_Int from_resolution, SANE_Int from_width,
+ SANE_Int myresize_mode)
+{
+ /*
+
+ to_buffer = FAC8 = 0x2353f0
+ to_resolution = FACC = 0x4b
+ to_width = FAD0 = 0x352
+ from_buffer = FAD4 = 0x234650
+ from_resolution = FAD8 = 0x64
+ from_width = FADC = 0x46d
+ myresize_mode = FAE0 = 1
+ */
+
+ SANE_Int rst = ERROR;
+ SANE_Int desp; /* fac0 */
+ SANE_Byte *myp2; /* faac */
+ SANE_Int mywidth; /* fab4 fab8 */
+ SANE_Int mychannels; /* fabc */
+ SANE_Int channels = 0; /* faa4 */
+ SANE_Int depth = 0; /* faa8 */
+ SANE_Int pos = 0; /* fae0 */
+ SANE_Int rescount;
+ SANE_Int val6 = 0;
+ SANE_Int val7 = 0;
+ SANE_Int value;
+ /**/
+ DBG (DBG_FNC,
+ "+ Resize_Increase(*to_buffer, to_resolution=%i, to_width=%i, *from_buffer, from_resolution=%i, from_width=%i, myresize_mode=%i):\n",
+ to_resolution, to_width, from_resolution, from_width, myresize_mode);
+
+ if (myresize_mode != RSZ_LINEART)
+ {
+ switch (myresize_mode)
+ {
+ case RSZ_GRAYL:
+ channels = 1;
+ depth = 8;
+ break;
+ case RSZ_COLOURL:
+ channels = 3;
+ depth = 8;
+ break;
+ case RSZ_COLOURH:
+ channels = 3;
+ depth = 16;
+ break;
+ case RSZ_GRAYH:
+ channels = 1;
+ depth = 16;
+ break;
+ }
+
+ if (channels > 0)
+ {
+ SANE_Byte channel_size;
+ SANE_Byte *p_dst; /* fac8 */
+ SANE_Byte *p_src; /* fad4 */
+
+ desp = to_buffer - from_buffer;
+ myp2 = from_buffer;
+ channel_size = (depth == 8) ? 1 : 2;
+
+ for (mychannels = 0; mychannels < channels; mychannels++)
+ {
+ pos = 0;
+ rescount = (from_resolution / 2) + to_resolution;
+
+ p_src = myp2;
+ p_dst = myp2 + desp;
+
+ /* f938 */
+ val7 = data_lsb_get (p_src, channel_size);
+
+ if (to_width > 0)
+ {
+ for (mywidth = 0; mywidth < to_width; mywidth++)
+ {
+ if (rescount >= to_resolution)
+ {
+ rescount -= to_resolution;
+ val6 = val7;
+ pos++;
+ if (pos < from_width)
+ {
+ p_src += (channels * channel_size);
+ val7 = data_lsb_get (p_src, channel_size);
+ }
+ }
+
+ /*f9a5 */
+ data_lsb_set (p_dst,
+ ((((to_resolution - rescount) * val6) +
+ (val7 * rescount)) / to_resolution),
+ channel_size);
+ rescount += from_resolution;
+ p_dst += (channels * channel_size);
+ }
+ }
+
+ myp2 += channel_size;
+ }
+
+ rst = OK;
+ }
+ else
+ rst = OK;
+ }
+ else
+ {
+ /* RSZ_LINEART mode */
+ /* fa02 */
+ /*
+ to_buffer = FAC8 = 0x2353f0
+ to_resolution = FACC = 0x4b
+ to_width = FAD0 = 0x352
+ from_buffer = FAD4 = 0x234650
+ from_resolution = FAD8 = 0x64
+ from_width = FADC = 0x46d
+ myresize_mode = FAE0 = 1
+ */
+ SANE_Int myres2; /* fac8 */
+ SANE_Int sres;
+ SANE_Int lfae0;
+ SANE_Int lfad8;
+ SANE_Int myres;
+ SANE_Int cont = 1;
+ SANE_Int someval;
+ SANE_Int bit; /*lfaa8 */
+
+ myres2 = from_resolution;
+ sres = (myres2 / 2) + to_resolution;
+ value = _B0 (*from_buffer);
+ bit = 0;
+ lfae0 = 0;
+ lfad8 = value >> 7;
+ someval = lfad8;
+ *to_buffer = 0;
+
+ if (to_width > 0)
+ {
+ myres = to_resolution;
+ to_resolution = myres / 2;
+ do
+ {
+ if (sres >= myres)
+ {
+ sres -= myres;
+ lfae0++;
+ cont++;
+ lfad8 = someval;
+ if (lfae0 < from_width)
+ {
+ if (cont == 8)
+ {
+ cont = 0;
+ from_buffer++;
+ }
+ bit = (((0x80 >> cont) & *from_buffer) != 0) ? 1 : 0;
+ }
+ }
+ /*faa6 */
+ if ((((myres - sres) * lfad8) + (bit * sres)) > to_resolution)
+ *to_buffer |= (0x80 >> bit);
+
+ bit++;
+ if (bit == 8)
+ {
+ bit = 0;
+ to_buffer++;
+ *to_buffer = 0;
+ }
+ to_width--;
+ sres += myres2;
+ }
+ while (to_width > 0);
+ rst = OK;
+ }
+ }
+
+ DBG (DBG_FNC, "- Resize_Increase: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Resize_Start (struct st_device *dev, SANE_Int * transferred)
+{
+ SANE_Int rst = ERROR;
+ struct st_resize *rz = dev->Resize;
+
+ DBG (DBG_FNC, "+ Resize_Start(*transferred):\n");
+
+ if (Resize_CreateBuffers
+ (dev, line_size, rz->bytesperline, rz->bytesperline) == ERROR)
+ return ERROR;
+
+ if (arrangeline2 == FIX_BY_SOFT)
+ {
+ /* fee0 */
+ if (scan2.colormode == CM_COLOR)
+ rst = Arrange_Colour (dev, rz->v3624, line_size, transferred);
+ else
+ rst = Arrange_NonColour (dev, rz->v3624, line_size, transferred);
+ }
+ else
+ rst = Read_Block (dev, line_size, rz->v3624, transferred); /* ff03 */
+
+ /* Redimensionado */
+ switch (rz->type)
+ {
+ case RSZ_DECREASE:
+ /* ff1b */
+ Resize_Decrease (rz->v3628, rz->resolution_x, rz->towidth, rz->v3624,
+ scan2.resolution_x, rz->fromwidth, rz->mode);
+ break;
+ case RSZ_INCREASE:
+ /* ff69 */
+ rz->rescount = 0;
+ Resize_Increase (rz->v3628, rz->resolution_x, rz->towidth, rz->v3624,
+ scan2.resolution_x, rz->fromwidth, rz->mode);
+ if (arrangeline2 == FIX_BY_SOFT)
+ {
+ /* ffb1 */
+ if (scan2.colormode == CM_COLOR)
+ rst = Arrange_Colour (dev, rz->v3624, line_size, transferred);
+ else
+ rst = Arrange_NonColour (dev, rz->v3624, line_size, transferred);
+ }
+ else
+ rst = Read_Block (dev, line_size, rz->v3624, transferred); /* ffe0 */
+
+ /* fff2 */
+ Resize_Increase (rz->v362c, rz->resolution_x, rz->towidth, rz->v3624,
+ scan2.resolution_x, rz->fromwidth, rz->mode);
+ break;
+ }
+
+ /* 002a */
+
+ DBG (DBG_FNC, "- Resize_Start(*transferred=%i): %i\n", *transferred, rst);
+
+ return rst;
+}
+
+static SANE_Int
+Resize_CreateBuffers (struct st_device *dev, SANE_Int size1, SANE_Int size2,
+ SANE_Int size3)
+{
+ SANE_Int rst = ERROR;
+ struct st_resize *rz = dev->Resize;
+
+ rz->v3624 = (SANE_Byte *) malloc ((size1 + 0x40) * sizeof (SANE_Byte));
+ rz->v3628 = (SANE_Byte *) malloc ((size2 + 0x40) * sizeof (SANE_Byte));
+ rz->v362c = (SANE_Byte *) malloc ((size3 + 0x40) * sizeof (SANE_Byte));
+
+ if ((rz->v3624 == NULL) || (rz->v3628 == NULL) || (rz->v362c == NULL))
+ Resize_DestroyBuffers (dev);
+ else
+ rst = OK;
+
+ DBG (DBG_FNC, "> Resize_CreateBuffers(size1=%i, size2=%i, size3=%i): %i\n",
+ size1, size2, size3, rst);
+
+ return rst;
+}
+
+static SANE_Int
+Resize_DestroyBuffers (struct st_device *dev)
+{
+ struct st_resize *rz = dev->Resize;
+
+ if (rz->v3624 != NULL)
+ free (rz->v3624);
+
+ if (rz->v3628 != NULL)
+ free (rz->v3628);
+
+ if (rz->v362c != NULL)
+ free (rz->v362c);
+
+ rz->v3624 = NULL;
+ rz->v3628 = NULL;
+ rz->v362c = NULL;
+
+ return OK;
+}
+
+static SANE_Int
+Reading_DestroyBuffers (struct st_device *dev)
+{
+ DBG (DBG_FNC, "> Reading_DestroyBuffers():\n");
+
+ if (dev->Reading->DMABuffer != NULL)
+ free (dev->Reading->DMABuffer);
+
+ if (dev->scanning->imagebuffer != NULL)
+ {
+ free (dev->scanning->imagebuffer);
+ dev->scanning->imagebuffer = NULL;
+ }
+
+ bzero (dev->Reading, sizeof (struct st_readimage));
+
+ return OK;
+}
+
+static SANE_Int
+Gamma_SendTables (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Byte * gammatable, SANE_Int size)
+{
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "+ Gamma_SendTables(*Regs, *gammatable, size=%i):\n", size);
+
+ if ((gammatable != NULL) && (size > 0))
+ {
+ SANE_Int transferred;
+ SANE_Int first_table;
+ SANE_Int cont = 0;
+ SANE_Int retry = TRUE;
+ SANE_Byte *mybuffer;
+
+ /* lock */
+ SetLock (dev->usb_handle, Regs, TRUE);
+
+ first_table = (data_lsb_get (&Regs[0x1b4], 2) & 0x3fff) >> 4;
+
+ mybuffer = (SANE_Byte *) malloc (sizeof (SANE_Byte) * size);
+ if (mybuffer != NULL)
+ {
+ /* Try to send buffer during 10 seconds */
+ long tick = GetTickCount () + 10000;
+ while ((retry == TRUE) && (tick > GetTickCount ()))
+ {
+ retry = FALSE;
+
+ /* Operation type 0x14 */
+ if (IWrite_Word (dev->usb_handle, 0x0000, 0x0014, 0x0800) == OK)
+ {
+ /* Send size to write */
+ if (RTS_DMA_Enable_Write (dev, 0x0000, size, first_table) ==
+ OK)
+ {
+ /* Send data */
+ if (Bulk_Operation
+ (dev, BLK_WRITE, size, gammatable,
+ &transferred) == OK)
+ {
+ /* Send size to read */
+ if (RTS_DMA_Enable_Read
+ (dev, 0x0000, size, first_table) == OK)
+ {
+ /* Retrieve data */
+ if (Bulk_Operation
+ (dev, BLK_READ, size, mybuffer,
+ &transferred) == OK)
+ {
+ /* Check data */
+ while ((cont < size) && (retry == FALSE))
+ {
+ if (mybuffer[cont] != gammatable[cont])
+ retry = TRUE;
+ cont++;
+ }
+
+ if (retry == FALSE)
+ rst = OK;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ free (mybuffer);
+ }
+
+ /* unlock */
+ SetLock (dev->usb_handle, Regs, FALSE);
+ }
+
+ DBG (DBG_FNC, "- Gamma_SendTables: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Gamma_GetTables (struct st_device *dev, SANE_Byte * Gamma_buffer)
+{
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "+ Gamma_GetTables(SANE_Byte *Gamma_buffer):\n");
+
+ if (Gamma_buffer == NULL)
+ return ERROR;
+
+ /* Operation type 0x14 */
+ if (IWrite_Word (dev->usb_handle, 0x0000, 0x0014, 0x0800) == 0x00)
+ {
+ SANE_Int size = 768;
+
+ if (RTS_DMA_Enable_Read (dev, 0x0000, size, 0) == OK)
+ {
+ SANE_Int transferred = 0;
+ usleep (1000 * 500);
+
+ /* Read buffer */
+ rst =
+ Bulk_Operation (dev, BLK_READ, size, Gamma_buffer, &transferred);
+ }
+ }
+
+ DBG (DBG_FNC, "- Gamma_GetTables: %i\n", rst);
+
+ return rst;
+}
+
+static void
+Gamma_FreeTables ()
+{
+ SANE_Int c;
+
+ DBG (DBG_FNC, "> Gamma_FreeTables()\n");
+
+ for (c = 0; c < 3; c++)
+ {
+ if (hp_gamma->table[c] != NULL)
+ {
+ free (hp_gamma->table[c]);
+ hp_gamma->table[c] = NULL;
+ }
+ }
+ use_gamma_tables = FALSE;
+}
+
+static void
+RTS_Scanner_StopScan (struct st_device *dev, SANE_Int wait)
+{
+ SANE_Byte data;
+
+ DBG (DBG_FNC, "+ RTS_Scanner_StopScan():\n");
+
+ data = 0;
+
+ Reading_DestroyBuffers (dev);
+ Resize_DestroyBuffers (dev);
+
+ RTS_DMA_Reset (dev);
+
+ data_bitset (&dev->init_regs[0x60b], 0x10, 0);
+ data_bitset (&dev->init_regs[0x60a], 0x40, 0);
+
+ if (Write_Buffer (dev->usb_handle, 0xee0a, &dev->init_regs[0x60a], 2) == OK)
+ Motor_Change (dev, dev->init_regs, 3);
+
+ usleep (1000 * 200);
+
+ if (wait == FALSE)
+ {
+ Read_Byte (dev->usb_handle, 0xe801, &data);
+ if ((data & 0x02) == 0)
+ {
+ if (Head_IsAtHome (dev, dev->init_regs) == FALSE)
+ {
+ /* clear execution bit */
+ data_bitset (&dev->init_regs[0x00], 0x80, 0);
+
+ Write_Byte (dev->usb_handle, 0x00, dev->init_regs[0x00]);
+ Head_ParkHome (dev, TRUE, dev->motorcfg->parkhomemotormove);
+ }
+ }
+ }
+ else
+ {
+ /*66a1 */
+ /* clear execution bit */
+ data_bitset (&dev->init_regs[0x00], 0x80, 0);
+
+ Write_Byte (dev->usb_handle, 0x00, dev->init_regs[0x00]);
+ if (Head_IsAtHome (dev, dev->init_regs) == FALSE)
+ Head_ParkHome (dev, TRUE, dev->motorcfg->parkhomemotormove);
+ }
+
+ /*66e0 */
+ RTS_Enable_CCD (dev, dev->init_regs, 0);
+
+ Lamp_Status_Timer_Set (dev, 13);
+
+ DBG (DBG_FNC, "- RTS_Scanner_StopScan()\n");
+}
+
+static SANE_Int
+Reading_CreateBuffers (struct st_device *dev)
+{
+ SANE_Byte data;
+ SANE_Int mybytesperline;
+ SANE_Int mybuffersize, a, b;
+
+ DBG (DBG_FNC, "+ Reading_CreateBuffers():\n");
+
+ data = 0;
+
+ /* Gets BinarythresholdH */
+ if (Read_Byte (dev->usb_handle, 0xe9a1, &data) == OK)
+ binarythresholdh = data;
+
+ mybytesperline =
+ (scan2.depth == 12) ? (bytesperline * 3) / 4 : bytesperline;
+
+ dev->Reading->Max_Size = 0xfc00;
+ dev->Reading->DMAAmount = 0;
+
+ a = (RTS_Debug->dmabuffersize / 63);
+ b = (((RTS_Debug->dmabuffersize - a) / 2) + a) >> 0x0f;
+ mybuffersize = ((b << 6) - b) << 10;
+ if (mybuffersize < 0x1f800)
+ mybuffersize = 0x1f800;
+
+ dev->Reading->DMABufferSize = mybuffersize; /*3FFC00 4193280 */
+
+ do
+ {
+ dev->Reading->DMABuffer =
+ (SANE_Byte *) malloc (dev->Reading->DMABufferSize *
+ sizeof (SANE_Byte));
+ if (dev->Reading->DMABuffer != NULL)
+ break;
+ dev->Reading->DMABufferSize -= dev->Reading->Max_Size;
+ }
+ while (dev->Reading->DMABufferSize >= dev->Reading->Max_Size);
+
+ /* 6003 */
+ dev->Reading->Starting = TRUE;
+
+ dev->Reading->Size4Lines = (mybytesperline > dev->Reading->Max_Size) ?
+ mybytesperline : (dev->Reading->Max_Size / mybytesperline) *
+ mybytesperline;
+
+ dev->Reading->ImageSize = imagesize;
+ read_v15b4 = v15b4;
+
+ DBG (DBG_FNC, "- Reading_CreateBuffers():\n");
+
+ return OK;
+}
+
+static SANE_Int
+RTS_ScanCounter_Inc (struct st_device *dev)
+{
+ /* Keep a count of the number of scans done by this scanner */
+
+ SANE_Int idata;
+
+ DBG (DBG_FNC, "+ RTS_ScanCounter_Inc():\n");
+
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ {
+ SANE_Byte cdata = 0;
+ SANE_Byte somebuffer[26];
+
+ switch (dev->chipset->model)
+ {
+ case RTS8822L_02A:
+ case RTS8822BL_03A:
+ /* value is 4 bytes size starting from address 0x21 in msb format */
+ if (RTS_EEPROM_ReadInteger (dev->usb_handle, 0x21, &idata) == OK)
+ {
+ idata = data_swap_endianess (idata, 4) + 1;
+ idata = data_swap_endianess (idata, 4);
+ RTS_EEPROM_WriteInteger (dev->usb_handle, 0x21, idata);
+ }
+ break;
+ default:
+ /* value is 4 bytes size starting from address 0x21 in lsb format */
+ bzero (&somebuffer, sizeof (somebuffer));
+ somebuffer[4] = 0x0c;
+
+ RTS_EEPROM_ReadInteger (dev->usb_handle, 0x21, &idata);
+ data_lsb_set (&somebuffer[0], idata + 1, 4);
+
+ RTS_EEPROM_ReadByte (dev->usb_handle, 0x003a, &cdata);
+ somebuffer[25] = cdata;
+ RTS_EEPROM_WriteBuffer (dev->usb_handle, 0x21, somebuffer, 0x1a);
+ break;
+ }
+ }
+
+ DBG (DBG_FNC, "- RTS_ScanCounter_Inc()\n");
+
+ return OK;
+}
+
+static SANE_Int
+RTS_ScanCounter_Get (struct st_device *dev)
+{
+ /* Returns the number of scans done by this scanner */
+
+ SANE_Int idata = 0;
+
+ DBG (DBG_FNC, "+ RTS_ScanCounter_Get():\n");
+
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ {
+ RTS_EEPROM_ReadInteger (dev->usb_handle, 0x21, &idata);
+
+ switch (dev->chipset->model)
+ {
+ case RTS8822L_02A:
+ case RTS8822BL_03A:
+ /* value is 4 bytes size starting from address 0x21 in msb format */
+ idata = data_swap_endianess (idata, 4);
+ break;
+ default: /* RTS8822L_01H */
+ /* value is 4 bytes size starting from address 0x21 in lsb format */
+ idata &= 0xffffffff;
+ break;
+ }
+ }
+
+ DBG (DBG_FNC, "- RTS_ScanCounter_Get(): %i\n", idata);
+
+ return idata;
+}
+
+static SANE_Int
+Read_Image (struct st_device *dev, SANE_Int buffer_size, SANE_Byte * buffer,
+ SANE_Int * transferred)
+{
+ SANE_Int rst;
+ SANE_Byte mycolormode;
+
+ DBG (DBG_FNC, "+ Read_Image(buffer_size=%i, *buffer, *transferred):\n",
+ buffer_size);
+
+ *transferred = 0;
+ mycolormode = scan2.colormode;
+ rst = ERROR;
+ if ((scan2.colormode != CM_COLOR) && (scan2.channel == 3))
+ mycolormode = 3;
+
+ if (dev->Resize->type == RSZ_NONE)
+ {
+ if (arrangeline == FIX_BY_SOFT)
+ {
+ switch (mycolormode)
+ {
+ case CM_COLOR:
+ rst = Arrange_Colour (dev, buffer, buffer_size, transferred);
+ break;
+ case 3:
+ rst = Arrange_Compose (dev, buffer, buffer_size, transferred);
+ break;
+ default:
+ rst = Arrange_NonColour (dev, buffer, buffer_size, transferred);
+ break;
+ }
+ }
+ else
+ rst = Read_Block (dev, buffer_size, buffer, transferred); /*00fe */
+ }
+ else
+ rst = Read_ResizeBlock (dev, buffer, buffer_size, transferred); /*010d */
+
+ DBG (DBG_FNC, "- Read_Image(*transferred=%i): %i\n", *transferred, rst);
+
+ return rst;
+}
+
+static SANE_Int
+Arrange_Compose (struct st_device *dev, SANE_Byte * buffer,
+ SANE_Int buffer_size, SANE_Int * transferred)
+{
+ /*
+ fnb250
+
+ 0600FA7C 05E10048 buffer
+ 0600FA80 0000F906 buffer_size
+ */
+ SANE_Byte *mybuffer = buffer; /* fa7c */
+ SANE_Int mydistance; /*ebp */
+ SANE_Int mydots; /*fa74 */
+ SANE_Int channel_size;
+ SANE_Int c;
+ struct st_scanning *scn;
+
+ /*mywidth = fa70 */
+
+ DBG (DBG_FNC, "+ Arrange_Compose(*buffer, buffer_size=%i, *transferred):\n",
+ buffer_size);
+
+ channel_size = (scan2.depth == 8) ? 1 : 2;
+
+ /* this is just to make code more legible */
+ scn = dev->scanning;
+
+ if (scn->imagebuffer == NULL)
+ {
+ if (dev->sensorcfg->type == CCD_SENSOR)
+ mydistance =
+ (dev->sensorcfg->line_distance * scan2.resolution_y) /
+ dev->sensorcfg->resolution;
+ else
+ mydistance = 0;
+
+ if (mydistance != 0)
+ {
+ scn->bfsize =
+ (scn->arrange_hres ==
+ TRUE) ? scn->arrange_sensor_evenodd_dist : 0;
+ scn->bfsize = line_size * (scn->bfsize + (mydistance * 2) + 1);
+ }
+ else
+ scn->bfsize = line_size * 2;
+
+ /*b2f0 */
+ scn->imagebuffer =
+ (SANE_Byte *) malloc (scn->bfsize * sizeof (SANE_Byte));
+ if (scn->imagebuffer == NULL)
+ return ERROR;
+
+ scn->imagepointer = scn->imagebuffer;
+ if (Read_Block (dev, scn->bfsize, scn->imagebuffer, transferred) ==
+ ERROR)
+ return ERROR;
+
+ /* Calculate channel displacements */
+ scn->arrange_orderchannel = FALSE;
+ for (c = CL_RED; c <= CL_BLUE; c++)
+ {
+ if (mydistance == 0)
+ {
+ /*b34e */
+ if (scn->arrange_hres == FALSE)
+ {
+ if ((((dev->sensorcfg->line_distance * scan2.resolution_y) *
+ 2) / dev->sensorcfg->resolution) == 1)
+ scn->arrange_orderchannel = TRUE;
+
+ if (scn->arrange_orderchannel == TRUE)
+ scn->desp[c] =
+ ((dev->sensorcfg->rgb_order[c] / 2) * line_size) +
+ (channel_size * c);
+ else
+ scn->desp[c] = channel_size * c;
+ }
+ }
+ else
+ {
+ /*b3e3 */
+ scn->desp[c] =
+ (dev->sensorcfg->rgb_order[c] * (mydistance * line_size)) +
+ (channel_size * c);
+
+ if (scn->arrange_hres == TRUE)
+ {
+ /*b43b */
+ scn->desp1[c] = scn->desp[c];
+ scn->desp2[c] =
+ ((channel_size * 3) + scn->desp1[c]) +
+ (scn->arrange_sensor_evenodd_dist * line_size);
+ };
+ }
+ }
+
+ for (c = CL_RED; c <= CL_BLUE; c++)
+ {
+ if (scn->arrange_hres == TRUE)
+ {
+ scn->pColour2[c] = scn->imagebuffer + scn->desp2[c];
+ scn->pColour1[c] = scn->imagebuffer + scn->desp1[c];
+ }
+ else
+ scn->pColour[c] = scn->imagebuffer + scn->desp[c];
+ }
+ }
+
+ /*b545 */
+ buffer_size /= line_size;
+ mydots = line_size / (channel_size * 3);
+
+ while (buffer_size > 0)
+ {
+ if (scn->arrange_orderchannel == FALSE)
+ {
+ /*b5aa */
+ if (scn->arrange_hres == TRUE)
+ Triplet_Compose_HRes (scn->pColour1[CL_RED],
+ scn->pColour1[CL_GREEN],
+ scn->pColour1[CL_BLUE],
+ scn->pColour2[CL_RED],
+ scn->pColour2[CL_GREEN],
+ scn->pColour2[CL_BLUE], mybuffer, mydots);
+ else
+ Triplet_Compose_LRes (scn->pColour[CL_RED],
+ scn->pColour[CL_GREEN],
+ scn->pColour[CL_BLUE], mybuffer, mydots);
+ }
+ else
+ Triplet_Compose_Order (dev, scn->pColour[CL_RED],
+ scn->pColour[CL_GREEN], scn->pColour[CL_BLUE],
+ mybuffer, mydots);
+
+ /*b5f8 */
+ mybuffer += line_size;
+ scn->arrange_size -= bytesperline;
+ if (scn->arrange_size < 0)
+ v15bc--;
+
+ buffer_size--;
+ if (buffer_size == 0)
+ {
+ if ((scn->arrange_size | v15bc) == 0)
+ return OK;
+ }
+
+ /*b63f */
+ if (Read_Block (dev, line_size, scn->imagepointer, transferred) ==
+ ERROR)
+ return ERROR;
+
+ for (c = CL_RED; c <= CL_BLUE; c++)
+ {
+ if (scn->arrange_hres == TRUE)
+ {
+ /*b663 */
+ scn->desp2[c] = (scn->desp2[c] + line_size) % scn->bfsize;
+ scn->desp1[c] = (scn->desp1[c] + line_size) % scn->bfsize;
+
+ scn->pColour2[c] = scn->imagebuffer + scn->desp2[c];
+ scn->pColour1[c] = scn->imagebuffer + scn->desp1[c];
+ }
+ else
+ {
+ /*b74a */
+ scn->desp[c] = (scn->desp[c] + line_size) % scn->bfsize;
+ scn->pColour[c] = scn->imagebuffer + scn->desp[c];
+ }
+ }
+
+ /*b7be */
+ scn->imagepointer += line_size;
+ if (scn->imagepointer >= (scn->imagebuffer + scn->bfsize))
+ scn->imagepointer = scn->imagebuffer;
+ }
+
+ return OK;
+}
+
+static void
+Triplet_Compose_HRes (SANE_Byte * pRed1, SANE_Byte * pGreen1,
+ SANE_Byte * pBlue1, SANE_Byte * pRed2,
+ SANE_Byte * pGreen2, SANE_Byte * pBlue2,
+ SANE_Byte * buffer, SANE_Int Width)
+{
+ SANE_Int Value;
+ SANE_Int Channel_size;
+ SANE_Int max_value;
+
+ DBG (DBG_FNC,
+ "> Triplet_Compose_HRes(*pRed1, *pGreen1, *pBlue1, *pRed2 *pGreen2, *pBlue2, *buffer, Width=%i):\n",
+ Width);
+
+ Width /= 2;
+ Channel_size = (scan2.depth > 8) ? 2 : 1;
+ max_value = (1 << scan2.depth) - 1;
+
+ while (Width > 0)
+ {
+ Value =
+ data_lsb_get (pRed1, Channel_size) + data_lsb_get (pGreen1,
+ Channel_size) +
+ data_lsb_get (pBlue1, Channel_size);
+
+ Value = min (Value, max_value);
+
+ if (v1600 != NULL)
+ {
+ if (scan2.depth > 8)
+ Value = *(v1600 + (Value >> 8)) | _B0 (Value);
+ else
+ Value = *(v1600 + Value);
+ }
+
+ data_lsb_set (buffer, Value, Channel_size);
+ buffer += Channel_size;
+
+ Value =
+ data_lsb_get (pRed2, Channel_size) + data_lsb_get (pGreen2,
+ Channel_size) +
+ data_lsb_get (pBlue2, Channel_size);
+
+ Value = min (Value, max_value);
+
+ if (v1600 != NULL)
+ {
+ if (scan2.depth > 8)
+ Value = *(v1600 + (Value >> 8)) | _B0 (Value);
+ else
+ Value = *(v1600 + Value);
+ }
+
+ data_lsb_set (buffer, Value, Channel_size);
+ buffer += Channel_size;
+
+ pRed1 += 6 * Channel_size;
+ pGreen1 += 6 * Channel_size;
+ pBlue1 += 6 * Channel_size;
+
+ pRed2 += 6 * Channel_size;
+ pGreen2 += 6 * Channel_size;
+ pBlue2 += 6 * Channel_size;
+
+ Width--;
+ }
+}
+
+static void
+Triplet_Compose_Order (struct st_device *dev, SANE_Byte * pRed,
+ SANE_Byte * pGreen, SANE_Byte * pBlue,
+ SANE_Byte * buffer, SANE_Int dots)
+{
+ SANE_Int Value;
+
+ DBG (DBG_FNC,
+ "> Triplet_Compose_Order(*pRed, *pGreen, *pBlue, *buffer, dots=%i):\n",
+ dots);
+
+ if (scan2.depth > 8)
+ {
+ /* c0fe */
+ dots = dots / 2;
+ while (dots > 0)
+ {
+ Value =
+ min (data_lsb_get (pRed, 2) + data_lsb_get (pGreen, 2) +
+ data_lsb_get (pBlue, 2), 0xffff);
+
+ if (v1600 != NULL)
+ Value = (*(v1600 + (Value >> 8)) << 8) | _B0 (Value);
+
+ data_lsb_set (buffer, Value, 2);
+
+ buffer += 2;
+ pRed += 6;
+ pGreen += 6;
+ pBlue += 6;
+ dots--;
+ }
+ }
+ else
+ {
+ SANE_Byte *myp1, *myp2, *myp3;
+
+ if (dev->sensorcfg->rgb_order[CL_RED] == 1)
+ {
+ myp1 = pRed;
+ myp2 = pGreen;
+ myp3 = pBlue;
+ }
+ else if (dev->sensorcfg->rgb_order[CL_GREEN] == 1)
+ {
+ myp1 = pGreen;
+ myp2 = pRed;
+ myp3 = pBlue;
+ }
+ else
+ {
+ myp1 = pBlue;
+ myp2 = pRed;
+ myp3 = pGreen;
+ }
+
+ while (dots > 0)
+ {
+ Value =
+ min (((*myp1 + *(line_size + myp1)) / 2) + *myp2 + *myp3, 0xff);
+
+ *buffer = (v1600 == NULL) ? _B0 (Value) : *(v1600 + Value);
+
+ buffer++;
+ myp1 += 3;
+ myp2 += 3;
+ myp3 += 3;
+ dots--;
+ }
+ }
+}
+
+static void
+Triplet_Compose_LRes (SANE_Byte * pRed, SANE_Byte * pGreen, SANE_Byte * pBlue,
+ SANE_Byte * buffer, SANE_Int dots)
+{
+ SANE_Int Value;
+ SANE_Int Channel_size;
+ SANE_Int max_value;
+
+ DBG (DBG_FNC,
+ "> Triplet_Compose_LRes(*pRed, *pGreen, *pBlue, *buffer, dots=%i):\n",
+ dots);
+
+ Channel_size = (scan2.depth > 8) ? 2 : 1;
+ max_value = (1 << scan2.depth) - 1;
+
+ /*bf59 */
+ while (dots > 0)
+ {
+ Value =
+ data_lsb_get (pRed, Channel_size) + data_lsb_get (pGreen,
+ Channel_size) +
+ data_lsb_get (pBlue, Channel_size);
+
+ Value = min (Value, max_value);
+
+ if (v1600 != NULL)
+ {
+ if (scan2.depth > 8)
+ Value = (*(v1600 + (Value >> 8)) << 8) | _B0 (Value);
+ else
+ Value = _B0 (*(v1600 + Value));
+ }
+
+ data_lsb_set (buffer, Value, Channel_size);
+
+ buffer += Channel_size;
+ pRed += Channel_size * 3;
+ pGreen += Channel_size * 3;
+ pBlue += Channel_size * 3;
+ dots--;
+ }
+}
+
+static void
+Triplet_Colour_Order (struct st_device *dev, SANE_Byte * pRed,
+ SANE_Byte * pGreen, SANE_Byte * pBlue,
+ SANE_Byte * buffer, SANE_Int Width)
+{
+ SANE_Int Value;
+
+ DBG (DBG_FNC,
+ "> Triplet_Colour_Order(*pRed, *pGreen, *pBlue, *buffer, Width=%i):\n",
+ Width);
+
+ if (scan2.depth > 8)
+ {
+ Width = Width / 2;
+ while (Width > 0)
+ {
+ Value = data_lsb_get (pRed, 2);
+ data_lsb_set (buffer, Value, 2);
+
+ Value = data_lsb_get (pGreen, 2);
+ data_lsb_set (buffer + 2, Value, 2);
+
+ Value = data_lsb_get (pBlue, 2);
+ data_lsb_set (buffer + 4, Value, 2);
+
+ pRed += 6;
+ pGreen += 6;
+ pBlue += 6;
+ buffer += 6;
+ Width--;
+ }
+ }
+ else
+ {
+ SANE_Int Colour;
+
+ if (dev->sensorcfg->rgb_order[CL_RED] == 1)
+ Colour = CL_RED;
+ else if (dev->sensorcfg->rgb_order[CL_GREEN] == 1)
+ Colour = CL_GREEN;
+ else
+ Colour = CL_BLUE;
+
+ while (Width > 0)
+ {
+ switch (Colour)
+ {
+ case CL_RED:
+ *buffer = (*pRed + *(pRed + line_size)) / 2;
+ *(buffer + 1) = *pGreen;
+ *(buffer + 2) = *pBlue;
+ break;
+ case CL_GREEN:
+ *buffer = *pRed;
+ *(buffer + 1) = ((*pGreen + *(pGreen + line_size)) / 2);
+ *(buffer + 2) = *pBlue;
+ break;
+ case CL_BLUE:
+ *buffer = *pRed;
+ *(buffer + 1) = *pGreen;
+ *(buffer + 2) = ((*pBlue + *(pBlue + line_size)) / 2);
+ break;
+ }
+
+ pRed += 3;
+ pGreen += 3;
+ pBlue += 3;
+ buffer += 3;
+
+ Width--;
+ }
+ }
+}
+
+static void
+Triplet_Colour_HRes (SANE_Byte * pRed1, SANE_Byte * pGreen1,
+ SANE_Byte * pBlue1, SANE_Byte * pRed2,
+ SANE_Byte * pGreen2, SANE_Byte * pBlue2,
+ SANE_Byte * buffer, SANE_Int Width)
+{
+ SANE_Int Value;
+ SANE_Int channel_size;
+ SANE_Int c;
+ SANE_Byte *pPointers[6];
+
+ pPointers[0] = pRed1;
+ pPointers[1] = pGreen1;
+ pPointers[2] = pBlue1;
+
+ pPointers[3] = pRed2;
+ pPointers[4] = pGreen2;
+ pPointers[5] = pBlue2;
+
+ DBG (DBG_FNC,
+ "> Triplet_Colour_HRes(*pRed1, *pGreen1, *pBlue1, *pRed2, *pGreen2, *pBlue2, *buffer, Width=%i):\n",
+ Width);
+
+ channel_size = (scan2.depth > 8) ? 2 : 1;
+
+ Width = Width / 2;
+ while (Width > 0)
+ {
+ for (c = 0; c < 6; c++)
+ {
+ Value = data_lsb_get (pPointers[c], channel_size);
+ data_lsb_set (buffer, Value, channel_size);
+
+ pPointers[c] += (6 * channel_size);
+ buffer += (channel_size);
+ }
+ Width--;
+ }
+}
+
+static void
+Triplet_Colour_LRes (SANE_Int Width, SANE_Byte * Buffer,
+ SANE_Byte * pChannel1, SANE_Byte * pChannel2,
+ SANE_Byte * pChannel3)
+{
+ /*
+ 05F0FA4C 04EBAE4A /CALL to Assumed StdFunc6 from hpgt3970.04EBAE45
+ 05F0FA50 00234FF8 |Arg1 = 00234FF8 pChannel3
+ 05F0FA54 002359EF |Arg2 = 002359EF pChannel2
+ 05F0FA58 002363E6 |Arg3 = 002363E6 pChannel1
+ 05F0FA5C 05D10048 |Arg4 = 05D10048 Buffer
+ 05F0FA60 00000352 |Arg5 = 00000352 Width
+ */
+
+ /* Esta funcion une los tres canales de color en un triplete
+ Inicialmente cada color está separado en 3 buffers apuntados
+ por pChannel1 ,2 y 3
+ */
+ SANE_Int Value;
+ SANE_Int channel_size;
+ SANE_Int c;
+ SANE_Byte *pChannels[3];
+
+ pChannels[0] = pChannel3;
+ pChannels[1] = pChannel2;
+ pChannels[2] = pChannel1;
+
+ DBG (DBG_FNC, "> Triplet_Colour_LRes(Width=%i, *Buffer2, *p1, *p2, *p3):\n",
+ Width);
+
+ channel_size = (scan2.depth > 8) ? 2 : 1;
+ while (Width > 0)
+ {
+ /* ba74 */
+ for (c = 0; c < 3; c++)
+ {
+ Value = data_lsb_get (pChannels[c], channel_size);
+ data_lsb_set (Buffer, Value, channel_size);
+
+ pChannels[c] += channel_size;
+ Buffer += channel_size;
+ }
+ Width--;
+ }
+}
+
+static SANE_Int
+Read_ResizeBlock (struct st_device *dev, SANE_Byte * buffer,
+ SANE_Int buffer_size, SANE_Int * transferred)
+{
+ /*The Beach
+ buffer = FA7C 05E30048
+ buffer_size = FA80 0000F906
+ */
+
+ SANE_Int rst = ERROR; /* fa68 */
+ SANE_Int lfa54;
+ SANE_Int lfa58;
+ SANE_Byte *pP1; /* fa5c */
+ SANE_Byte *pP2; /* fa60 */
+ SANE_Int bOk;
+ struct st_resize *rz = dev->Resize;
+
+ /* fa74 = Resize->resolution_y */
+ /* fa70 = Resize->resolution_x */
+ /* fa64 = scan2.resolution_y */
+ /* fa6c = scan2.resolution_x */
+
+ DBG (DBG_FNC,
+ "+ Read_ResizeBlock(*buffer, buffer_size=%i, *transferred):\n",
+ buffer_size);
+
+ if (rz->type == RSZ_DECREASE)
+ {
+ lfa58 = 0;
+ do
+ {
+ bOk = 1;
+ if (arrangeline2 == FIX_BY_SOFT)
+ {
+ if (scan2.colormode == CM_COLOR)
+ rst = Arrange_Colour (dev, rz->v3624, line_size, transferred);
+ else
+ rst =
+ Arrange_NonColour (dev, rz->v3624, line_size, transferred);
+ }
+ else
+ rst = Read_Block (dev, line_size, rz->v3624, transferred);
+
+ /*f2df */
+ Resize_Decrease (rz->v362c, rz->resolution_x, rz->towidth,
+ rz->v3624, scan2.resolution_x, rz->fromwidth,
+ rz->mode);
+ rz->rescount += rz->resolution_y;
+
+ if (rz->rescount > scan2.resolution_y)
+ {
+ /*f331 */
+ rz->rescount -= scan2.resolution_y;
+ if (scan2.depth == 8)
+ {
+ /* f345 */
+ pP1 = rz->v3628;
+ pP2 = rz->v362c;
+ if (rz->mode == RSZ_LINEART)
+ {
+ /* f36b */
+ SANE_Int bit = 0;
+ SANE_Byte *pP3 = rz->v362c;
+ SANE_Int value;
+
+ *buffer = 0;
+ lfa54 = 0;
+ while (lfa54 < rz->towidth)
+ {
+ if (bit == 8)
+ {
+ buffer++;
+ *buffer = 0;
+ pP1++;
+ bit = 0;
+ pP3++;
+ }
+
+ value =
+ ((*pP1 & (0x80 >> bit)) != 0) ? rz->rescount : 0;
+
+ if ((*pP3 & (0x80 >> bit)) != 0)
+ value += (scan2.resolution_y - rz->rescount);
+
+ if (value > rz->resolution_y)
+ *buffer |= (0x80 >> bit);
+
+ bit++;
+ lfa54++;
+ }
+ }
+ else
+ {
+ /* f414 */
+ lfa54 = 0;
+ while (lfa54 < rz->bytesperline)
+ {
+ *buffer =
+ _B0 ((((scan2.resolution_y -
+ rz->rescount) * *pP2) +
+ (*pP1 * rz->rescount)) /
+ scan2.resolution_y);
+ pP1++;
+ pP2++;
+ buffer++;
+ lfa54++;
+ }
+ }
+ }
+ else
+ {
+ /* f47d */
+ lfa54 = 0;
+ pP1 = rz->v3628;
+ pP2 = rz->v362c;
+
+ if ((rz->bytesperline & 0xfffffffe) > 0)
+ {
+ SANE_Int value;
+ do
+ {
+ value =
+ (((scan2.resolution_y -
+ rz->rescount) * data_lsb_get (pP2,
+ 2)) +
+ (data_lsb_get (pP1, 2) * rz->rescount)) /
+ scan2.resolution_y;
+ data_lsb_set (buffer, value, 2);
+
+ buffer += 2;
+ pP1 += 2;
+ pP2 += 2;
+ lfa54++;
+ }
+ while (lfa54 < (rz->bytesperline / 2));
+ }
+ }
+ }
+ else
+ bOk = 0;
+ /* f4fd f502 */
+ pP1 = rz->v3628;
+ /* swap pointers */
+ rz->v3628 = rz->v362c;
+ rz->v362c = pP1;
+ }
+ while (bOk == 0);
+ }
+ else
+ {
+ /*f530 */
+ SANE_Int lfa68;
+ SANE_Int transferred;
+ SANE_Int channel_size;
+
+ rz->rescount += scan2.resolution_y;
+ lfa58 = 0;
+ if (rz->rescount > rz->resolution_y)
+ {
+ lfa68 = 1;
+ rz->rescount -= rz->resolution_y;
+ }
+ else
+ lfa68 = 0;
+
+ pP1 = rz->v3628;
+ pP2 = rz->v362c;
+
+ if (rz->mode == RSZ_LINEART)
+ {
+ /*f592 */
+ *buffer = 0;
+
+ if (rz->towidth > 0)
+ {
+ SANE_Int mask, mres;
+ /* lfa60 = rz->resolution_y */
+ /* lfa7c = rz->resolution_y / 2 */
+
+ for (lfa54 = 0; lfa54 < rz->towidth; lfa54++)
+ {
+ mask = 0x80 >> lfa58;
+
+ mres = ((mask & *pP1) != 0) ? rz->rescount : 0;
+
+ if ((mask & *pP2) != 0)
+ mres += (rz->resolution_y - rz->rescount);
+
+ if (mres > (rz->resolution_y / 2))
+ *buffer = *buffer | mask;
+
+ lfa58++;
+ if (lfa58 == 8)
+ {
+ lfa58 = 0;
+ buffer++;
+ pP1++;
+ pP2++;
+ *buffer = 0;
+ }
+ }
+ }
+ }
+ else
+ {
+ /*f633 */
+ channel_size = (scan2.depth > 8) ? 2 : 1;
+
+ if (rz->rescount < scan2.resolution_y)
+ {
+ if (rz->bytesperline != 0)
+ {
+ SANE_Int value;
+
+ for (lfa54 = 0; lfa54 < rz->bytesperline; lfa54++)
+ {
+ value =
+ (((scan2.resolution_y -
+ rz->rescount) * data_lsb_get (pP2,
+ channel_size)) +
+ (rz->rescount * data_lsb_get (pP1, channel_size))) /
+ scan2.resolution_y;
+ data_lsb_set (buffer, value, channel_size);
+
+ pP1 += channel_size;
+ pP2 += channel_size;
+ buffer += channel_size;
+ }
+ }
+ }
+ else
+ memcpy (buffer, rz->v3628, rz->bytesperline); /*f6a8 */
+ }
+
+ /*f736 */
+ if (lfa68 != 0)
+ {
+ SANE_Byte *temp;
+
+ if (arrangeline2 == FIX_BY_SOFT)
+ {
+ /*f74b */
+ if (scan2.colormode == CM_COLOR)
+ rst =
+ Arrange_Colour (dev, rz->v3624, line_size, &transferred);
+ else
+ rst =
+ Arrange_NonColour (dev, rz->v3624, line_size, &transferred);
+ }
+ else
+ rst = Read_Block (dev, line_size, rz->v3624, &transferred); /*f77a */
+
+ /*f78c */
+ /* swap buffers */
+ temp = rz->v3628;
+ rz->v3628 = rz->v362c;
+ rz->v362c = temp;
+
+ Resize_Increase (temp, rz->resolution_x, rz->towidth, rz->v3624,
+ scan2.resolution_x, rz->fromwidth, rz->mode);
+ }
+ else
+ rst = OK;
+ }
+
+ DBG (DBG_FNC, "- Read_ResizeBlock(*transferred=%i): %i\n", *transferred,
+ rst);
+
+ return rst;
+}
+
+static void
+Split_into_12bit_channels (SANE_Byte * destino, SANE_Byte * fuente,
+ SANE_Int size)
+{
+ /*
+ Each letter represents a bit
+ abcdefgh 12345678 lmnopqrs << before splitting
+ [efgh1234 0000abcd] [lmnopqrs 00005678] << after splitting, in memory
+ [0000abcd efgh1234] [00005678 lmnopqrs] << resulting channels
+ */
+
+ DBG (DBG_FNC, "> Split_into_12bit_channels(*destino, *fuente, size=%i\n",
+ size);
+
+ if ((destino != NULL) && (fuente != NULL))
+ {
+ if ((size - (size & 0x03)) != 0)
+ {
+ SANE_Int C;
+
+ C = (size - (size & 0x03) + 3) / 4;
+ do
+ {
+ *destino = _B0 ((*(fuente + 1) >> 4) + (*fuente << 4));
+ *(destino + 1) = _B0 (*fuente >> 4);
+ *(destino + 2) = _B0 (*(fuente + 2));
+ *(destino + 3) = *(fuente + 1) & 0x0f;
+ destino += 4;
+ fuente += 3;
+ C--;
+ }
+ while (C > 0);
+ }
+
+ /**/ if ((size & 0x03) != 0)
+ {
+ *destino = _B0 ((*(fuente + 1) >> 4) + (*fuente << 4));
+ *(destino + 1) = _B0 (*fuente >> 4);
+ }
+ }
+}
+
+static SANE_Int
+Read_NonColor_Block (struct st_device *dev, SANE_Byte * buffer,
+ SANE_Int buffer_size, SANE_Byte ColorMode,
+ SANE_Int * transferred)
+{
+ /* FA50 05DA0048 buffer
+ FA54 0000F906 buffer_size
+ FA58 00 ColorMode
+ */
+
+ SANE_Int rst = OK;
+ SANE_Int lfa38 = 0;
+ SANE_Byte *gamma = v1600;
+ SANE_Int block_bytes_per_line;
+ SANE_Int mysize;
+ SANE_Byte *mybuffer;
+
+ DBG (DBG_FNC,
+ "+ Read_NonColor_Block(*buffer, buffer_size=%i, ColorMode=%s):\n",
+ buffer_size, dbg_colour (ColorMode));
+
+ if (ColorMode != CM_GRAY)
+ {
+ /* Lineart mode */
+ if ((lineart_width & 7) != 0)
+ lfa38 = 8 - (lineart_width & 7);
+ block_bytes_per_line = (lineart_width + 7) / 8;
+ }
+ else
+ block_bytes_per_line = line_size;
+ /*61b2 */
+
+ mysize = (buffer_size / block_bytes_per_line) * bytesperline;
+ mybuffer = (SANE_Byte *) malloc (mysize * sizeof (SANE_Byte)); /*fa40 */
+
+ if (mybuffer != NULL)
+ {
+ SANE_Int LinesCount;
+ SANE_Int mysize4lines;
+ SANE_Byte *pBuffer = buffer;
+ SANE_Byte *pImage = NULL; /* fa30 */
+ SANE_Int puntero;
+ SANE_Int value;
+
+ do
+ {
+ mysize4lines =
+ (mysize <=
+ dev->Reading->Size4Lines) ? mysize : dev->Reading->Size4Lines;
+ LinesCount = mysize4lines / bytesperline;
+
+ if (ColorMode == CM_GRAY)
+ {
+ if (scan2.depth == 12)
+ {
+ /* 633b */
+ /*GRAY Bit mode 12 */
+ rst =
+ Scan_Read_BufferA (dev, (mysize4lines * 3) / 4, 0,
+ mybuffer, transferred);
+ if (rst == OK)
+ {
+ pImage = mybuffer;
+ pBuffer += LinesCount * block_bytes_per_line;
+ while (LinesCount > 0)
+ {
+ Split_into_12bit_channels (mybuffer, pImage,
+ line_size);
+ pImage += (bytesperline * 3) / 4;
+ LinesCount--;
+ }
+ }
+ else
+ break;
+ }
+ else
+ {
+ /* grayscale 8 and 16 bits */
+
+ SANE_Int channel_size;
+
+ rst =
+ Scan_Read_BufferA (dev, mysize4lines, 0, mybuffer,
+ transferred);
+
+ if (rst == OK)
+ {
+ channel_size = (scan2.depth > 8) ? 2 : 1;
+
+ pImage = mybuffer;
+
+ /* No gamma tables */
+ while (LinesCount > 0)
+ {
+ if (line_size > 0)
+ {
+ puntero = 0;
+ do
+ {
+ value =
+ data_lsb_get (pImage + puntero,
+ channel_size);
+
+ if (gamma != NULL)
+ value +=
+ *gamma << (8 * (channel_size - 1));
+
+ data_lsb_set (pBuffer, value, channel_size);
+
+ pBuffer += channel_size;
+ puntero += channel_size;
+ }
+ while (puntero < line_size);
+ }
+ pImage += bytesperline;
+ LinesCount--;
+ }
+ }
+ else
+ break;
+ }
+ }
+ else
+ {
+ /*6429 */
+ /* LINEART */
+ SANE_Int desp;
+ rst =
+ Scan_Read_BufferA (dev, mysize4lines, 0, mybuffer,
+ transferred);
+ if (rst == OK)
+ {
+ pImage = mybuffer;
+ while (LinesCount > 0)
+ {
+ if (lineart_width > 0)
+ {
+ desp = 0;
+ do
+ {
+ if ((desp % 7) == 0)
+ *pBuffer = 0;
+
+ /* making a byte bit per bit */
+ *pBuffer = *pBuffer << 1;
+
+ /* bit 1 if data is under thresholdh value */
+ if (*(pImage + desp) >= binarythresholdh) /* binarythresholdh = 0x0c */
+ *pBuffer = *pBuffer | 1;
+
+ desp++;
+ if ((desp % 7) == 0)
+ pBuffer++;
+
+ }
+ while (desp < lineart_width);
+ }
+
+ if (lfa38 != 0)
+ {
+ *pBuffer = (*pBuffer << lfa38);
+ pBuffer++;
+ }
+ /* 64b0 */
+ pImage += bytesperline;
+ LinesCount--;
+ }
+ }
+ else
+ break;
+ }
+ /* 64c0 */
+ mysize -= mysize4lines;
+ }
+ while ((mysize > 0) && (dev->status->cancel == FALSE));
+
+ free (mybuffer);
+ }
+ else
+ rst = ERROR;
+
+ DBG (DBG_FNC, "- Read_NonColor_Block(*transferred=%i): %i\n", *transferred,
+ rst);
+
+ return rst;
+}
+
+static SANE_Int
+Read_Block (struct st_device *dev, SANE_Int buffer_size, SANE_Byte * buffer,
+ SANE_Int * transferred)
+{
+ /*
+ SANE_Int buffer_size fa80
+ SANE_Byte *buffer fa7c
+ */
+/*
+scan2:
+04F0155C 01 08 00 02 03 00 58 02 ..X
+04F01564 58 02 58 02 C5 00 00 00 XXÅ...
+04F0156C B4 07 00 00 8B 01 00 00 ´..‹..
+04F01574 10 06 00 00 EC 13 00 00 ..ì..
+04F0157C B2 07 00 00 B4 07 00 00 ²..´..
+04F01584 CF 08 00 00 Ï..
+
+arrangeline2 = 1
+*/
+ SANE_Int rst, LinesCount;
+ SANE_Int mysize;
+ SANE_Byte *readbuffer = NULL;
+ SANE_Byte *pImage = NULL;
+
+ DBG (DBG_FNC, "+ Read_Block(buffer_size=%i, *buffer):\n", buffer_size);
+
+ rst = ERROR;
+ *transferred = 0;
+
+ if ((scan2.colormode != CM_COLOR) && (scan2.channel == 3)
+ && (arrangeline2 != FIX_BY_SOFT))
+ {
+ /*6510 */
+ return Read_NonColor_Block (dev, buffer, buffer_size, scan2.colormode,
+ transferred);
+ }
+
+ /*6544 */
+ mysize = (buffer_size / line_size) * bytesperline;
+ readbuffer = (SANE_Byte *) malloc (mysize * sizeof (SANE_Byte));
+ pImage = buffer;
+
+ if (readbuffer != NULL)
+ {
+ do
+ {
+ buffer_size =
+ (dev->Reading->Size4Lines <
+ mysize) ? dev->Reading->Size4Lines : mysize;
+ LinesCount = buffer_size / bytesperline;
+
+ if (scan2.depth == 12)
+ {
+ rst =
+ Scan_Read_BufferA (dev, buffer_size, 0, readbuffer,
+ transferred);
+ if (rst == OK)
+ {
+ if (LinesCount > 0)
+ {
+ SANE_Byte *destino, *fuente;
+ destino = buffer;
+ fuente = readbuffer;
+ do
+ {
+ Split_into_12bit_channels (destino, fuente,
+ line_size);
+ destino += line_size;
+ fuente += (bytesperline * 3) / 4;
+ LinesCount--;
+ }
+ while (LinesCount > 0);
+ }
+ }
+ else
+ break;
+ }
+ else
+ {
+ /*65d9 */
+ rst =
+ Scan_Read_BufferA (dev, buffer_size, 0, readbuffer,
+ transferred);
+ if (rst == OK)
+ {
+ memcpy (pImage, readbuffer, *transferred);
+
+ /* apply white shading correction */
+ if ((RTS_Debug->wshading == TRUE)
+ && (scan2.scantype == ST_NORMAL))
+ WShading_Emulate (pImage, &wshading->ptr, *transferred,
+ scan2.depth);
+
+ pImage += *transferred;
+ }
+ else
+ break;
+ }
+ /*6629 */
+ mysize -= buffer_size;
+ }
+ while ((mysize > 0) && (dev->status->cancel == FALSE));
+
+ free (readbuffer);
+ }
+
+ DBG (DBG_FNC, "- Read_Block(*transferred=%i): %i\n", *transferred, rst);
+
+ return rst;
+}
+
+static SANE_Int
+Scan_Read_BufferA (struct st_device *dev, SANE_Int buffer_size, SANE_Int arg2,
+ SANE_Byte * pBuffer, SANE_Int * bytes_transfered)
+{
+ SANE_Int rst = OK;
+ SANE_Byte *ptBuffer = NULL;
+ SANE_Byte *ptImg = NULL;
+ struct st_readimage *rd = dev->Reading;
+
+ DBG (DBG_FNC,
+ "+ Scan_Read_BufferA(buffer_size=%i, arg2, *pBuffer, *bytes_transfered):\n",
+ buffer_size);
+
+ arg2 = arg2; /* silence gcc */
+ *bytes_transfered = 0;
+
+ if (pBuffer != NULL)
+ {
+ ptBuffer = pBuffer;
+
+ while ((buffer_size > 0) && (rst == OK)
+ && (dev->status->cancel == FALSE))
+ {
+ /* Check if we've already started */
+ if (rd->Starting == TRUE)
+ {
+ /* Get channels per dot and channel's size in bytes */
+ SANE_Byte data;
+
+ rd->Channels_per_dot = 1;
+ if (Read_Byte (dev->usb_handle, 0xe812, &data) == OK)
+ {
+ data = data >> 6;
+ if (data != 0)
+ rd->Channels_per_dot = data;
+ }
+
+ rd->Channel_size = 1;
+ if (Read_Byte (dev->usb_handle, 0xee0b, &data) == OK)
+ if (((data & 0x40) != 0) && ((data & 0x08) == 0))
+ rd->Channel_size = 2;
+
+ rd->RDStart = rd->DMABuffer;
+ rd->RDSize = 0;
+ rd->DMAAmount = 0;
+ rd->Starting = FALSE;
+ }
+
+ /* Is there any data to read from scanner? */
+ if ((rd->ImageSize > 0) && (rd->RDSize == 0))
+ {
+ /* Try to read from scanner all possible data to fill DMABuffer */
+ if (rd->RDSize < rd->DMABufferSize)
+ {
+ SANE_Int iAmount, dofree;
+
+ /* Check if we have already notify buffer size */
+ if (rd->DMAAmount <= 0)
+ {
+ /* Initially I suppose that I can read all image */
+ iAmount = min (rd->ImageSize, rd->Max_Size);
+ rd->DMAAmount =
+ ((RTS_Debug->dmasetlength * 2) / iAmount) * iAmount;
+ rd->DMAAmount = min (rd->DMAAmount, rd->ImageSize);
+ Reading_BufferSize_Notify (dev, 0, rd->DMAAmount);
+ iAmount = min (iAmount, rd->DMABufferSize - rd->RDSize);
+ }
+ else
+ {
+ iAmount = min (rd->DMAAmount, rd->ImageSize);
+ iAmount = min (iAmount, rd->Max_Size);
+ }
+
+ /* Allocate buffer to read image if it's necessary */
+ if ((rd->RDSize == 0) && (iAmount <= buffer_size))
+ {
+ ptImg = ptBuffer;
+ dofree = FALSE;
+ }
+ else
+ {
+ ptImg =
+ (SANE_Byte *) malloc (iAmount * sizeof (SANE_Byte));
+ dofree = TRUE;
+ }
+
+ if (ptImg != NULL)
+ {
+ /* We must wait for scanner to get data */
+ SANE_Int opStatus, sc;
+
+ sc = (iAmount < rd->Max_Size) ? TRUE : FALSE;
+ opStatus = Reading_Wait (dev, rd->Channels_per_dot,
+ rd->Channel_size,
+ iAmount,
+ &rd->Bytes_Available, 10, sc);
+
+ /* If something fails, perhaps we can read some bytes... */
+ if (opStatus != OK)
+ {
+ if (rd->Bytes_Available > 0)
+ iAmount = rd->Bytes_Available;
+ else
+ rst = ERROR;
+ }
+
+ if (rst == OK)
+ {
+ /* Try to read from scanner */
+ SANE_Int transferred = 0;
+ opStatus =
+ Bulk_Operation (dev, BLK_READ, iAmount, ptImg,
+ &transferred);
+
+ DBG (DBG_FNC,
+ "> Scan_Read_BufferA: Bulk read %i bytes\n",
+ transferred);
+
+ /*if something fails may be we can read some bytes */
+ iAmount = (SANE_Int) transferred;
+ if (iAmount != 0)
+ {
+ /* Lets copy data into DMABuffer if it's necessary */
+ if (ptImg != ptBuffer)
+ {
+ SANE_Byte *ptDMABuffer;
+
+ ptDMABuffer = rd->RDStart + rd->RDSize;
+ if ((ptDMABuffer - rd->DMABuffer) >=
+ rd->DMABufferSize)
+ ptDMABuffer -= rd->DMABufferSize;
+
+ if ((ptDMABuffer + iAmount) >=
+ (rd->DMABuffer + rd->DMABufferSize))
+ {
+ SANE_Int rest =
+ iAmount - (rd->DMABufferSize -
+ (ptDMABuffer -
+ rd->DMABuffer));
+ memcpy (ptDMABuffer, ptImg,
+ iAmount - rest);
+ memcpy (rd->DMABuffer,
+ ptImg + (iAmount - rest), rest);
+ }
+ else
+ memcpy (ptDMABuffer, ptImg, iAmount);
+ rd->RDSize += iAmount;
+ }
+ else
+ {
+ *bytes_transfered += iAmount;
+ buffer_size -= iAmount;
+ }
+
+ rd->DMAAmount -= iAmount;
+ rd->ImageSize -= iAmount;
+ }
+ else
+ rst = ERROR;
+ }
+
+ /* Lets free buffer */
+ if (dofree == TRUE)
+ {
+ free (ptImg);
+ ptImg = NULL;
+ }
+ }
+ else
+ rst = ERROR;
+ }
+ }
+
+ /* is there any data read from scanner? */
+ if (rd->RDSize > 0)
+ {
+ /* Add to the given buffer so many bytes as posible */
+ SANE_Int iAmount;
+
+ iAmount = min (buffer_size, rd->RDSize);
+ if ((rd->RDStart + iAmount) >=
+ (rd->DMABuffer + rd->DMABufferSize))
+ {
+ SANE_Int rest =
+ rd->DMABufferSize - (rd->RDStart - rd->DMABuffer);
+ memcpy (ptBuffer, rd->RDStart, rest);
+ memcpy (ptBuffer + rest, rd->DMABuffer, iAmount - rest);
+ rd->RDStart = rd->DMABuffer + (iAmount - rest);
+ }
+ else
+ {
+ memcpy (ptBuffer, rd->RDStart, iAmount);
+ rd->RDStart += iAmount;
+ }
+
+ ptBuffer += iAmount;
+ rd->RDSize -= iAmount;
+ buffer_size -= iAmount;
+ *bytes_transfered += iAmount;
+
+ /* if there isn't any data in DMABuffer we can point RDStart
+ to the begining of DMABuffer */
+ if (rd->RDSize == 0)
+ rd->RDStart = rd->DMABuffer;
+ }
+
+ /* in case of all data is read we return OK with bytes_transfered = 0 */
+ if ((*bytes_transfered == 0)
+ || ((rd->RDSize == 0) && (rd->ImageSize == 0)))
+ break;
+ }
+
+ if (rst == ERROR)
+ RTS_DMA_Cancel (dev);
+ }
+
+ DBG (DBG_FNC, "-> *bytes_transfered=%i\n", *bytes_transfered);
+ DBG (DBG_FNC, "-> Reading->ImageSize=%i\n", rd->ImageSize);
+ DBG (DBG_FNC, "-> Reading->DMAAmount=%i\n", rd->DMAAmount);
+ DBG (DBG_FNC, "-> Reading->RDSize =%i\n", rd->RDSize);
+
+ DBG (DBG_FNC, "- Scan_Read_BufferA: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Reading_BufferSize_Get (struct st_device *dev, SANE_Byte channels_per_dot,
+ SANE_Int channel_size)
+{
+ /* returns the ammount of bytes in scanner's buffer ready to be read */
+
+ SANE_Int rst;
+
+ DBG (DBG_FNC,
+ "+ Reading_BufferSize_Get(channels_per_dot=%i, channel_size=%i):\n",
+ channels_per_dot, channel_size);
+
+ rst = 0;
+
+ if (channel_size > 0)
+ {
+ SANE_Int myAmount;
+
+ if (channels_per_dot < 1)
+ {
+ /* read channels per dot from registers */
+ if (Read_Byte (dev->usb_handle, 0xe812, &channels_per_dot) == OK)
+ channels_per_dot = _B0 (channels_per_dot >> 6);
+
+ if (channels_per_dot == 0)
+ channels_per_dot++;
+ }
+
+ if (Read_Integer (dev->usb_handle, 0xef16, &myAmount) == OK)
+ rst = ((channels_per_dot * 32) / channel_size) * myAmount;
+ }
+
+ DBG (DBG_FNC, "- Reading_BufferSize_Get: %i bytes\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Lamp_Warmup (struct st_device *dev, SANE_Byte * Regs, SANE_Int lamp,
+ SANE_Int resolution)
+{
+ SANE_Int rst = OK;
+
+ DBG (DBG_FNC, "+ Lamp_Warmup(*Regs, lamp=%i, resolution=%i)\n", lamp,
+ resolution);
+
+ if (Regs != NULL)
+ {
+ SANE_Byte flb_lamp, tma_lamp;
+ SANE_Int overdrivetime;
+
+ Lamp_Status_Get (dev, &flb_lamp, &tma_lamp);
+
+ /* ensure that selected lamp is switched on */
+ if (lamp == FLB_LAMP)
+ {
+ overdrivetime = RTS_Debug->overdrive_flb;
+
+ if (flb_lamp == 0)
+ {
+ /* FLB-Lamp is turned off, lets turn on */
+ Lamp_Status_Set (dev, Regs, TRUE, FLB_LAMP);
+ waitforpwm = TRUE;
+ }
+ }
+ else
+ {
+ /* is tma device attached to scanner ? */
+ if (RTS_isTmaAttached (dev) == TRUE)
+ {
+ overdrivetime = RTS_Debug->overdrive_ta;
+
+ if (tma_lamp == 0)
+ {
+ /* tma lamp is turned off */
+ Lamp_Status_Set (dev, Regs, FALSE, TMA_LAMP);
+ waitforpwm = TRUE;
+ }
+ }
+ else
+ rst = ERROR;
+ }
+
+ /* perform warmup process */
+ if (rst == OK)
+ {
+ Lamp_PWM_Setup (dev, lamp);
+
+ if (waitforpwm == TRUE)
+ {
+ /*Lamp_PWM_DutyCycle_Set(dev, (lamp == TMA_LAMP)? 0x0e : 0x00); */
+
+ if (RTS_Debug->warmup == TRUE)
+ {
+ long ticks = GetTickCount () + overdrivetime;
+
+ DBG (DBG_VRB, "- Lamp Warmup process. Please wait...\n");
+
+ dev->status->warmup = TRUE;
+
+ while (GetTickCount () <= ticks)
+ usleep (1000 * 200);
+
+ Lamp_PWM_CheckStable (dev, resolution, lamp);
+
+ }
+ else
+ DBG (DBG_VRB, "- Lamp Warmup process disabled.\n");
+ }
+
+ /*Lamp_PWM_Setup(dev, lamp);
+
+ if (waitforpwm == TRUE)
+ {
+ if (RTS_Debug->warmup == TRUE)
+ Lamp_PWM_CheckStable(dev, resolution, lamp);
+
+ waitforpwm = FALSE;
+ } */
+ }
+
+ }
+ else
+ rst = ERROR;
+
+ dev->status->warmup = FALSE;
+
+ DBG (DBG_FNC, "- Lamp_Warmup: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Scan_Start (struct st_device *dev)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ Scan_Start:\n");
+
+ rst = ERROR;
+ if (RTS_Enable_CCD (dev, dev->init_regs, 0x0f) == OK)
+ {
+ SANE_Byte Regs[RT_BUFFER_LEN], mlock;
+ SANE_Int ypos, xpos, runb1;
+ struct st_scanparams scancfg;
+ struct st_hwdconfig hwdcfg;
+ struct st_calibration myCalib;
+ long tick;
+
+ memcpy (&Regs, dev->init_regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+ memcpy (&scancfg, &scan, sizeof (struct st_scanparams));
+
+ dbg_ScanParams (&scancfg);
+
+ /* reserva buffer 6 dwords en fa84-fa9f */
+ bzero (&hwdcfg, sizeof (struct st_hwdconfig));
+
+ /* wait till lamp is at home (should use timeout
+ windows driver doesn't use it)
+ */
+ tick = GetTickCount () + 10000;
+ while ((Head_IsAtHome (dev, Regs) == FALSE)
+ && (tick > GetTickCount ()));
+
+ if (v14b4 != 0)
+ {
+ SANE_Int lfaa0 = 0;
+
+ if (GainOffset_Counter_Inc (dev, &lfaa0) != OK)
+ return 0x02;
+ }
+
+ tick = GetTickCount ();
+
+ /* set margin references */
+ Refs_Set (dev, Regs, &scancfg);
+
+ /* locate head to right position */
+ Load_StripCoords (scantype, &ypos, &xpos);
+ if (ypos != 0)
+ Head_Relocate (dev, dev->motorcfg->parkhomemotormove, MTR_FORWARD,
+ ypos);
+
+ /* perform lamp warmup */
+ if (Lamp_Warmup
+ (dev, Regs, (scancfg.scantype == ST_NORMAL) ? FLB_LAMP : TMA_LAMP,
+ scan.resolution_x) == ERROR)
+ return ERROR;
+
+ /* Calibration process */
+
+ /*592c */
+ if (Calib_CreateBuffers (dev, &myCalib, v14b4) != OK)
+ return ERROR;
+
+ /*5947 */
+
+/*
+if (Calib_BlackShading_jkd(dev, Regs, &myCalib, &scancfg) == OK)
+ Head_ParkHome(dev, TRUE, dev->motorcfg->parkhomemotormove);
+*/
+
+/*
+if (Calib_test(dev, Regs, &myCalib, &scancfg) == OK )
+ Head_ParkHome(dev, TRUE, dev->motorcfg->parkhomemotormove);
+*/
+
+/* Calibrate White shading correction */
+ if ((RTS_Debug->wshading == TRUE) && (scan.scantype == ST_NORMAL))
+ if (WShading_Calibrate (dev, Regs, &myCalib, &scancfg) == OK)
+ Head_ParkHome (dev, TRUE, dev->motorcfg->parkhomemotormove);
+
+ hwdcfg.calibrate = RTS_Debug->calibrate;
+
+ if (RTS_Debug->calibrate != 0)
+ {
+ /* Let's calibrate */
+ if ((scancfg.colormode != CM_COLOR) && (scancfg.channel == 3))
+ scancfg.colormode = CM_COLOR;
+
+ hwdcfg.arrangeline = 0;
+
+ if (scan.scantype == ST_NORMAL)
+ {
+ /* Calibration for reflective type */
+
+ /*59e3 */
+ memcpy (&Regs, dev->init_regs,
+ RT_BUFFER_LEN * sizeof (SANE_Byte));
+
+ if (Calibration (dev, Regs, &scancfg, &myCalib, 0) != OK)
+ {
+ if (v14b4 == 0)
+ Calib_FreeBuffers (&myCalib);
+ return ERROR;
+ }
+ }
+ else
+ {
+ /*59ed */
+ /* Calibration for negative/slide type */
+
+ }
+
+ /*5af1 */
+ if (RTS_Debug->ScanWhiteBoard != FALSE)
+ {
+ Head_ParkHome (dev, TRUE, dev->motorcfg->basespeedmotormove);
+ scan.ler = 1;
+ }
+
+ scancfg.colormode = scan.colormode;
+ }
+ else
+ {
+ /*5b1e */
+ /*Don't calibrate */
+ if (scan.scantype == ST_NORMAL)
+ {
+ Lamp_Status_Set (dev, NULL, TRUE, FLB_LAMP);
+ }
+ else
+ {
+ if ((scan.scantype == ST_TA) || (scan.scantype == ST_NEG))
+ {
+ /*SANE_Int ta_y_start; */
+ Lamp_Status_Set (dev, NULL, FALSE, TMA_LAMP);
+ /*ta_y_start =
+ get_value(SCAN_PARAM, TA_Y_START, 0x2508, usbfile);
+ ta_y_start += (((((scan.coord.top * 3) * 5) * 5) * 32) / scancfg.resolution_x);
+ if (ta_y_start >= 500)
+ {
+ Head_Relocate(dev, dev->motorcfg->highspeedmotormove, MTR_FORWARD, ta_y_start);
+ scancfg.coord.top = 1;
+ scan.ler = 1;
+ } else
+ {
+ / *5ba9* /
+ if (ta_y_start > 0)
+ {
+ Head_Relocate(dev, dev->motorcfg->basespeedmotormove, MTR_FORWARD, ta_y_start);
+ scancfg.coord.top = 1;
+ scan.ler = 1;
+ }
+ } */
+ }
+ }
+ }
+
+ /*5bd0 */
+ usleep (1000 * 200);
+
+ hwdcfg.scantype = scan.scantype;
+ hwdcfg.motor_direction = MTR_FORWARD;
+
+ /* Set Origin */
+ if ((scan.scantype >= ST_NORMAL) || (scan.scantype <= ST_NEG))
+ {
+ scancfg.coord.left += scan.ser;
+ scancfg.coord.top += scan.ler;
+ }
+
+ hwdcfg.sensorevenodddistance = dev->sensorcfg->evenodd_distance;
+ hwdcfg.highresolution = (scancfg.resolution_x <= 1200) ? FALSE : TRUE;
+
+ /*5c55 */
+ /*
+ if (RTS_Debug->calibrate == FALSE)
+ {
+ SANE_Int mytop = (((scancfg.coord.top * 5) * 5) * 16) / scancfg.resolution_y;
+ if ((scancfg.resolution_y <= 150)&&(mytop < 300))
+ {
+ scancfg.coord.top = scancfg.resolution_y / 4;
+ } else
+ {
+ if (mytop < 100)
+ scancfg.coord.top = scancfg.resolution_y / 12;
+ }
+ }
+ */
+
+ /*5cd9 */
+ if (compression != FALSE)
+ hwdcfg.compression = TRUE;
+
+ /* setting arrangeline option */
+ hwdcfg.arrangeline = arrangeline;
+ if (scancfg.resolution_x == 2400)
+ {
+ /* 5cfa */
+ if (scancfg.colormode != CM_COLOR)
+ {
+ if ((scancfg.colormode == CM_GRAY) && (scancfg.channel == 3))
+ hwdcfg.arrangeline = FIX_BY_SOFT;
+ }
+ else
+ hwdcfg.arrangeline = FIX_BY_SOFT;
+ }
+
+ /*5d12 */
+ if (dev->sensorcfg->type == CCD_SENSOR)
+ {
+ /*5d3a */
+ scancfg.coord.left += 24;
+ switch (scancfg.resolution_x)
+ {
+ case 1200:
+ scancfg.coord.left -= 63;
+ break;
+ case 2400:
+ scancfg.coord.left -= 127;
+ break;
+ }
+ }
+ else
+ {
+ /*5d5a */
+ /* CIS sensor */
+ /*5d6d */
+ scancfg.coord.left += 50;
+ switch (scancfg.resolution_x)
+ {
+ case 1200:
+ scancfg.coord.left -= 63;
+ break;
+ case 2400:
+ scancfg.coord.left -= 127;
+ break;
+ }
+ }
+
+ /* 5d92 */
+ DBG (DBG_FNC, " ->Scan_Start xStart=%i, xExtent=%i\n",
+ scancfg.coord.left, scancfg.coord.width);
+
+ runb1 = 1;
+ if (scan.scantype == ST_NORMAL)
+ {
+ /*5db7 */
+ if ((scancfg.resolution_x == 1200)
+ || (scancfg.resolution_x == 2400))
+ {
+ /*5e41 */
+ if ((scancfg.resolution_y / 10) > scancfg.coord.top)
+ runb1 = 0;
+ }
+ else
+ {
+ if ((scancfg.resolution_x == 600)
+ && (RTS_Debug->usbtype == USB11)
+ && (scancfg.colormode == CM_COLOR))
+ {
+ /*5ded */
+ if ((scancfg.resolution_y / 10) > scancfg.coord.top)
+ runb1 = 0;
+ }
+ else
+ {
+ if ((scancfg.resolution_x == 600)
+ || (scancfg.resolution_x == 300))
+ {
+ /*5e11 */
+ if (scancfg.resolution_y > scancfg.coord.top)
+ runb1 = 0;
+ }
+ else
+ runb1 = 0;
+ }
+ }
+ }
+ else
+ {
+ /*5e7c *//* entra aquí */
+ if ((scancfg.resolution_y / 10) > scancfg.coord.top)
+ runb1 = 0;
+ }
+ /*5eb1 */
+ if (runb1 == 1) /*entra */
+ {
+ SANE_Int val1 = scancfg.coord.top - (scancfg.resolution_y / 10);
+ scancfg.coord.top -= val1;
+ Head_Relocate (dev, dev->motorcfg->highspeedmotormove, MTR_FORWARD, (dev->motorcfg->resolution / scancfg.resolution_y) * val1); /*x168 */
+ }
+
+ /*5efe */
+ if (RTS_Debug->calibrate != FALSE)
+ {
+ if (use_gamma_tables != FALSE)
+ {
+ hwdcfg.use_gamma_tables = TRUE;
+ hp_gamma->depth = 0;
+ }
+
+ /*5f24 */
+ hwdcfg.white_shading = TRUE;
+ hwdcfg.black_shading = TRUE;
+ hwdcfg.unk3 = 0;
+ RTS_Setup (dev, Regs, &scancfg, &hwdcfg, &calibdata->gain_offset);
+
+ myCalib.shading_type = 0;
+ myCalib.shadinglength =
+ min (myCalib.shadinglength, scan.shadinglength);
+
+ if (scancfg.colormode != CM_COLOR)
+ {
+ if ((scancfg.channel > 0) && (scancfg.channel < 3))
+ myCalib.WRef[0] = myCalib.WRef[scancfg.channel];
+ }
+
+ RTS_WriteRegs (dev->usb_handle, Regs);
+
+ /* apply gamma if required */
+ Gamma_Apply (dev, Regs, &scancfg, &hwdcfg, hp_gamma);
+
+ Shading_apply (dev, Regs, &scancfg, &myCalib);
+
+ /* Save to file? */
+ if (RTS_Debug->DumpShadingData != FALSE)
+ dump_shading (&myCalib); /*5ff9 */
+ }
+ else
+ RTS_Setup (dev, Regs, &scancfg, &hwdcfg, default_gain_offset);
+
+ /*602a */
+ RTS_Debug->calibrate = hwdcfg.calibrate;
+ binarythresholdh = bw_threshold;
+ binarythresholdl = bw_threshold;
+ DBG (DBG_FNC, "> bw threshold -- hi=%i, lo=%i\n", binarythresholdh,
+ binarythresholdl);
+
+ /* set threshold high */
+ data_lsb_set (&Regs[0x1a0], binarythresholdh, 2);
+
+ /* set threshold low */
+ data_lsb_set (&Regs[0x19e], binarythresholdl, 2);
+
+ /* if has motorcurves... */
+ if ((Regs[0xdf] & 0x10) != 0)
+ data_bitset (&Regs[0x01], 0x02, 1);
+
+ /* Set MLOCK */
+ mlock = get_value (SCAN_PARAM, MLOCK, 0, usbfile) & 1;
+ data_bitset (&Regs[0x00], 0x10, mlock); /*---x----*/
+
+ if (dev->motorcfg->changemotorcurrent != FALSE)
+ Motor_Change (dev, Regs,
+ Motor_GetFromResolution (scancfg.resolution_x));
+
+ /* set gain control mode */
+ Lamp_SetGainMode (dev, Regs, scancfg.resolution_x,
+ Lamp_GetGainMode (dev, scancfg.resolution_x,
+ scan.scantype));
+
+ RTS_WaitScanEnd (dev, 15000);
+ if (v14b4 == 0)
+ Calib_FreeBuffers (&myCalib);
+
+ /* release motor */
+ Motor_Release (dev);
+
+
+#ifdef developing
+/* prueba(Regs);
+ dbg_registers(Regs);*/
+ /*WShading_Calibrate(dev, Regs, &myCalib, &scancfg); */
+ /*shadingtest1(dev, Regs, &myCalib); */
+#endif
+
+ if (RTS_Warm_Reset (dev) == OK)
+ {
+ RTS_WriteRegs (dev->usb_handle, Regs);
+ usleep (1000 * 500);
+
+ if (RTS_Execute (dev) == OK)
+ {
+ Lamp_Status_Timer_Set (dev, 0);
+
+ /* Let scanner some time to store some data */
+ if ((dev->chipset->model == RTS8822L_02A)
+ && (scancfg.resolution_x > 2400))
+ usleep (1000 * 5000);
+
+ rst = OK;
+ }
+ }
+ }
+
+ DBG (DBG_FNC, "- Scan_Start: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_Setup_Motor (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg, SANE_Int somevalue)
+{
+ SANE_Int rst = ERROR; /* default */
+
+ DBG (DBG_FNC, "+ RTS_Setup_Motor(*Regs, *scancfg, somevalue=%i):\n",
+ somevalue);
+ dbg_ScanParams (scancfg);
+
+ if ((Regs != NULL) && (scancfg != NULL))
+ {
+ SANE_Int colormode, mymode;
+
+ colormode = ((scancfg->colormode != CM_COLOR)
+ && (scancfg->channel == 3)) ? 3 : scancfg->colormode;
+ mymode =
+ RTS_GetScanmode (dev, scantype, colormode, scancfg->resolution_x);
+
+ if (mymode != -1)
+ {
+ SANE_Int mbs[2] = { 0 }; /* motor back steps */
+ SANE_Int step_size, step_type, dummyline, myvalue, lf02c;
+ struct st_scanmode *sm;
+
+ sm = dev->scanmodes[mymode];
+
+ /* set motor step type */
+ data_bitset (&Regs[0xd9], 0x70, sm->scanmotorsteptype); /*-xxx----*/
+
+ /* set motor direction (polarity) */
+ data_bitset (&Regs[0xd9], 0x80, somevalue >> 3); /*e------- */
+
+ /* next value doesn't seem to have any effect */
+ data_bitset (&Regs[0xd9], 0x0f, somevalue); /*----efgh*/
+
+ /* 0 enable/1 disable motor */
+ data_bitset (&Regs[0xdd], 0x80, somevalue >> 4); /*d------- */
+
+ /* next value doesn't seem to have any effect */
+ data_bitset (&Regs[0xdd], 0x40, somevalue >> 4); /*-d------*/
+
+ switch (sm->scanmotorsteptype)
+ {
+ case STT_OCT:
+ step_type = 8;
+ break;
+ case STT_QUART:
+ step_type = 4;
+ break;
+ case STT_HALF:
+ step_type = 2;
+ break;
+ default:
+ step_type = 1;
+ break; /* STT_FULL */
+ }
+
+ /* set dummy lines */
+ dummyline = sm->dummyline;
+ if (dummyline == 0)
+ dummyline++;
+
+ data_bitset (&Regs[0xd6], 0xf0, dummyline); /*xxxx---- */
+
+ /* Set if motor has curves */
+ data_bitset (&Regs[0xdf], 0x10, ((sm->motorcurve != -1) ? 1 : 0)); /*---x----*/
+
+ /* set last step of deccurve.scanbufferfull table to 16 */
+ data_lsb_set (&Regs[0xea], 0x10, 3);
+
+ /* set last step of deccurve.normalscan table to 16 */
+ data_lsb_set (&Regs[0xed], 0x10, 3);
+
+ /* set last step of deccurve.smearing table to 16 */
+ data_lsb_set (&Regs[0xf0], 0x10, 3);
+
+ /* set last step of deccurve.parkhome table to 16 */
+ data_lsb_set (&Regs[0xf3], 0x10, 3);
+
+ /* set step size */
+ step_size =
+ _B0 ((dev->motorcfg->resolution * step_type) /
+ (dummyline * scancfg->resolution_y));
+ data_lsb_set (&Regs[0xe0], step_size - 1, 1);
+
+ /* set line exposure time */
+ myvalue = data_lsb_get (&Regs[0x30], 3);
+ myvalue += ((myvalue + 1) % step_size);
+ data_lsb_set (&Regs[0x30], myvalue, 3);
+
+ /* set last step of accurve.normalscan table */
+ myvalue = ((myvalue + 1) / step_size) - 1;
+ data_lsb_set (&Regs[0xe1], myvalue, 3);
+
+ /* 42b30eb */
+ lf02c = 0;
+ if (sm->motorcurve != -1)
+ {
+ if (sm->motorcurve < dev->mtrsetting_count)
+ {
+ struct st_motorcurve *ms = dev->mtrsetting[sm->motorcurve];
+ ms->motorbackstep = sm->motorbackstep;
+ }
+
+ DBG (DBG_FNC, " -> Setting up step motor using motorcurve %i\n",
+ sm->motorcurve);
+ lf02c = Motor_Setup_Steps (dev, Regs, sm->motorcurve);
+
+ /* set motor back steps */
+ mbs[1] = sm->motorbackstep;
+ if (mbs[1] >= (smeardeccurvecount + smearacccurvecount))
+ mbs[0] =
+ mbs[1] - (smeardeccurvecount + smearacccurvecount) + 2;
+ else
+ mbs[0] = 0;
+
+ if (mbs[1] >= (deccurvecount + acccurvecount))
+ mbs[1] -= (deccurvecount + acccurvecount) + 2;
+ else
+ mbs[1] = 0;
+ }
+ else
+ {
+ /* this scanner hasn't got any motorcurve */
+
+ /* set last step of accurve.smearing table (same as accurve.normalscan) */
+ data_lsb_set (&Regs[0xe4], myvalue, 3);
+
+ /* set last step of accurve.parkhome table (same as accurve.normalscan) */
+ data_lsb_set (&Regs[0xe7], myvalue, 3);
+
+ /* both motorbacksteps are equal */
+ mbs[0] = sm->motorbackstep;
+ mbs[1] = sm->motorbackstep;
+ }
+
+ /* show msi and motorbacksteps */
+ DBG (DBG_FNC, " -> msi = %i\n", sm->msi);
+ DBG (DBG_FNC, " -> motorbackstep1 = %i\n", mbs[0]);
+ DBG (DBG_FNC, " -> motorbackstep2 = %i\n", mbs[1]);
+
+ /* set msi */
+ data_bitset (&Regs[0xda], 0xff, _B0 (sm->msi)); /*xxxxxxxx */
+ data_bitset (&Regs[0xdd], 0x03, _B1 (sm->msi)); /*------xx*/
+
+ /* set motorbackstep (a) */
+ data_bitset (&Regs[0xdb], 0xff, _B0 (mbs[0])); /*xxxxxxxx */
+ data_bitset (&Regs[0xdd], 0x0c, _B1 (mbs[0])); /*----xx--*/
+
+ /* set motorbackstep (b) */
+ data_bitset (&Regs[0xdc], 0xff, _B0 (mbs[1])); /*xxxxxxxx */
+ data_bitset (&Regs[0xdd], 0x30, _B1 (mbs[1])); /*--xx----*/
+
+ /* 328b */
+
+ /* get dummy lines count */
+ dummyline = data_bitget (&Regs[0xd6], 0xf0);
+
+ myvalue = scancfg->coord.top * (dummyline * step_size);
+
+ if (lf02c >= myvalue)
+ scancfg->coord.top = 1;
+ else
+ scancfg->coord.top -= (lf02c / (dummyline * step_size)) - 1;
+
+ rst = lf02c; /* Result from Motor_Setup_Steps */
+ }
+ }
+
+ DBG (DBG_FNC, "- RTS_Setup_Motor: %i\n", rst);
+
+ return rst;
+}
+
+static void
+RTS_Setup_Exposure_Times (SANE_Byte * Regs, struct st_scanparams *scancfg,
+ struct st_scanmode *sm)
+{
+ DBG (DBG_FNC, "> RTS_Setup_Exposure_Times\n");
+
+ if ((sm != NULL) && (Regs != NULL) && (scancfg != NULL))
+ {
+ SANE_Int myexpt[3], linexpt, a;
+
+ /* calculate line exposure time */
+ linexpt = sm->ctpc + 1;
+ if (RTS_Debug->usbtype == USB11)
+ linexpt *= sm->multiexposureforfullspeed;
+
+ if (scancfg->depth > 8)
+ linexpt *= sm->multiexposurefor16bitmode;
+
+ linexpt--;
+
+ /* generate exposure times for each channel color */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ if ((linexpt > sm->mexpt[a]) && (sm->expt[a] == 0))
+ sm->expt[a] = sm->mexpt[a];
+
+ myexpt[a] = (sm->expt[a] == 0) ? sm->mexpt[a] : sm->expt[a];
+ }
+
+ /* save exposure times */
+ DBG (DBG_FNC, "-> Exposure times : %04x, %04x, %04x\n", sm->expt[0],
+ sm->expt[1], sm->expt[2]);
+ data_lsb_set (&Regs[0x36], sm->expt[CL_RED], 3);
+ data_lsb_set (&Regs[0x3c], sm->expt[CL_GREEN], 3);
+ data_lsb_set (&Regs[0x42], sm->expt[CL_BLUE], 3);
+
+ /* save maximum exposure times */
+ DBG (DBG_FNC, "-> Maximum exposure times: %04x, %04x, %04x\n",
+ sm->mexpt[0], sm->mexpt[1], sm->mexpt[2]);
+ data_lsb_set (&Regs[0x33], sm->mexpt[CL_RED], 3);
+ data_lsb_set (&Regs[0x39], sm->mexpt[CL_GREEN], 3);
+ data_lsb_set (&Regs[0x3f], sm->mexpt[CL_BLUE], 3);
+
+ /* save line exposure time */
+ data_lsb_set (&Regs[0x30], linexpt, 3);
+
+ /* scancfg->expt = lowest value */
+ scancfg->expt = min (min (myexpt[1], myexpt[2]), myexpt[0]);
+ }
+}
+
+static SANE_Int
+RTS_Setup_Line_Distances (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg,
+ struct st_hwdconfig *hwdcfg, SANE_Int mycolormode,
+ SANE_Int arrangeline)
+{
+ SANE_Int iLineDistance = 0;
+
+ if (arrangeline == FIX_BY_HARD)
+ {
+ /* we don't need to arrange retrieved line */
+ SANE_Int mylinedistance, myevenodddist;
+
+ mylinedistance =
+ (dev->sensorcfg->line_distance * scancfg->resolution_y) /
+ dev->sensorcfg->resolution;
+
+ if (hwdcfg->highresolution == TRUE)
+ myevenodddist =
+ (hwdcfg->sensorevenodddistance * scancfg->resolution_y) /
+ dev->sensorcfg->resolution;
+ else
+ myevenodddist = 0;
+
+ data_bitset (&Regs[0x149], 0x3f, myevenodddist);
+ data_bitset (&Regs[0x14a], 0x3f, mylinedistance);
+ data_bitset (&Regs[0x14b], 0x3f, mylinedistance + myevenodddist);
+ data_bitset (&Regs[0x14c], 0x3f, mylinedistance * 2);
+ data_bitset (&Regs[0x14d], 0x3f, (mylinedistance * 2) + myevenodddist);
+ }
+ else
+ {
+ /* arrange retrieved line */
+ data_bitset (&Regs[0x149], 0x3f, 0);
+ data_bitset (&Regs[0x14a], 0x3f, 0);
+ data_bitset (&Regs[0x14b], 0x3f, 0);
+ data_bitset (&Regs[0x14c], 0x3f, 0);
+ data_bitset (&Regs[0x14d], 0x3f, 0);
+
+ if (arrangeline == FIX_BY_SOFT)
+ {
+ if (hwdcfg->highresolution == FALSE)
+ {
+ if (mycolormode == CM_COLOR)
+ {
+ iLineDistance =
+ (dev->sensorcfg->line_distance * scan2.resolution_y) * 2;
+ iLineDistance =
+ (iLineDistance / dev->sensorcfg->resolution) + 1;
+ if (iLineDistance < 2)
+ iLineDistance = 2;
+ }
+ }
+ else
+ {
+ /* bcc */
+ if (mycolormode == CM_COLOR)
+ iLineDistance =
+ ((dev->sensorcfg->line_distance * 2) +
+ hwdcfg->sensorevenodddistance) * scan2.resolution_y;
+ else
+ iLineDistance =
+ dev->sensorcfg->line_distance * scan2.resolution_y;
+
+ iLineDistance =
+ (iLineDistance / dev->sensorcfg->resolution) + 1;
+ if (iLineDistance < 2)
+ iLineDistance = 2;
+ }
+
+ /* c25 */
+ iLineDistance &= 0xffff;
+ v15b4 = (iLineDistance > 0) ? 1 : 0;
+ imagesize += iLineDistance * bytesperline;
+ }
+ }
+
+ DBG (DBG_FNC,
+ "> RTS_Setup_Line_Distances(*Regs, *scancfg, *hwdcfg, mycolormode=%i, arrangeline=%i): %i\n",
+ mycolormode, arrangeline, iLineDistance);
+
+ return iLineDistance;
+}
+
+static SANE_Int
+RTS_Setup_Depth (SANE_Byte * Regs, struct st_scanparams *scancfg,
+ SANE_Int mycolormode)
+{
+ /* channels_per_line = channels_per_dot * scan.width
+ bytes_per_line = channels_per_line * bits_per_channel
+ */
+
+ SANE_Int bytes_per_line = 0;
+
+ if ((scancfg != NULL) && (Regs != NULL))
+ {
+ SANE_Int channels_per_line =
+ data_bitget (&Regs[0x12], 0xc0) * scancfg->coord.width;
+
+ bytes_per_line = channels_per_line;
+
+ /* set bits per channel in shading correction's register (0x1cf) */
+ if (mycolormode == CM_LINEART)
+ {
+ /* lineart mode */
+ bytes_per_line = (bytes_per_line + 7) / 8;
+ data_bitset (&Regs[0x1cf], 0x30, 3); /*--11----*/
+ }
+ else
+ {
+ /*f0c */
+ switch (scancfg->depth)
+ {
+ case 16:
+ /* 16 bits per channel */
+ bytes_per_line *= 2;
+ data_bitset (&Regs[0x1cf], 0x30, 2); /*--10----*/
+ break;
+ case 12:
+ /* 12 bits per channel */
+ bytes_per_line *= 2;
+ data_bitset (&Regs[0x1cf], 0x30, 1); /*--01----*/
+ break;
+ default:
+ /* 8 bits per channel */
+ data_bitset (&Regs[0x1cf], 0x30, 0); /*--00----*/
+ break;
+ }
+ }
+ }
+
+ return bytes_per_line;
+}
+
+static void
+RTS_Setup_Shading (SANE_Byte * Regs, struct st_scanparams *scancfg,
+ struct st_hwdconfig *hwdcfg, SANE_Int bytes_per_line)
+{
+ DBG (DBG_FNC,
+ "> RTS_Setup_Shading(*Regs, *scancfg, *hwdcfg, bytes_per_line=%i)\n",
+ bytes_per_line);
+
+ if ((Regs != NULL) && (hwdcfg != NULL))
+ {
+ SANE_Int dots_count, myvalue, myvalue2, mem_available, resolution_ratio,
+ sensor_line_distance;
+ SANE_Int channels, table_size;
+
+ resolution_ratio = Regs[0x0c0] & 0x1f;
+
+ /* 50de */
+ data_bitset (&Regs[0x1bf], 0x18, hwdcfg->unk3); /*---xx---*/
+
+ /* Enable black shading correction ? */
+ data_bitset (&Regs[0x1cf], 0x08, hwdcfg->black_shading); /*----x---*/
+
+ /* Enable white shading correction ? */
+ data_bitset (&Regs[0x1cf], 0x04, hwdcfg->white_shading); /*-----x--*/
+
+ if ((hwdcfg->white_shading != FALSE) && (hwdcfg->black_shading != FALSE)
+ && (hwdcfg->unk3 != 0))
+ data_bitset (&Regs[0x1cf], 0x04, 0); /*-----x--*/
+
+ table_size = 0;
+
+ /* if hwdcfg->black_shading */
+ if ((Regs[0x1cf] & 8) != 0)
+ table_size = (resolution_ratio * scancfg->coord.width) * 2; /* black shading buffer size? */
+
+ /* if hwdcfg->white_shading */
+ if ((Regs[0x1cf] & 4) != 0)
+ table_size += (resolution_ratio * scancfg->coord.width) * 2; /* white shading buffer size? */
+
+ /* Regs 0x1ba, 0x1bb, 0x1bd, 0x1c0 seem to be 4 pointers
+ to some buffer related to shading correction */
+
+ Regs[0x1ba] = 0x00;
+ table_size = (table_size + v160c_block_size - 1) / v160c_block_size;
+ table_size = ((table_size + 15) / 16) + 16;
+
+ Regs[0x1bf] &= 0xfe;
+ Regs[0x1bb] = _B0 (table_size);
+ Regs[0x1bc] = _B1 (table_size);
+ Regs[0x1bf] |= _B2 (table_size) & 1; /*-------x*/
+
+ Regs[0x1bf] &= 0xf9;
+ Regs[0x1bd] = _B0 (table_size * 2);
+ Regs[0x1be] = _B1 (table_size * 2);
+ Regs[0x1bf] |= (_B2 (table_size * 2) & 3) << 1; /*-----xx-*/
+
+ data_wide_bitset (&Regs[0x1c0], 0xfffff, table_size * 3);
+
+ mem_available = mem_total - ((table_size * 3) * 16);
+ sensor_line_distance = Regs[0x14a] & 0x3f;
+
+ /* select case channels_per_dot */
+ channels = data_lsb_get (&Regs[0x12], 1) >> 6;
+
+ switch (channels)
+ {
+ case 3: /* 3 channels per dot */
+ /* 528d */
+ dots_count = bytes_per_line / 3; /* 882 */
+ myvalue =
+ (((sensor_line_distance + 1) * dots_count) + v160c_block_size -
+ 1) / v160c_block_size;
+ myvalue2 = myvalue;
+ mem_available = (mem_available - (myvalue * 3) + 2) / 3;
+
+ myvalue += (table_size * 3) * 8;
+ myvalue = ((myvalue * 2) + mem_available);
+
+ data_bitset (&Regs[0x1c2], 0xf0, _B2 ((myvalue / 16) + 1)); /* 4 higher bits xxxx---- */
+ data_wide_bitset (&Regs[0x1c3], 0xffff, (myvalue / 16) + 1); /* 16 lower bits */
+
+ myvalue = myvalue + myvalue2 + mem_available;
+ data_wide_bitset (&Regs[0x1c5], 0xfffff, (myvalue / 16) + 1);
+ break;
+ case 2: /* 2 channels per dot */
+ dots_count = bytes_per_line / 2;
+ myvalue =
+ (((sensor_line_distance + 1) * dots_count) + v160c_block_size -
+ 1) / v160c_block_size;
+ mem_available = ((mem_available - myvalue) + 1) / 2;
+ myvalue += (((table_size * 3) + mem_available) / 16) + 1;
+
+ data_bitset (&Regs[0x1c2], 0xf0, _B2 (myvalue)); /* 4 higher bits xxxx---- */
+ data_wide_bitset (&Regs[0x1c3], 0xffff, myvalue); /* 16 lower bits */
+ break;
+ default:
+ dots_count = bytes_per_line;
+ break;
+ }
+
+ Regs[0x01c7] &= 0x0f;
+ Regs[0x01c8] = _B0 ((mem_total - 1) / 16);
+ Regs[0x01c9] = _B1 ((mem_total - 1) / 16);
+ Regs[0x01c7] |= (_B2 ((mem_total - 1) / 16) & 0x0f) << 4;
+
+ mem_available -= (dots_count + v160c_block_size - 1) / v160c_block_size;
+ mem_available /= 16;
+ Regs[0x0712] &= 0x0f;
+ Regs[0x0710] = _B0 (mem_available);
+ Regs[0x0711] = _B1 (mem_available);
+ Regs[0x0712] |= _B0 (_B2 (mem_available) << 4); /*xxxx---- */
+
+ Regs[0x0713] = 0x00;
+ Regs[0x0714] = 0x10;
+ Regs[0x0715] &= 0xf0;
+ }
+}
+
+static void
+RTS_Setup_Arrangeline (struct st_device *dev, struct st_hwdconfig *hwdcfg,
+ SANE_Int colormode)
+{
+ dev->scanning->arrange_compression =
+ (colormode == CM_LINEART) ? FALSE : hwdcfg->compression;
+
+ if ((colormode == CM_LINEART)
+ || ((colormode == CM_GRAY) && (hwdcfg->highresolution == FALSE)))
+ arrangeline2 = 0;
+ else
+ arrangeline2 = hwdcfg->arrangeline;
+
+ dev->scanning->arrange_hres = hwdcfg->highresolution;
+ dev->scanning->arrange_sensor_evenodd_dist =
+ (hwdcfg->highresolution == FALSE) ? 0 : hwdcfg->sensorevenodddistance;
+}
+
+static void
+RTS_Setup_Channels (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg, SANE_Int mycolormode)
+{
+ DBG (DBG_FNC, "> RTS_Setup_Channels(colormode=%i)\n", mycolormode);
+
+ if ((scancfg != NULL) && (Regs != NULL))
+ {
+ if ((mycolormode != CM_COLOR) && (mycolormode != 3))
+ {
+ /* CM_GRAY || CM_LINEART */
+ if (scancfg->samplerate == LINE_RATE)
+ {
+ /* Setting channels_per_dot to 1 */
+ data_bitset (&Regs[0x12], 0xc0, 1); /*01------ */
+
+ /* setting one rgb_channel_order */
+ data_bitset (&Regs[0x12], 0x03, dev->sensorcfg->rgb_order[scancfg->channel]); /*------xx*/
+
+ /* set sensor_channel_color_order */
+ data_bitset (&Regs[0x60a], 0x3f, 6); /*--xxxxxx*/
+
+ /* set samplerate */
+ data_bitset (&Regs[0x1cf], 0x40, PIXEL_RATE); /*-x------*/
+
+ /* set unknown data */
+ data_bitset (&Regs[0x1cf], 0x80, 1); /*x------- */
+
+ if (scancfg->channel == dev->sensorcfg->rgb_order[1])
+ {
+ /* mexpts[CL_RED] = mexpts[CL_GREEN] */
+ data_lsb_set (&Regs[0x33], data_lsb_get (&Regs[0x39], 3),
+ 3);
+
+ /* expts[CL_RED] = expts[CL_GREEN] */
+ data_lsb_set (&Regs[0x36], data_lsb_get (&Regs[0x3c], 3),
+ 3);
+ }
+ else if (scancfg->channel == dev->sensorcfg->rgb_order[2])
+ {
+ /* mexpts[CL_RED] = mexpts[CL_BLUE] */
+ data_lsb_set (&Regs[0x33], data_lsb_get (&Regs[0x3f], 3),
+ 3);
+
+ /* expts[CL_RED] = expts[CL_BLUE] */
+ data_lsb_set (&Regs[0x36], data_lsb_get (&Regs[0x42], 3),
+ 3);
+ }
+ }
+ else
+ {
+ /* e01 */
+ /* setting channels_per_dot to 2 */
+ data_bitset (&Regs[0x12], 0xc0, 2);
+
+ /* set two channel color order */
+ data_bitset (&Regs[0x12], 0x03, dev->sensorcfg->channel_gray[0]); /*------xx*/
+ data_bitset (&Regs[0x12], 0x0c, dev->sensorcfg->channel_gray[1]); /*----xx--*/
+
+ /* set samplerate */
+ data_bitset (&Regs[0x1cf], 0x40, LINE_RATE);
+
+ /* set unknown data */
+ data_bitset (&Regs[0x1cf], 0x80, 1);
+ }
+ }
+ else
+ {
+ /* CM_COLOR || 3 */
+ /* e42 */
+
+ /* setting channels_per_dot to 3 */
+ data_bitset (&Regs[0x12], 0xc0, 3);
+
+ /* setting samplerate */
+ data_bitset (&Regs[0x1cf], 0x40, scancfg->samplerate);
+
+ /* set unknown data */
+ data_bitset (&Regs[0x1cf], 0x80, 0);
+
+ /* set sensor chanel_color_order */
+ data_bitset (&Regs[0x60a], 0x03, dev->sensorcfg->channel_color[2]); /*------xx*/
+ data_bitset (&Regs[0x60a], 0x0c, dev->sensorcfg->channel_color[1]); /*----xx--*/
+ data_bitset (&Regs[0x60a], 0x30, dev->sensorcfg->channel_color[0]); /*--xx----*/
+
+ /* set rgb_channel_order */
+ data_bitset (&Regs[0x12], 0x03, dev->sensorcfg->rgb_order[0]); /*------xx*/
+ data_bitset (&Regs[0x12], 0x0c, dev->sensorcfg->rgb_order[1]); /*----xx--*/
+ data_bitset (&Regs[0x12], 0x30, dev->sensorcfg->rgb_order[2]); /*--xx----*/
+ }
+ }
+}
+
+static SANE_Int
+RTS_Setup (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg, struct st_hwdconfig *hwdcfg,
+ struct st_gain_offset *gain_offset)
+{
+ SANE_Int rst = ERROR; /* default */
+ SANE_Int lSMode;
+ SANE_Byte mycolormode;
+
+ DBG (DBG_FNC, "+ RTS_Setup:\n");
+ dbg_ScanParams (scancfg);
+ dbg_hwdcfg (hwdcfg);
+
+ mycolormode = scancfg->colormode;
+ if (scancfg->colormode != CM_COLOR)
+ {
+ if (scancfg->colormode == CM_LINEART)
+ scancfg->depth = 8;
+
+ if (scancfg->channel == 3)
+ {
+ if (scancfg->colormode == CM_GRAY)
+ mycolormode = (hwdcfg->arrangeline != FIX_BY_SOFT) ? 3 : CM_COLOR;
+ else
+ mycolormode = 3;
+ }
+ }
+
+ /* 42b47d6 */
+ memcpy (&scan2, scancfg, sizeof (struct st_scanparams));
+
+ scantype = hwdcfg->scantype;
+ lSMode =
+ RTS_GetScanmode (dev, scantype, mycolormode, scancfg->resolution_x);
+ if (lSMode >= 0)
+ {
+ struct st_scanmode *sm = dev->scanmodes[lSMode];
+
+ if (sm != NULL)
+ {
+ SANE_Int dummyline, iLineDistance, resolution_ratio, bytes_per_line;
+ struct st_coords rts_coords;
+
+ iLineDistance = 0;
+
+ scancfg->timing = sm->timing;
+ scancfg->sensorresolution =
+ dev->timings[scancfg->timing]->sensorresolution;
+ scancfg->shadinglength =
+ (((scancfg->sensorresolution * 17) / 2) + 3) & 0xfffffffc;
+ scancfg->samplerate = sm->samplerate;
+
+ hwdcfg->motorplus = sm->motorplus;
+
+ /* set systemclock */
+ data_bitset (&Regs[0x00], 0x0f, sm->systemclock);
+
+ /* setting exposure times */
+ RTS_Setup_Exposure_Times (Regs, scancfg, sm);
+
+ /* setting arranges */
+ RTS_Setup_Arrangeline (dev, hwdcfg, mycolormode);
+
+ /* set up line distances */
+ iLineDistance =
+ RTS_Setup_Line_Distances (dev, Regs, scancfg, hwdcfg, mycolormode,
+ arrangeline);
+
+ /* 4c67 */
+
+ /* setup channel colors */
+ RTS_Setup_Channels (dev, Regs, scancfg, mycolormode);
+
+ /* setup depth */
+ bytes_per_line = RTS_Setup_Depth (Regs, scancfg, mycolormode);
+
+ /* f61 */
+
+ /* Set resolution ratio */
+ resolution_ratio =
+ (scancfg->sensorresolution / scancfg->resolution_x) & 0x1f;
+ data_bitset (&Regs[0xc0], 0x1f, resolution_ratio);
+
+ /* set sensor timing values */
+ RTS_Setup_SensorTiming (dev, scancfg->timing, Regs);
+
+ data_bitset (&Regs[0xd8], 0x40, ((scantype == ST_NORMAL) ? 0 : 1)); /*-x------*/
+
+ /* Use static head ? */
+ data_bitset (&Regs[0xd8], 0x80, ((hwdcfg->static_head == FALSE) ? 1 : 0)); /*x------- */
+
+ /* Setting up gamma */
+ RTS_Setup_Gamma (Regs, hwdcfg);
+
+ /* setup shading correction */
+ RTS_Setup_Shading (Regs, scancfg, hwdcfg, bytes_per_line);
+
+ /* setup stepper motor */
+ hwdcfg->startpos =
+ RTS_Setup_Motor (dev, Regs, scancfg,
+ hwdcfg->motor_direction | MTR_ENABLED);
+
+ /* set coordinates */
+ dummyline = data_bitget (&Regs[0xd6], 0xf0);
+
+ if (scancfg->coord.left == 0)
+ scancfg->coord.left++;
+ if (scancfg->coord.top == 0)
+ scancfg->coord.top++;
+
+ rts_coords.left = scancfg->coord.left * resolution_ratio;
+ rts_coords.width = scancfg->coord.width * resolution_ratio;
+ rts_coords.top = scancfg->coord.top * dummyline;
+ rts_coords.height =
+ ((Regs[0x14d] & 0x3f) + scancfg->coord.height +
+ iLineDistance) * dummyline;
+
+ if ((rts_coords.left & 1) == 0)
+ rts_coords.left++;
+
+ RTS_Setup_Coords (Regs, rts_coords.left, rts_coords.top,
+ rts_coords.width, rts_coords.height);
+
+ data_bitset (&Regs[0x01], 0x06, 0); /*-----xx-*/
+
+ /* dummy_scan? */
+ data_bitset (&Regs[0x01], 0x10, hwdcfg->dummy_scan); /*---x----*/
+
+ data_bitset (&Regs[0x163], 0xc0, 1); /*xx------ */
+
+ if (dev->scanning->arrange_compression != FALSE)
+ {
+ Regs[0x60b] &= 0x8f;
+ data_bitset (&Regs[0x60b], 0x10, 1); /*-001----*/
+ }
+ else
+ data_bitset (&Regs[0x60b], 0x7f, 0); /*-0000000*/
+
+ if (mycolormode == 3)
+ {
+ SANE_Int channels_per_line;
+
+ /* Set channels_per_line = channels_per_dot * scan_width */
+ channels_per_line =
+ data_bitget (&Regs[0x12], 0xc0) * scancfg->coord.width;
+ data_wide_bitset (&Regs[0x060c], 0x3ffff, channels_per_line);
+
+ /* Sets 16 bits per channel */
+ data_bitset (&Regs[0x1cf], 0x30, 2); /*--10----*/
+
+ Regs[0x60b] |= 0x40;
+ if (v1619 == 0x21)
+ {
+ dev->scanning->arrange_compression = FALSE;
+ data_bitset (&Regs[0x60b], 0x10, 0); /*---0----*/
+ }
+
+ switch (scancfg->depth)
+ {
+ case 8:
+ case 16:
+ Regs[0x060b] &= 0xf3;
+ break;
+ case 12:
+ Regs[0x060b] = (Regs[0x060b] & 0xfb) | 0x08;
+ break;
+ }
+
+ if (scancfg->colormode == CM_LINEART)
+ data_bitset (&Regs[0x60b], 0x0c, 0);
+
+ /* disable gamma correction ¿? */
+ data_bitset (&Regs[0x1d0], 0x40, 0);
+ }
+
+ /* 5683 */
+ /* Set calibration table */
+ RTS_Setup_GainOffset (Regs, gain_offset);
+
+ rst = OK;
+ }
+ }
+
+ DBG (DBG_FNC, "- RTS_Setup: %i\n", rst);
+
+ return rst;
+}
+
+static void
+RTS_Setup_Coords (SANE_Byte * Regs, SANE_Int iLeft, SANE_Int iTop,
+ SANE_Int width, SANE_Int height)
+{
+ DBG (DBG_FNC,
+ "> RTS_Setup_Coords(*Regs, iLeft=%i, iTop=%i, width=%i, height=%i)\n",
+ iLeft, iTop, width, height);
+
+ if (Regs != NULL)
+ {
+ /* Set Left coord */
+ data_lsb_set (&Regs[0xb0], iLeft, 2);
+
+ /* Set Right coord */
+ data_lsb_set (&Regs[0xb2], iLeft + width, 2);
+
+ /* Set Top coord */
+ data_lsb_set (&Regs[0xd0], iTop, 2);
+ data_bitset (&Regs[0xd4], 0x0f, _B2 (iTop));
+
+ /* Set Down coord */
+ data_lsb_set (&Regs[0xd2], iTop + height, 2);
+ data_bitset (&Regs[0xd4], 0xf0, _B2 (iTop + height));
+ }
+}
+
+static void
+RTS_Setup_GainOffset (SANE_Byte * Regs, struct st_gain_offset *gain_offset)
+{
+ SANE_Byte fake[] =
+ { 0x19, 0x15, 0x19, 0x64, 0x64, 0x64, 0x74, 0xc0, 0x74, 0xc0, 0x6d,
+ 0xc0, 0x6d, 0xc0, 0x5f, 0xc0, 0x5f, 0xc0
+ };
+
+ DBG (DBG_FNC, "> RTS_Setup_GainOffset(*Regs, *gain_offset)\n");
+ dbg_calibtable (gain_offset);
+
+ if ((Regs != NULL) && (gain_offset != NULL))
+ {
+ if (RTS_Debug->calibrate == FALSE)
+ {
+ data_bitset (&Regs[0x13], 0x03, gain_offset->pag[CL_RED]); /*------xx*/
+ data_bitset (&Regs[0x13], 0x0c, gain_offset->pag[CL_GREEN]); /*----xx--*/
+ data_bitset (&Regs[0x13], 0x30, gain_offset->pag[CL_BLUE]); /*--xx----*/
+
+ memcpy (&Regs[0x14], &fake, 18);
+ }
+ else
+ {
+ SANE_Int a;
+
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ /* Offsets */
+ Regs[0x1a + (a * 4)] = _B0 (gain_offset->edcg1[a]);
+ Regs[0x1b + (a * 4)] =
+ ((gain_offset->edcg1[a] >> 1) & 0x80) | (gain_offset->
+ edcg2[a] & 0x7f);
+ Regs[0x1c + (a * 4)] = _B0 (gain_offset->odcg1[a]);
+ Regs[0x1d + (a * 4)] =
+ ((gain_offset->odcg1[a] >> 1) & 0x80) | (gain_offset->
+ odcg2[a] & 0x7f);
+
+ /* Variable Gain Amplifier */
+ data_bitset (&Regs[0x14 + a], 0x1f, gain_offset->vgag1[a]);
+ data_bitset (&Regs[0x17 + a], 0x1f, gain_offset->vgag2[a]);
+ }
+
+ data_bitset (&Regs[0x13], 0x03, gain_offset->pag[CL_RED]); /*------xx*/
+ data_bitset (&Regs[0x13], 0x0c, gain_offset->pag[CL_GREEN]); /*----xx--*/
+ data_bitset (&Regs[0x13], 0x30, gain_offset->pag[CL_BLUE]); /*--xx----*/
+ }
+ }
+}
+
+static void
+Calibrate_Free (struct st_cal2 *calbuffers)
+{
+ DBG (DBG_FNC, "> Calibrate_Free(*calbuffers)\n");
+
+ if (calbuffers != NULL)
+ {
+ SANE_Int c;
+
+ if (calbuffers->table2 != NULL)
+ {
+ free (calbuffers->table2);
+ calbuffers->table2 = NULL;
+ }
+
+ for (c = 0; c < 4; c++)
+ {
+ if (calbuffers->tables[c] != NULL)
+ {
+ free (calbuffers->tables[c]);
+ calbuffers->tables[c] = NULL;
+ }
+ }
+
+ calbuffers->shadinglength1 = 0;
+ calbuffers->tables_size = 0;
+ calbuffers->shadinglength3 = 0;
+ }
+}
+
+static SANE_Int
+Calibrate_Malloc (struct st_cal2 *calbuffers, SANE_Byte * Regs,
+ struct st_calibration *myCalib, SANE_Int somelength)
+{
+ SANE_Int myshadinglength, pos;
+ SANE_Int rst;
+
+ if ((calbuffers != NULL) && (Regs != NULL) && (myCalib != NULL))
+ {
+ if ((Regs[0x1bf] & 0x18) == 0)
+ {
+ if ((((Regs[0x1cf] >> 1) & Regs[0x1cf]) & 0x04) != 0)
+ calbuffers->table_count = 2;
+ else
+ calbuffers->table_count = 4;
+ }
+ else
+ calbuffers->table_count = 4;
+
+ /*365d */
+ myshadinglength = myCalib->shadinglength * 2;
+ calbuffers->shadinglength1 = min (myshadinglength, somelength);
+
+ if ((myshadinglength % somelength) != 0)
+ calbuffers->tables_size =
+ (myshadinglength >= somelength) ? somelength * 2 : somelength;
+ else
+ calbuffers->tables_size = somelength;
+
+ if (myshadinglength >= somelength)
+ {
+ calbuffers->shadinglength1 =
+ (myshadinglength % calbuffers->shadinglength1) +
+ calbuffers->shadinglength1;
+ calbuffers->shadinglength3 =
+ ((myCalib->shadinglength * 2) / somelength) - 1;
+ }
+ else
+ calbuffers->shadinglength3 = 0;
+
+ calbuffers->shadinglength3 =
+ (somelength / 16) * calbuffers->shadinglength3;
+
+ rst = OK;
+ for (pos = 0; pos < calbuffers->table_count; pos++)
+ {
+ calbuffers->tables[pos] =
+ (USHORT *) malloc (calbuffers->tables_size * sizeof (USHORT));
+ if (calbuffers->tables[pos] == NULL)
+ {
+ rst = ERROR;
+ break;
+ }
+ }
+
+ if (rst == OK)
+ {
+ calbuffers->table2 =
+ (USHORT *) malloc (calbuffers->tables_size * sizeof (USHORT));
+ if (calbuffers->table2 == NULL)
+ rst = ERROR;
+ }
+
+ if (rst != OK)
+ Calibrate_Free (calbuffers);
+ }
+ else
+ rst = ERROR;
+
+ DBG (DBG_FNC,
+ "> Calibrate_Malloc(*calbuffers, *Regs, *myCalib, somelength=%i): %i\n",
+ somelength, rst);
+
+ return rst;
+}
+
+static SANE_Int
+fn3560 (USHORT * table, struct st_cal2 *calbuffers, SANE_Int * tablepos)
+{
+ /*05FEF974 001F99B0 |table = 001F99B0
+ 05FEF978 05FEFA08 |calbuffers->tables[0] = 05FEFA08
+ 05FEF97C 000000A0 |calbuffers->shadinglength3 = 000000A0
+ 05FEF980 00000348 |calbuffers->shadinglength1 = 00000348
+ 05FEF984 04F01502 |calbuffers->table_count = 04F01502
+ 05FEF988 05FEF998 \Arg6 = 05FEF998
+ */
+
+ if (table != NULL)
+ {
+ SANE_Int pos[4] = { 0, 0, 0, 0 }; /*f960 f964 f968 f96c */
+ SANE_Int usetable = 0;
+ SANE_Int a;
+
+ SANE_Int mylength3 = calbuffers->shadinglength1; /*f97c */
+ SANE_Byte *pPointer =
+ (SANE_Byte *) (table + (calbuffers->shadinglength3 * 16));
+
+ DBG (DBG_FNC, "> fn3560(*table, *calbuffers, *tablepos)\n");
+
+ if (mylength3 > 0)
+ {
+ do
+ {
+ if (calbuffers->tables[usetable] != NULL)
+ {
+ if (mylength3 <= 16)
+ {
+ if (mylength3 > 0)
+ {
+ do
+ {
+ *(calbuffers->tables[usetable] +
+ pos[usetable]) = _B0 (*pPointer);
+ pPointer++;
+ pos[usetable]++;
+ mylength3--;
+ }
+ while (mylength3 > 0);
+ }
+ break;
+ }
+
+ for (a = 0; a < 16; a++)
+ {
+ *(calbuffers->tables[usetable] + pos[usetable]) =
+ _B0 (*pPointer);
+ pPointer++;
+ pos[usetable]++;
+ }
+ }
+
+ mylength3 -= 16;
+ usetable++;
+ if (usetable == calbuffers->table_count)
+ usetable = 0;
+ }
+ while (mylength3 > 0);
+ }
+
+ /*35f8 */
+ if (calbuffers->table_count > 0)
+ {
+ /* Return position of each table */
+ memcpy (tablepos, pos, sizeof (SANE_Int) * 4);
+ }
+ }
+
+ return OK;
+}
+
+static SANE_Int
+Calib_WriteTable (struct st_device *dev, SANE_Byte * table, SANE_Int size,
+ SANE_Int data)
+{
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "+ Calib_WriteTable(*table, size=%i):\n", size);
+
+ if ((table != NULL) && (size > 0))
+ {
+ SANE_Int transferred;
+
+ if (RTS_DMA_Reset (dev) == OK)
+ {
+ /* Send size to write */
+ if (RTS_DMA_Enable_Write (dev, 0x0004, size, data) == OK)
+ /* Send data */
+ rst = Bulk_Operation (dev, BLK_WRITE, size, table, &transferred);
+ }
+ }
+
+ DBG (DBG_FNC, "- Calib_WriteTable: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Calib_ReadTable (struct st_device *dev, SANE_Byte * table, SANE_Int size,
+ SANE_Int data)
+{
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "+ Calib_ReadTable(*table, size=%i):\n", size);
+
+ if ((table != NULL) && (size > 0))
+ {
+ SANE_Int transferred;
+
+ if (RTS_DMA_Reset (dev) == OK)
+ {
+ /* Send size to read */
+ if (RTS_DMA_Enable_Read (dev, 0x0004, size, data) == OK)
+ /* Retrieve data */
+ rst = Bulk_Operation (dev, BLK_READ, size, table, &transferred);
+ }
+ }
+
+ DBG (DBG_FNC, "- Calib_ReadTable: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+fn3330 (struct st_device *dev, SANE_Byte * Regs, struct st_cal2 *calbuffers,
+ SANE_Int sensorchannelcolor, SANE_Int * tablepos, SANE_Int data)
+{
+ /*05EEF968 04F0F7F8 |Regs = 04F0F7F8
+ 05EEF96C 02DEC838 |calbuffers->table2 = 02DEC838
+ 05EEF970 05EEFA08 |calbuffers->tables[] = 05EEFA08
+ 05EEF974 00000000 |sensorchannelcolor = 00000000
+ 05EEF978 000000A0 |calbuffers->shadinglength3 = 000000A0
+ 05EEF97C 00000400 |calbuffers->tables_size = 00000400
+ 05EEF980 05EEF998 |&pos = 05EEF998
+ 05EEF984 00221502 |calbuffers->table_count = 00221502
+ 05EEF988 00000000 \data = 00000000
+ */
+
+ SANE_Int table_count = calbuffers->table_count; /*f960 */
+ SANE_Int schcolor = _B0 (sensorchannelcolor);
+ SANE_Int a = 0;
+ SANE_Int tablelength = calbuffers->shadinglength3 / table_count; /*f954 */
+ SANE_Int val_color = 0; /*f974 */
+ SANE_Int val_lineart = 0; /*f978 */
+ SANE_Int val_gray = 0; /*ebx */
+ SANE_Int value4 = 0; /*ebp */
+ SANE_Int size;
+ SANE_Int rst = OK;
+
+ DBG (DBG_FNC,
+ "+ fn3330(*Regs, *calbuffers, sensorchannelcolor=%i, *tablepos, data=%i):\n",
+ sensorchannelcolor, data);
+
+ if (calbuffers->table_count > 0)
+ {
+ do
+ {
+ if (calbuffers->table_count == 2)
+ {
+ /*338c */
+ if (a != 0)
+ {
+ /*3394 */
+ if (_B0 (data) == 0)
+ {
+ val_color = 0x100000;
+ val_lineart = 0x100000;
+ val_gray = 0x200000;
+ }
+ else
+ {
+ /*343a */
+ val_color = 0x300000;
+ val_lineart = 0x300000;
+ val_gray = 0;
+ }
+ }
+ else
+ {
+ /*33be */
+ if (_B0 (data) == 0)
+ {
+ val_color = 0;
+ val_lineart = 0;
+ val_gray = 0x300000;
+ }
+ else
+ {
+ /*342a */
+ val_color = 0x200000;
+ val_lineart = 0x200000;
+ val_gray = 0x100000;
+ }
+ }
+ }
+ else
+ {
+ /*33d5 */
+ switch (a)
+ {
+ case 0:
+ val_color = 0;
+ val_lineart = 0;
+ val_gray = 0x300000;
+ break;
+ case 1:
+ val_color = 0x200000;
+ val_lineart = 0x200000;
+ val_gray = 0x100000;
+ break;
+ case 2:
+ val_color = 0x100000;
+ val_lineart = 0x100000;
+ val_gray = 0x200000;
+ break;
+ case 3:
+ val_color = 0x300000;
+ val_lineart = 0x300000;
+ val_gray = 0;
+ break;
+ }
+ }
+
+ /*3449 */
+ switch (schcolor)
+ {
+ case CM_LINEART:
+ size =
+ (((Regs[0x1bf] >> 1) & 3) << 0x10) | (Regs[0x1be] << 0x08) |
+ Regs[0x1bd];
+ value4 = (tablelength + size) | val_lineart;
+ break;
+ case CM_GRAY:
+ size =
+ ((Regs[0x1bf] & 1) << 0x10) | (Regs[0x1bc] << 0x08) |
+ Regs[0x1bb];
+ value4 = (tablelength + size) | val_gray;
+ break;
+ default:
+ size = _B0 (Regs[0x1ba]);
+ value4 = (tablelength + size) | val_color;
+ break;
+ }
+
+ if (Calib_ReadTable
+ (dev, (SANE_Byte *) calbuffers->table2, calbuffers->tables_size,
+ value4) != OK)
+ {
+ rst = ERROR;
+ break;
+ }
+
+ memcpy (calbuffers->tables[a], calbuffers->table2, tablepos[a]);
+
+ if (tablepos[a + 1] == 0)
+ break;
+
+ a++;
+ }
+ while (a < calbuffers->table_count);
+ }
+
+ DBG (DBG_FNC, "- fn3330: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+fn3730 (struct st_device *dev, struct st_cal2 *calbuffers, SANE_Byte * Regs,
+ USHORT * table, SANE_Int sensorchannelcolor, SANE_Int data)
+{
+ /*05FEF9AC |calbuffers = 05FEF9F8
+ 05FEF9B0 |Regs = 04EFF7F8
+ 05FEF9B4 |table = 001F99B0
+ 05FEF9B8 |sensorchannelcolor = 00000000
+ 05FEF9BC |data = 00000000
+ */
+
+ SANE_Int pos[4] = { 0, 0, 0, 0 }; /*f998 f99c f9a0 f9a4 */
+ SANE_Int rst;
+
+ DBG (DBG_FNC,
+ "+ fn3730(*calbuffers, *Regs, *table, sensorchannelcolor=%i, data=%i):\n",
+ sensorchannelcolor, data);
+
+ fn3560 (table, calbuffers, pos);
+ rst = fn3330 (dev, Regs, calbuffers, sensorchannelcolor, pos, data);
+
+ DBG (DBG_FNC, "- fn3730: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Shading_white_apply (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Int channels, struct st_calibration *myCalib,
+ struct st_cal2 *calbuffers)
+{
+ SANE_Int rst = OK;
+
+ DBG (DBG_FNC, "+ Shading_white_apply(channels=%i)\n", channels);
+
+ /*3e7f */
+ Calibrate_Malloc (calbuffers, Regs, myCalib,
+ (RTS_Debug->usbtype == USB20) ? 0x200 : 0x40);
+
+ if (channels > 0)
+ {
+ /*int a; */
+ SANE_Int chnl;
+ SANE_Int pos; /*fa2c */
+ SANE_Int transferred;
+
+ rst = ERROR;
+
+ for (chnl = 0; chnl < channels; chnl++)
+ {
+ /*for (a = 0; a < myCalib->shadinglength; a++)
+ myCalib->black_shading[chnl][a] = 0x2000; */
+ /* 11 tries */
+ for (pos = 0; pos <= 10; pos++)
+ {
+ /* Send size to write */
+ if (RTS_DMA_Enable_Write
+ (dev, dev->sensorcfg->channel_color[chnl] | 0x14,
+ myCalib->shadinglength, 0) == OK)
+ /* Send data */
+ Bulk_Operation (dev, BLK_WRITE,
+ myCalib->shadinglength * sizeof (USHORT),
+ (SANE_Byte *) & myCalib->
+ white_shading[chnl][myCalib->first_position -
+ 1], &transferred);
+
+ /*3df7 */
+ if (fn3730
+ (dev, calbuffers, Regs,
+ &myCalib->white_shading[chnl][myCalib->first_position - 1],
+ dev->sensorcfg->channel_color[chnl], 1) == OK)
+ {
+ rst = OK;
+ break;
+ }
+
+ RTS_DMA_Cancel (dev);
+ }
+ }
+ }
+
+ Calibrate_Free (calbuffers);
+
+ DBG (DBG_FNC, "- Shading_white_apply: %i\n", rst);
+
+ return OK;
+}
+
+static SANE_Int
+Shading_black_apply (struct st_device *dev, SANE_Byte * Regs,
+ SANE_Int channels, struct st_calibration *myCalib,
+ struct st_cal2 *calbuffers)
+{
+ SANE_Int rst = OK;
+
+ DBG (DBG_FNC, "+ Shading_black_apply(channels=%i)\n", channels);
+
+ /* 3d79 */
+ Calibrate_Malloc (calbuffers, Regs, myCalib,
+ (RTS_Debug->usbtype == USB20) ? 0x200 : 0x40);
+
+ if (channels > 0)
+ {
+ /*int a; */
+ SANE_Int chnl;
+ SANE_Int pos; /*fa2c */
+ SANE_Int transferred;
+
+ rst = ERROR;
+
+ for (chnl = 0; chnl < channels; chnl++)
+ {
+ /* 11 tries */
+ /*for (a = 0; a < myCalib->shadinglength; a++)
+ myCalib->black_shading[chnl][a] = 0x2000; */
+
+ for (pos = 0; pos <= 10; pos++)
+ {
+ /* Send size to write */
+ if (RTS_DMA_Enable_Write
+ (dev, dev->sensorcfg->channel_color[chnl] | 0x10,
+ myCalib->shadinglength, 0) == OK)
+ /* Send data */
+ Bulk_Operation (dev, BLK_WRITE,
+ myCalib->shadinglength * sizeof (USHORT),
+ (SANE_Byte *) & myCalib->
+ black_shading[chnl][myCalib->first_position -
+ 1], &transferred);
+
+ /*3df7 */
+ if (fn3730
+ (dev, calbuffers, Regs,
+ &myCalib->black_shading[chnl][myCalib->first_position - 1],
+ dev->sensorcfg->channel_color[chnl], 0) == OK)
+ {
+ rst = OK;
+ break;
+ }
+
+ RTS_DMA_Cancel (dev);
+ }
+ }
+ }
+
+ /*3e62 */
+ Calibrate_Free (calbuffers);
+
+ DBG (DBG_FNC, "- Shading_black_apply: %i\n", rst);
+
+ return OK;
+}
+
+static SANE_Int
+Shading_apply (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *myvar, struct st_calibration *myCalib)
+{
+ /*
+ Regs f1bc
+ myvar f020
+ hwdcfg e838
+ arg4 e81c
+ myCalib e820
+ */
+
+ SANE_Int rst; /* lf9e0 */
+ SANE_Int myfact; /* e820 */
+ SANE_Int shadata;
+ SANE_Byte channels; /* f9d4 */
+ SANE_Int myShadingBase; /* e818 */
+
+ char lf9d1;
+ char lf9d0;
+
+ DBG (DBG_FNC, "+ Shading_apply(*Regs, *myvar, *mygamma, *myCalib):\n");
+ dbg_ScanParams (myvar);
+
+ lf9d0 = (Regs[0x60b] >> 6) & 1;
+ lf9d1 = (Regs[0x60b] >> 4) & 1;
+ Regs[0x060b] &= 0xaf;
+ rst = Write_Byte (dev->usb_handle, 0xee0b, Regs[0x060b]);
+ if (rst == OK)
+ {
+ SANE_Byte colormode = myvar->colormode; /*fa24 */
+ SANE_Int le7cc, le7d8;
+ struct st_cal2 calbuffers; /* f9f8 */
+
+ if (colormode != CM_COLOR)
+ {
+ if (myvar->channel != 3)
+ {
+ if (colormode != 3)
+ channels = (myvar->samplerate == PIXEL_RATE) ? 2 : 1;
+ else
+ channels = 3;
+ }
+ else
+ {
+ colormode = 3;
+ channels = 3;
+ }
+ }
+ else
+ channels = 3;
+
+ /*
+ White shading formula : 2000H x Target / (Wn-Dn) = White Gain data ----- for 8 times system
+ White shading formula : 4000H x Target / (Wn-Dn) = White Gain data ----- for 4 times system
+ For example : Target = 3FFFH Wn = 2FFFH Dn = 0040H and 8 times system operation
+ then White Gain = 2000H x 3FFFH / (2FFFH-0040H) = 2AE4H (1.34033 times)
+ */
+ /* 3aad */
+ if (colormode == 3)
+ {
+ /*
+ SANE_Int pos;
+ SANE_Int colour;
+
+ myShadingBase = shadingbase;
+
+ for (colour = 0; colour < channels; colour++)
+ {
+ if (myCalib->white_shading[colour] != NULL)
+ {
+ myfact = shadingfact[colour];
+ if (myCalib->shadinglength > 0)
+ {
+ for (pos = myCalib->first_position - 1; pos < myCalib->shadinglength; pos++)
+ myCalib->white_shading[colour][pos] = (myCalib->white_shading[colour][pos] * myfact) / myShadingBase;
+ }
+ } else break;
+ }
+ */
+ }
+
+ /* 3b3b */
+ if (myCalib->shading_enabled != FALSE)
+ {
+ /* 3b46 */
+ SANE_Int colour, pos;
+ le7cc = shadingbase;
+ le7d8 = shadingbase;
+
+ DBG (DBG_FNC, "-> Shading type: %i\n", myCalib->shading_type);
+
+ for (colour = 0; colour < channels; colour++)
+ {
+ if (colormode == 3)
+ le7cc = shadingfact[colour];
+
+ myShadingBase = ((Regs[0x1cf] & 2) != 0) ? 0x2000 : 0x4000;
+
+ myfact = myCalib->WRef[colour] * myShadingBase;
+
+ if (myCalib->shading_type == 2)
+ {
+ /*3bd8 */
+ if ((myCalib->black_shading[colour] != NULL)
+ && (myCalib->white_shading[colour] != NULL))
+ {
+ for (pos = myCalib->first_position - 1;
+ pos < myCalib->shadinglength; pos++)
+ {
+ if (myCalib->white_shading[colour][pos] == 0)
+ shadata = myShadingBase;
+ else
+ shadata =
+ myfact / myCalib->white_shading[colour][pos];
+
+ shadata = min ((shadata * le7cc) / le7d8, 0xff00);
+ myCalib->black_shading[colour][pos] &= 0xff;
+ myCalib->black_shading[colour][pos] |=
+ shadata & 0xff00;
+ }
+ }
+ else
+ break;
+ }
+ else
+ {
+ /*3c63 */
+ if (myCalib->shading_type == 3)
+ {
+ /*3c68 */
+ if (myCalib->black_shading[colour] != NULL)
+ {
+ for (pos = myCalib->first_position - 1;
+ pos < myCalib->shadinglength; pos++)
+ {
+ if (myCalib->black_shading[colour][pos] == 0)
+ shadata = myShadingBase;
+ else
+ shadata =
+ myfact /
+ myCalib->black_shading[colour][pos];
+
+ shadata =
+ min ((shadata * le7cc) / le7d8, 0xffc0);
+ myCalib->black_shading[colour][pos] &= 0x3f;
+ myCalib->black_shading[colour][pos] |=
+ shadata & 0xffc0;
+ }
+ }
+ else
+ break;
+ }
+ else
+ {
+ /*3ce3 */
+ if (myCalib->white_shading[colour] != NULL)
+ {
+ for (pos = 0; pos < myCalib->shadinglength; pos++)
+ {
+ if (myCalib->white_shading[colour][pos] == 0)
+ shadata = myShadingBase;
+ else
+ shadata =
+ myfact /
+ myCalib->white_shading[colour][pos];
+
+ shadata =
+ min ((shadata * le7cc) / le7d8, 0xffff);
+ myCalib->white_shading[colour][pos] = shadata;
+ }
+ }
+ else
+ break;
+ }
+ }
+ }
+ }
+
+ /*3d4c */
+ bzero (&calbuffers, sizeof (struct st_cal2));
+
+ /* If black shading correction is enabled ... */
+ if ((Regs[0x1cf] & 8) != 0)
+ Shading_black_apply (dev, Regs, channels, myCalib, &calbuffers);
+
+ /*3e6e */
+
+ /* If white shading correction is enabled ... */
+ if ((Regs[0x1cf] & 4) != 0)
+ Shading_white_apply (dev, Regs, channels, myCalib, &calbuffers);
+
+ /* 3f74 */
+ if (rst == 0)
+ {
+ data_bitset (&Regs[0x60b], 0x40, lf9d0); /*-x------*/
+ data_bitset (&Regs[0x60b], 0x10, lf9d1); /*---x----*/
+
+ rst = Write_Byte (dev->usb_handle, 0xee0b, Regs[0x060b]);
+ }
+ }
+ /*3fb5 */
+
+ DBG (DBG_FNC, "- Shading_apply: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Bulk_Operation (struct st_device *dev, SANE_Byte op, SANE_Int buffer_size,
+ SANE_Byte * buffer, SANE_Int * transfered)
+{
+ SANE_Int iTransferSize, iBytesToTransfer, iPos, rst, iBytesTransfered;
+
+ DBG (DBG_FNC, "+ Bulk_Operation(op=%s, buffer_size=%i, buffer):\n",
+ ((op & 0x01) != 0) ? "READ" : "WRITE", buffer_size);
+
+ iBytesToTransfer = buffer_size;
+ iPos = 0;
+ rst = OK;
+ iBytesTransfered = 0;
+
+ if (transfered != NULL)
+ *transfered = 0;
+
+ iTransferSize = min (buffer_size, RTS_Debug->dmatransfersize);
+
+ if (op != 0)
+ {
+ /* Lectura */
+ do
+ {
+ iTransferSize = min (iTransferSize, iBytesToTransfer);
+
+ iBytesTransfered =
+ Read_Bulk (dev->usb_handle, &buffer[iPos], iTransferSize);
+ if (iBytesTransfered < 0)
+ {
+ rst = ERROR;
+ break;
+ }
+ else
+ {
+ if (transfered != NULL)
+ *transfered += iBytesTransfered;
+ }
+ iPos += iTransferSize;
+ iBytesToTransfer -= iTransferSize;
+ }
+ while (iBytesToTransfer > 0);
+ }
+ else
+ {
+ /* Escritura */
+ do
+ {
+ iTransferSize = min (iTransferSize, iBytesToTransfer);
+
+ if (Write_Bulk (dev->usb_handle, &buffer[iPos], iTransferSize) !=
+ OK)
+ {
+ rst = ERROR;
+ break;
+ }
+ else
+ {
+ if (transfered != NULL)
+ *transfered += iTransferSize;
+ }
+ iPos += iTransferSize;
+ iBytesToTransfer -= iTransferSize;
+ }
+ while (iBytesToTransfer > 0);
+ }
+
+ DBG (DBG_FNC, "- Bulk_Operation: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Reading_BufferSize_Notify (struct st_device *dev, SANE_Int data,
+ SANE_Int size)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ Reading_BufferSize_Notify(data=%i, size=%i):\n", data,
+ size);
+
+ rst = RTS_DMA_Enable_Read (dev, 0x0008, size, data);
+
+ DBG (DBG_FNC, "- Reading_BufferSize_Notify: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Reading_Wait (struct st_device *dev, SANE_Byte Channels_per_dot,
+ SANE_Byte Channel_size, SANE_Int size, SANE_Int * last_amount,
+ SANE_Int seconds, SANE_Byte op)
+{
+ SANE_Int rst;
+ SANE_Byte cTimeout, executing;
+ SANE_Int lastAmount, myAmount;
+ long tick;
+
+ DBG (DBG_FNC,
+ "+ Reading_Wait(Channels_per_dot=%i, Channel_size=%i, size=%i, *last_amount, seconds=%i, op=%i):\n",
+ Channels_per_dot, Channel_size, size, seconds, op);
+
+ rst = OK;
+ cTimeout = FALSE;
+ lastAmount = 0;
+
+ myAmount = Reading_BufferSize_Get (dev, Channels_per_dot, Channel_size);
+ if (myAmount < size)
+ {
+ /* Wait until scanner fills its buffer */
+ if (seconds == 0)
+ seconds = 10;
+ tick = GetTickCount () + (seconds * 1000);
+
+ while (cTimeout == FALSE)
+ {
+ myAmount =
+ Reading_BufferSize_Get (dev, Channels_per_dot, Channel_size);
+
+ /* check special case */
+ if (op == TRUE)
+ {
+ if (((myAmount + 0x450) > size)
+ || (RTS_IsExecuting (dev, &executing) == FALSE))
+ break;
+ }
+
+ if (myAmount < size)
+ {
+ /* Check timeout */
+ if (myAmount == lastAmount)
+ {
+ /* we are in timeout? */
+ if (tick < GetTickCount ())
+ {
+ /* TIMEOUT */
+ rst = ERROR;
+ cTimeout = TRUE;
+ }
+ else
+ usleep (100 * 1000);
+ }
+ else
+ {
+ /* Amount increased, update tick */
+ lastAmount = myAmount;
+ tick = GetTickCount () + (seconds * 1000);
+ }
+ }
+ else
+ {
+ lastAmount = myAmount;
+ break; /* buffer full */
+ }
+ }
+ }
+
+ if (last_amount != NULL)
+ *last_amount = myAmount;
+
+ DBG (DBG_FNC, "- Reading_Wait: %i , last_amount=%i\n", rst, myAmount);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_GetImage_GetBuffer (struct st_device *dev, double dSize,
+ char unsigned *buffer, double *transferred)
+{
+ SANE_Int rst = ERROR;
+ SANE_Int itransferred;
+ double dtransferred = 0;
+
+ DBG (DBG_FNC, "+ RTS_GetImage_GetBuffer(dSize=%f, buffer, transferred):\n",
+ dSize);
+
+ rst = OK;
+ dSize /= 2;
+
+ if (dSize > 0)
+ {
+ SANE_Int myLength;
+ SANE_Int iPos = 0;
+
+ do
+ {
+ itransferred = 0;
+ myLength =
+ (dSize <=
+ RTS_Debug->dmasetlength) ? dSize : RTS_Debug->dmasetlength;
+
+ if (myLength > 0x1ffe0)
+ myLength = 0x1ffe0;
+
+ rst = ERROR;
+ if (Reading_Wait (dev, 0, 1, myLength * 2, NULL, 5, FALSE) == OK)
+ {
+ if (Reading_BufferSize_Notify (dev, 0, myLength * 2) == OK)
+ rst =
+ Bulk_Operation (dev, BLK_READ, myLength * 2, &buffer[iPos],
+ &itransferred);
+ }
+
+ if (rst != OK)
+ break;
+
+ iPos += itransferred;
+ dSize -= itransferred;
+ dtransferred += itransferred * 2;
+ }
+ while (dSize > 0);
+ }
+
+ /* Return bytes transferred */
+ if (transferred != NULL)
+ *transferred = dtransferred;
+
+ if (rst != OK)
+ RTS_DMA_Cancel (dev);
+
+ DBG (DBG_FNC, "- RTS_GetImage_GetBuffer: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_GetImage_Read (struct st_device *dev, SANE_Byte * buffer,
+ struct st_scanparams *scancfg, struct st_hwdconfig *hwdcfg)
+{
+ /*buffer f80c = esp+14
+ scancfg f850 = esp+18
+ hwdcfg faac = */
+
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC, "+ RTS_GetImage_Read(buffer, scancfg, hwdcfg):\n");
+
+ if (buffer != NULL)
+ {
+ double dSize = scancfg->bytesperline * scancfg->coord.height;
+ SANE_Byte exfn;
+
+ if (scancfg->depth == 12)
+ dSize = (dSize * 3) / 4;
+
+ /*3ff6 */
+ exfn = 1;
+ if (hwdcfg != NULL)
+ if (hwdcfg->compression != FALSE)
+ exfn = 0;
+
+ if (exfn != 0)
+ {
+ double transferred;
+ rst = RTS_GetImage_GetBuffer (dev, dSize, buffer, &transferred);
+ }
+
+ if (rst == OK)
+ RTS_WaitScanEnd (dev, 1500);
+ }
+
+ DBG (DBG_FNC, "- RTS_GetImage_Read: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_GetImage (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg,
+ struct st_gain_offset *gain_offset, SANE_Byte * buffer,
+ struct st_calibration *myCalib, SANE_Int options,
+ SANE_Int gaincontrol)
+{
+ /* 42b8e10 */
+
+ SANE_Int rst = ERROR; /* default */
+
+ DBG (DBG_FNC,
+ "+ RTS_GetImage(*Regs, *scancfg, *gain_offset, *buffer, myCalib, options=0x%08x, gaincontrol=%i):\n",
+ options, gaincontrol);
+ dbg_ScanParams (scancfg);
+
+ /* validate arguments */
+ if ((Regs != NULL) && (scancfg != NULL))
+ {
+ if ((scancfg->coord.width != 0) && (scancfg->coord.height != 0))
+ {
+ struct st_scanparams *myscancfg;
+
+ /* let's make a copy of scan config */
+ myscancfg =
+ (struct st_scanparams *) malloc (sizeof (struct st_scanparams));
+ if (myscancfg != NULL)
+ {
+ struct st_hwdconfig *hwdcfg;
+
+ memcpy (myscancfg, scancfg, sizeof (struct st_scanparams));
+
+ /* Allocate space for low level config */
+ hwdcfg =
+ (struct st_hwdconfig *) malloc (sizeof (struct st_hwdconfig));
+ if (hwdcfg != NULL)
+ {
+ bzero (hwdcfg, sizeof (struct st_hwdconfig));
+
+ if (((options & 2) != 0) || ((_B1 (options) & 1) != 0))
+ {
+ /* switch off lamp */
+ data_bitset (&Regs[0x146], 0x40, 0);
+
+ Write_Byte (dev->usb_handle, 0xe946, Regs[0x146]);
+ usleep (1000 * ((v14b4 == 0) ? 500 : 300));
+ }
+
+ hwdcfg->scantype = scan.scantype;
+ hwdcfg->use_gamma_tables =
+ ((options & OP_USE_GAMMA) != 0) ? 1 : 0;
+ hwdcfg->white_shading =
+ ((options & OP_WHITE_SHAD) != 0) ? 1 : 0;
+ hwdcfg->black_shading =
+ ((options & OP_BLACK_SHAD) != 0) ? 1 : 0;
+ hwdcfg->motor_direction =
+ ((options & OP_BACKWARD) !=
+ 0) ? MTR_BACKWARD : MTR_FORWARD;
+ hwdcfg->compression =
+ ((options & OP_COMPRESSION) != 0) ? 1 : 0;
+ hwdcfg->static_head =
+ ((options & OP_STATIC_HEAD) != 0) ? 1 : 0;
+ hwdcfg->dummy_scan = (buffer == NULL) ? TRUE : FALSE;
+ hwdcfg->arrangeline = 0;
+ hwdcfg->highresolution =
+ (myscancfg->resolution_x > 1200) ? TRUE : FALSE;
+ hwdcfg->unk3 = 0;
+
+ /* Set Left coord */
+ myscancfg->coord.left +=
+ ((dev->sensorcfg->type == CCD_SENSOR) ? 24 : 50);
+
+ switch (myscancfg->resolution_x)
+ {
+ case 1200:
+ myscancfg->coord.left -= 63;
+ break;
+ case 2400:
+ myscancfg->coord.left -= 126;
+ break;
+ }
+
+ if (myscancfg->coord.left < 0)
+ myscancfg->coord.left = 0;
+
+ RTS_Setup (dev, Regs, myscancfg, hwdcfg, gain_offset);
+
+ /* Setting exposure time */
+ switch (scan.scantype)
+ {
+ case ST_NORMAL:
+ if (scan.resolution_x == 100)
+ {
+ SANE_Int iValue;
+ SANE_Byte *myRegs;
+
+ myRegs =
+ (SANE_Byte *) malloc (RT_BUFFER_LEN *
+ sizeof (SANE_Byte));
+ if (myRegs != NULL)
+ {
+ bzero (myRegs,
+ RT_BUFFER_LEN * sizeof (SANE_Byte));
+ RTS_Setup (dev, myRegs, &scan, hwdcfg,
+ gain_offset);
+
+ iValue = data_lsb_get (&myRegs[0x30], 3);
+ data_lsb_set (&Regs[0x30], iValue, 3);
+
+ /*Copy myregisters mexpts to Regs mexpts */
+ iValue = data_lsb_get (&myRegs[0x33], 3);
+ data_lsb_set (&Regs[0x33], iValue, 3);
+
+ iValue = data_lsb_get (&myRegs[0x39], 3);
+ data_lsb_set (&Regs[0x39], iValue, 3);
+
+ iValue = data_lsb_get (&myRegs[0x3f], 3);
+ data_lsb_set (&Regs[0x3f], iValue, 3);
+
+ free (myRegs);
+ }
+ }
+ break;
+ case ST_NEG:
+ {
+ SANE_Int myvalue;
+
+ /* Setting exposure times for Negative scans */
+ data_lsb_set (&Regs[0x30], myscancfg->expt, 3);
+ data_lsb_set (&Regs[0x33], myscancfg->expt, 3);
+ data_lsb_set (&Regs[0x39], myscancfg->expt, 3);
+ data_lsb_set (&Regs[0x3f], myscancfg->expt, 3);
+
+ data_lsb_set (&Regs[0x36], 0, 3);
+ data_lsb_set (&Regs[0x3c], 0, 3);
+ data_lsb_set (&Regs[0x42], 0, 3);
+
+ myvalue =
+ ((myscancfg->expt +
+ 1) / (data_lsb_get (&Regs[0xe0], 1) + 1)) - 1;
+ data_lsb_set (&Regs[0xe1], myvalue, 3);
+ }
+ break;
+ }
+
+ /* 91a0 */
+ if (myscancfg->resolution_y > 600)
+ {
+ options |= 0x20000000;
+ if (options != 0) /* Always true ... */
+ SetMultiExposure (dev, Regs);
+ else
+ myscancfg->coord.top += hwdcfg->startpos;
+ }
+ else
+ SetMultiExposure (dev, Regs);
+
+ /* 91e2 */
+ RTS_WriteRegs (dev->usb_handle, Regs);
+ if (myCalib != NULL)
+ Shading_apply (dev, Regs, myscancfg, myCalib);
+
+ if (dev->motorcfg->changemotorcurrent != FALSE)
+ Motor_Change (dev, Regs,
+ Motor_GetFromResolution (myscancfg->
+ resolution_x));
+
+ /* mlock = 0 */
+ data_bitset (&Regs[0x00], 0x10, 0);
+
+ data_wide_bitset (&Regs[0xde], 0xfff, 0);
+
+ /* release motor */
+ Motor_Release (dev);
+
+ if (RTS_Warm_Reset (dev) == OK)
+ {
+ rst = OK;
+
+ SetLock (dev->usb_handle, Regs,
+ (myscancfg->depth == 16) ? FALSE : TRUE);
+
+ /* set gain control */
+ Lamp_SetGainMode (dev, Regs, myscancfg->resolution_x,
+ gaincontrol);
+
+ /* send registers to scanner */
+ if (RTS_WriteRegs (dev->usb_handle, Regs) == OK)
+ {
+ /* execute! */
+ if (RTS_Execute (dev) == OK)
+ RTS_GetImage_Read (dev, buffer, myscancfg, hwdcfg); /*92e7 */
+ }
+
+ /*92fc */
+ SetLock (dev->usb_handle, Regs, FALSE);
+
+ if ((options & 0x200) != 0)
+ {
+ /* switch on lamp */
+ data_bitset (&Regs[0x146], 0x40, 1);
+
+ Write_Byte (dev->usb_handle, 0xe946, Regs[0x146]);
+ /* Wait 3 seconds */
+ usleep (1000 * 3000);
+ }
+
+ /*9351 */
+ if (dev->motorcfg->changemotorcurrent == TRUE)
+ Motor_Change (dev, dev->init_regs, 3);
+ }
+
+ /* free low level configuration */
+ free (hwdcfg);
+ }
+
+ /* free scanning configuration */
+ free (myscancfg);
+ }
+ }
+ }
+
+ DBG (DBG_FNC, "- RTS_GetImage: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Refs_Detect (struct st_device *dev, SANE_Byte * Regs, SANE_Int resolution_x,
+ SANE_Int resolution_y, SANE_Int * x, SANE_Int * y)
+{
+ SANE_Int rst = ERROR; /* default */
+
+ DBG (DBG_FNC, "+ Refs_Detect(*Regs, resolution_x=%i, resolution_y=%i):\n",
+ resolution_x, resolution_y);
+
+ if ((x != NULL) && (y != NULL))
+ {
+ SANE_Byte *image;
+ struct st_scanparams scancfg;
+
+ *x = *y = 0; /* default */
+
+ /* set configuration to scan a little area at the top-left corner */
+ bzero (&scancfg, sizeof (struct st_scanparams));
+ scancfg.depth = 8;
+ scancfg.colormode = CM_GRAY;
+ scancfg.channel = CL_RED;
+ scancfg.resolution_x = resolution_x;
+ scancfg.resolution_y = resolution_y;
+ scancfg.coord.left = 4;
+ scancfg.coord.width = (resolution_x * 3) / 10;
+ scancfg.coord.top = 1;
+ scancfg.coord.height = (resolution_y * 4) / 10;
+ scancfg.shadinglength = (resolution_x * 17) / 2;
+ scancfg.bytesperline = scancfg.coord.width;
+
+ /* allocate space to store image */
+ image =
+ (SANE_Byte *) malloc ((scancfg.coord.height * scancfg.coord.width) *
+ sizeof (SANE_Byte));
+ if (image != NULL)
+ {
+ struct st_gain_offset gain_offset;
+ SANE_Int gaincontrol, pwmlamplevel_backup, C;
+
+ gaincontrol = 0;
+ if (RTS_Debug->use_fixed_pwm == FALSE)
+ {
+ /* 3877 */
+ gaincontrol = Lamp_GetGainMode (dev, resolution_x, ST_NORMAL); /* scan.scantype */
+ pwmlamplevel = 0;
+ Lamp_PWM_use (dev, 1);
+ Lamp_PWM_DutyCycle_Set (dev, (gaincontrol == 0) ? 0x12 : 0x26);
+
+ /* Enciende flb lamp */
+ Lamp_Status_Set (dev, NULL, TRUE, FLB_LAMP);
+ usleep (1000 * 2000);
+ }
+
+ /* 38d6 */
+ pwmlamplevel_backup = pwmlamplevel;
+ pwmlamplevel = 0;
+ Lamp_PWM_use (dev, 1);
+
+ bzero (&gain_offset, sizeof (struct st_gain_offset));
+ for (C = CL_RED; C <= CL_BLUE; C++)
+ {
+ gain_offset.pag[C] = 3;
+ gain_offset.vgag1[C] = 4;
+ gain_offset.vgag2[C] = 4;
+ }
+
+ /* perform lamp warmup */
+ Lamp_Warmup (dev, Regs, FLB_LAMP, resolution_x);
+
+ /* retrieve image from scanner */
+ if (RTS_GetImage
+ (dev, Regs, &scancfg, &gain_offset, image, 0, 0x20000000,
+ gaincontrol) == OK)
+ {
+ SANE_Int ser1, ler1;
+
+ /* same image to disk if required by user */
+ if (RTS_Debug->SaveCalibFile != FALSE)
+ {
+ dbg_tiff_save ("pre-autoref.tiff",
+ scancfg.coord.width,
+ scancfg.coord.height,
+ scancfg.depth,
+ CM_GRAY,
+ scancfg.resolution_x,
+ scancfg.resolution_y,
+ image,
+ scancfg.coord.height * scancfg.coord.width);
+ }
+
+ /* calculate reference position */
+ if (Refs_Analyze_Pattern (&scancfg, image, &ler1, 1, &ser1, 0)
+ == OK)
+ {
+ *y = scancfg.coord.top + ler1;
+ *x = scancfg.coord.left + ser1;
+
+ rst = OK;
+ }
+ }
+
+ free (image);
+
+ pwmlamplevel = pwmlamplevel_backup;
+ }
+
+ DBG (DBG_FNC, " -> Detected refs: x=%i , y=%i\n", *x, *y);
+ }
+
+ DBG (DBG_FNC, "- Refs_Detect: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Refs_Set (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg)
+{
+ SANE_Int rst;
+ SANE_Int y, x;
+ struct st_autoref refcfg;
+
+ DBG (DBG_FNC, "+ Refs_Set(*Regs, *scancfg):\n");
+ dbg_ScanParams (scancfg);
+
+ rst = OK;
+
+ /* get fixed references for given resolution */
+ cfg_vrefs_get (dev->sensorcfg->type, scancfg->resolution_x, &scan.ler,
+ &scan.ser);
+ scan.leftleading = scan.ser;
+ scan.startpos = scan.ler;
+
+ /* get auto reference configuration */
+ cfg_autoref_get (&refcfg);
+
+ if (refcfg.type != REF_NONE)
+ {
+ /* if reference counter is == 0 perform auto detection */
+ if (Refs_Counter_Load (dev) == 0)
+ {
+ DBG (DBG_FNC,
+ " -> Refs_Set - Autodetection mandatory (counter == 0)\n");
+
+ refcfg.type = REF_AUTODETECT;
+ }
+
+ switch (refcfg.type)
+ {
+ case REF_AUTODETECT:
+ /* try to autodetect references scanning a little area */
+ if (Refs_Detect
+ (dev, Regs, refcfg.resolution, refcfg.resolution, &x, &y) == OK)
+ Refs_Save (dev, x, y);
+ else
+ rst = ERROR;
+
+ Head_ParkHome (dev, TRUE, dev->motorcfg->parkhomemotormove);
+ break;
+
+ case REF_TAKEFROMSCANNER:
+ /* Try to get values from scanner */
+ if (Refs_Load (dev, &x, &y) == ERROR)
+ {
+ if (Refs_Detect
+ (dev, Regs, refcfg.resolution, refcfg.resolution, &x,
+ &y) == OK)
+ Refs_Save (dev, x, y);
+ else
+ rst = ERROR;
+
+ Head_ParkHome (dev, TRUE, dev->motorcfg->parkhomemotormove);
+ }
+ break;
+ }
+
+ if (rst == OK)
+ {
+ /* values are based on resolution given by refcfg.resolution.
+
+ offset_x and y are based on 2400 dpi so convert values to that dpi
+ before adding offsets and then return to resolution given by user */
+
+ x *= (2400 / refcfg.resolution);
+ y *= (2400 / refcfg.resolution);
+
+ scan.leftleading = x;
+ scan.startpos = y;
+ scan.ser = ((x + refcfg.offset_x) * scancfg->resolution_x) / 2400;
+ scan.ler = ((y + refcfg.offset_y) * scancfg->resolution_y) / 2400;
+
+ DBG (DBG_FNC,
+ " -> After SEROffset and LEROffset, xoffset = %i, yoffset =%i\n",
+ scan.ser, scan.ler);
+ }
+
+ /* increase refs counter */
+ Refs_Counter_Inc (dev);
+ }
+
+ DBG (DBG_FNC, "- Refs_Set: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Lamp_Status_Set (struct st_device *dev, SANE_Byte * Regs, SANE_Int turn_on,
+ SANE_Int lamp)
+{
+ SANE_Int rst = ERROR; /* default */
+ SANE_Byte freevar = FALSE;
+
+ DBG (DBG_FNC, "+ Lamp_Status_Set(*Regs, turn_on=%i->%s, lamp=%s)\n",
+ turn_on,
+ ((((lamp - 1) | turn_on) & 1) == 1) ? "Yes" : "No",
+ (lamp == FLB_LAMP) ? "FLB_LAMP" : "TMA_LAMP");
+
+ if (Regs == NULL)
+ {
+ Regs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
+
+ if (Regs != NULL)
+ freevar = TRUE;
+ }
+
+ if (Regs != NULL)
+ {
+ RTS_ReadRegs (dev->usb_handle, Regs);
+
+ /* next op depends on chipset */
+ switch (dev->chipset->model)
+ {
+ case RTS8822BL_03A:
+ /* register 0xe946 has 2 bits and each one referres one lamp
+ 0x40: FLB_LAMP | 0x20 : TMA_LAMP
+ if both were enabled both lamps would be switched on */
+ data_bitset (&Regs[0x146], 0x20, ((lamp == TMA_LAMP) && (turn_on == TRUE)) ? 1 : 0); /* TMA */
+ data_bitset (&Regs[0x146], 0x40, ((lamp == FLB_LAMP) && (turn_on == TRUE)) ? 1 : 0); /* FLB */
+
+ data_bitset (&Regs[0x155], 0x10, (lamp != FLB_LAMP) ? 1 : 0);
+ break;
+ default:
+ /* the other chipsets only use one bit to indicate when a lamp is
+ switched on or not being bit 0x10 in 0xe955 who decides which lamp
+ is affected */
+ /* switch on lamp? yes if TMA_LAMP, else whatever turn_on says */
+ data_bitset (&Regs[0x146], 0x40, ((lamp - 1) | turn_on));
+ /* what lamp must be switched on? */
+ if ((Regs[0x146] & 0x40) != 0)
+ data_bitset (&Regs[0x155], 0x10, (lamp != FLB_LAMP) ? 1 : 0);
+ break;
+ }
+
+ /*42b8cd1 */
+ /* switch on/off lamp */
+ /*dev->init_regs[0x0146] = (dev->init_regs[0x146] & 0xbf) | (Regs[0x146] & 0x40); */
+ dev->init_regs[0x0146] = (dev->init_regs[0x146] & 0x9f) | (Regs[0x146] & 0x60); /*-xx-----*/
+
+ /* Which lamp */
+ dev->init_regs[0x0155] = Regs[0x0155];
+ Write_Byte (dev->usb_handle, 0xe946, Regs[0x0146]);
+ usleep (1000 * 200);
+ Write_Buffer (dev->usb_handle, 0xe954, &Regs[0x0154], 2);
+ }
+
+ if (freevar != FALSE)
+ {
+ free (Regs);
+ Regs = NULL;
+ }
+
+ DBG (DBG_FNC, "- Lamp_Status_Set: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Get_PAG_Value (SANE_Byte scantype, SANE_Byte color)
+{
+ SANE_Int rst, iType, iColor;
+
+ switch (scantype)
+ {
+ case ST_NEG:
+ iType = CALIBNEGATIVEFILM;
+ break;
+ case ST_TA:
+ iType = CALIBTRANSPARENT;
+ break;
+ case ST_NORMAL:
+ iType = CALIBREFLECTIVE;
+ break;
+ default:
+ iType = CALIBREFLECTIVE;
+ break;
+ }
+
+ switch (color)
+ {
+ case CL_BLUE:
+ iColor = PAGB;
+ break;
+ case CL_GREEN:
+ iColor = PAGG;
+ break;
+ case CL_RED:
+ iColor = PAGR;
+ break;
+ default:
+ iColor = PAGR;
+ break;
+ }
+
+ rst = get_value (iType, iColor, 1, FITCALIBRATE);
+
+ DBG (DBG_FNC, "> Get_PAG_Value(scantype=%s, color=%i): %i\n",
+ dbg_scantype (scantype), color, rst);
+
+ return rst;
+}
+
+static SANE_Byte
+Lamp_GetGainMode (struct st_device *dev, SANE_Int resolution,
+ SANE_Byte scantype)
+{
+ SANE_Byte ret;
+ SANE_Int mygain, iValue;
+
+ switch (scantype)
+ {
+ case ST_TA:
+ ret = 0;
+ iValue = DPIGAINCONTROL_TA600;
+ break;
+ case ST_NEG:
+ ret = 1;
+ iValue = DPIGAINCONTROL_NEG600;
+ break;
+ default: /* Reflective */
+ ret = 1;
+ iValue = DPIGAINCONTROL600;
+ break;
+ }
+
+ mygain = get_value (SCAN_PARAM, iValue, ret, usbfile);
+ ret = 0;
+
+/*
+
+*/
+ if (scantype == ST_NORMAL)
+ {
+ if (dev->chipset->model == RTS8822L_02A)
+ {
+ switch (resolution)
+ {
+ case 100:
+ case 150:
+ case 300:
+ case 600:
+ case 1200:
+ case 2400:
+ case 4800:
+ ret = ((RTS_Debug->usbtype != USB11) && (mygain != 0)) ? 1 : 0;
+ break;
+ }
+ }
+ else
+ {
+ switch (resolution)
+ {
+ case 100:
+ case 200:
+ case 300:
+ case 600:
+ if (RTS_Debug->usbtype != USB11)
+ ret = (mygain != 0) ? 1 : 0;
+ else
+ ret = (resolution == 100) ? 1 : 0;
+ break;
+ case 1200:
+ case 2400:
+ ret = 0;
+ break;
+ }
+ }
+ }
+ else if (scantype == ST_TA)
+ {
+ switch (resolution)
+ {
+ /*hp3970 */
+ case 100:
+ case 200:
+ /*common */
+ case 300:
+ case 600:
+ case 1200:
+ case 2400:
+ /*hp4370 */
+ case 150:
+ case 4800:
+ ret = ((RTS_Debug->usbtype != USB11) && (mygain != 0)) ? 1 : 0;
+ break;
+ }
+ }
+ else
+ {
+ /* ST_NEG */
+ switch (resolution)
+ {
+ case 100:
+ case 200:
+ case 300:
+ case 600:
+ ret = ((RTS_Debug->usbtype != USB11) && (mygain != 0)) ? 1 : 0;
+ break;
+ case 1200:
+ case 2400:
+ case 4800: /*hp4370 */
+ ret = 0;
+ break;
+ }
+ }
+
+ DBG (DBG_FNC, "> Lamp_GetGainMode(resolution=%i, scantype=%s): %i\n",
+ resolution, dbg_scantype (scantype), ret);
+
+ return ret;
+}
+
+static SANE_Int
+GetOneLineInfo (struct st_device *dev, SANE_Int resolution,
+ SANE_Int * maximus, SANE_Int * minimus, double *average)
+{
+ SANE_Int rst = ERROR;
+
+ DBG (DBG_FNC,
+ "+ GetOneLineInfo(resolution=%i, *maximus, *minimus, *average):\n",
+ resolution);
+
+ /* Check parameters */
+ if ((maximus != NULL) && (minimus != NULL) && (average != NULL))
+ {
+ SANE_Byte *Regs, *image;
+ SANE_Int a, gainmode;
+ struct st_gain_offset gain_offset;
+ struct st_scanparams scancfg;
+
+ Regs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
+ if (Regs != NULL)
+ {
+ /* Copy scanner registers */
+ memcpy (Regs, dev->init_regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+
+ /* Setting some registers */
+ for (a = 0x192; a <= 0x19d; a++)
+ Regs[a] = 0;
+
+ /* Create calibration table */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ gain_offset.edcg1[a] = 256;
+ gain_offset.edcg2[a] = 0;
+ gain_offset.odcg1[a] = 256;
+ gain_offset.odcg2[a] = 0;
+ gain_offset.vgag1[a] = 4;
+ gain_offset.vgag2[a] = 4;
+ gain_offset.pag[a] = Get_PAG_Value (scan.scantype, a);
+ }
+
+ RTS_GetScanmode (dev, scantype, 0, resolution);
+
+ /* Setting scanning params */
+ memset (&scancfg, 0, sizeof (struct st_scanparams));
+ scancfg.colormode = CM_COLOR;
+ scancfg.resolution_x = resolution;
+ scancfg.resolution_y = resolution;
+ scancfg.coord.left = 100;
+ scancfg.coord.width = (resolution * 8.5) - 100;
+ scancfg.coord.top = 1;
+ scancfg.coord.height = 1;
+ scancfg.depth = 8;
+ scancfg.shadinglength = resolution * 8.5;
+ scancfg.v157c = scancfg.coord.width * 3;
+ scancfg.bytesperline = scancfg.v157c;
+
+ /* Reserve buffer for line */
+ image =
+ (SANE_Byte *) malloc (((scancfg.coord.width * 0x21) * 3) *
+ sizeof (SANE_Byte));
+ if (image != NULL)
+ {
+ gainmode =
+ Lamp_GetGainMode (dev, resolution & 0xffff, scan.scantype);
+ if (RTS_GetImage
+ (dev, Regs, &scancfg, &gain_offset, image, 0,
+ OP_STATIC_HEAD, gainmode) != ERROR)
+ {
+ /* Read all image to take max min and average colours */
+ SANE_Byte *pointer1 = image;
+ SANE_Byte *pointer2;
+ SANE_Byte *pointer3;
+ SANE_Int cmin[3]; /* min values */
+ SANE_Int cmax[3]; /* max values */
+ double cave[3]; /* average values */
+ SANE_Int mysize;
+
+ if (scancfg.colormode != CM_GRAY)
+ {
+ pointer2 = image;
+ pointer3 = image;
+ }
+ else
+ {
+ pointer2 = image + 1;
+ pointer3 = image + 2;
+ }
+
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ cmin[a] = 255;
+ cmax[a] = 0;
+ cave[a] = 0;
+ }
+
+ if (scancfg.coord.height > 0)
+ {
+ SANE_Int y, x;
+ SANE_Byte *mypointer;
+ SANE_Byte color;
+ SANE_Int desp[3];
+
+ desp[CL_RED] = pointer1 - pointer3;
+ desp[CL_GREEN] = pointer2 - pointer3;
+ desp[CL_BLUE] = 0;
+
+ for (y = 0; y < scancfg.coord.height; y++)
+ {
+ if (scancfg.coord.width > 0)
+ {
+ mypointer = pointer3;
+
+ for (x = 0; x < scancfg.coord.width; x++)
+ {
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ /* Take colour values */
+ color = *(mypointer + desp[a]);
+
+ /* Take max values for each color */
+ cmax[a] = max (cmax[a], color);
+
+ /* Take min values for each color */
+ cmin[a] = min (cmin[a], color);
+
+ /* Average */
+ cave[a] += color;
+ }
+
+ mypointer += 3;
+ }
+ }
+
+ /* point to the pixel that is below */
+ pointer1 += scancfg.coord.width * 3;
+ pointer2 += scancfg.coord.width * 3;
+ pointer3 += scancfg.coord.width * 3;
+ }
+ }
+
+ mysize = scancfg.coord.height * scancfg.coord.width;
+ if (mysize < 1)
+ mysize = 1;
+
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ maximus[a] = cmax[a];
+ minimus[a] = cmin[a];
+ average[a] = cave[a] / mysize;
+ }
+
+ DBG (DBG_FNC, " -> GetOneLineInfo: max r=%3i g=%3i b=%3i\n",
+ maximus[CL_RED], maximus[CL_GREEN], maximus[CL_BLUE]);
+ DBG (DBG_FNC, " -> min r=%3i g=%3i b=%3i\n",
+ minimus[CL_RED], minimus[CL_GREEN], minimus[CL_BLUE]);
+ DBG (DBG_FNC,
+ " -> avg r=%3.0f g=%3.0f b=%3.0f\n",
+ average[CL_RED], average[CL_GREEN], average[CL_BLUE]);
+
+ rst = OK;
+ }
+
+ free (image);
+ }
+
+ free (Regs);
+ }
+ }
+
+ DBG (DBG_FNC, "- GetOneLineInfo: %i\n", rst);
+
+ return OK;
+}
+
+static SANE_Int
+Lamp_PWM_CheckStable (struct st_device *dev, SANE_Int resolution,
+ SANE_Int lamp)
+{
+ struct st_checkstable check;
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ Lamp_PWM_CheckStable(resolution=%i, lamp=%i):\n",
+ resolution, lamp);
+
+ rst = cfg_checkstable_get (lamp, &check);
+
+ if (rst == OK)
+ {
+ SANE_Int maximus[3] = { 0 };
+ SANE_Int minimus[3] = { 0 };
+ double average[3] = { 0 };
+ SANE_Int maxbigger;
+ SANE_Int last_colour = 0;
+
+ double diff = check.diff * 0.01;
+ long tottime = GetTickCount () + check.tottime;
+
+ while (GetTickCount () <= tottime)
+ {
+ rst = GetOneLineInfo (dev, resolution, maximus, minimus, average);
+ if (rst == OK)
+ {
+ /* Takes maximal colour value */
+ maxbigger =
+ max (maximus[CL_GREEN],
+ max (maximus[CL_BLUE], maximus[CL_RED]));
+
+ /*breaks when colour intensity increases 'diff' or lower */
+ if (abs (maxbigger - last_colour) < diff)
+ {
+ DBG (DBG_FNC, " -> PWM is ready\n");
+ break;
+ }
+
+ last_colour = maxbigger;
+ }
+
+ usleep (1000 * check.interval);
+ }
+
+ }
+
+ DBG (DBG_FNC, "- Lamp_PWM_CheckStable: %i\n", rst);
+
+ return OK;
+}
+
+static SANE_Byte
+Refs_Counter_Load (struct st_device *dev)
+{
+ SANE_Byte data = 15;
+
+ DBG (DBG_FNC, "+ Refs_Counter_Load:\n");
+
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ if (RTS_EEPROM_ReadByte (dev->usb_handle, 0x78, &data) != OK)
+ data = 15;
+
+ DBG (DBG_FNC, "- Refs_Counter_Load: %i\n", _B0 (data));
+
+ return data;
+}
+
+static SANE_Int
+Refs_Counter_Save (struct st_device *dev, SANE_Byte data)
+{
+ SANE_Int rst = OK;
+
+ DBG (DBG_FNC, "+ Refs_Counter_Save(data=%i):\n", data);
+
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ {
+ if (data > 15)
+ data = 15;
+
+ rst = RTS_EEPROM_WriteByte (dev->usb_handle, 0x78, data);
+ }
+
+ DBG (DBG_FNC, "- Refs_Counter_Save: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Refs_Counter_Inc (struct st_device *dev)
+{
+ SANE_Byte data;
+
+ DBG (DBG_FNC, "+ Refs_Counter_Inc:\n");
+
+ data = Refs_Counter_Load (dev) + 1;
+
+ if (data >= 15)
+ data = 0;
+
+ Refs_Counter_Save (dev, data);
+
+ DBG (DBG_FNC, "- Refs_Counter_Inc() : Count=%i\n", data);
+
+ return OK;
+}
+
+static SANE_Int
+Load_StripCoords (SANE_Int scantype, SANE_Int * ypos, SANE_Int * xpos)
+{
+ SANE_Int iType;
+
+ switch (scantype)
+ {
+ case 3:
+ iType = CALIBNEGATIVEFILM;
+ break;
+ case 2:
+ iType = CALIBTRANSPARENT;
+ break;
+ default:
+ iType = CALIBREFLECTIVE;
+ break;
+ }
+
+ *xpos = get_value (iType, WSTRIPXPOS, 0, FITCALIBRATE);
+ *ypos = get_value (iType, WSTRIPYPOS, 0, FITCALIBRATE);
+
+ DBG (DBG_FNC, "> Load_StripCoords(scantype=%s): ypos=%i, xpos=%i\n",
+ dbg_scantype (scantype), *ypos, *xpos);
+
+ return OK;
+}
+
+static SANE_Int
+Head_Relocate (struct st_device *dev, SANE_Int speed, SANE_Int direction,
+ SANE_Int ypos)
+{
+ SANE_Int rst;
+ SANE_Byte *Regs;
+
+ DBG (DBG_FNC, "+ Head_Relocate(speed=%i, direction=%i, ypos=%i):\n", speed,
+ direction, ypos);
+
+ rst = ERROR;
+
+ Regs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
+ if (Regs != NULL)
+ {
+ struct st_motormove mymotor;
+ struct st_motorpos mtrpos;
+
+ bzero (&mymotor, sizeof (struct st_motormove));
+ memcpy (Regs, dev->init_regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+
+ if (speed < dev->motormove_count)
+ memcpy (&mymotor, dev->motormove[speed],
+ sizeof (struct st_motormove));
+
+ /*83fe */
+ mtrpos.coord_y = ypos;
+ mtrpos.options =
+ MTR_ENABLED | ((direction == MTR_BACKWARD) ? MTR_BACKWARD :
+ MTR_FORWARD);
+ mtrpos.v12e448 = 0;
+ mtrpos.v12e44c = 1;
+
+ Motor_Move (dev, Regs, &mymotor, &mtrpos);
+
+ /* waits 15 seconds */
+ RTS_WaitScanEnd (dev, 15000);
+
+ free (Regs);
+ rst = OK;
+ }
+
+ DBG (DBG_FNC, "- Head_Relocate: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Calib_CreateFixedBuffers ()
+{
+ SANE_Byte channel;
+ SANE_Int ret;
+
+ DBG (DBG_FNC, "> Calib_CreateFixedBuffers()\n");
+
+ ret = OK;
+ channel = 0;
+
+ while ((channel < 3) && (ret == OK))
+ {
+ /* First table */
+ if (fixed_black_shading[channel] == NULL)
+ fixed_black_shading[channel] =
+ (USHORT *) malloc (0x7f8 * sizeof (USHORT));
+
+ if (fixed_black_shading[channel] != NULL)
+ bzero (fixed_black_shading[channel], 0x7f8 * sizeof (USHORT));
+ else
+ ret = ERROR;
+
+ /* Second table */
+ if (fixed_white_shading[channel] == NULL)
+ fixed_white_shading[channel] =
+ (USHORT *) malloc (0x7f8 * sizeof (USHORT));
+
+ if (fixed_white_shading[channel] != NULL)
+ bzero (fixed_white_shading[channel], 0x7f8 * sizeof (USHORT));
+ else
+ ret = ERROR;
+
+ channel++;
+ }
+
+ return ret;
+}
+
+static SANE_Int
+Calib_CreateBuffers (struct st_device *dev, struct st_calibration *buffer,
+ SANE_Int my14b4)
+{
+ SANE_Int ebp, ret, channel;
+
+ ret = ERROR;
+ dev = dev;
+
+ buffer->shadinglength = scan.coord.width;
+ ebp = 0x14;
+
+ if (my14b4 != 0)
+ {
+ /* 673d */
+ if (Calib_CreateFixedBuffers () == OK)
+ {
+ for (channel = 0; channel < 3; channel++)
+ {
+ buffer->white_shading[channel] = fixed_white_shading[channel];
+ buffer->black_shading[channel] = fixed_black_shading[channel];
+ }
+ ret = OK;
+ }
+ }
+ else
+ {
+ /* 677f */
+ SANE_Int pos;
+ channel = 0;
+ while ((channel < 3) && (ret == OK))
+ {
+ buffer->black_shading[channel] =
+ (USHORT *) malloc (ebp +
+ (buffer->shadinglength * sizeof (USHORT)));
+ buffer->white_shading[channel] =
+ (USHORT *) malloc (ebp +
+ (buffer->shadinglength * sizeof (USHORT)));
+ if ((buffer->black_shading[channel] != NULL)
+ && (buffer->white_shading[channel] != NULL))
+ {
+ for (pos = 0; pos < buffer->shadinglength; pos++)
+ {
+ buffer->black_shading[channel][pos] = 0x00;
+ buffer->white_shading[channel][pos] = 0x4000;
+ }
+ ret = OK;
+ }
+ else
+ Calib_FreeBuffers (buffer);
+
+ channel++;
+ }
+ }
+
+ DBG (DBG_FNC, "> Calib_CreateBuffers: *buffer, my14b4=%i): %i\n", my14b4,
+ ret);
+
+ return ret;
+}
+
+static void
+Calib_FreeBuffers (struct st_calibration *caltables)
+{
+ DBG (DBG_FNC, "> Calib_FreeBuffers(*caltables)\n");
+
+ if (caltables != NULL)
+ {
+ SANE_Int channel;
+
+ for (channel = 0; channel < 3; channel++)
+ {
+ if (caltables->black_shading[channel] != NULL)
+ {
+ free (caltables->black_shading[channel]);
+ caltables->black_shading[channel] = NULL;
+ }
+
+ if (caltables->white_shading[channel] != NULL)
+ {
+ free (caltables->white_shading[channel]);
+ caltables->white_shading[channel] = NULL;
+ }
+ }
+ }
+}
+
+static SANE_Int
+Calib_LoadConfig (struct st_device *dev,
+ struct st_calibration_config *calibcfg, SANE_Int scantype,
+ SANE_Int resolution, SANE_Int bitmode)
+{
+ SANE_Int section, a;
+ struct st_autoref refcfg;
+
+ DBG (DBG_FNC,
+ "> Calib_LoadConfig(*calibcfg, scantype=%s, resolution=%i, bitmode=%i)\n",
+ dbg_scantype (scantype), resolution, bitmode);
+
+ switch (scantype)
+ {
+ case ST_NEG:
+ section = CALIBNEGATIVEFILM;
+ break;
+ case ST_TA:
+ section = CALIBTRANSPARENT;
+ break;
+ default:
+ section = CALIBREFLECTIVE;
+ break;
+ }
+
+ calibcfg->WStripXPos = get_value (section, WSTRIPXPOS, 0, FITCALIBRATE);
+ calibcfg->WStripYPos = get_value (section, WSTRIPYPOS, 0, FITCALIBRATE);
+ calibcfg->BStripXPos = get_value (section, BSTRIPXPOS, 0, FITCALIBRATE);
+ calibcfg->BStripYPos = get_value (section, WSTRIPYPOS, 0, FITCALIBRATE);
+
+ /* get calibration wrefs */
+ cfg_wrefs_get (dev->sensorcfg->type, bitmode, resolution, scantype,
+ &calibcfg->WRef[CL_RED], &calibcfg->WRef[CL_GREEN],
+ &calibcfg->WRef[CL_BLUE]);
+
+ /* 4913 */
+
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ WRef[a] = _B0 (calibcfg->WRef[a]);
+
+ calibcfg->BRef[a] = get_value (section, BREFR + a, 10, FITCALIBRATE);
+ calibcfg->OffsetEven1[a] =
+ get_value (section, OFFSETEVEN1R + a, 256, FITCALIBRATE);
+ calibcfg->OffsetEven2[a] =
+ get_value (section, OFFSETEVEN2R + a, 0, FITCALIBRATE);
+ calibcfg->OffsetOdd1[a] =
+ get_value (section, OFFSETODD1R + a, 256, FITCALIBRATE);
+ calibcfg->OffsetOdd2[a] =
+ get_value (section, OFFSETODD2R + a, 0, FITCALIBRATE);
+ }
+
+ calibcfg->RefBitDepth =
+ _B0 (get_value (section, REFBITDEPTH, 8, FITCALIBRATE));
+ calibcfg->CalibOffset10n =
+ _B0 (get_value (section, CALIBOFFSET10N, 3, FITCALIBRATE));
+ calibcfg->CalibOffset20n =
+ _B0 (get_value (section, CALIBOFFSET20N, 0, FITCALIBRATE));
+ calibcfg->OffsetHeight =
+ get_value (section, OFFSETHEIGHT, 10, FITCALIBRATE);
+
+ /* 4ae9 */
+
+ /* get left coordinate and length to calibrate offset */
+ cfg_offset_get (dev->sensorcfg->type, resolution, scantype,
+ &calibcfg->OffsetPixelStart, &calibcfg->OffsetNPixel);
+
+ /*4c49 */
+ calibcfg->OffsetNSigma = get_value (section, OFFSETNSIGMA, 2, FITCALIBRATE);
+ calibcfg->OffsetTargetMax =
+ get_value (section, OFFSETTARGETMAX, 0x32, FITCALIBRATE) * 0.01;
+ calibcfg->OffsetTargetMin =
+ get_value (section, OFFSETTARGETMIN, 2, FITCALIBRATE) * 0.01;
+ calibcfg->OffsetBoundaryRatio1 =
+ get_value (section, OFFSETBOUNDARYRATIO1, 0x64, FITCALIBRATE) * 0.01;
+ calibcfg->OffsetBoundaryRatio2 =
+ get_value (section, OFFSETBOUNDARYRATIO2, 0x64, FITCALIBRATE) * 0.01;
+
+ calibcfg->OffsetAvgRatio1 =
+ get_value (section, OFFSETAVGRATIO1, 0x64, FITCALIBRATE) * 0.01;
+ calibcfg->OffsetAvgRatio2 =
+ get_value (section, OFFSETAVGRATIO2, 0x64, FITCALIBRATE) * 0.01;
+ calibcfg->AdcOffQuickWay =
+ get_value (section, ADCOFFQUICKWAY, 1, FITCALIBRATE);
+ calibcfg->AdcOffPredictStart =
+ get_value (section, ADCOFFPREDICTSTART, 0xc8, FITCALIBRATE);
+ calibcfg->AdcOffPredictEnd =
+ get_value (section, ADCOFFPREDICTEND, 0x1f4, FITCALIBRATE);
+ calibcfg->AdcOffEvenOdd =
+ get_value (section, ADCOFFEVENODD, 1, FITCALIBRATE);
+ calibcfg->OffsetTuneStep1 =
+ _B0 (get_value (section, OFFSETTUNESTEP1, 1, FITCALIBRATE));
+ calibcfg->OffsetTuneStep2 =
+ _B0 (get_value (section, OFFSETTUNESTEP2, 1, FITCALIBRATE));
+ calibcfg->CalibGain10n = get_value (section, CALIBGAIN10N, 1, FITCALIBRATE);
+ calibcfg->CalibGain20n = get_value (section, CALIBGAIN20N, 0, FITCALIBRATE);
+ calibcfg->CalibPAGOn = get_value (section, CALIBPAGON, 0, FITCALIBRATE);
+
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ calibcfg->OffsetAvgTarget[a] =
+ _B0 (get_value (section, OFFSETAVGTARGETR + a, 0x0d, FITCALIBRATE));
+ calibcfg->PAG[a] = get_value (section, PAGR + a, 3, FITCALIBRATE);
+ calibcfg->Gain1[a] = get_value (section, GAIN1R + a, 4, FITCALIBRATE);
+ calibcfg->Gain2[a] = get_value (section, GAIN2R + a, 4, FITCALIBRATE);
+ calibcfg->WShadingPreDiff[a] =
+ get_value (section, WSHADINGPREDIFFR + a, -1, FITCALIBRATE);
+ calibcfg->BShadingPreDiff[a] =
+ get_value (section, BSHADINGPREDIFFR + a, 2, FITCALIBRATE);
+ }
+
+ calibcfg->GainHeight = get_value (section, GAINHEIGHT, 0x1e, FITCALIBRATE);
+ calibcfg->GainTargetFactor =
+ get_value (section, GAINTARGETFACTOR, 0x5a, FITCALIBRATE) * 0.01;
+ calibcfg->TotShading = get_value (section, TOTSHADING, 0, FITCALIBRATE);
+
+ /* White shading */
+ calibcfg->WShadingOn = get_value (section, WSHADINGON, 3, FITCALIBRATE);
+ calibcfg->WShadingHeight =
+ get_value (section, WSHADINGHEIGHT, 0x18, FITCALIBRATE);
+
+ /* Black shading */
+ calibcfg->BShadingOn = get_value (section, BSHADINGON, 2, FITCALIBRATE);
+ calibcfg->BShadingHeight =
+ get_value (section, BSHADINGHEIGHT, 0x1e, FITCALIBRATE);
+
+ calibcfg->BShadingDefCutOff =
+ get_value (section, BSHADINGDEFCUTOFF, 0, FITCALIBRATE);
+
+ refcfg.extern_boundary = 0;
+ cfg_autoref_get (&refcfg);
+ calibcfg->ExternBoundary = refcfg.extern_boundary * 0.01;
+
+ calibcfg->EffectivePixel =
+ cfg_effectivepixel_get (dev->sensorcfg->type, resolution);
+
+ return OK;
+}
+
+static SANE_Int
+Calib_AdcGain (struct st_device *dev, struct st_calibration_config *calibcfg,
+ SANE_Int arg2, SANE_Int gaincontrol)
+{
+ /*
+ 0606F8E0 04F60738 |Arg1 = 04F60738
+ 0606F8E4 0606F90C |Arg2 = 0606F90C calibcfg
+ 0606F8E8 00000001 |Arg3 = 00000001 arg2
+ 0606F8EC 00000001 \Arg4 = 00000001 gaincontrol
+ */
+
+ SANE_Int rst = ERROR;
+ SANE_Byte *myRegs; /*f1c0 */
+
+ DBG (DBG_FNC, "+ Calib_AdcGain(*calibcfg, arg2=%i, gaincontrol=%i)\n", arg2,
+ gaincontrol);
+
+ myRegs = (SANE_Byte *) malloc (sizeof (SANE_Byte) * RT_BUFFER_LEN);
+ if (myRegs != NULL)
+ {
+ struct st_scanparams *scancfg; /*f17c */
+ SANE_Int bytes_per_line, bytes_to_next_colour, bytes_per_pixel;
+
+ /* get register values to perform adc gain calibration */
+ memcpy (myRegs, &calibdata->Regs, sizeof (SANE_Byte) * RT_BUFFER_LEN);
+
+ scancfg =
+ (struct st_scanparams *) malloc (sizeof (struct st_scanparams));
+ if (scancfg != NULL)
+ {
+ SANE_Byte *image, *pgain, *pcalgain;
+
+ /* get proper scan configuration */
+ memcpy (scancfg, &calibdata->scancfg,
+ sizeof (struct st_scanparams));
+
+ /* set gain control type */
+ Lamp_SetGainMode (dev, myRegs, scancfg->resolution_x, gaincontrol);
+
+ /* 8-bit depth */
+ scancfg->depth = 8;
+
+ /* set coordinates */
+ if ((scan.scantype > 0) && (scan.scantype < 4))
+ scancfg->coord.left += scan.ser;
+
+ if ((scancfg->coord.width & 1) == 0)
+ scancfg->coord.width++;
+
+ scancfg->coord.top = 1;
+ scancfg->coord.height = calibcfg->OffsetHeight;
+
+ /* three more values to read image data after getting image from scanner */
+ switch (scancfg->colormode)
+ {
+ case CM_GRAY:
+ case CM_LINEART:
+ bytes_to_next_colour = 0;
+ bytes_per_pixel = 1;
+ bytes_per_line = scancfg->coord.width;
+ break;
+ default: /* CM_COLOR */
+ /* c027 */
+ bytes_to_next_colour = 1;
+ bytes_per_line = scancfg->coord.width * 3;
+ if (scancfg->samplerate == LINE_RATE)
+ {
+ bytes_to_next_colour = scancfg->coord.width;
+ bytes_per_pixel = 1;
+ }
+ else
+ bytes_per_pixel = 3;
+ break;
+ }
+
+ /*7fc7 */
+ scancfg->v157c = bytes_per_line;
+ scancfg->bytesperline = bytes_per_line;
+
+ /* select type of gain parameters to set */
+ if (arg2 != 0)
+ {
+ pgain = calibdata->gain_offset.vgag1;
+ pcalgain = calibcfg->Gain1;
+ }
+ else
+ {
+ /*7ff2 */
+ pgain = calibdata->gain_offset.vgag2;
+ pcalgain = calibcfg->Gain2;
+ }
+
+ /*8002 */
+ /* Allocate space for image | size = 132912 */
+ image =
+ (SANE_Byte *) malloc (sizeof (SANE_Byte) *
+ ((scancfg->coord.height +
+ 16) * bytes_per_line));
+ if (image != NULL)
+ {
+ /* Lets read image */
+ if (RTS_GetImage
+ (dev, myRegs, scancfg, &calibdata->gain_offset, image, NULL,
+ OP_STATIC_HEAD, gaincontrol) == OK)
+ {
+ SANE_Int a;
+ SANE_Int vmin[3], vmax[3];
+ double dval[3] = { 0.0 }; /*f1a8 f1b0 f1b8 */
+ SANE_Byte *pimage = image;
+
+ /* initialize values */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ calibcfg->unk1[a] = 0;
+ calibcfg->unk2[a] = 0xff;
+
+ vmin[a] = 0xff;
+ vmax[a] = 0;
+ }
+
+ /* process image data */
+ if (scancfg->coord.width > 0)
+ {
+ /*8104 */
+ SANE_Int pos, myheight /*f164 */ ;
+ SANE_Int chn_sum[3];
+
+ for (pos = scancfg->coord.width; pos > 0; pos--)
+ {
+ chn_sum[CL_RED] = chn_sum[CL_GREEN] =
+ chn_sum[CL_BLUE] = 0;
+
+ if (scancfg->coord.height > 0)
+ for (myheight = 0;
+ myheight < scancfg->coord.height; myheight++)
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ chn_sum[a] +=
+ *(pimage + (bytes_per_line * myheight) +
+ (bytes_to_next_colour * a));
+
+ /*816e */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ vmin[a] =
+ min (vmin[a],
+ chn_sum[a] / scancfg->coord.height);
+ vmax[a] =
+ max (vmax[a],
+ chn_sum[a] / scancfg->coord.height);
+
+ calibcfg->unk1[a] =
+ max (calibcfg->unk1[a], vmax[a]);
+ calibcfg->unk2[a] =
+ min (calibcfg->unk1[a], vmin[a]);
+
+ dval[a] += vmax[a] & 0xffff;
+ }
+
+ pimage += bytes_per_pixel;
+ }
+ }
+
+ /*82b0 */
+ dval[CL_RED] /= scancfg->coord.width;
+ dval[CL_GREEN] /= scancfg->coord.width;
+ dval[CL_BLUE] /= scancfg->coord.width;
+
+ DBG (DBG_FNC, " -> adcgain (av/l): r=%f, g=%f, b=%f\n",
+ dval[CL_RED], dval[CL_GREEN], dval[CL_BLUE]);
+ DBG (DBG_FNC, " -> (max ): R=%i, G=%i, B=%i\n",
+ calibcfg->unk1[CL_RED], calibcfg->unk1[CL_GREEN],
+ calibcfg->unk1[CL_BLUE]);
+ DBG (DBG_FNC, " -> (min ): r=%i, g=%i, b=%i\n",
+ calibcfg->unk2[CL_RED], calibcfg->unk2[CL_GREEN],
+ calibcfg->unk2[CL_BLUE]);
+
+ if (scancfg->colormode == CM_COLOR)
+ {
+ /*8353 */
+ double dvalue;
+ SANE_Int ival;
+
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ dvalue =
+ ((((calibcfg->WRef[a] * (1 << scancfg->depth)) *
+ calibcfg->GainTargetFactor) * 0.00390625) /
+ dval[a]) * ((44 - pgain[a]) / 40);
+ if (dvalue > 0.9090909090909091)
+ {
+ /*83d7 */
+ dvalue = min (44 - (40 / dvalue), 31);
+ ival = dvalue;
+ pgain[a] = _B0 (ival);
+ pcalgain[a] = _B0 (ival);
+ }
+ else
+ {
+ pgain[a] = 0;
+ pcalgain[a] = 0;
+ }
+ }
+ }
+ else
+ {
+ /*843c */
+ /*falta codigo */
+ double dvalue;
+ SANE_Int ival;
+
+ dvalue =
+ ((44 -
+ pgain[CL_RED]) / 40) * ((((1 << scancfg->depth) *
+ calibcfg->WRef[scancfg->
+ channel]) *
+ 0.9) * 0.00390625) /
+ 17.08509389671362;
+
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ if (dvalue > 0.9090909090909091)
+ {
+ dvalue = min (44 - (40 / dvalue), 31);
+ ival = dvalue;
+ pgain[a] = _B0 (ival);
+ pcalgain[a] = _B0 (ival);
+ }
+ else
+ {
+ /*84e3 */
+ pgain[a] = 0;
+ pcalgain[a] = 0;
+ }
+ }
+ }
+
+ /*84fa */
+ /* Save buffer */
+ if (RTS_Debug->SaveCalibFile != FALSE)
+ {
+ dbg_tiff_save ("adcgain.tiff",
+ scancfg->coord.width,
+ scancfg->coord.height,
+ scancfg->depth,
+ CM_COLOR,
+ scancfg->resolution_x,
+ scancfg->resolution_y,
+ image,
+ (scancfg->coord.height +
+ 16) * bytes_per_line);
+ }
+
+ /* check if peak values are above offset average target + 5 */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ if (calibcfg->unk1[a] >= calibcfg->OffsetAvgTarget[a] + 5)
+ {
+ rst = OK;
+ break;
+ }
+ }
+
+ free (image);
+ }
+
+ free (scancfg);
+ }
+
+ free (myRegs);
+ }
+
+ /* v14b8 = (rst == OK)? 0: 1; */
+
+ /* show */
+ dbg_calibtable (&calibdata->gain_offset);
+
+ DBG (DBG_FNC, "- Calib_AdcGain: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+GainOffset_Save (struct st_device *dev, SANE_Int * offset, SANE_Byte * gain)
+{
+ SANE_Int rst = OK;
+
+ DBG (DBG_FNC, "+ GainOffset_Save(*offset, *gain):\n");
+
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ {
+ if ((offset != NULL) && (gain != NULL))
+ {
+ SANE_Int a, crc, value;
+
+ crc = 0x5B;
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ value = (*gain << 9) | *offset;
+ crc = _B0 (abs (crc - _B0 (value)));
+ rst =
+ RTS_EEPROM_WriteWord (dev->usb_handle, 0x70 + (a * 2), value);
+ }
+
+ if (rst == OK)
+ rst = RTS_EEPROM_WriteByte (dev->usb_handle, 0x76, crc);
+ }
+ else
+ rst = ERROR;
+ }
+
+ DBG (DBG_FNC, "- GainOffset_Save: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+Calib_PAGain (struct st_device *dev, struct st_calibration_config *calibcfg,
+ SANE_Int gainmode)
+{
+ SANE_Byte *Regs;
+ struct st_scanparams *scancfg;
+ SANE_Int channel_size;
+ SANE_Int bytes_to_next_colour = 0;
+ SANE_Int bytes_per_pixel = 0;
+ SANE_Int length = 0;
+ SANE_Byte *image;
+ double rst;
+ SANE_Int ret = ERROR;
+
+ DBG (DBG_FNC, "+ Calib_PAGain(*calibcfg, gainmode=%i)\n", gainmode);
+
+ Regs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
+ if (Regs != NULL)
+ {
+ scancfg =
+ (struct st_scanparams *) malloc (sizeof (struct st_scanparams));
+ if (scancfg != NULL)
+ {
+ memcpy (Regs, &calibdata->Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+ memcpy (scancfg, &calibdata->scancfg,
+ sizeof (struct st_scanparams));
+
+ if (scan.scantype == ST_NORMAL)
+ {
+ /* bfa5 */
+ scancfg->coord.left = scan.ser;
+ scancfg->coord.width = (scancfg->sensorresolution * 17) / 2;
+ }
+ else
+ {
+ scancfg->coord.left = scan.ser + v0750;
+ scancfg->coord.width = (scancfg->sensorresolution * 3) / 2;
+ }
+
+ /* bfca */
+ if ((scancfg->coord.width & 1) == 1)
+ scancfg->coord.width++;
+
+ scancfg->coord.top = 1;
+ scancfg->coord.height = calibcfg->OffsetHeight;
+
+ channel_size = (scancfg->depth > 8) ? 2 : 1;
+
+ switch (scancfg->colormode)
+ {
+ case CM_GRAY:
+ case CM_LINEART:
+ bytes_to_next_colour = 0;
+ bytes_per_pixel = 1;
+ length = channel_size * scancfg->coord.width;
+ break;
+ default: /* CM_COLOR */
+ /* c027 */
+ bytes_to_next_colour = 1;
+ length = (channel_size * scancfg->coord.width) * 3;
+ if (scancfg->samplerate == LINE_RATE)
+ {
+ bytes_to_next_colour = scancfg->coord.width;
+ bytes_per_pixel = 1;
+ }
+ else
+ bytes_per_pixel = 3;
+ break;
+ }
+
+ /* c070 */
+ scancfg->v157c = length;
+
+ image =
+ (SANE_Byte *) malloc ((scancfg->coord.height * length) *
+ sizeof (SANE_Byte));
+ if (image != NULL)
+ {
+ ret =
+ RTS_GetImage (dev, Regs, scancfg, &calibdata->gain_offset,
+ image, 0, OP_STATIC_HEAD, gainmode);
+ if (ret == OK)
+ {
+ /* 429c105 */
+ SANE_Int a;
+ SANE_Byte *ptr[3];
+ SANE_Int vmin[3] = { 255, 255, 255 }; /* f16c|f16e|f170 */
+ SANE_Int vmax[3] = { 0, 0, 0 }; /* f164|f166|f168 */
+ SANE_Int total[3];
+
+ ptr[CL_RED] = image;
+ ptr[CL_GREEN] = image + bytes_to_next_colour;
+ ptr[CL_BLUE] = image + (bytes_to_next_colour * 2);
+
+ if (scancfg->coord.width > 0)
+ {
+ SANE_Int pos, b;
+
+ for (pos = 0; pos < scancfg->coord.width; pos++)
+ {
+ total[CL_BLUE] = 0;
+ total[CL_GREEN] = 0;
+ total[CL_RED] = 0;
+
+ for (a = 0; a < scancfg->coord.height; a++)
+ {
+ for (b = CL_RED; b <= CL_BLUE; b++)
+ total[b] +=
+ *(ptr[b] +
+ ((scancfg->coord.height - a) * length));
+ }
+
+ /* c1a5 */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ total[a] /= scancfg->coord.height;
+ vmin[a] = min (vmin[a], total[a]);
+ vmax[a] = max (vmax[a], total[a]);
+
+ ptr[a] += bytes_per_pixel;
+ }
+ }
+ }
+
+ /* 429c234 */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ rst =
+ (calibcfg->WRef[a] * calibcfg->GainTargetFactor) /
+ vmax[a];
+ if (rst <= 1.5)
+ {
+ if (rst <= 1.286)
+ {
+ if (rst <= 1.125)
+ calibdata->gain_offset.pag[a] = 0;
+ else
+ calibdata->gain_offset.pag[a] = 1;
+ }
+ else
+ calibdata->gain_offset.pag[a] = 2;
+ }
+ else
+ calibdata->gain_offset.pag[a] = 3;
+ }
+ }
+ free (image);
+ }
+ free (scancfg);
+ }
+ free (Regs);
+ }
+
+ DBG (DBG_FNC, "- Calib_PAGain: %i\n", ret);
+
+ return ret;
+}
+
+static SANE_Int
+Chipset_ID (struct st_device *dev)
+{
+ SANE_Int ret;
+
+ if (Read_Word (dev->usb_handle, 0xfe3c, &ret) == OK)
+ ret = _B0 (ret);
+ else
+ ret = 0;
+
+ DBG (DBG_FNC, "> Chipset_ID(): %i\n", ret);
+
+ return ret;
+}
+
+static SANE_Int
+Chipset_Name (struct st_device *dev, char *name, SANE_Int size)
+{
+ SANE_Int rst = ERROR;
+
+ if (name != NULL)
+ {
+ strncpy (name, dev->chipset->name, size);
+ rst = OK;
+ }
+
+ return rst;
+}
+
+static SANE_Int
+Refs_Load (struct st_device *dev, SANE_Int * x, SANE_Int * y)
+{
+ SANE_Int ret = OK;
+
+ DBG (DBG_FNC, "+ Refs_Load:\n");
+
+ *y = *x = 0;
+
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ {
+ SANE_Int data;
+
+ ret = ERROR;
+
+ if (RTS_EEPROM_ReadWord (dev->usb_handle, 0x6a, &data) == OK)
+ {
+ *x = data;
+ if (RTS_EEPROM_ReadWord (dev->usb_handle, 0x6c, &data) == OK)
+ {
+ *y = data;
+ if (RTS_EEPROM_ReadWord (dev->usb_handle, 0x6e, &data) == OK)
+ {
+ if ((_B0 (*y + *x + data)) == 0x5a)
+ ret = OK;
+ }
+ }
+ }
+ }
+
+ DBG (DBG_FNC, "- Refs_Load(y=%i, x=%i) : %i\n", *y, *x, ret);
+
+ return ret;
+}
+
+static SANE_Int
+Refs_Save (struct st_device *dev, SANE_Int left_leading, SANE_Int start_pos)
+{
+ SANE_Int ret = OK;
+
+ DBG (DBG_FNC, "+ Refs_Save(left_leading=%i, start_pos=%i)\n", left_leading,
+ start_pos);
+
+ /* check if chipset supports accessing eeprom */
+ if ((dev->chipset->capabilities & CAP_EEPROM) != 0)
+ {
+ ret = ERROR;
+
+ if (RTS_EEPROM_WriteWord (dev->usb_handle, 0x6a, left_leading) == OK)
+ {
+ if (RTS_EEPROM_WriteWord (dev->usb_handle, 0x6c, start_pos) == OK)
+ {
+ SANE_Byte data = _B0 (0x5a - (start_pos + left_leading));
+ ret = RTS_EEPROM_WriteByte (dev->usb_handle, 0x6e, data);
+ }
+ }
+ }
+
+ DBG (DBG_FNC, "- Refs_Save: %i\n", ret);
+
+ return ret;
+}
+
+static SANE_Int
+Calib_AdcOffsetRT (struct st_device *dev,
+ struct st_calibration_config *calibcfg, SANE_Int value)
+{
+/*
+05EFF8E4 04F10738 |Arg1 = 04F10738
+05EFF8E8 05EFF90C |Arg2 = 05EFF90C calibcfg
+05EFF8EC 00000001 \Arg3 = 00000001 value
+*/
+ SANE_Byte Regs[RT_BUFFER_LEN]; /*f1c4 */
+ SANE_Int channels_per_dot; /*f108 */
+ struct st_scanparams scancfg; /*f18c */
+ SANE_Int *pedcg; /*f114 */
+ SANE_Int *podcg; /*f118 */
+ SANE_Int *poffseteven; /*f130 */
+ SANE_Int *poffsetodd; /*f128 */
+ SANE_Int channel;
+ SANE_Int avgtarget[3]; /*f1b8 f1bc f1c0 */
+ SANE_Byte *scanbuffer; /*f0f8 */
+ SANE_Int scan_options; /*f12c */
+ SANE_Int highresolution; /*f144 */
+ double dbValues[3] = { 0, 0, 0 }; /*f148 f14c f150 */
+ SANE_Int do_loop; /*f0ec */
+ SANE_Int gainmode;
+ SANE_Byte *ptr; /*f0f4 */
+ SANE_Byte *mvgag; /*f0e4 *//*f10c */
+ USHORT wvalues[9]; /*0856 0858 085a 085c 085e 0860 0862 0864 0866 */
+ SANE_Int imgcount = 0;
+ /* myoffsetnpixel = f120 */
+ /* desp f0e8 & f140 */
+
+ DBG (DBG_FNC, "+ Calib_AdcOffsetRT(*calibcfg, value=%i)\n", value);
+
+ memcpy (&Regs, &calibdata->Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+ memcpy (&scancfg, &calibdata->scancfg, sizeof (struct st_scanparams));
+
+ channels_per_dot = (calibdata->scancfg.colormode == CM_COLOR) ? 3 : 1;
+
+ if (value != 0)
+ {
+ pedcg = &calibdata->gain_offset.edcg1[CL_RED];
+ podcg = &calibdata->gain_offset.odcg1[CL_RED];
+ poffseteven = &calibcfg->OffsetEven1[CL_RED];
+ poffsetodd = &calibcfg->OffsetOdd1[CL_RED];
+ }
+ else
+ {
+ /*c37c */
+ pedcg = &calibdata->gain_offset.edcg2[CL_RED];
+ podcg = &calibdata->gain_offset.odcg2[CL_RED];
+ poffseteven = &calibcfg->OffsetEven2[CL_RED];
+ poffsetodd = &calibcfg->OffsetOdd2[CL_RED];
+ }
+
+ /*c3a4 */
+ scancfg.coord.left = calibcfg->OffsetPixelStart;
+
+ if (channels_per_dot > 0)
+ {
+ for (channel = 0; channel < channels_per_dot; channel++)
+ {
+ avgtarget[channel] = calibcfg->OffsetAvgTarget[channel] << 8;
+ if (avgtarget[channel] == 0)
+ avgtarget[channel] = 0x80;
+ }
+ }
+
+ /* set image coordinates to scan */
+ scancfg.coord.width = calibcfg->OffsetNPixel;
+ if ((scancfg.coord.width & 1) == 0)
+ scancfg.coord.width++;
+
+ scancfg.bytesperline = channels_per_dot * scancfg.coord.width;
+ scancfg.coord.top = 1;
+ scancfg.coord.height = calibcfg->OffsetHeight;
+ scancfg.depth = 8;
+
+ /* allocate memory to store image */
+ scanbuffer =
+ (SANE_Byte *) malloc ((scancfg.bytesperline * calibcfg->OffsetHeight) *
+ sizeof (SANE_Byte));
+ if (scanbuffer == NULL)
+ return ERROR;
+
+ /*42ac477 */
+ scan_options = (linedarlampoff == 1) ? 1 : 0x101;
+ highresolution = (scancfg.sensorresolution >= 1200) ? TRUE : FALSE;
+
+ do
+ {
+ if (channels_per_dot > 0)
+ {
+ for (channel = 0; channel < channels_per_dot; channel++)
+ dbValues[channel] =
+ (40 / (44 - calibdata->gain_offset.vgag2[channel])) * (40 /
+ (44 -
+ calibdata->
+ gain_offset.
+ vgag1
+ [channel]));
+ }
+
+ /*429c50f */
+ /* Get Image */
+ gainmode = Lamp_GetGainMode (dev, scancfg.resolution_x, scan.scantype);
+ if (RTS_GetImage
+ (dev, Regs, &scancfg, &calibdata->gain_offset, scanbuffer, 0,
+ scan_options, gainmode) != OK)
+ {
+ free (scanbuffer);
+ return ERROR;
+ }
+
+ /*429c55f */
+ /* Save retrieved image */
+ if (RTS_Debug->SaveCalibFile != FALSE)
+ {
+ char fname[30];
+
+ imgcount++;
+ if (snprintf (fname, 30, "adcoffset_rt%i.tiff", imgcount) > 0)
+ dbg_tiff_save (fname,
+ scancfg.coord.width,
+ scancfg.coord.height,
+ scancfg.depth,
+ CM_COLOR,
+ scancfg.resolution_x,
+ scancfg.resolution_y,
+ scanbuffer,
+ scancfg.bytesperline * calibcfg->OffsetHeight);
+ }
+
+ /*429c5a5 */
+ do_loop = FALSE;
+
+ if (highresolution == TRUE)
+ {
+ /* f0fc = f0e4 = channel */
+ SANE_Int lf104;
+ SANE_Int *mydcg; /*f0f4 */
+ USHORT *mywvalue; /*ebp */
+
+ SANE_Byte is_ready[6]; /*f174 f178 f17c f180 f184 f18c */
+ SANE_Byte *ptr_ready; /*f11c */
+ SANE_Int colour;
+
+ for (channel = 0; channel < 6; channel++)
+ is_ready[channel] = FALSE;
+
+ if (channels_per_dot <= 0)
+ break;
+
+ ptr = scanbuffer;
+ mvgag = (SANE_Byte *) calibdata->gain_offset.vgag1;
+
+ for (channel = 0; channel < channels_per_dot; channel++)
+ {
+ for (lf104 = 0; lf104 < 2; lf104++)
+ {
+ if (lf104 == 0)
+ {
+ mywvalue = &wvalues[channel];
+ mydcg = pedcg;
+ ptr_ready = &is_ready[0];
+ }
+ else
+ {
+ /*1645 */
+ mywvalue = &wvalues[3];
+ mydcg = podcg;
+ ptr_ready = &is_ready[3];
+ }
+
+ /*1658 */
+ if (ptr_ready[channel] == FALSE)
+ {
+ colour = 0;
+ if (lf104 < calibcfg->OffsetNPixel)
+ {
+ SANE_Int dot;
+
+ for (dot = 0;
+ dot < (calibcfg->OffsetNPixel - lf104 + 1) / 2;
+ dot++)
+ colour +=
+ scanbuffer[mvgag[(lf104 * channels_per_dot)] +
+ (dot * (channels_per_dot * 2))];
+ }
+
+ /*c6b2 */
+ colour = colour << 8;
+ if (colour == 0)
+ {
+ /*c6b9 */
+ if (mydcg[channel] != 0x1ff)
+ {
+ /*c6d5 */
+ mydcg[channel] = 0x1ff;
+ do_loop = TRUE;
+ }
+ else
+ ptr_ready[channel] = TRUE;
+ }
+ else
+ {
+ SANE_Int myesi;
+ SANE_Int d;
+
+ /*c6e8 */
+ if (*mywvalue == 0)
+ mywvalue += 2;
+
+ colour /= (calibcfg->OffsetNPixel / 2);
+ if (colour >= avgtarget[channel])
+ {
+ colour -= avgtarget[channel];
+ myesi = 0;
+ }
+ else
+ {
+ colour = avgtarget[channel] - colour;
+ myesi = 1;
+ }
+
+ d = mydcg[channel];
+ if (d < 0x100)
+ d = 0xff - d;
+
+ if (myesi != 0)
+ {
+ /*c76e */
+ if ((d + colour) > 0x1ff)
+ {
+ if (*mvgag > 0)
+ {
+ *mvgag = *mvgag - 1;
+ do_loop = TRUE;
+ }
+ else
+ ptr_ready[channel] = TRUE; /*c7a0 */
+ }
+ else
+ d += colour;
+ }
+ else
+ {
+ /*c7ad */
+ if (colour > d)
+ {
+ if (*mvgag > 0)
+ {
+ *mvgag = *mvgag - 1;
+ do_loop = TRUE;
+ }
+ else
+ ptr_ready[channel] = TRUE;
+ }
+ else
+ d -= colour;
+ }
+
+ /*c7dd */
+ mydcg[channel] = (d < 0x100) ? 0x100 - d : d;
+ }
+
+ dbg_calibtable (&calibdata->gain_offset);
+ }
+ }
+
+ /*c804 */
+ mvgag++;
+ }
+ }
+ else
+ {
+ /* Low resolution */
+
+ SANE_Byte is_ready[3];
+ SANE_Int colour;
+
+ /*429c845 */
+ for (channel = 0; channel < channels_per_dot; channel++)
+ is_ready[channel] = FALSE;
+
+ if (channels_per_dot <= 0)
+ break;
+
+ ptr = scanbuffer;
+ mvgag = (SANE_Byte *) calibdata->gain_offset.vgag1;
+
+ for (channel = 0; channel < channels_per_dot; channel++)
+ {
+ if (is_ready[channel] == FALSE)
+ {
+ colour = 0;
+ if (calibcfg->OffsetNPixel > 0)
+ {
+ SANE_Int dot;
+
+ /* Take one channel colour values from offsetnpixel pixels */
+ for (dot = 0; dot < calibcfg->OffsetNPixel; dot++)
+ colour += *(ptr + (dot * channels_per_dot));
+ }
+
+ colour <<= 8;
+ if (colour == 0)
+ {
+ if (pedcg[channel] != 0x1ff)
+ {
+ do_loop = TRUE;
+ podcg[channel] = 0x1ff;
+ pedcg[channel] = 0x1ff;
+ }
+ else
+ is_ready[channel] = TRUE;
+ }
+ else
+ {
+ /*c8f7 */
+ SANE_Int myesi;
+ SANE_Int op1, op2, op3;
+
+ /* Get colour average */
+ colour /= calibcfg->OffsetNPixel;
+
+ /* get absolute difference with avgtarget */
+ myesi = (colour > avgtarget[channel]) ? 0 : 1;
+ colour = abs (avgtarget[channel] - colour);
+
+ if (scancfg.resolution_x > 600)
+ {
+ /*c923 */
+ if (wvalues[channel + 3] == 0)
+ wvalues[channel + 3]++;
+
+ if (wvalues[channel] == 0)
+ wvalues[channel]++;
+
+ op3 = max (wvalues[channel], wvalues[channel + 3]);
+ }
+ else
+ {
+ if (wvalues[channel + 6] == 0)
+ wvalues[channel + 6]++;
+
+ op3 = wvalues[channel + 6];
+ }
+
+ /*c9d3 */
+ op1 = (SANE_Int) (colour / (dbValues[channel] * op3));
+ op2 =
+ (pedcg[channel] <
+ 0x100) ? pedcg[channel] - 0xff : pedcg[channel];
+
+ if (myesi != 0)
+ {
+ /*c9f5 */
+ if (((op2 + op1) & 0xffff) > 0x1ff)
+ {
+ if (*mvgag != 0)
+ {
+ do_loop = TRUE;
+ *mvgag = *mvgag - 1;
+ }
+ else
+ is_ready[channel] = TRUE;
+ }
+ else
+ op2 += op1;
+ }
+ else
+ {
+ /*ca31 */
+ if (op1 > op2)
+ {
+ if (*mvgag > 0)
+ {
+ do_loop = TRUE;
+ *mvgag = *mvgag - 1;
+ }
+ else
+ is_ready[channel] = TRUE;
+ }
+ else
+ op2 -= op1;
+ }
+
+ /*ca54 */
+ if (op2 < 0x100)
+ op2 = 0x100 - op2;
+
+ pedcg[channel] = op2;
+ podcg[channel] = op2;
+ }
+ }
+ /*ca6f */
+ ptr++;
+ mvgag++;
+ dbg_calibtable (&calibdata->gain_offset);
+ }
+ }
+ }
+ while (do_loop != FALSE);
+
+ /*429cad1 */
+ for (channel = 0; channel < 3; channel++)
+ {
+ poffseteven[channel] =
+ (pedcg[channel] < 0x100) ? 0xff - pedcg[channel] : pedcg[channel];
+ poffsetodd[channel] =
+ (podcg[channel] < 0x100) ? 0xff - podcg[channel] : podcg[channel];
+ }
+
+ free (scanbuffer);
+
+ return OK;
+}
+
+static void
+Calib_LoadCut (struct st_device *dev, struct st_scanparams *scancfg,
+ SANE_Int scantype, struct st_calibration_config *calibcfg)
+{
+ double mylong; /*ee78 */
+ double mylong2;
+ /**/ SANE_Int channel[3];
+ SANE_Int a;
+
+ cfg_shading_cut_get (dev->sensorcfg->type, scancfg->depth,
+ scancfg->resolution_x, scantype, &channel[0],
+ &channel[1], &channel[2]);
+
+ mylong = 1 << scancfg->depth;
+
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ mylong2 = channel[a];
+ calibcfg->ShadingCut[a] = (mylong * mylong2) * 0.000390625;
+ }
+}
+
+static SANE_Int
+Calib_BWShading (struct st_calibration_config *calibcfg,
+ struct st_calibration *myCalib, SANE_Int gainmode)
+{
+ /*
+ 0603F8E4 0603F90C |Arg1 = 0603F90C calibcfg
+ 0603F8E8 0603FAAC |Arg2 = 0603FAAC myCalib
+ 0603F8EC 00000001 \Arg3 = 00000001 gainmode
+ */
+
+ /*falta codigo */
+
+ /*silence gcc */
+ calibcfg = calibcfg;
+ myCalib = myCalib;
+ gainmode = gainmode;
+
+ return OK;
+}
+
+static SANE_Int
+Calib_WhiteShading_3 (struct st_device *dev,
+ struct st_calibration_config *calibcfg,
+ struct st_calibration *myCalib, SANE_Int gainmode)
+{
+/*
+05EDF8E0 04F00738 |Arg1 = 04F00738
+05EDF8E4 05EDF90C |Arg2 = 05EDF90C calibcfg
+05EDF8E8 05EDFAAC |Arg3 = 05EDFAAC myCalib
+05EDF8EC 00000001 \Arg4 = 00000001 gainmode
+*/
+ SANE_Byte *myRegs; /*f1bc */
+ struct st_scanparams scancfg; /*f170 */
+ SANE_Int myWidth; /*f14c */
+ SANE_Int lf168, bytes_per_pixel;
+ SANE_Int bytes_per_line;
+ /**/ SANE_Int a;
+ double lf1a4[3];
+ SANE_Int otherheight; /*f150 */
+ SANE_Int otherheight2;
+ SANE_Int lf12c;
+ SANE_Int lf130;
+ double *buffer1; /*f138 */
+ double *buffer2; /*f144 */
+ SANE_Byte *scanbuffer; /*f164 */
+ SANE_Byte *ptr; /*f148 */
+ SANE_Int position; /*f140 */
+ SANE_Int lf13c, myHeight;
+ SANE_Int myESI, myEDI;
+ SANE_Int channel; /*f134 */
+ double myst;
+ double sumatorio;
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "> Calib_WhiteShading3(*calibcfg, *myCalib, gainmode=%i)\n",
+ gainmode);
+
+ myRegs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
+ memcpy (myRegs, &calibdata->Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+ memcpy (&scancfg, &calibdata->scancfg, sizeof (struct st_scanparams));
+
+ Lamp_SetGainMode (dev, myRegs, scancfg.resolution_x, gainmode);
+
+ rst = OK;
+ scancfg.resolution_y = 200;
+ switch (scan.scantype)
+ {
+ case ST_NORMAL:
+ /*a184 */
+ scancfg.coord.left += scan.ser;
+ scancfg.coord.width &= 0xffff;
+ break;
+ case ST_TA:
+ case ST_NEG:
+ scancfg.coord.left += scan.ser;
+ break;
+ }
+
+ /*a11b */
+ if ((scancfg.coord.width & 1) != 0)
+ scancfg.coord.width++;
+
+ scancfg.coord.top = 1;
+ scancfg.coord.height = calibcfg->WShadingHeight;
+
+ switch (scancfg.colormode)
+ {
+ case CM_GRAY:
+ case CM_LINEART:
+ myWidth = scancfg.coord.width;
+ lf168 = 0;
+ bytes_per_line = ((scancfg.depth + 7) / 8) * myWidth;
+ bytes_per_pixel = 1;
+ break;
+ default: /* CM_COLOR */
+ myWidth = scancfg.coord.width * 3;
+ bytes_per_line = ((scancfg.depth + 7) / 8) * myWidth;
+ lf168 = (scancfg.samplerate == LINE_RATE) ? scancfg.coord.width : 1;
+ bytes_per_pixel = (scancfg.samplerate == PIXEL_RATE) ? 3 : 1;
+ break;
+ }
+
+ /*a1e8 */
+ scancfg.v157c = bytes_per_line;
+ scancfg.bytesperline = bytes_per_line;
+
+ for (a = 0; a < 3; a++)
+ lf1a4[a] = (calibcfg->WRef[a] * (1 << scancfg.depth)) >> 8;
+
+ /* debug this code because if it's correct, lf130 and lf12c are always 2 */
+ otherheight = calibcfg->WShadingHeight - 3;
+ otherheight -= (otherheight - 4);
+ otherheight2 = otherheight / 2;
+ otherheight -= otherheight2;
+ lf130 = otherheight2;
+ lf12c = otherheight;
+
+ buffer1 = (double *) malloc (otherheight * sizeof (double));
+ if (buffer1 == NULL)
+ return ERROR;
+
+ buffer2 = (double *) malloc (otherheight * sizeof (double));
+ if (buffer2 == NULL)
+ {
+ free (buffer1);
+ return ERROR;
+ }
+
+ scanbuffer =
+ (SANE_Byte *) malloc (((scancfg.coord.height + 16) * bytes_per_line) *
+ sizeof (SANE_Byte));
+ if (scanbuffer == NULL)
+ {
+ free (buffer1);
+ free (buffer2);
+ return ERROR;
+ }
+
+ /* Scan image */
+ myCalib->shading_enabled = FALSE;
+ rst =
+ RTS_GetImage (dev, myRegs, &scancfg, &calibdata->gain_offset, scanbuffer,
+ myCalib, 0x20000080, gainmode);
+
+ for (a = 0; a < 3; a++)
+ myCalib->WRef[a] *= ((1 << scancfg.depth) >> 8);
+
+ if (rst == ERROR)
+ {
+ free (buffer1);
+ free (buffer2);
+ free (scanbuffer);
+ return ERROR;
+ }
+
+ if (scancfg.depth > 8)
+ {
+ /*a6d9 */
+ position = 0;
+ sumatorio = 0;
+ if (myWidth > 0)
+ {
+ do
+ {
+ switch (scancfg.colormode)
+ {
+ case CM_GRAY:
+ case CM_LINEART:
+ channel = 0;
+ lf13c = position;
+ break;
+ default: /*CM_COLOR */
+ if (scancfg.samplerate == PIXEL_RATE)
+ {
+ /* pixel rate */
+ channel = position % bytes_per_pixel;
+ lf13c = position / bytes_per_pixel;
+ }
+ else
+ {
+ /* line rate */
+ channel = position / lf168;
+ lf13c = position % lf168;
+ }
+ break;
+ }
+
+ /*a743 */
+ if (lf130 > 0)
+ bzero (buffer1, lf130 * sizeof (double));
+
+ /*a761 */
+ if (lf12c > 0)
+ {
+ for (a = 0; a < lf12c; a++)
+ buffer2[a] = (1 << scancfg.depth) - 1.0;
+ }
+
+ /*a78f */
+ myESI = 0;
+ myEDI = 0;
+ ptr = scanbuffer + (position * 2);
+ myHeight = 0;
+
+ if (otherheight > 0)
+ {
+ do
+ {
+ myst = 0;
+ for (a = 0; a < 4; a++)
+ myst += data_lsb_get (ptr + (a * (myWidth * 2)), 2);
+
+ myEDI = 0;
+ myst = myst * 0.25;
+ if (myHeight < (otherheight - 4))
+ {
+ if (myst < buffer2[myESI])
+ {
+ buffer2[myESI] = myst;
+ if (lf12c > 0)
+ {
+ for (a = 0; a < lf12c; a++)
+ if (buffer2[myESI] < buffer2[a])
+ myESI = a;
+ }
+ }
+
+ /*a820 */
+ if (myst >= buffer1[myEDI])
+ {
+ buffer1[myEDI] = myst;
+ if (lf130 > 0)
+ {
+ for (a = 0; a < lf130; a++)
+ if (buffer1[myEDI] >= buffer1[a])
+ myEDI = a;
+ }
+ }
+ sumatorio += myst;
+ }
+ else
+ {
+ /*a853 */
+ if (myHeight == (otherheight - 4))
+ {
+ if (lf12c > 0)
+ {
+ for (a = 0; a < lf12c; a++)
+ if (buffer2[myESI] >= buffer2[a])
+ myESI = a;
+ }
+
+ if (lf130 > 0)
+ {
+ for (a = 0; a < lf130; a++)
+ if (buffer1[myEDI] < buffer1[a])
+ myEDI = a;
+ }
+ }
+
+ /*a895 */
+ if (myst >= buffer2[myESI])
+ {
+ /*a89c */
+ sumatorio -= buffer2[myESI];
+ sumatorio += myst;
+ buffer2[myESI] = myst;
+ if (lf12c > 0)
+ {
+ for (a = 0; a < lf12c; a++)
+ if (buffer2[myESI] >= buffer2[a])
+ myESI = a;
+ }
+ }
+ else
+ {
+ if (myst < buffer1[myEDI])
+ {
+ sumatorio -= buffer1[myEDI];
+ sumatorio += myst;
+ buffer1[myEDI] = myst;
+
+ if (lf130 > 0)
+ {
+ for (a = 0; a < lf130; a++)
+ if (buffer1[myEDI] < buffer1[a])
+ myEDI = a;
+ }
+ }
+ }
+ }
+
+ /*a901 */
+ ptr += (myWidth * 2);
+ myHeight++;
+ }
+ while (myHeight < otherheight);
+ }
+
+ /*a924 */
+ scancfg.ser = 0;
+ scancfg.startpos = otherheight - 4;
+
+ sumatorio = sumatorio / scancfg.startpos;
+ if (myCalib->shading_enabled != FALSE)
+ {
+ /*a94a */
+ myCalib->white_shading[channel][lf13c] =
+ (unsigned short) sumatorio;
+ }
+ else
+ {
+ /*a967 */
+ if ((scancfg.colormode != CM_GRAY)
+ && (scancfg.colormode != CM_LINEART))
+ sumatorio /= lf1a4[channel];
+ else
+ sumatorio /= lf1a4[scancfg.channel];
+
+ sumatorio = min (sumatorio * 0x4000, 65535);
+
+ if (myRegs[0x1bf] != 0x18)
+ myCalib->black_shading[channel][lf13c] |=
+ (0x140 -
+ ((((myRegs[0x1bf] >> 3) & 3) *
+ 3) << 6)) & ((int) sumatorio);
+ else
+ myCalib->white_shading[channel][lf13c] =
+ (unsigned short) sumatorio;
+ }
+
+ /*a9fd */
+ position++;
+ }
+ while (position < myWidth);
+ }
+ }
+ else
+ {
+ /*a6d9 */
+ position = 0;
+ sumatorio = 0;
+ if (myWidth > 0)
+ {
+ do
+ {
+ switch (scancfg.colormode)
+ {
+ case CM_GRAY:
+ case CM_LINEART:
+ channel = 0;
+ lf13c = position;
+ break;
+ default: /*CM_COLOR */
+ if (scancfg.samplerate == PIXEL_RATE)
+ {
+ channel = position % bytes_per_pixel;
+ lf13c = position / bytes_per_pixel;
+ }
+ else
+ {
+ channel = position / lf168;
+ lf13c = position % lf168;
+ }
+ break;
+ }
+
+ /*a743 */
+ if (lf130 > 0)
+ bzero (buffer1, lf130 * sizeof (double));
+
+ /*a761 */
+ if (lf12c > 0)
+ {
+ for (a = 0; a < lf12c; a++)
+ buffer2[a] = (1 << scancfg.depth) - 1.0;
+ }
+
+ /*a78f */
+ myESI = 0;
+ myEDI = 0;
+ ptr = scanbuffer + position;
+ myHeight = 0;
+
+ if (otherheight > 0)
+ {
+ do
+ {
+ myst = 0;
+ for (a = 0; a < 4; a++)
+ myst += *(ptr + (a * myWidth));
+
+ myEDI = 0;
+ myst *= 0.25;
+ if (myHeight < (otherheight - 4))
+ {
+ if (myst < buffer2[myESI])
+ {
+ buffer2[myESI] = myst;
+ if (lf12c > 0)
+ {
+ for (a = 0; a < lf12c; a++)
+ if (buffer2[myESI] < buffer2[a])
+ myESI = a;
+ }
+ }
+ /*a820 */
+ if (myst >= buffer1[myEDI])
+ {
+ buffer1[myEDI] = myst;
+ if (lf130 > 0)
+ {
+ for (a = 0; a < lf130; a++)
+ if (buffer1[myEDI] >= buffer1[a])
+ myEDI = a;
+ }
+ }
+ sumatorio += myst;
+ }
+ else
+ {
+ /*a853 */
+ if (myHeight == (otherheight - 4))
+ {
+ if (lf12c > 0)
+ {
+ for (a = 0; a < lf12c; a++)
+ if (buffer2[myESI] >= buffer2[a])
+ myESI = a;
+ }
+
+ if (lf130 > 0)
+ {
+ for (a = 0; a < lf130; a++)
+ if (buffer1[myEDI] < buffer1[a])
+ myEDI = a;
+ }
+ }
+
+ /*a895 */
+ if (myst >= buffer2[myESI])
+ {
+ /*a89c */
+ sumatorio -= buffer2[myESI];
+ sumatorio += myst;
+ buffer2[myESI] = myst;
+ if (lf12c > 0)
+ {
+ for (a = 0; a < lf12c; a++)
+ if (buffer2[myESI] >= buffer2[a])
+ myESI = a;
+ }
+ }
+ else
+ {
+ if (myst < buffer1[myEDI])
+ {
+ sumatorio -= buffer1[myEDI];
+ sumatorio += myst;
+ buffer1[myEDI] = myst;
+
+ if (lf130 > 0)
+ {
+ for (a = 0; a < lf130; a++)
+ if (buffer1[myEDI] < buffer1[a])
+ myEDI = a;
+ }
+ }
+ }
+ }
+ /*a901 */
+ ptr += myWidth;
+ myHeight++;
+ }
+ while (myHeight < otherheight);
+ }
+ /*a924 */
+ scancfg.ser = 0;
+ scancfg.startpos = otherheight - 4;
+
+ sumatorio /= scancfg.startpos;
+ if (myCalib->shading_enabled != FALSE)
+ {
+ /*a94a */
+ myCalib->white_shading[channel][lf13c] =
+ (unsigned short) sumatorio;
+ }
+ else
+ {
+ /*a967 */
+ if ((scancfg.colormode != CM_GRAY)
+ && (scancfg.colormode != CM_LINEART))
+ sumatorio /= lf1a4[channel];
+ else
+ sumatorio /= lf1a4[scancfg.channel];
+
+ sumatorio = min (sumatorio * 0x4000, 65535);
+
+ if (myRegs[0x1bf] != 0x18)
+ myCalib->black_shading[channel][lf13c] |=
+ (0x140 -
+ ((((myRegs[0x1bf] >> 3) & 0x03) *
+ 3) << 6)) & ((int) sumatorio);
+ else
+ myCalib->white_shading[channel][lf13c] =
+ (unsigned short) sumatorio;
+ }
+ /*a9fd */
+ position++;
+ }
+ while (position < myWidth);
+ }
+ }
+
+ /*aa12 */
+ if (RTS_Debug->SaveCalibFile != FALSE)
+ {
+ dbg_tiff_save ("whiteshading3.tiff",
+ scancfg.coord.width,
+ scancfg.coord.height,
+ scancfg.depth,
+ CM_COLOR,
+ scancfg.resolution_x,
+ scancfg.resolution_y,
+ scanbuffer,
+ (scancfg.coord.height + 16) * bytes_per_line);
+ }
+
+ free (buffer1);
+ free (buffer2);
+ free (scanbuffer);
+
+ return OK;
+}
+
+static SANE_Int
+Calib_BlackShading (struct st_device *dev,
+ struct st_calibration_config *calibcfg,
+ struct st_calibration *myCalib, SANE_Int gainmode)
+{
+ /*
+ gainmode f8ec
+ myCalib f8e8
+ calibcfg f8e4
+ */
+ SANE_Byte *myRegs; /*f1bc */
+ struct st_scanparams scancfg; /*f020 */
+ double shadingprediff[6]; /*f08c f094 f09c f0a4 f0ac f0b4 */
+ double mylong; /*f018 */
+ double maxvalue; /*eff8 */
+ double sumatorio = 0.0;
+ double myst;
+ SANE_Int rst;
+ SANE_Int a;
+ SANE_Int mheight; /*efe0 */
+ SANE_Int current_line; /*efe4 */
+ SANE_Int bytes_per_line; /*efd8 */
+ SANE_Int position; /*lefcc */
+ SANE_Int leff0, lf010, lefd0;
+ SANE_Byte *buffer; /*efd4 */
+ SANE_Byte buff2[256]; /*F0BC */
+ SANE_Int buff3[0x8000];
+ SANE_Byte *ptr; /*f008 */
+ SANE_Int my14b4; /*f008 pisa ptr */
+ SANE_Int biggest; /*bx */
+ SANE_Int lowest; /*dx */
+ SANE_Int lefdc;
+ SANE_Int channel;
+ SANE_Int smvalues[3]; /*f04c f04e f050 */
+ double dbvalue[6]; /*lf05c lf060, lf064 lf068, lf06c lf070,
+ lf074 lf078, lf07c lf080, lf084 lf088 */
+
+ DBG (DBG_FNC, "> Calib_BlackShading(*calibcfg, *myCalib, gainmode=%i)\n",
+ gainmode);
+
+ rst = OK;
+ myRegs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
+ memcpy (myRegs, &calibdata->Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+ memcpy (&scancfg, &calibdata->scancfg, sizeof (struct st_scanparams));
+
+ Lamp_SetGainMode (dev, myRegs, scancfg.resolution_x, gainmode);
+
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ shadingprediff[a + 3] = calibcfg->BShadingPreDiff[a];
+
+ if ((scan.scantype >= ST_NORMAL) && (scan.scantype <= ST_NEG))
+ scancfg.coord.left += scan.ser;
+
+ if ((scancfg.coord.width & 1) != 0)
+ scancfg.coord.width++;
+
+ scancfg.coord.top = 1;
+ scancfg.depth = 8;
+ scancfg.coord.height = calibcfg->BShadingHeight;
+
+ if (scancfg.colormode != CM_COLOR)
+ {
+ bytes_per_line = scancfg.coord.width;
+ leff0 = 0;
+ lf010 = 1;
+ }
+ else
+ {
+ /*876c */
+ bytes_per_line = scancfg.coord.width * 3;
+ if (scancfg.samplerate == LINE_RATE)
+ {
+ leff0 = scancfg.coord.width;
+ lf010 = 1;
+ }
+ else
+ {
+ leff0 = 1;
+ lf010 = 3;
+ }
+ }
+
+ scancfg.v157c = bytes_per_line;
+ scancfg.bytesperline = bytes_per_line;
+
+ mylong = 1 << (16 - scancfg.depth);
+ if ((myRegs[0x1bf] & 0x18) != 0)
+ mylong /= 1 << (((myRegs[0x1bf] >> 5) & 3) + 4);
+
+ lefd0 =
+ ((((myRegs[0x1bf] >> 3) & 2) << 8) -
+ ((((myRegs[0x1bf] >> 3) & 1) * 3) << 6)) - 1;
+
+ if (scancfg.depth >= 8)
+ maxvalue = ((1 << (scancfg.depth - 8)) << 8) - 1;
+ else
+ maxvalue = (256 / (1 << (8 - scancfg.depth))) - 1;
+
+ Calib_LoadCut (dev, &scancfg, scan.scantype, calibcfg);
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ shadingprediff[a] = calibcfg->ShadingCut[a];
+
+ if (calibcfg->BShadingOn == -1)
+ {
+ SANE_Int b, d;
+ double e;
+
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ myst = max (shadingprediff[a], 0);
+ myst = (maxvalue >= myst) ? shadingprediff[a] : maxvalue;
+ shadingprediff[a] = max (myst, 0);
+ }
+
+ b = 0;
+
+ while (b < bytes_per_line)
+ {
+ if (scancfg.colormode != CM_COLOR)
+ {
+ channel = 0;
+ d = b;
+ }
+ else
+ {
+ if (scancfg.samplerate == PIXEL_RATE)
+ {
+ channel = (b % lf010) & 0xffff;
+ d = (b / lf010) & 0xffff;
+ }
+ else
+ {
+ channel = (b / leff0) & 0xffff;
+ d = (b % leff0) & 0xffff;
+ }
+ }
+ /*89d0 */
+ e = min (lefd0, mylong * shadingprediff[channel]);
+ myCalib->black_shading[channel][d] |= (unsigned short) e & 0xffff;
+ b++;
+ }
+
+ return OK;
+ }
+
+ /* Allocate buffer to read image */
+ mheight = scancfg.coord.height;
+ buffer =
+ (SANE_Byte *) malloc (((scancfg.coord.height + 16) * bytes_per_line) *
+ sizeof (SANE_Byte));
+ if (buffer == NULL)
+ return ERROR;
+
+ /* Turn off lamp */
+ Lamp_Status_Set (dev, NULL, FALSE, FLB_LAMP);
+ usleep (200 * 1000);
+
+ /* Scan image */
+ myCalib->shading_enabled = FALSE;
+ rst =
+ RTS_GetImage (dev, myRegs, &scancfg, &calibdata->gain_offset, buffer,
+ myCalib, 0x101, gainmode);
+ if (rst == ERROR)
+ {
+ /*8ac2 */
+ free (buffer);
+ memcpy (&calibdata->Regs, myRegs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+ free (myRegs);
+ return ERROR;
+ }
+
+ /* myRegs isn't going to be used anymore */
+ free (myRegs);
+ myRegs = NULL;
+
+ /* Turn on lamp again */
+ if (scan.scantype != ST_NORMAL)
+ {
+ Lamp_Status_Set (dev, NULL, FALSE, TMA_LAMP);
+ usleep (1000 * 1000);
+ }
+ else
+ Lamp_Status_Set (dev, NULL, TRUE, FLB_LAMP);
+
+ /* Save buffer */
+ if (RTS_Debug->SaveCalibFile != FALSE)
+ {
+ dbg_tiff_save ("blackshading.tiff",
+ scancfg.coord.width,
+ scancfg.coord.height,
+ scancfg.depth,
+ CM_COLOR,
+ scancfg.resolution_x,
+ scancfg.resolution_y,
+ buffer, (scancfg.coord.height + 16) * bytes_per_line);
+ }
+
+ if (scancfg.depth > 8)
+ {
+ /*8bb2 */
+ bzero (&dbvalue, 6 * sizeof (double));
+ position = 0;
+
+ if (bytes_per_line > 0)
+ {
+ do
+ {
+ bzero (&buff3, 0x8000 * sizeof (SANE_Int));
+ sumatorio = 0;
+ ptr = buffer + position;
+ current_line = 0;
+ biggest = 0;
+ lowest = (int) maxvalue;
+ /* Toma los valores de una columna */
+ if (mheight > 0)
+ {
+ SANE_Int value;
+ do
+ {
+ value = data_lsb_get (ptr, 2);
+ biggest = max (biggest, value);
+ if (current_line < mheight)
+ {
+ sumatorio += value;
+ lowest = min (lowest, value);
+ biggest = max (biggest, value);
+
+ buff3[value]++;
+ }
+ else
+ {
+ /*8cab */
+ if (value > lowest)
+ {
+ buff3[lowest]--;
+ buff3[value]++;
+ sumatorio += value;
+ sumatorio -= lowest;
+
+ if (buff3[lowest] != 0)
+ {
+ do
+ {
+ lowest++;
+ }
+ while (buff3[lowest] == 0);
+ }
+ }
+ }
+ /*8d0b */
+ ptr += (bytes_per_line * 2);
+ current_line++;
+ }
+ while (current_line < mheight);
+ }
+ /*8d27 */
+ sumatorio /= mheight;
+
+ if (scancfg.colormode != CM_COLOR)
+ {
+ channel = 0;
+ lefdc = position;
+ }
+ else
+ {
+ /*8d5f */
+ if (scancfg.samplerate == PIXEL_RATE)
+ {
+ channel = position % lf010;
+ lefdc = (position / lf010) & 0xffff;
+ }
+ else
+ {
+ channel = position / leff0;
+ lefdc = position % leff0;
+ }
+ }
+
+ dbvalue[channel] += sumatorio;
+ if ((scancfg.colormode == CM_GRAY)
+ || (scancfg.colormode == CM_LINEART))
+ sumatorio += shadingprediff[scancfg.channel];
+ else
+ sumatorio += shadingprediff[channel];
+
+ myst = min (max (0, sumatorio), maxvalue);
+
+ dbvalue[channel + 3] = myst;
+
+ if ((calibcfg->BShadingOn == 1) || (calibcfg->BShadingOn == 2))
+ {
+ if (calibcfg->BShadingOn == 2)
+ {
+ myst -=
+ calibcfg->BRef[channel] * (1 << (scancfg.depth - 8));
+ myst = max (myst, 0);
+ }
+ /*8e6d */
+ myst *= mylong;
+ myCalib->black_shading[channel][lefdc] = min (myst, lefd0);
+ }
+
+ position++;
+ }
+ while (position < bytes_per_line);
+ }
+ }
+ else
+ {
+ /*8eb6 */
+ bzero (&dbvalue, 6 * sizeof (double));
+ position = 0;
+
+ if (bytes_per_line > 0)
+ {
+ do
+ {
+ bzero (&buff2, 256 * sizeof (SANE_Byte));
+ sumatorio = 0;
+ /* ptr points to the next position of the first line */
+ ptr = buffer + position;
+ biggest = 0;
+ lowest = (int) maxvalue;
+ current_line = 0;
+ /* Toma los valores de una columna */
+ if (mheight > 0)
+ {
+ my14b4 = v14b4;
+ do
+ {
+ biggest = max (biggest, *ptr);
+
+ if (my14b4 == 0)
+ {
+ /*8fd7 */
+ if (current_line < mheight)
+ {
+ sumatorio += *ptr;
+
+ lowest = min (lowest, *ptr);
+ biggest = max (biggest, *ptr);
+
+ buff2[*ptr]++;
+ }
+ else
+ {
+ /*9011 */
+ if (*ptr > lowest)
+ {
+ buff2[lowest]--;
+ buff2[*ptr]++;
+ sumatorio += *ptr;
+ sumatorio -= lowest;
+
+ if (buff2[lowest] != 0)
+ {
+ do
+ {
+ lowest++;
+ }
+ while (buff2[lowest] == 0);
+ }
+ }
+ }
+ }
+ else
+ sumatorio += *ptr;
+ /*9067 */
+ /* Point to the next pixel under current line */
+ ptr += bytes_per_line;
+ current_line++;
+ }
+ while (current_line < mheight);
+ }
+
+ /*908a */
+ /* Calculates average of each column */
+ sumatorio = sumatorio / mheight;
+
+ if (scancfg.colormode != CM_COLOR)
+ {
+ channel = 0;
+ lefdc = position;
+ }
+ else
+ {
+ /*90c5 */
+ if (scancfg.samplerate == PIXEL_RATE)
+ {
+ channel = position % lf010;
+ lefdc = (position / lf010) & 0xffff;
+ }
+ else
+ {
+ /*90fb */
+ channel = position / leff0;
+ lefdc = position % leff0;
+ }
+ }
+
+ /*911f */
+ dbvalue[channel] += sumatorio;
+ if ((scancfg.colormode == CM_GRAY)
+ || (scancfg.colormode == CM_LINEART))
+ sumatorio += shadingprediff[scancfg.channel];
+ else
+ sumatorio += shadingprediff[channel];
+
+ /*9151 */
+ myst = min (max (0, sumatorio), maxvalue);
+
+ /*9198 */
+ if (position >= 3)
+ {
+ double myst2;
+
+ myst -= dbvalue[channel + 3];
+ myst2 = myst;
+ myst = min (myst, shadingprediff[channel + 3]);
+
+ my14b4 = -shadingprediff[channel + 3];
+ if (myst >= my14b4)
+ myst = min (myst2, shadingprediff[channel + 3]);
+ else
+ myst = my14b4;
+
+ myst += dbvalue[channel + 3];
+ }
+
+ /*9203 */
+ dbvalue[channel + 3] = myst;
+
+ switch (calibcfg->BShadingOn)
+ {
+ case 1:
+ myCalib->black_shading[channel][lefdc] |=
+ (unsigned short) (((int) myst & 0xff) << 8) & 0xffff;
+ break;
+ case 2:
+ /*9268 */
+ my14b4 =
+ calibcfg->BRef[channel] / (1 << (8 - scancfg.depth));
+ myst -= my14b4;
+ myst = max (myst, 0);
+ myst *= mylong;
+ myCalib->black_shading[channel][lefdc] = min (myst, lefd0);
+ break;
+ }
+
+ /*92d8 */
+ position++;
+ }
+ while (position < bytes_per_line);
+ }
+ }
+
+ /*9306 */
+ if (calibcfg->BShadingOn == -2)
+ {
+ for (a = 0; a < 3; a++)
+ {
+ dbvalue[a] =
+ (dbvalue[a] / scancfg.coord.width) + calibcfg->ShadingCut[a];
+ if (dbvalue[a] < 0)
+ dbvalue[a] = 0;
+ smvalues[a] = min ((int) (dbvalue[a] + 0.5) & 0xffff, maxvalue);
+ }
+
+ if (scancfg.coord.width > 0)
+ {
+ SANE_Int b, c;
+
+ for (c = 0; c < scancfg.coord.width; c++)
+ for (b = 0; b < 3; b++)
+ myCalib->black_shading[b][c] |=
+ (unsigned short) min (smvalues[b] * mylong, lefd0);
+ }
+ }
+ /*9425 */
+ free (buffer);
+
+ return OK;
+}
+
+static SANE_Int
+Calibration (struct st_device *dev, SANE_Byte * Regs,
+ struct st_scanparams *scancfg, struct st_calibration *myCalib,
+ SANE_Int value)
+{
+ /*//SANE_Int Calibration([fa20]char *Regs, [fa24]struct st_scanparams *scancfg, [fa28]struct st_calibration myCalib, [fa2c]SANE_Int value)
+ */
+
+ struct st_calibration_config calibcfg; /* f90c */
+ SANE_Int a;
+ SANE_Byte gainmode;
+ SANE_Int lf900;
+
+ DBG (DBG_FNC, "> Calibration\n");
+ dbg_ScanParams (scancfg);
+
+ value = value; /*silence gcc */
+
+ memcpy (&calibdata->Regs, Regs, sizeof (SANE_Byte) * RT_BUFFER_LEN);
+
+ /*4213be8 */
+ memset (&calibcfg, 0x30, sizeof (struct st_calibration_config));
+ Calib_LoadConfig (dev, &calibcfg, scan.scantype, scancfg->resolution_x,
+ scancfg->depth);
+
+ bzero (&calibdata->gain_offset, sizeof (struct st_gain_offset)); /*[42b3654] */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ myCalib->WRef[a] = calibcfg.WRef[a];
+
+ calibdata->gain_offset.edcg1[a] = 256;
+ calibdata->gain_offset.odcg1[a] = 256;
+ calibdata->gain_offset.vgag1[a] = 4;
+ calibdata->gain_offset.vgag2[a] = 4;
+
+ /*3654|3656|3658
+ 365a|365c|365e
+ 3660|3662|3664
+ 3666|3668|366a
+ 366c|366d|366e
+ 366f|3670|3671
+ 3672|3673|3674 */
+ }
+
+ memcpy (&calibdata->scancfg, scancfg, sizeof (struct st_scanparams));
+ gainmode = Lamp_GetGainMode (dev, scancfg->resolution_x, scan.scantype); /* [lf904] = 1 */
+
+ /* 3cf3 */
+ myCalib->first_position = 1;
+ myCalib->shading_type = 0;
+ if (calibdata->scancfg.colormode == CM_LINEART)
+ {
+ calibdata->scancfg.colormode = CM_GRAY;
+ calibcfg.GainTargetFactor = 1.3;
+ }
+
+ lf900 = OK;
+ if (calibcfg.CalibPAGOn != 0)
+ {
+ if (Calib_PAGain (dev, &calibcfg, gainmode) != 0)
+ lf900 = ERROR;
+ /*ERROR*/}
+ else
+ {
+ /*3da7 */
+ if ((calibdata->scancfg.colormode != CM_GRAY)
+ && (calibdata->scancfg.colormode != CM_LINEART))
+ {
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ calibdata->gain_offset.pag[a] = calibcfg.PAG[a];
+ }
+ else
+ {
+ /* 3dd3 */
+ /* Default PAGain */
+ if (calibdata->scancfg.channel > 2)
+ calibdata->scancfg.channel = 0;
+
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ calibdata->gain_offset.pag[a] =
+ calibcfg.PAG[calibdata->scancfg.channel];
+ }
+ }
+
+ /* 3e01 */
+ if (calibcfg.CalibOffset10n != 0) /*==2*/
+ {
+ /*v14b4=1 offset[CL_RED]=0x174 offset[CL_GREEN]=0x16d offset[CL_BLUE]=0x160 */
+ if ((v14b4 != 0) && (offset[CL_RED] != 0) && (offset[CL_GREEN] != 0)
+ && (offset[CL_BLUE] != 0))
+ {
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ calibdata->gain_offset.edcg1[a] = offset[a];
+ calibdata->gain_offset.odcg1[a] = offset[a];
+ }
+ }
+ else
+ {
+ /* 3e84 */
+ if ((calibcfg.CalibOffset10n > 0) && (calibcfg.CalibOffset10n < 4))
+ {
+ /*if (calibcfg.CalibOffset10n != 0) */
+ if (calibcfg.CalibOffset10n == 3)
+ {
+ lf900 = Calib_AdcOffsetRT (dev, &calibcfg, 1);
+ }
+ else
+ {
+ /* 3eb2 */
+ /*falta codigo */
+ }
+ }
+ }
+ }
+ else
+ {
+ /* 3faf */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ calibdata->gain_offset.edcg1[a] =
+ abs (calibcfg.OffsetEven1[a] - 0x100);
+ calibdata->gain_offset.odcg1[a] =
+ abs (calibcfg.OffsetOdd1[a] - 0x100);
+ }
+ }
+
+ /* 3f13 3f0b */
+ if ((gainmode != 0) && (calibcfg.CalibGain10n != 0))
+ {
+ /*gain[CL_RED]=0x17 gain[CL_GREEN]=0x12 gain[CL_BLUE]=0x17 */
+ if ((v14b4 != 0) && (gain[CL_RED] != 0) && (gain[CL_GREEN] != 0)
+ && (gain[CL_BLUE] != 0))
+ {
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ calibdata->gain_offset.vgag1[a] = gain[a];
+ }
+ else
+ {
+ /*4025 */
+ lf900 = Calib_AdcGain (dev, &calibcfg, 1, gainmode);
+
+ if ((v14b4 != 0) && (lf900 == OK))
+ GainOffset_Save (dev, &calibdata->gain_offset.edcg1[0],
+ &calibdata->gain_offset.vgag1[0]);
+ }
+ }
+ else
+ {
+ /*4089 */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ calibdata->gain_offset.vgag1[a] = calibcfg.Gain1[a];
+ }
+
+ /*40a5 */
+ if ((gainmode != 0) && (calibcfg.CalibOffset20n != 0))
+ {
+ switch (calibcfg.CalibOffset20n)
+ {
+ case 3:
+ lf900 = Calib_AdcOffsetRT (dev, &calibcfg, 2);
+ break;
+ }
+ /*4140 */
+ /*falta codigo */
+ }
+ else
+ {
+ /*4162 */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ {
+ calibdata->gain_offset.edcg2[a] =
+ abs (calibcfg.OffsetEven2[a] - 0x40);
+ calibdata->gain_offset.odcg2[a] =
+ abs (calibcfg.OffsetOdd2[a] - 0x40);
+ }
+ }
+
+ /*41d6 */
+ if ((gainmode != 0) && (calibcfg.CalibGain20n != 0))
+ {
+ lf900 = Calib_AdcGain (dev, &calibcfg, 0, gainmode);
+ }
+ else
+ {
+ /*423c */
+ for (a = CL_RED; a <= CL_BLUE; a++)
+ calibdata->gain_offset.vgag2[a] = calibcfg.Gain2[a];
+ }
+
+ /*4258 */
+ if (calibcfg.TotShading != 0)
+ {
+ lf900 = Calib_BWShading (&calibcfg, myCalib, gainmode);
+ /*falta codigo */
+ }
+ else
+ {
+ /*428f */
+ if (gainmode != 0)
+ {
+ if (calibcfg.BShadingOn != 0)
+ lf900 = Calib_BlackShading (dev, &calibcfg, myCalib, gainmode);
+
+ /*42fd */
+ if ((lf900 != ERROR) && (calibcfg.WShadingOn != 0))
+ {
+ switch (calibcfg.WShadingOn)
+ {
+ default:
+ break;
+ case 3:
+ lf900 =
+ Calib_WhiteShading_3 (dev, &calibcfg, myCalib, gainmode);
+ break;
+ case 2:
+ break;
+ }
+ }
+ else
+ myCalib->shading_enabled = FALSE;
+ }
+ else
+ myCalib->shading_enabled = FALSE;
+ }
+
+ /*43ca */
+ memcpy (&myCalib->gain_offset, &calibdata->gain_offset,
+ sizeof (struct st_gain_offset));
+ memcpy (&mitabla2, &calibdata->gain_offset, sizeof (struct st_gain_offset));
+
+ /*4424 */
+ /* Park home after calibration */
+ if (get_value (SCANINFO, PARKHOMEAFTERCALIB, TRUE, FITCALIBRATE) == FALSE)
+ scan.ler -= calibcfg.WShadingHeight;
+ else
+ Head_ParkHome (dev, TRUE, dev->motorcfg->parkhomemotormove);
+
+ return OK;
+}
+
+/*static void show_diff(struct st_device *dev, SANE_Byte *original)
+{
+ SANE_Byte *buffer = (SANE_Byte *)malloc(RT_BUFFER_LEN * sizeof(SANE_Byte));
+ SANE_Int a;
+
+ if ((buffer == NULL)||(original == NULL))
+ return;
+
+ if (RTS_ReadRegs(dev->usb_handle, buffer) != OK)
+ {
+ free(buffer);
+ return;
+ }
+
+ for (a = 0; a < RT_BUFFER_LEN; a++)
+ {
+ if ((original[a] & 0xff) != (buffer[a] & 0xff))
+ {
+ printf("%5i: %i -> %i\n", a, original[a] & 0xff, buffer[a] & 0xff);
+ original[a] = buffer[a] & 0xff;
+ }
+ }
+
+ free(buffer);
+} */
+
+static SANE_Int
+Load_Constrains (struct st_device *dev)
+{
+ SANE_Int rst = ERROR;
+
+ if (dev->constrains != NULL)
+ Free_Constrains (dev);
+
+ DBG (DBG_FNC, "> Load_Constrains\n");
+
+ dev->constrains =
+ (struct st_constrains *) malloc (sizeof (struct st_constrains));
+ if (dev->constrains != NULL)
+ {
+ cfg_constrains_get (dev->constrains);
+ rst = OK;
+ }
+
+ return rst;
+}
+
+static SANE_Int
+Constrains_Check (struct st_device *dev, SANE_Int Resolution,
+ SANE_Int scantype, struct st_coords *mycoords)
+{
+ /*
+ Constrains:
+ 100 dpi 850 x 1170 | 164 x 327
+ 300 dpi 2550 x 3510
+ 600 dpi 5100 x 7020
+ 1200 dpi 10200 x 14040
+ */
+
+ SANE_Int rst = ERROR;
+
+ if (dev->constrains != NULL)
+ {
+ struct st_coords coords;
+ struct st_coords *mc;
+
+ if ((scantype < ST_NORMAL) || (scantype > ST_NEG))
+ scantype = ST_NORMAL;
+
+ switch (scantype)
+ {
+ case ST_TA:
+ mc = &dev->constrains->slide;
+ break;
+ case ST_NEG:
+ mc = &dev->constrains->negative;
+ break;
+ default:
+ mc = &dev->constrains->reflective;
+ break;
+ }
+
+ coords.left = MM_TO_PIXEL (mc->left, Resolution);
+ coords.width = MM_TO_PIXEL (mc->width, Resolution);
+ coords.top = MM_TO_PIXEL (mc->top, Resolution);
+ coords.height = MM_TO_PIXEL (mc->height, Resolution);
+
+ /* Check left and top */
+ if (mycoords->left < 0)
+ mycoords->left = 0;
+
+ mycoords->left += coords.left;
+
+ if (mycoords->top < 0)
+ mycoords->top = 0;
+
+ mycoords->top += coords.top;
+
+ /* Check width and height */
+ if ((mycoords->width < 0) || (mycoords->width > coords.width))
+ mycoords->width = coords.width;
+
+ if ((mycoords->height < 0) || (mycoords->height > coords.height))
+ mycoords->height = coords.height;
+
+ rst = OK;
+ }
+
+ DBG (DBG_FNC,
+ "> Constrains_Check: Source=%s, Res=%i, LW=(%i,%i), TH=(%i,%i): %i\n",
+ dbg_scantype (scantype), Resolution, mycoords->left, mycoords->width,
+ mycoords->top, mycoords->height, rst);
+
+ return rst;
+}
+
+static struct st_coords *
+Constrains_Get (struct st_device *dev, SANE_Byte scantype)
+{
+ static struct st_coords *rst = NULL;
+
+ if (dev->constrains != NULL)
+ {
+ switch (scantype)
+ {
+ case ST_TA:
+ rst = &dev->constrains->slide;
+ break;
+ case ST_NEG:
+ rst = &dev->constrains->negative;
+ break;
+ default:
+ rst = &dev->constrains->reflective;
+ break;
+ }
+ }
+
+ return rst;
+}
+
+static void
+Free_Constrains (struct st_device *dev)
+{
+ DBG (DBG_FNC, "> Free_Constrains\n");
+
+ if (dev->constrains != NULL)
+ {
+ free (dev->constrains);
+ dev->constrains = NULL;
+ }
+}
+
+static void
+RTS_DebugInit ()
+{
+ /* Default vaules */
+ RTS_Debug->dev_model = HP3970;
+
+ RTS_Debug->DumpShadingData = FALSE;
+ RTS_Debug->SaveCalibFile = FALSE;
+ RTS_Debug->ScanWhiteBoard = FALSE;
+ RTS_Debug->EnableGamma = TRUE;
+ RTS_Debug->use_fixed_pwm = TRUE;
+ RTS_Debug->dmatransfersize = 0x80000;
+ RTS_Debug->dmasetlength = 0x7c0000;
+ RTS_Debug->dmabuffersize = 0x400000;
+ RTS_Debug->usbtype = -1;
+
+ /* Lamp settings */
+ RTS_Debug->overdrive_flb = 10000; /* msecs */
+ RTS_Debug->overdrive_ta = 10000; /* msecs */
+
+ RTS_Debug->warmup = TRUE;
+
+ /* Calibration settings */
+ RTS_Debug->calibrate = FALSE;
+ RTS_Debug->wshading = TRUE;
+}
+
+static void
+RTS_Setup_Gamma (SANE_Byte * Regs, struct st_hwdconfig *hwdcfg)
+{
+ DBG (DBG_FNC, "> RTS_Setup_Gamma(*Regs, *hwdcfg)\n");
+
+ if ((hwdcfg != NULL) && (Regs != NULL))
+ {
+ if (hwdcfg->use_gamma_tables != FALSE)
+ {
+ SANE_Int table_size;
+
+ /* set set table size */
+ data_bitset (&Regs[0x1d0], 0x0f, hwdcfg->gamma_tablesize);
+
+ /* enable gamma correction */
+ data_bitset (&Regs[0x1d0], 0x40, 1);
+
+
+ switch (Regs[0x1d0] & 0x0c)
+ {
+ case 0:
+ table_size = (Regs[0x1d0] & 1) | 0x0100;
+ break;
+ case 4:
+ table_size = (Regs[0x1d0] & 1) | 0x0400;
+ break;
+ case 8:
+ table_size = (Regs[0x1d0] & 1) | 0x1000;
+ break;
+ default:
+ table_size = hwdcfg->startpos & 0xffff;
+ break;
+ }
+
+ /* 5073 */
+ /* points to red gamma table */
+ data_wide_bitset (&Regs[0x1b4], 0x3fff, 0);
+
+ /* points to green gamma table */
+ data_wide_bitset (&Regs[0x1b6], 0x3fff, table_size);
+
+ /* points to blue gamma table */
+ data_wide_bitset (&Regs[0x1b8], 0x3fff, table_size * 2);
+
+ v15f8 = (((table_size * 3) + 15) / 16) & 0xffff;
+ }
+ else
+ {
+ /* disable gamma correction */
+ data_bitset (&Regs[0x1d0], 0x40, 0);
+ v15f8 = 0;
+ }
+ }
+}
+
+static SANE_Int
+RTS_USBType (struct st_device *dev)
+{
+ /* Gets USB type of this scanner */
+
+ SANE_Int rst = ERROR;
+ SANE_Byte data;
+
+ DBG (DBG_FNC, "+ RTS_USBType\n");
+
+ if (Read_Byte (dev->usb_handle, 0xfe11, &data) == OK)
+ rst = (data & 1);
+
+ DBG (DBG_FNC, "- RTS_USBType(void): %s\n",
+ (rst == USB11) ? "USB1.1" : "USB2.0");
+
+ return rst;
+}
+
+static SANE_Int
+Init_Vars (void)
+{
+ SANE_Int rst = OK;
+
+ hp_gamma = malloc (sizeof (struct st_gammatables));
+ if (hp_gamma != NULL)
+ bzero (hp_gamma, sizeof (struct st_gammatables));
+ else
+ rst = ERROR;
+
+ if (rst == OK)
+ {
+ RTS_Debug = malloc (sizeof (struct st_debug_opts));
+ if (RTS_Debug != NULL)
+ bzero (RTS_Debug, sizeof (struct st_debug_opts));
+ else
+ rst = ERROR;
+ }
+
+ if (rst == OK)
+ {
+ default_gain_offset = malloc (sizeof (struct st_gain_offset));
+ if (default_gain_offset != NULL)
+ bzero (default_gain_offset, sizeof (struct st_gain_offset));
+ else
+ rst = ERROR;
+ }
+
+ if (rst == OK)
+ {
+ calibdata = malloc (sizeof (struct st_calibration_data));
+ if (calibdata != NULL)
+ bzero (calibdata, sizeof (struct st_calibration_data));
+ else
+ rst = ERROR;
+ }
+
+ if (rst == OK)
+ {
+ wshading = malloc (sizeof (struct st_shading));
+ if (wshading != NULL)
+ bzero (wshading, sizeof (struct st_shading));
+ else
+ rst = ERROR;
+ }
+
+ waitforpwm = TRUE;
+
+ use_gamma_tables = TRUE;
+
+ if (rst == OK)
+ RTS_DebugInit ();
+ else
+ Free_Vars ();
+
+ return rst;
+}
+
+static void
+Free_Vars (void)
+{
+ if (RTS_Debug != NULL)
+ {
+ free (RTS_Debug);
+ RTS_Debug = NULL;
+ }
+
+ if (hp_gamma != NULL)
+ {
+ free (hp_gamma);
+ hp_gamma = NULL;
+ }
+
+ if (calibdata != NULL)
+ {
+ free (calibdata);
+ calibdata = NULL;
+ }
+
+ if (wshading != NULL)
+ {
+ if (wshading->rates != NULL)
+ free (wshading->rates);
+
+ free (wshading);
+ wshading = NULL;
+ }
+
+ if (default_gain_offset != NULL)
+ {
+ free (default_gain_offset);
+ default_gain_offset = NULL;
+ }
+
+}
+
+static SANE_Int
+Chipset_Reset (struct st_device *dev)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ Chipset_Reset:\n");
+
+ /* I've found two ways to reset chipset. Next one will stay commented
+ rst = ERROR;
+ if (Read_Byte(dev->usb_handle, 0xe800, &data) == OK)
+ {
+ data |= 0x20;
+ if (Write_Byte(dev->usb_handle, 0xe800, data) == OK)
+ {
+ data &= 0xdf;
+ rst = Write_Byte(dev->usb_handle, 0xe800, data);
+ }
+ }
+ */
+
+ rst = IWrite_Buffer (dev->usb_handle, 0x0000, NULL, 0, 0x0801);
+
+ DBG (DBG_FNC, "- Chipset_Reset: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_DMA_Enable_Read (struct st_device *dev, SANE_Int dmacs, SANE_Int size,
+ SANE_Int options)
+{
+ SANE_Int rst = ERROR;
+ SANE_Byte buffer[6];
+
+ DBG (DBG_FNC,
+ "+ RTS_DMA_Enable_Read(dmacs=0x%04x, size=%i, options=0x%06x)\n",
+ dmacs, size, options);
+
+ data_msb_set (&buffer[0], options, 3);
+
+ /* buffer size divided by 2 (words count) */
+ data_lsb_set (&buffer[3], size / 2, 3);
+
+ rst = IWrite_Buffer (dev->usb_handle, dmacs, buffer, 6, 0x0400);
+
+ DBG (DBG_FNC, "- RTS_DMA_Enable_Read: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_DMA_Enable_Write (struct st_device *dev, SANE_Int dmacs, SANE_Int size,
+ SANE_Int options)
+{
+ SANE_Int rst = ERROR;
+ SANE_Byte buffer[6];
+
+ DBG (DBG_FNC,
+ "+ RTS_DMA_Enable_Write(dmacs=0x%04x, size=%i, options=0x%06x)\n",
+ dmacs, size, options);
+
+ data_msb_set (&buffer[0], options, 3);
+
+ /* buffer size divided by 2 (words count) */
+ data_lsb_set (&buffer[3], size / 2, 3);
+
+ rst = IWrite_Buffer (dev->usb_handle, dmacs, buffer, 6, 0x0401);
+
+ DBG (DBG_FNC, "- RTS_DMA_Enable_Write: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_DMA_Cancel (struct st_device *dev)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ RTS_DMA_Cancel:\n");
+
+ rst = IWrite_Word (dev->usb_handle, 0x0000, 0, 0x0600);
+
+ DBG (DBG_FNC, "- RTS_DMA_Cancel: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_DMA_Reset (struct st_device *dev)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ RTS_DMA_Reset:\n");
+
+ rst = IWrite_Word (dev->usb_handle, 0x0000, 0x0000, 0x0800);
+
+ DBG (DBG_FNC, "- RTS_DMA_Reset: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_EEPROM_WriteByte (USB_Handle usb_handle, SANE_Int address, SANE_Byte data)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ RTS_EEPROM_WriteByte(address=%04x, data=%i):\n", address,
+ data);
+
+ rst = IWrite_Byte (usb_handle, address, data, 0x200, 0x200);
+
+ DBG (DBG_FNC, "- RTS_EEPROM_WriteByte: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_EEPROM_ReadWord (USB_Handle usb_handle, SANE_Int address, SANE_Int * data)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ RTS_EEPROM_ReadWord(address=%04x, data):\n", address);
+
+ rst = IRead_Word (usb_handle, address, data, 0x200);
+
+ DBG (DBG_FNC, "- RTS_EEPROM_ReadWord: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_EEPROM_ReadByte (USB_Handle usb_handle, SANE_Int address,
+ SANE_Byte * data)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ RTS_EEPROM_ReadByte(address=%04x, data):\n", address);
+
+ rst = IRead_Byte (usb_handle, address, data, 0x200);
+
+ DBG (DBG_FNC, "- RTS_EEPROM_ReadByte: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_EEPROM_WriteWord (USB_Handle usb_handle, SANE_Int address, SANE_Int data)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ RTS_EEPROM_WriteWord(address=%04x, data=%i):\n", address,
+ data);
+
+ rst = IWrite_Word (usb_handle, address, data, 0x0200);
+
+ DBG (DBG_FNC, "- RTS_EEPROM_WriteWord: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_EEPROM_ReadInteger (USB_Handle usb_handle, SANE_Int address,
+ SANE_Int * data)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ RTS_EEPROM_ReadInteger(address=%04x, data):\n", address);
+
+ rst = IRead_Integer (usb_handle, address, data, 0x200);
+
+ DBG (DBG_FNC, "- RTS_EEPROM_ReadInteger: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_EEPROM_WriteInteger (USB_Handle usb_handle, SANE_Int address,
+ SANE_Int data)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ RTS_EEPROM_WriteInteger(address=%04x, data):\n", address);
+
+ rst = IWrite_Integer (usb_handle, address, data, 0x200);
+
+ DBG (DBG_FNC, "- RTS_EEPROM_WriteInteger: %i\n", rst);
+
+ return rst;
+}
+
+static SANE_Int
+RTS_EEPROM_WriteBuffer (USB_Handle usb_handle, SANE_Int address,
+ SANE_Byte * data, SANE_Int size)
+{
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "+ RTS_EEPROM_WriteBuffer(address=%04x, data, size=%i):\n",
+ address, size);
+
+ rst = IWrite_Buffer (usb_handle, address, data, size, 0x200);
+
+ DBG (DBG_FNC, "- RTS_EEPROM_WriteBuffer: %i\n", rst);
+
+ return rst;
+}
+
+static void
+WShading_Emulate (SANE_Byte * buffer, SANE_Int * chnptr, SANE_Int size,
+ SANE_Int depth)
+{
+ if ((wshading->rates != NULL) && (chnptr != NULL))
+ {
+ if (*chnptr < wshading->count)
+ {
+ double maxvalue, chncolor;
+ SANE_Int chnsize;
+ SANE_Int pos;
+ SANE_Int icolor;
+
+ maxvalue = (1 << depth) - 1;
+ chnsize = (depth > 8) ? 2 : 1;
+
+ pos = 0;
+ while (pos < size)
+ {
+ /* get channel color */
+ chncolor = data_lsb_get (buffer + pos, chnsize);
+
+ /* apply shading coeficient */
+ chncolor *= wshading->rates[*chnptr];
+
+ /* care about limits */
+ chncolor = min (chncolor, maxvalue);
+
+ /* save color */
+ icolor = chncolor;
+ data_lsb_set (buffer + pos, icolor, chnsize);
+
+ *chnptr = *chnptr + 1;
+ if (*chnptr >= wshading->count)
+ *chnptr = 0;
+
+ pos += chnsize;
+ }
+ }
+ }
+}
+
+static SANE_Int
+WShading_Calibrate (struct st_device *dev, SANE_Byte * Regs,
+ struct st_calibration *myCalib,
+ struct st_scanparams *scancfg)
+{
+ struct st_calibration_config *calibcfg;
+ struct st_gain_offset myCalibTable;
+ struct st_scanparams *myscancfg;
+ SANE_Byte *myRegs; /*f1bc */
+ SANE_Int bytes_per_line;
+ /**/ SANE_Int x, y, a, C;
+ SANE_Byte *pattern; /*f164 */
+ double sumatorio;
+ SANE_Int gainmode;
+ SANE_Int rst;
+ SANE_Byte *avg_colors;
+
+ DBG (DBG_FNC, "> WShading_Calibrate(*myCalib)\n");
+
+ bzero (&myCalibTable, sizeof (struct st_gain_offset));
+ for (C = CL_RED; C <= CL_BLUE; C++)
+ {
+ myCalibTable.pag[C] = 3;
+ myCalibTable.vgag1[C] = 4;
+ myCalibTable.vgag2[C] = 4;
+ }
+
+ calibcfg =
+ (struct st_calibration_config *)
+ malloc (sizeof (struct st_calibration_config));
+ memset (calibcfg, 0x30, sizeof (struct st_calibration_config));
+
+ myscancfg = (struct st_scanparams *) malloc (sizeof (struct st_scanparams));
+ memcpy (myscancfg, scancfg, sizeof (struct st_scanparams));
+
+ myRegs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
+ memcpy (myRegs, Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+
+ Calib_LoadConfig (dev, calibcfg, scan.scantype, myscancfg->resolution_x,
+ myscancfg->depth);
+ gainmode = Lamp_GetGainMode (dev, myscancfg->resolution_x, scan.scantype);
+
+ Lamp_SetGainMode (dev, myRegs, myscancfg->resolution_x, gainmode);
+
+ rst = OK;
+
+ switch (scan.scantype)
+ {
+ case ST_NORMAL:
+ /*a184 */
+ myscancfg->coord.left += scan.ser;
+ myscancfg->coord.width &= 0xffff;
+ break;
+ case ST_TA:
+ case ST_NEG:
+ myscancfg->coord.left += scan.ser;
+ break;
+ }
+
+ /*a11b */
+ if ((myscancfg->coord.width & 1) != 0)
+ myscancfg->coord.width++;
+
+ myscancfg->coord.top = 1;
+ myscancfg->coord.height = calibcfg->WShadingHeight;
+
+ myscancfg->sensorresolution = 0;
+
+ bytes_per_line =
+ myscancfg->coord.width * (((myscancfg->colormode == CM_COLOR) ? 3 : 1) *
+ ((myscancfg->depth > 8) ? 2 : 1));
+
+ /*a1e8 */
+ myscancfg->v157c = bytes_per_line;
+ myscancfg->bytesperline = bytes_per_line;
+
+ /* allocate space for pattern */
+ pattern =
+ (SANE_Byte *) malloc (((myscancfg->coord.height) * bytes_per_line) *
+ sizeof (SANE_Byte));
+ if (pattern == NULL)
+ return ERROR;
+
+ /* Scan image */
+ myCalib->shading_enabled = FALSE;
+ rst =
+ RTS_GetImage (dev, myRegs, myscancfg, &myCalibTable, pattern, myCalib,
+ 0x20000000, gainmode);
+
+ if (rst != ERROR)
+ {
+ SANE_Int chn;
+ double colors[3] = { 0, 0, 0 };
+ double prueba;
+ SANE_Int data;
+ SANE_Int bytes_per_channel;
+
+ bytes_per_channel = (myscancfg->depth > 8) ? 2 : 1;
+
+ avg_colors = (SANE_Byte *) malloc (sizeof (SANE_Byte) * bytes_per_line);
+
+ if (avg_colors != NULL)
+ {
+ wshading->ptr = 0;
+ wshading->count = bytes_per_line / bytes_per_channel;
+
+ if (wshading->rates != NULL)
+ {
+ free (wshading->rates);
+ wshading->rates = NULL;
+ }
+ wshading->rates =
+ (double *) malloc (sizeof (double) * wshading->count);
+
+ chn = 0;
+ for (x = 0; x < wshading->count; x++)
+ {
+ sumatorio = 0;
+
+ for (y = 0; y < myscancfg->coord.height; y++)
+ {
+ data =
+ data_lsb_get (pattern +
+ ((x * bytes_per_channel) +
+ (bytes_per_line * y)), bytes_per_channel);
+ sumatorio += data;
+ }
+
+ sumatorio /= myscancfg->coord.height;
+ a = sumatorio;
+ colors[chn] = max (colors[chn], sumatorio);
+ chn++;
+ if (chn > 2)
+ chn = 0;
+
+ data_lsb_set (avg_colors + (x * bytes_per_channel), a,
+ bytes_per_channel);
+ }
+
+ DBG (DBG_FNC, " -> max colors RGB= %f %f %f\n", colors[0],
+ colors[1], colors[2]);
+
+ chn = 0;
+ for (x = 0; x < wshading->count; x++)
+ {
+ data =
+ data_lsb_get (avg_colors + (x * bytes_per_channel),
+ bytes_per_channel);
+ prueba = data;
+ *(wshading->rates + x) = colors[chn] / prueba;
+ chn++;
+ if (chn > 2)
+ chn = 0;
+ }
+ }
+
+ if (RTS_Debug->SaveCalibFile != FALSE)
+ {
+ dbg_tiff_save ("whiteshading_jkd.tiff",
+ myscancfg->coord.width,
+ myscancfg->coord.height,
+ myscancfg->depth,
+ CM_COLOR,
+ scancfg->resolution_x,
+ scancfg->resolution_y,
+ pattern, (myscancfg->coord.height) * bytes_per_line);
+ }
+
+#ifdef developing
+ {
+ FILE *archivo;
+ char texto[1024];
+
+ /* apply correction to the pattern to see the result */
+ chn = 0;
+ for (x = 0; x < myscancfg->coord.height * wshading->count; x++)
+ {
+ data =
+ data_lsb_get (pattern + (x * bytes_per_channel),
+ bytes_per_channel);
+ sumatorio = data;
+ sumatorio *= wshading->rates[chn];
+ if (sumatorio > ((1 << myscancfg->depth) - 1))
+ sumatorio = (1 << myscancfg->depth) - 1;
+
+ a = sumatorio;
+ data_lsb_set (pattern + (x * bytes_per_channel), a,
+ bytes_per_channel);
+
+ chn++;
+ if (chn == wshading->count)
+ chn = 0;
+ }
+
+ /* save corrected pattern */
+ dbg_tiff_save ("onwhiteshading_jkd.tiff",
+ myscancfg->coord.width,
+ myscancfg->coord.height,
+ myscancfg->depth,
+ CM_COLOR,
+ scancfg->resolution_x,
+ scancfg->resolution_y,
+ pattern, (myscancfg->coord.height) * bytes_per_line);
+
+ /* export coefficients */
+ archivo = fopen ("wShading.txt", "w");
+ for (x = 0; x < wshading->count; x++)
+ {
+ snprintf (texto, 1024, "%f", wshading->rates[x]);
+ fprintf (archivo, "%s\n", texto);
+ }
+
+ fclose (archivo);
+ }
+#endif
+ }
+
+ free (pattern);
+
+ return OK;
+}
+
+#ifdef developing
+static SANE_Int
+motor_pos (struct st_device *dev, SANE_Byte * Regs,
+ struct st_calibration *myCalib, struct st_scanparams *scancfg)
+{
+ struct st_calibration_config *calibcfg;
+ struct st_gain_offset myCalibTable;
+ struct st_scanparams *myscancfg;
+ SANE_Byte *myRegs; /*f1bc */
+ SANE_Int bytes_per_line;
+ /**/ SANE_Int a, C;
+ SANE_Byte *scanbuffer; /*f164 */
+ SANE_Int gainmode;
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "> Calib_test(*myCalib)\n");
+
+ bzero (&myCalibTable, sizeof (struct st_gain_offset));
+
+ calibcfg =
+ (struct st_calibration_config *)
+ malloc (sizeof (struct st_calibration_config));
+ memset (calibcfg, 0x30, sizeof (struct st_calibration_config));
+
+ myscancfg = (struct st_scanparams *) malloc (sizeof (struct st_scanparams));
+ memcpy (myscancfg, scancfg, sizeof (struct st_scanparams));
+
+ myRegs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
+ memcpy (myRegs, Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+
+ Calib_LoadConfig (dev, calibcfg, scan.scantype, myscancfg->resolution_x,
+ myscancfg->depth);
+ gainmode = Lamp_GetGainMode (dev, myscancfg->resolution_x, scan.scantype);
+
+ Lamp_SetGainMode (dev, myRegs, myscancfg->resolution_x, gainmode);
+
+ rst = OK;
+
+ switch (scan.scantype)
+ {
+ case ST_NORMAL:
+ /*a184 */
+ myscancfg->coord.left += scan.ser;
+ myscancfg->coord.width &= 0xffff;
+ break;
+ case ST_TA:
+ case ST_NEG:
+ myscancfg->coord.left += scan.ser;
+ break;
+ }
+
+ /*a11b */
+ if ((myscancfg->coord.width & 1) != 0)
+ myscancfg->coord.width++;
+
+ myscancfg->coord.top = 100;
+ myscancfg->coord.height = 30;
+
+ bytes_per_line = myscancfg->coord.width * 3;
+
+ /*a1e8 */
+ myscancfg->v157c = bytes_per_line;
+ myscancfg->bytesperline = bytes_per_line;
+
+ scanbuffer =
+ (SANE_Byte *) malloc (((myscancfg->coord.height + 16) * bytes_per_line) *
+ sizeof (SANE_Byte));
+ if (scanbuffer == NULL)
+ return ERROR;
+
+ /* Scan image */
+ myCalib->shading_enabled = FALSE;
+ /*Head_Relocate(dev, dev->motorcfg->highspeedmotormove, MTR_FORWARD, 5500); */
+
+ for (a = 0; a < 10; a++)
+ {
+ for (C = CL_RED; C <= CL_BLUE; C++)
+ {
+ myCalibTable.pag[C] = 3;
+ myCalibTable.vgag1[C] = 4;
+ myCalibTable.vgag2[C] = 4;
+ myCalibTable.edcg1[C] = a * 20;
+ }
+
+ dbg_ScanParams (myscancfg);
+
+ Head_Relocate (dev, dev->motorcfg->highspeedmotormove, MTR_FORWARD,
+ 5000);
+ rst =
+ RTS_GetImage (dev, myRegs, myscancfg, &myCalibTable, scanbuffer,
+ myCalib, 0x20000000, gainmode);
+ Head_ParkHome (dev, TRUE, dev->motorcfg->parkhomemotormove);
+
+ if (rst != ERROR)
+ {
+ char name[30];
+ snprintf (name, 30, "calibtest-%i.tiff", a);
+ dbg_tiff_save (name,
+ myscancfg->coord.width,
+ myscancfg->coord.height,
+ myscancfg->depth,
+ CM_COLOR,
+ myscancfg->resolution_x,
+ myscancfg->resolution_y,
+ scanbuffer,
+ (myscancfg->coord.height + 16) * bytes_per_line);
+ }
+ }
+
+ free (scanbuffer);
+
+ exit (0);
+ return OK;
+}
+
+static SANE_Int
+hp4370_prueba (struct st_device *dev)
+{
+ SANE_Int rst;
+ SANE_Int data = 0x0530, a;
+ SANE_Int transferred;
+ SANE_Byte buffer[512];
+
+ for (a = 0; a < 256; a++)
+ data_lsb_set (buffer + (a * 2), 0x9d7, 2);
+
+ rst = IWrite_Word (dev->usb_handle, 0x0000, data, 0x0800);
+ RTS_DMA_Enable_Write (dev, 0x4, 512, 0);
+ Bulk_Operation (dev, BLK_WRITE, 512, buffer, &transferred);
+
+ return rst;
+}
+
+static SANE_Int
+Calib_BlackShading_jkd (struct st_device *dev, SANE_Byte * Regs,
+ struct st_calibration *myCalib,
+ struct st_scanparams *scancfg)
+{
+ struct st_calibration_config *calibcfg;
+ struct st_gain_offset myCalibTable;
+ struct st_scanparams *myscancfg;
+ SANE_Byte *myRegs; /*f1bc */
+ SANE_Int bytes_per_line;
+ /**/ SANE_Int x, y, a, C;
+ SANE_Byte *scanbuffer; /*f164 */
+ double sumatorio;
+ SANE_Int gainmode;
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "> Calib_BlackShading_jkd(*myCalib)\n");
+
+ bzero (&myCalibTable, sizeof (struct st_gain_offset));
+ for (C = CL_RED; C <= CL_BLUE; C++)
+ {
+ myCalibTable.pag[C] = 3;
+ myCalibTable.vgag1[C] = 4;
+ myCalibTable.vgag2[C] = 4;
+ }
+
+ calibcfg =
+ (struct st_calibration_config *)
+ malloc (sizeof (struct st_calibration_config));
+ memset (calibcfg, 0x30, sizeof (struct st_calibration_config));
+
+ myscancfg = (struct st_scanparams *) malloc (sizeof (struct st_scanparams));
+ memcpy (myscancfg, scancfg, sizeof (struct st_scanparams));
+
+ myRegs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
+ memcpy (myRegs, Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+
+ Calib_LoadConfig (dev, calibcfg, scan.scantype, myscancfg->resolution_x,
+ myscancfg->depth);
+ gainmode = Lamp_GetGainMode (dev, myscancfg->resolution_x, scan.scantype);
+
+ Lamp_SetGainMode (dev, myRegs, myscancfg->resolution_x, gainmode);
+
+ rst = OK;
+
+ switch (scan.scantype)
+ {
+ case ST_NORMAL:
+ /*a184 */
+ myscancfg->coord.left += scan.ser;
+ myscancfg->coord.width &= 0xffff;
+ break;
+ case ST_TA:
+ case ST_NEG:
+ myscancfg->coord.left += scan.ser;
+ break;
+ }
+
+ /*a11b */
+ if ((myscancfg->coord.width & 1) != 0)
+ myscancfg->coord.width++;
+
+ myscancfg->coord.top = 1;
+ myscancfg->coord.height = calibcfg->BShadingHeight;
+
+ bytes_per_line = myscancfg->coord.width * 3;
+
+ /*a1e8 */
+ myscancfg->v157c = bytes_per_line;
+ myscancfg->bytesperline = bytes_per_line;
+
+ scanbuffer =
+ (SANE_Byte *) malloc (((myscancfg->coord.height + 16) * bytes_per_line) *
+ sizeof (SANE_Byte));
+ if (scanbuffer == NULL)
+ return ERROR;
+
+ /* Turn off lamp */
+ Lamp_Status_Set (dev, NULL, FALSE, FLB_LAMP);
+ usleep (200 * 1000);
+
+ /* Scan image */
+ myCalib->shading_enabled = FALSE;
+ rst =
+ RTS_GetImage (dev, myRegs, myscancfg, &myCalibTable, scanbuffer, myCalib,
+ 0x101, gainmode);
+
+ /* Turn on lamp again */
+ if (scan.scantype != ST_NORMAL)
+ {
+ Lamp_Status_Set (dev, NULL, FALSE, TMA_LAMP);
+ usleep (1000 * 1000);
+ }
+ else
+ Lamp_Status_Set (dev, NULL, TRUE, FLB_LAMP);
+
+ if (rst != ERROR)
+ {
+ jkd_black = (SANE_Byte *) malloc (bytes_per_line);
+
+ if (jkd_black != NULL)
+ {
+ jkd_blackbpl = bytes_per_line;
+
+ for (x = 0; x < bytes_per_line; x++)
+ {
+ sumatorio = 0;
+
+ for (y = 0; y < myscancfg->coord.height + 16; y++)
+ sumatorio += scanbuffer[x + (bytes_per_line * y)];
+
+ sumatorio /= myscancfg->coord.height + 16;
+ a = sumatorio;
+ *(jkd_black + x) = _B0 (a);
+ }
+ }
+
+ /*if (RTS_Debug->SaveCalibFile != FALSE) */
+ {
+ dbg_tiff_save ("blackshading_jkd.tiff",
+ myscancfg->coord.width,
+ myscancfg->coord.height,
+ myscancfg->depth,
+ CM_COLOR,
+ myscancfg->resolution_x,
+ myscancfg->resolution_y,
+ scanbuffer,
+ (myscancfg->coord.height + 16) * bytes_per_line);
+ }
+ }
+
+ free (scanbuffer);
+
+ return OK;
+}
+
+static SANE_Int
+Calib_test (struct st_device *dev, SANE_Byte * Regs,
+ struct st_calibration *myCalib, struct st_scanparams *scancfg)
+{
+ struct st_calibration_config *calibcfg;
+ struct st_gain_offset myCalibTable;
+ struct st_scanparams *myscancfg;
+ SANE_Byte *myRegs; /*f1bc */
+ SANE_Int bytes_per_line;
+ /**/ SANE_Int a, C;
+ SANE_Byte *scanbuffer; /*f164 */
+ SANE_Int gainmode;
+ SANE_Int rst;
+
+ DBG (DBG_FNC, "> Calib_test(*myCalib)\n");
+
+ bzero (&myCalibTable, sizeof (struct st_gain_offset));
+
+ calibcfg =
+ (struct st_calibration_config *)
+ malloc (sizeof (struct st_calibration_config));
+ memset (calibcfg, 0x30, sizeof (struct st_calibration_config));
+
+ myscancfg = (struct st_scanparams *) malloc (sizeof (struct st_scanparams));
+ memcpy (myscancfg, scancfg, sizeof (struct st_scanparams));
+
+ myRegs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
+ memcpy (myRegs, Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
+
+ Calib_LoadConfig (dev, calibcfg, scan.scantype, myscancfg->resolution_x,
+ myscancfg->depth);
+ gainmode = Lamp_GetGainMode (dev, myscancfg->resolution_x, scan.scantype);
+
+ Lamp_SetGainMode (dev, myRegs, myscancfg->resolution_x, gainmode);
+
+ rst = OK;
+
+ switch (scan.scantype)
+ {
+ case ST_NORMAL:
+ /*a184 */
+ myscancfg->coord.left += scan.ser;
+ myscancfg->coord.width &= 0xffff;
+ break;
+ case ST_TA:
+ case ST_NEG:
+ myscancfg->coord.left += scan.ser;
+ break;
+ }
+
+ /*a11b */
+ if ((myscancfg->coord.width & 1) != 0)
+ myscancfg->coord.width++;
+
+ myscancfg->coord.top = 100;
+ myscancfg->coord.height = 30;
+
+ bytes_per_line = myscancfg->coord.width * 3;
+
+ /*a1e8 */
+ myscancfg->v157c = bytes_per_line;
+ myscancfg->bytesperline = bytes_per_line;
+
+ scanbuffer =
+ (SANE_Byte *) malloc (((myscancfg->coord.height + 16) * bytes_per_line) *
+ sizeof (SANE_Byte));
+ if (scanbuffer == NULL)
+ return ERROR;
+
+ /* Scan image */
+ myCalib->shading_enabled = FALSE;
+ /*Head_Relocate(dev, dev->motorcfg->highspeedmotormove, MTR_FORWARD, 5500); */
+
+ for (a = 0; a < 10; a++)
+ {
+ for (C = CL_RED; C <= CL_BLUE; C++)
+ {
+ myCalibTable.pag[C] = 3;
+ myCalibTable.vgag1[C] = 4;
+ myCalibTable.vgag2[C] = 4;
+ myCalibTable.edcg1[C] = a * 20;
+ }
+
+ Head_Relocate (dev, dev->motorcfg->highspeedmotormove, MTR_FORWARD,
+ 5000);
+ rst =
+ RTS_GetImage (dev, myRegs, myscancfg, &myCalibTable, scanbuffer,
+ myCalib, 0x20000000, gainmode);
+ Head_ParkHome (dev, TRUE, dev->motorcfg->parkhomemotormove);
+
+ if (rst != ERROR)
+ {
+ char name[30];
+ snprintf (name, 30, "calibtest-%i.tiff", a);
+ dbg_tiff_save (name,
+ myscancfg->coord.width,
+ myscancfg->coord.height,
+ myscancfg->depth,
+ CM_COLOR,
+ myscancfg->resolution_x,
+ myscancfg->resolution_y,
+ scanbuffer,
+ (myscancfg->coord.height + 16) * bytes_per_line);
+ }
+ }
+
+ free (scanbuffer);
+
+ exit (0);
+ return OK;
+}
+
+static void
+prueba (SANE_Byte * a)
+{
+ /* SANE_Byte p[] = {}; */
+ /*int z = 69; */
+
+ /*(a + 11) = 0x0; */
+ /*a[1] = a[1] | 0x40; */
+
+ /*memcpy(a, &p, sizeof(p)); */
+
+ /*memcpy(a + 0x12, p, 10); */
+ /*a[0x146] &= 0xdf; */
+
+}
+
+void
+shadingtest1 (struct st_device *dev, SANE_Byte * Regs,
+ struct st_calibration *myCalib)
+{
+ USHORT *buffer;
+ int a;
+ int bit[2];
+
+ DBG (DBG_FNC, "+ shadingtest1(*Regs, *myCalib):\n");
+
+ if ((Regs == NULL) || (myCalib == NULL))
+ return;
+
+ RTS_DMA_Reset (dev);
+
+ bit[0] = (Regs[0x60b] >> 6) & 1;
+ bit[1] = (Regs[0x60b] >> 4) & 1;
+ Regs[0x060b] &= 0xaf;
+
+ Write_Byte (dev->usb_handle, 0xee0b, Regs[0x060b]);
+
+ Regs[0x1cf] = 0; /* reset config. By default black shading disabled and pixel-rate */
+ /*Regs[0x1cf] |= 2; shadingbase 0x2000 */
+ Regs[0x1cf] |= 4; /* White shading enabled */
+ Regs[0x1cf] |= 0x20; /* 16 bits per channel */
+
+ Write_Byte (dev->usb_handle, 0xe9cf, Regs[0x01cf]);
+
+ buffer = (USHORT *) malloc (sizeof (USHORT) * myCalib->shadinglength);
+
+ DBG (DBG_FNC, " -> shading length = %i\n", myCalib->shadinglength);
+
+ /* fill buffer */
+ for (a = 0; a < myCalib->shadinglength; a++)
+ buffer[a] = RTS_Debug->shd + (a * 500);
+
+ for (a = 0; a < 3; a++)
+ {
+ RTS_DMA_Write (dev, a | 0x14, 0,
+ sizeof (USHORT) * myCalib->shadinglength,
+ (SANE_Byte *) buffer);
+ }
+
+ data_bitset (&Regs[0x60b], 0x40, bit[0]); /*-x------*/
+ data_bitset (&Regs[0x60b], 0x10, bit[1]); /*---x----*/
+
+ Write_Byte (dev->usb_handle, 0xee0b, Regs[0x060b]);
+
+ DBG (DBG_FNC, "- shadingtest1\n");
+}
+
+#endif
+
+#endif /* RTS8822_CORE */
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-16 19:27:05 +0000