mirror
/
sane-project-backends
kopia lustrzana https://gitlab.com/sane-project/backends
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

1200 DPI working again

merge-requests/1/head
Stphane Voltz 2011-02-23 21:36:37 +01:00
rodzic d67135cf4c
commit 7f30df8b6f
7 zmienionych plików z 66 dodań i 264 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

48
backend/genesys.c
Wyświetl plik

@ -4749,7 +4749,7 @@ genesys_fill_segmented_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst, s
if(dev->settings.double_xres==SANE_TRUE)
{
/* copy only even pixel */
work_buffer_dst[count] = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->oe_buffer.pos];
work_buffer_dst[count] = dev->oe_buffer.buffer[dev->cur + dev->oe_buffer.pos];
/* update counter and pointer */
count++;
dev->cur++;
@ -4764,9 +4764,9 @@ genesys_fill_segmented_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst, s
while (dev->cur < dev->len && count < size)
{
/* copy even pixel */
work_buffer_dst[count] = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->oe_buffer.pos];
work_buffer_dst[count] = dev->oe_buffer.buffer[dev->cur + dev->oe_buffer.pos];
/* copy odd pixel */
work_buffer_dst[count + 1] = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 1] = dev->oe_buffer.buffer[dev->cur + dev->dist + dev->oe_buffer.pos];
/* update counter and pointer */
count += 2;
dev->cur++;
@ -4777,11 +4777,11 @@ genesys_fill_segmented_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst, s
while (dev->cur < dev->len && count < size)
{
/* copy even pixel */
work_buffer_dst[count] = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->oe_buffer.pos];
work_buffer_dst[count+1] = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->oe_buffer.pos+1];
work_buffer_dst[count] = dev->oe_buffer.buffer[dev->cur + dev->oe_buffer.pos];
work_buffer_dst[count+1] = dev->oe_buffer.buffer[dev->cur + dev->oe_buffer.pos+1];
/* copy odd pixel */
work_buffer_dst[count + 2] = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 3] = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->dist + dev->oe_buffer.pos+1];
work_buffer_dst[count + 2] = dev->oe_buffer.buffer[dev->cur + dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 3] = dev->oe_buffer.buffer[dev->cur + dev->dist + dev->oe_buffer.pos+1];
/* update counter and pointer */
count += 4;
dev->cur+=2;
@ -4790,8 +4790,8 @@ genesys_fill_segmented_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst, s
while (dev->cur < dev->len && count < size)
{
/* get values to merge */
odd = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->oe_buffer.pos];
even = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->dist + dev->oe_buffer.pos];
odd = dev->oe_buffer.buffer[dev->cur + dev->oe_buffer.pos];
even = dev->oe_buffer.buffer[dev->cur + dev->dist + dev->oe_buffer.pos];
/* interleave bits .... */
merged=0;
@ -4831,10 +4831,10 @@ genesys_fill_segmented_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst, s
{
while (dev->cur < dev->len && count < size)
{
work_buffer_dst[count + 0] = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->oe_buffer.pos];
work_buffer_dst[count + 1] = dev->oe_buffer.buffer[dev->cur + dev->skip + 2*dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 2] = dev->oe_buffer.buffer[dev->cur + dev->skip + 1*dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 3] = dev->oe_buffer.buffer[dev->cur + dev->skip + 3*dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 0] = dev->oe_buffer.buffer[dev->cur + dev->oe_buffer.pos];
work_buffer_dst[count + 1] = dev->oe_buffer.buffer[dev->cur + 2*dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 2] = dev->oe_buffer.buffer[dev->cur + 1*dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 3] = dev->oe_buffer.buffer[dev->cur + 3*dev->dist + dev->oe_buffer.pos];
/* update counter and pointer */
count += 4;
dev->cur+=1;
@ -4844,14 +4844,14 @@ genesys_fill_segmented_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst, s
{
while (dev->cur < dev->len && count < size)
{
work_buffer_dst[count + 0] = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->oe_buffer.pos];
work_buffer_dst[count + 1] = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->oe_buffer.pos+1];
work_buffer_dst[count + 2] = dev->oe_buffer.buffer[dev->cur + dev->skip + 2*dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 3] = dev->oe_buffer.buffer[dev->cur + dev->skip + 2*dev->dist + dev->oe_buffer.pos+1];
work_buffer_dst[count + 4] = dev->oe_buffer.buffer[dev->cur + dev->skip + 1*dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 5] = dev->oe_buffer.buffer[dev->cur + dev->skip + 1*dev->dist + dev->oe_buffer.pos+1];
work_buffer_dst[count + 6] = dev->oe_buffer.buffer[dev->cur + dev->skip + 3*dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 7] = dev->oe_buffer.buffer[dev->cur + dev->skip + 3*dev->dist + dev->oe_buffer.pos+1];
work_buffer_dst[count + 0] = dev->oe_buffer.buffer[dev->cur + dev->oe_buffer.pos];
work_buffer_dst[count + 1] = dev->oe_buffer.buffer[dev->cur + dev->oe_buffer.pos+1];
work_buffer_dst[count + 2] = dev->oe_buffer.buffer[dev->cur + 2*dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 3] = dev->oe_buffer.buffer[dev->cur + 2*dev->dist + dev->oe_buffer.pos+1];
work_buffer_dst[count + 4] = dev->oe_buffer.buffer[dev->cur + 1*dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 5] = dev->oe_buffer.buffer[dev->cur + 1*dev->dist + dev->oe_buffer.pos+1];
work_buffer_dst[count + 6] = dev->oe_buffer.buffer[dev->cur + 3*dev->dist + dev->oe_buffer.pos];
work_buffer_dst[count + 7] = dev->oe_buffer.buffer[dev->cur + 3*dev->dist + dev->oe_buffer.pos+1];
/* update counter and pointer */
count += 8;
@ -4861,8 +4861,8 @@ genesys_fill_segmented_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst, s
while (dev->cur < dev->len && count < size)
{
/* get values to merge */
odd = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->oe_buffer.pos];
even = dev->oe_buffer.buffer[dev->cur + dev->skip + dev->dist + dev->oe_buffer.pos];
odd = dev->oe_buffer.buffer[dev->cur + dev->oe_buffer.pos];
even = dev->oe_buffer.buffer[dev->cur + dev->dist + dev->oe_buffer.pos];
/* interleave bits .... */
merged=0;
@ -5652,6 +5652,7 @@ calc_parameters (Genesys_Scanner * s)
s->dev->settings.yres = resolution;
/* double x resolution mode */
/* XXX STEF XXX
s->dev->settings.double_xres = SANE_FALSE;
if ((s->dev->model->flags & GENESYS_FLAG_SIS_SENSOR)
&& s->dev->settings.xres <= s->dev->sensor.optical_res / 2
@ -5659,6 +5660,7 @@ calc_parameters (Genesys_Scanner * s)
{
s->dev->settings.double_xres = SANE_TRUE;
}
*/
s->params.lines = ((br_y - tl_y) * s->dev->settings.yres) / MM_PER_INCH;
s->params.pixels_per_line =

4
backend/genesys_devices.c
Wyświetl plik

@ -440,8 +440,8 @@ static Genesys_Sensor Sensor[] = {
4800, /* optical resolution */
87*4, /* black pixels */
16*4, /* dummy pixels */
303*4,
5144*8,
320*8, /* CCD_startx_offset */
5136*8, /* 5144 */
210,
200,
{0x00, 0x00, 0x00, 0x00},

2
backend/genesys_gl124.c
Wyświetl plik

@ -1436,7 +1436,6 @@ gl124_init_optical_regs_scan (Genesys_Device * dev,
dev->len = dev->bpl/segnb;
dev->dist = dev->bpl/segnb;
dev->segnb = segnb;
dev->skip = 0;
dev->line_count = 0;
if(dpiset>=300)
{
@ -1457,7 +1456,6 @@ gl124_init_optical_regs_scan (Genesys_Device * dev,
DBG (DBG_io2, "%s: dev->bpl =%lu\n", __FUNCTION__, (unsigned long)dev->bpl);
DBG (DBG_io2, "%s: dev->len =%lu\n", __FUNCTION__, (unsigned long)dev->len);
DBG (DBG_io2, "%s: dev->dist =%lu\n", __FUNCTION__, (unsigned long)dev->dist);
DBG (DBG_io2, "%s: dev->skip =%lu\n", __FUNCTION__, (unsigned long)dev->skip);
words_per_line *= channels;
dev->wpl = words_per_line;

253
backend/genesys_gl847.c
Wyświetl plik

@ -878,7 +878,7 @@ gl847_init_motor_regs_scan (Genesys_Device * dev,
factor = gl847_get_step_multiplier (reg);
use_fast_fed=0;
if(scan_yres>=300 && feed_steps>900)
if(scan_yres>600 && feed_steps>900)
use_fast_fed=1;
sanei_genesys_set_triple(reg, REG_LINCNT, scan_lines);
@ -939,6 +939,7 @@ gl847_init_motor_regs_scan (Genesys_Device * dev,
{
dist += fast_steps*2;
}
dist *=factor;
DBG (DBG_io2, "%s: acceleration distance=%d\n", __FUNCTION__, dist);
/* get sure we don't use insane value */
@ -953,9 +954,9 @@ gl847_init_motor_regs_scan (Genesys_Device * dev,
sanei_genesys_calculate_zmode2 (use_fast_fed,
scan_exposure_time,
scan_table,
scan_steps,
scan_steps*factor,
feedl,
scan_steps,
fast_steps*factor,
&z1,
&z2);
@ -1085,6 +1086,7 @@ gl847_init_optical_regs_scan (Genesys_Device * dev,
unsigned int bytes;
Genesys_Register_Set *r;
SANE_Status status;
Sensor_Profile *sensor;
DBG (DBG_proc, "gl847_init_optical_regs_scan : exposure_time=%d, "
"used_res=%d, start=%d, pixels=%d, channels=%d, depth=%d, "
@ -1103,32 +1105,32 @@ gl847_init_optical_regs_scan (Genesys_Device * dev,
DBG (DBG_io2, "%s: dpihw=%d (factor=%d)\n", __FUNCTION__, dpihw, factor);
/* sensor parameters */
sensor=get_sensor_profile(dev->model->ccd_type, dpihw);
gl847_setup_sensor (dev, reg, dpihw);
dpiset = used_res * cksel;
/* start and end coordinate in optical dpi coordinates */
/* startx = start/cksel + dev->sensor.dummy_pixel; XXX STEF XXX */
startx = start/cksel;
startx = start/cksel+dev->sensor.CCD_start_xoffset;
used_pixels=pixels/cksel;
endx = startx + used_pixels;
/* sensors are built from 600 dpi segments */
segnb=dpihw/600;
/* pixel coordinate factor correction when used dpihw is not maximal one
* in case of software handling of multi-segment sensors, we must
* use the whole sensor, so we override start and end pixel
*/
/* compute pixel coordinate in the given dpihw space,
* taking segments into account */
startx/=factor*segnb;
endx/=factor*segnb;
dev->len=endx-startx;
dev->dist=0;
/* in cas of multi-segments sensor, we have to add the witdh
* of the sensor crossed by the scan area */
if (dev->model->flags & GENESYS_FLAG_SIS_SENSOR && segnb>1)
{
startx = dev->sensor.dummy_pixel + 1 + dev->sensor.CCD_start_xoffset;
endx = startx + dev->sensor.sensor_pixels/factor;
}
else
{ /* no segment to care about */
startx/=factor;
endx/=factor;
dev->dist = sensor->segcnt*(segnb-1);
}
endx += dev->dist;
used_pixels=endx-startx;
status = gl847_set_fe (dev, AFE_SET);
@ -1262,23 +1264,19 @@ gl847_init_optical_regs_scan (Genesys_Device * dev,
if (depth == 1)
{
words_per_line = (words_per_line >> 3) + ((words_per_line & 7) ? 1 : 0);
dev->len = (dev->len >> 3) + ((dev->len & 7) ? 1 : 0);
dev->dist = (dev->dist >> 3) + ((dev->dist & 7) ? 1 : 0);
}
else
{
words_per_line *= bytes;
dev->dist *= bytes;
dev->len *= bytes;
}
dev->bpl = words_per_line;
dev->cur=0;
dev->len=dev->bpl/segnb;
dev->dist=dev->bpl/segnb;
dev->segnb=segnb;
dev->skip=((start*dpiset)/dpihw)/segnb*bytes;
if(dev->skip>=dev->dist)
{
dev->skip-=dev->dist;
}
dev->line_interp = 0;
DBG (DBG_io2, "%s: used_pixels=%d\n", __FUNCTION__, used_pixels);
@ -1287,7 +1285,7 @@ gl847_init_optical_regs_scan (Genesys_Device * dev,
DBG (DBG_io2, "%s: dev->bpl =%lu\n", __FUNCTION__, (unsigned long)dev->bpl);
DBG (DBG_io2, "%s: dev->len =%lu\n", __FUNCTION__, (unsigned long)dev->len);
DBG (DBG_io2, "%s: dev->dist =%lu\n", __FUNCTION__, (unsigned long)dev->dist);
DBG (DBG_io2, "%s: dev->skip =%lu\n", __FUNCTION__, (unsigned long)dev->skip);
DBG (DBG_io2, "%s: dev->segnb =%lu\n", __FUNCTION__, (unsigned long)dev->segnb);
words_per_line *= channels;
dev->wpl = words_per_line;
@ -1298,20 +1296,11 @@ gl847_init_optical_regs_scan (Genesys_Device * dev,
}
RIE (sanei_genesys_buffer_alloc (&(dev->oe_buffer), dev->wpl));
/* MAXWD is expressed in 4 words unit */
r = sanei_genesys_get_address (reg, 0x35);
r->value = LOBYTE (HIWORD (words_per_line >> 2));
r = sanei_genesys_get_address (reg, 0x36);
r->value = HIBYTE (LOWORD (words_per_line >> 2));
r = sanei_genesys_get_address (reg, 0x37);
r->value = LOBYTE (LOWORD (words_per_line >> 2));
sanei_genesys_set_triple(reg, REG_MAXWD, (words_per_line >> 2));
DBG (DBG_io2, "%s: words_per_line used=%d\n", __FUNCTION__, words_per_line);
r = sanei_genesys_get_address (reg, 0x38);
r->value = HIBYTE (exposure_time);
r = sanei_genesys_get_address (reg, 0x39);
r->value = LOBYTE (exposure_time);
sanei_genesys_set_double(reg, REG_LPERIOD, exposure_time);
DBG (DBG_io2, "%s: exposure_time used=%d\n", __FUNCTION__, exposure_time);
r = sanei_genesys_get_address (reg, 0x34);
@ -1321,28 +1310,6 @@ gl847_init_optical_regs_scan (Genesys_Device * dev,
return SANE_STATUS_GOOD;
}
#if 0
static int
gl847_get_led_exposure (Genesys_Device * dev)
{
int d, r, g, b, m;
if (!dev->model->is_cis)
return 0;
d = dev->reg[reg_0x19].value;
r = dev->sensor.regs_0x10_0x1d[1] | (dev->sensor.regs_0x10_0x1d[0] << 8);
g = dev->sensor.regs_0x10_0x1d[3] | (dev->sensor.regs_0x10_0x1d[2] << 8);
b = dev->sensor.regs_0x10_0x1d[5] | (dev->sensor.regs_0x10_0x1d[4] << 8);
m = r;
if (m < g)
m = g;
if (m < b)
m = b;
return m + d;
}
#endif
/* set up registers for an actual scan
*
* this function sets up the scanner to scan in normal or single line mode
@ -2033,107 +2000,6 @@ gl847_end_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
return status;
}
/* Moves the slider to steps */
static SANE_Status
gl847_feed (Genesys_Device * dev, int steps)
{
Genesys_Register_Set local_reg[GENESYS_GL847_MAX_REGS];
SANE_Status status;
Genesys_Register_Set *r;
float resolution;
uint8_t val;
int loop;
DBG (DBG_proc, "gl847_feed (steps = %d)\n", steps);
status = gl847_stop_action (dev);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"gl847_feed: failed to stop action: %s\n",
sane_strstatus (status));
return status;
}
memset (local_reg, 0, sizeof (local_reg));
memcpy (local_reg, dev->reg,
GENESYS_GL847_MAX_REGS * sizeof (Genesys_Register_Set));
resolution=sanei_genesys_get_lowest_ydpi(dev);
gl847_init_scan_regs (dev,
local_reg,
resolution,
resolution,
0,
steps,
100,
3,
8,
3,
dev->settings.color_filter,
SCAN_FLAG_DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA |
SCAN_FLAG_FEEDING |
SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE |
SCAN_FLAG_IGNORE_LINE_DISTANCE);
sanei_genesys_set_double(local_reg,REG_EXPR,0);
sanei_genesys_set_double(local_reg,REG_EXPG,0);
sanei_genesys_set_double(local_reg,REG_EXPB,0);
/* clear scan and feed count */
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRLNCNT));
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRMCNT));
/* set up for no scan */
r = sanei_genesys_get_address (local_reg, REG01);
r->value &= ~REG01_SCAN;
/* send registers */
RIE (gl847_bulk_write_register (dev, local_reg, GENESYS_GL847_MAX_REGS));
status = gl847_start_action (dev);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"gl847_feed: failed to start motor: %s\n",
sane_strstatus (status));
gl847_stop_action (dev);
/* send original registers */
gl847_bulk_write_register (dev, dev->reg, GENESYS_GL847_MAX_REGS);
return status;
}
loop = 0;
while (loop < 300) /* do not wait longer then 30 seconds */
{
status = sanei_genesys_get_status (dev, &val);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"gl847_feed: failed to read home sensor: %s\n",
sane_strstatus (status));
return status;
}
if (!(val & REG41_MOTORENB)) /* motor enabled */
{
DBG (DBG_proc, "gl847_feed: finished\n");
dev->scanhead_position_in_steps += steps;
return SANE_STATUS_GOOD;
}
usleep (100000); /* sleep 100 ms */
++loop;
}
/* when we come here then the scanner needed too much time for this, so we better stop the motor */
gl847_stop_action (dev);
DBG (DBG_error,
"gl847_feed: timeout while feeding\n");
return SANE_STATUS_IO_ERROR;
}
/* Moves the slider to the home (top) postion slowly */
static SANE_Status
gl847_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
@ -2586,19 +2452,6 @@ gl847_init_regs_for_scan (Genesys_Device * dev)
move = (move * move_dpi) / MM_PER_INCH;
DBG (DBG_info, "gl847_init_regs_for_scan: move=%f steps\n", move);
/* at high res we do fast move to scan area */
/* XXX STEF XXX
if(dev->settings.xres>150)
{
status = gl847_feed (dev, move);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to move to scan area\n",__FUNCTION__);
return status;
}
move=0;
} */
/* clear scancnt and fedcnt */
val = REG0D_CLRLNCNT;
RIE (sanei_genesys_write_register (dev, REG0D, val));
@ -3371,59 +3224,6 @@ gl847_cold_boot (Genesys_Device * dev)
return SANE_STATUS_GOOD;
}
/** @brief dummy scan at 150 to warm scanner
*
* */
static SANE_Status
gl847_warm_scan (Genesys_Device * dev)
{
SANE_Status status;
size_t size;
uint8_t *line;
float pixels;
int dpi = 300;
DBGSTART;
pixels = (dev->sensor.sensor_pixels * dpi) / dev->sensor.optical_res;
status = gl847_init_scan_regs (dev,
dev->reg,
dpi,
dpi,
0,
90,
pixels,
1,
16,
3,
0,
SCAN_FLAG_DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA |
SCAN_FLAG_IGNORE_LINE_DISTANCE);
RIE (gl847_bulk_write_register
(dev, dev->reg, GENESYS_GL847_MAX_REGS));
/* colors * bytes_per_color * scan lines */
size = ((int) pixels) * 3 * 2 * 1;
line = malloc (size);
if (!line)
return SANE_STATUS_NO_MEM;
DBG (DBG_info, "%s: starting dummy data reading\n", __FUNCTION__);
RIE (gl847_begin_scan (dev, dev->reg, SANE_TRUE));
sanei_genesys_read_data_from_scanner (dev, line, size);
RIE (gl847_end_scan (dev, dev->reg, SANE_TRUE));
free (line);
RIE (gl847_slow_back_home (dev, SANE_TRUE));
DBGCOMPLETED;
return SANE_STATUS_GOOD;
}
/* *
* initialize backend and ASIC : registers, motor tables, and gamma tables
* then ensure scanner's head is at home
@ -3530,9 +3330,6 @@ gl847_init (Genesys_Device * dev)
/* Move home if needed */
RIE (gl847_slow_back_home (dev, SANE_TRUE));
/* XXX STEF XXX
RIE (gl847_warm_scan (dev));
*/
dev->scanhead_position_in_steps = 0;
/* Set powersaving (default = 15 minutes) */

17
backend/genesys_gl847.h
Wyświetl plik

@ -319,6 +319,8 @@
#define REG_STRPIXEL 0x30
#define REG_ENDPIXEL 0x32
#define REG_LINCNT 0x25
#define REG_MAXWD 0x35
#define REG_LPERIOD 0x38
#define REG_FEEDL 0x3d
#define REG_FMOVDEC 0x5e
#define REG_FSHDEC 0x69
@ -543,17 +545,20 @@ static Sensor_Profile sensors[]={
{CIS_CANONLIDE200, 150, 2848, 240, 636, 340, 5144, 0, 255, 637, 637, 637},
{CIS_CANONLIDE200, 300, 1424, 240, 636, 340, 5144, 0, 255, 637, 637, 637},
*/
{CIS_CANONLIDE200, 200, 2848, 60, 159, 85, 5144, 255, 410, 275, 203, 0x0a},
{CIS_CANONLIDE200, 600, 1432, 60, 159, 85, 5144, 255, 410, 275, 203, 0x0a},
{CIS_CANONLIDE200, 1200, 2712, 60, 159, 85, 5144, 255, 746, 478, 353, 0x08},
{CIS_CANONLIDE200, 2400, 5280, 60, 159, 85, 5144, 255, 1417, 909, 643, 0x06},
{CIS_CANONLIDE200, 4800, 10416, 60, 159, 85, 5144, 255, 2692, 1728, 1221, 0x04},
{CIS_CANONLIDE200, 200, 2848, 60, 159, 85, 5136, 255, 410, 275, 203, 0x0a},
{CIS_CANONLIDE200, 600, 1432, 60, 159, 85, 5136, 255, 410, 275, 203, 0x0a},
{CIS_CANONLIDE200, 1200, 2712, 60, 159, 85, 5136, 255, 746, 478, 353, 0x08},
{CIS_CANONLIDE200, 2400, 5280, 60, 159, 85, 5136, 255, 1417, 909, 643, 0x06},
{CIS_CANONLIDE200, 4800, 10416, 60, 159, 85, 5136, 255, 2692, 1728, 1221, 0x04},
};
/* *INDENT-ON* */
/* target=((exposure * dpi) / base_dpi)>>step_type; */
/* too fast for the motor
static uint16_t lide200_fast[] = { 46876, 2343, 2343, 2343, 2343, 2343, 2343, 2343, 2343, 2334, 2325, 2316, 2306, 2297, 2288, 2279, 2270, 2261, 2252, 2243, 2233, 2224, 2215, 2206, 2197, 2188, 2179, 2170, 2160, 2151, 2142, 2133, 2124, 2115, 2106, 2096, 2087, 2078, 2069, 2060, 2051, 2042, 2033, 2023, 2014, 2005, 1996, 1987, 1978, 1969, 1960, 1950, 1941, 1932, 1923, 1914, 1905, 1896, 1887, 1877, 1868, 1859, 1850, 1841, 1832, 1823, 1813, 1804, 1795, 1786, 1777, 1768, 1759, 1750, 1740, 1731, 1722, 1713, 1704, 1695, 1686, 1677, 1667, 1658, 1649, 1640, 1631, 1622, 1613, 1603, 1594, 1585, 1576, 1567, 1558, 1549, 1540, 1530, 1521, 1512, 1503, 1494, 1485, 1476, 1467, 1457, 1448, 1439, 1430, 1421, 1412, 1403, 1393, 1384, 1375, 1366, 1357, 1348, 1339, 1330, 1320, 1311, 1302, 1293, 1284, 1275, 1266, 1257, 1247, 1238, 1229, 1220, 1211, 1202, 1193, 1183, 1174, 1165, 1156, 1147, 1138, 1129, 1120, 1110, 1101, 1092, 1083, 1074, 1065, 1056, 1047, 1037, 1028, 1019, 1010, 1001, 992, 983, 974, 964, 955, 946, 937, 928, 919, 910, 900, 891, 882, 873, 864, 855, 846, 837, 827, 818, 809, 800, 791, 782, 773, 764, 754, 745, 736, 727, 718, 709, 700, 690, 681, 672, 663, 654, 645, 636, 627, 617, 608, 599, 590, 581, 572, 563, 554, 544, 535, 526, 517, 508, 499, 490, 480, 471, 462, 453, 444, 435, 426, 417, 407, 398, 389, 380, 371, 362, 353, 344, 334, 325, 316, 307, 298, 289, 280, 270, 261, 252, 243, 234, 225, 216, 207, 197, 188, 179, 170, 161, 152, 143, 134, 124, 115, 106, 97, 88, 0 };
*/
static uint16_t lide200_base[] = { 46876, 2343, 2343, 2343, 2343, 2343, 2343, 2343, 2343, 2336, 2329, 2322, 2314, 2307, 2300,2292,2285,2278,2271,2263,2256,2249,2241,2234,2227,2219,2212,2205,2198,2190,2183,2176,2168,2161,2154,2146,2139,2132,2125,2117,2110,2103,2095,2088,2081,2073,2066,2059,2052,2044,2037,2030,2022,2015,2008,2001,1993,1986,1979,1971,1964,1957,1949,1942,1935,1928,1920,1913,1906,1898,1891,1884,1876,1869,1862,1855,1847,1840,1833,1825,1818,1811,1803,1796,1789,1782,1774,1767,1760,1752,1745,1738,1731,1723,1716,1709,1701,1694,1687,1679,1672,1665,1658,1650,1643,1636,1628,1621,1614,1606,1599,1592,1585,1577,1570,1563,1555,1548,1541,1533,1526,1519,1512,1504,1497,1490,1482,1475,1468,1461,1453,1446,1439,1431,1424,1417,1409,1402,1395,1388,1380,1373,1366,1358,1351,1344,1336,1329,1322,1315,1307,1300,1293,1285,1278,1271,1263,1256,1249,1242,1234,1227,1220,1212,1205,1198,1191,1183,1176,1169,1161,1154,1147,1139,1132,1125,1118,1110,1103,1096,1088,1081,1074,1066,1059,1052,1045,1037,1030,1023,1015,1008,1001,993,986,979,972,964,957,950,942,935,928,921,913,906,899,891,884,877,869,862,855,848,840,833,826,818,811,804,796,789,782,775,767,760,753,745,738,731,723,716,709,702,694,687,680,672,665,658,651,643,636,629,621,614,607,599,592,585,578,570,563,556,534,534, 0};
static uint16_t lide200_medium[] = { 46876, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136, 8136,0};
/**
* database of motor profiles
@ -563,7 +568,7 @@ static uint16_t lide200_base[] = { 46876, 2343, 2343, 2343, 2343, 2343, 2343, 23
static Motor_Profile gl847_motors[]={
{MOTOR_CANONLIDE200, 2848, 0, lide200_base},
{MOTOR_CANONLIDE200, 1432, 0, lide200_base},
{MOTOR_CANONLIDE200, 2712, 1, lide200_base},
{MOTOR_CANONLIDE200, 2712, 2, lide200_medium},
{MOTOR_CANONLIDE200, 5280, 2, lide200_base},
{MOTOR_CANONLIDE200, 10416, 2, lide200_base},
/* end of database entry */

5
backend/genesys_low.c
Wyświetl plik

@ -1264,7 +1264,7 @@ Motor_Profile *profile;
current=profile->table[0];
/* loop on profile copying and apply step type */
while(i<SLOPE_TABLE_SIZE && current>=target)
while(profile->table[i]!=0 && current>=target)
{
slope[i]=current;
sum+=slope[i];
@ -1273,7 +1273,7 @@ Motor_Profile *profile;
}
/* range checking */
if(profile->table[i]==0 && DBG_LEVEL >= DBG_warn)
if(profile->table[i]==0 && DBG_LEVEL >= DBG_warn && current>target)
{
DBG (DBG_warn,"%s: short slope table, failed to reach %d. target too low ?\n",__FUNCTION__,target);
}
@ -1293,6 +1293,7 @@ Motor_Profile *profile;
/* ensure minimal slope size */
while(i<8)
{
slope[i+1]=slope[i];
sum+=slope[i];
i++;
}

1
backend/genesys_low.h
Wyświetl plik

@ -661,7 +661,6 @@ struct Genesys_Device
int line_interp; /**> number of lines used in line interpolation */
int line_count; /**> number of scan lines used during scan */
size_t bpl; /**> bytes per full scan widthline */
size_t skip; /**> bytes to skip from start of line to get first required pixel */
size_t dist; /**> bytes distance between an odd and an even pixel */
size_t len; /**> number of even pixels */
size_t cur; /**> current pixel position within sub window */