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

genesys: Simplify calculations when on early document end

merge-requests/190/head
Povilas Kanapickas 2019-09-16 09:34:14 +03:00
rodzic 20ad0c8c2e
commit 5e60cc3636
3 zmienionych plików z 60 dodań i 131 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

27
backend/genesys_gl646.cc
Wyświetl plik

@ -1432,7 +1432,7 @@ static void gl646_detect_document_end(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val, gpio;
unsigned int bytes_left, lines;
unsigned int bytes_left;
// test for document presence
sanei_genesys_get_status(dev, &val);
@ -1458,29 +1458,26 @@ static void gl646_detect_document_end(Genesys_Device* dev)
*/
DBG(DBG_io, "%s: total_bytes_to_read=%lu\n", __func__, (u_long) dev->total_bytes_to_read);
DBG(DBG_io, "%s: total_bytes_read =%lu\n", __func__, (u_long) dev->total_bytes_read);
DBG(DBG_io, "%s: read_bytes_left_after_deseg =%lu\n", __func__, (u_long) dev->read_bytes_left_after_deseg);
// amount of data available from scanner is what to scan
sanei_genesys_read_valid_words(dev, &bytes_left);
/* we add the number of lines needed to read the last part of the document in */
lines = (SANE_UNFIX(dev->model->y_offset) * dev->session.params.yres) / MM_PER_INCH;
DBG(DBG_io, "%s: adding %d line to flush\n", __func__, lines);
bytes_left += lines * dev->session.output_line_bytes_raw;
unsigned lines_in_buffer = bytes_left / dev->session.output_line_bytes_raw;
if (dev->session.params.depth > 8) {
bytes_left = 2 * bytes_left;
}
if (dev->session.params.channels > 1) {
bytes_left = 3 * bytes_left;
}
if (bytes_left < dev->read_bytes_left_after_deseg) {
// we add the number of lines needed to read the last part of the document in
unsigned lines_offset = (SANE_UNFIX(dev->model->y_offset) * dev->session.params.yres) /
MM_PER_INCH;
unsigned remaining_lines = lines_in_buffer + lines_offset;
bytes_left = remaining_lines * dev->session.output_line_bytes_raw;
if (bytes_left < dev->get_pipeline_source().remaining_bytes()) {
dev->get_pipeline_source().set_remaining_bytes(bytes_left);
dev->total_bytes_to_read = dev->total_bytes_read + bytes_left;
dev->read_bytes_left_after_deseg = bytes_left;
}
DBG(DBG_io, "%s: total_bytes_to_read=%lu\n", __func__, (u_long) dev->total_bytes_to_read);
DBG(DBG_io, "%s: total_bytes_read =%lu\n", __func__, (u_long) dev->total_bytes_read);
DBG(DBG_io, "%s: read_bytes_left =%lu\n", __func__, (u_long) dev->read_bytes_left_after_deseg);
}
}

56
backend/genesys_gl841.cc
Wyświetl plik

@ -2347,9 +2347,6 @@ static void gl841_detect_document_end(Genesys_Device* dev)
{
DBG_HELPER(dbg);
SANE_Bool paper_loaded;
unsigned int scancnt = 0, lincnt, postcnt;
uint8_t val;
size_t total_bytes_to_read;
gl841_get_paper_sensor(dev, &paper_loaded);
@ -2363,43 +2360,44 @@ static void gl841_detect_document_end(Genesys_Device* dev)
* might have been slow to read data, so we re-evaluate the
* amount of data to scan form the hardware settings
*/
unsigned scanned_lines = 0;
try {
sanei_genesys_read_scancnt(dev, &scancnt);
sanei_genesys_read_scancnt(dev, &scanned_lines);
} catch (...) {
dev->total_bytes_to_read = dev->total_bytes_read;
dev->read_bytes_left_after_deseg = 0;
throw;
}
if (dev->settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS && dev->model->is_cis)
{
scancnt/=3;
if (dev->settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS && dev->model->is_cis) {
scanned_lines /= 3;
}
DBG(DBG_io, "%s: scancnt=%u lines\n", __func__, scancnt);
val = dev->read_register(0x25);
lincnt = 65536 * val;
val = dev->read_register(0x26);
lincnt += 256 * val;
val = dev->read_register(0x27);
lincnt += val;
DBG(DBG_io, "%s: lincnt=%u lines\n", __func__, lincnt);
postcnt = (SANE_UNFIX(dev->model->post_scan)/MM_PER_INCH) * dev->settings.yres;
DBG(DBG_io, "%s: postcnt=%u lines\n", __func__, postcnt);
std::size_t output_lines = dev->session.output_line_count;
/* the current scancnt is also the final one, so we use it to
* compute total bytes to read. We also add the line count to eject document */
total_bytes_to_read=(scancnt+postcnt) * dev->session.output_line_bytes_raw;
std::size_t offset_lines = (SANE_UNFIX(dev->model->post_scan) / MM_PER_INCH) *
dev->settings.yres;
DBG(DBG_io, "%s: old total_bytes_to_read=%u\n", __func__,
(unsigned int)dev->total_bytes_to_read);
DBG(DBG_io, "%s: new total_bytes_to_read=%u\n", __func__, (unsigned int)total_bytes_to_read);
std::size_t scan_end_lines = scanned_lines + offset_lines;
/* assign new end value */
if(dev->total_bytes_to_read>total_bytes_to_read)
{
DBG(DBG_io, "%s: scan shorten\n", __func__);
dev->total_bytes_to_read=total_bytes_to_read;
std::size_t remaining_lines = dev->get_pipeline_source().remaining_bytes() /
dev->session.output_line_bytes_raw;
DBG(DBG_io, "%s: scanned_lines=%u\n", __func__, scanned_lines);
DBG(DBG_io, "%s: scan_end_lines=%zu\n", __func__, scan_end_lines);
DBG(DBG_io, "%s: output_lines=%zu\n", __func__, output_lines);
DBG(DBG_io, "%s: remaining_lines=%zu\n", __func__, remaining_lines);
if (scan_end_lines > output_lines) {
auto skip_lines = scan_end_lines - output_lines;
if (remaining_lines > skip_lines) {
DBG(DBG_io, "%s: skip_lines=%zu\n", __func__, skip_lines);
remaining_lines -= skip_lines;
dev->get_pipeline_source().set_remaining_bytes(remaining_lines *
dev->session.output_line_bytes_raw);
dev->total_bytes_to_read -= skip_lines * dev->session.output_line_bytes_requested;
}
}
}
}

108
backend/genesys_gl843.cc
Wyświetl plik

@ -1507,9 +1507,6 @@ static void gl843_detect_document_end(Genesys_Device* dev)
{
DBG_HELPER(dbg);
SANE_Bool paper_loaded;
unsigned int scancnt = 0;
int flines, bytes_remain, sublines,
bytes_to_flush, lines, sub_bytes, tmp, read_bytes_left;
gl843_get_paper_sensor(dev, &paper_loaded);
@ -1519,99 +1516,36 @@ static void gl843_detect_document_end(Genesys_Device* dev)
DBG(DBG_info, "%s: no more document\n", __func__);
dev->document = SANE_FALSE;
unsigned channels = dev->session.params.channels;
unsigned depth = dev->session.params.depth;
read_bytes_left = (int) dev->read_bytes_left_after_deseg;
DBG(DBG_io, "%s: read_bytes_left=%d\n", __func__, read_bytes_left);
unsigned scanned_lines = 0;
catch_all_exceptions(__func__, [&](){ sanei_genesys_read_scancnt(dev, &scanned_lines); });
// get lines read
try {
sanei_genesys_read_scancnt(dev, &scancnt);
} catch (...) {
flines = 0;
}
std::size_t output_lines = dev->session.output_line_count;
/* compute number of line read */
tmp = (int) dev->total_bytes_read;
if (depth == 1 || dev->settings.scan_mode == ScanColorMode::LINEART)
flines = tmp * 8 / dev->settings.pixels / channels;
else
flines = tmp / (depth / 8) / dev->settings.pixels / channels;
std::size_t offset_lines = (SANE_UNFIX(dev->model->post_scan) * dev->session.params.yres) /
MM_PER_INCH;
/* number of scanned lines, but no read yet */
flines = scancnt - flines;
std::size_t scan_end_lines = scanned_lines + offset_lines;
DBG(DBG_io, "%s: %d scanned but not read lines\n", __func__, flines);
std::size_t remaining_lines = dev->get_pipeline_source().remaining_bytes() /
dev->session.output_line_bytes_raw;
// Adjust number of bytes to read. We need to read the final bytes which are word per
// line times number of last lines to have doc leaving feeder
lines = (SANE_UNFIX(dev->model->post_scan) * dev->session.params.yres) / MM_PER_INCH +
flines;
DBG(DBG_io, "%s: scanned_lines=%u\n", __func__, scanned_lines);
DBG(DBG_io, "%s: scan_end_lines=%zu\n", __func__, scan_end_lines);
DBG(DBG_io, "%s: output_lines=%zu\n", __func__, output_lines);
DBG(DBG_io, "%s: remaining_lines=%zu\n", __func__, remaining_lines);
DBG(DBG_io, "%s: adding %d line to flush\n", __func__, lines);
if (scan_end_lines > output_lines) {
auto skip_lines = scan_end_lines - output_lines;
// number of bytes to read from scanner to get document out of it after
// end of document dectected by hardware sensor */
bytes_to_flush = lines * dev->session.output_line_bytes_raw;
if (remaining_lines > skip_lines) {
DBG(DBG_io, "%s: skip_lines=%zu\n", __func__, skip_lines);
/* if we are already close to end of scan, flushing isn't needed */
if (bytes_to_flush < read_bytes_left)
{
/* we take all these step to work around an overflow on some plateforms */
tmp = (int) dev->total_bytes_read;
DBG (DBG_io, "%s: tmp=%d\n", __func__, tmp);
bytes_remain = (int) dev->total_bytes_to_read;
DBG(DBG_io, "%s: bytes_remain=%d\n", __func__, bytes_remain);
bytes_remain = bytes_remain - tmp;
DBG(DBG_io, "%s: bytes_remain=%d\n", __func__, bytes_remain);
/* remaining lines to read by frontend for the current scan */
if (depth == 1 || dev->settings.scan_mode == ScanColorMode::LINEART)
{
flines = bytes_remain * 8 / dev->settings.pixels / channels;
}
else
flines = bytes_remain / (depth / 8)
/ dev->settings.pixels / channels;
DBG(DBG_io, "%s: flines=%d\n", __func__, flines);
if (flines > lines)
{
/* change the value controlling communication with the frontend :
* total bytes to read is current value plus the number of remaining lines
* multiplied by bytes per line */
sublines = flines - lines;
if (depth == 1 || dev->settings.scan_mode == ScanColorMode::LINEART)
sub_bytes =
((dev->settings.pixels * sublines) / 8 +
(((dev->settings.pixels * sublines) % 8) ? 1 : 0)) *
channels;
else
sub_bytes =
dev->settings.pixels * sublines * channels * (depth / 8);
dev->total_bytes_to_read -= sub_bytes;
/* then adjust the desegmented bytes to read */
if (read_bytes_left > sub_bytes) {
dev->read_bytes_left_after_deseg -= sub_bytes;
} else {
dev->total_bytes_to_read = dev->total_bytes_read;
dev->read_bytes_left_after_deseg = 0;
remaining_lines -= skip_lines;
dev->get_pipeline_source().set_remaining_bytes(remaining_lines *
dev->session.output_line_bytes_raw);
dev->total_bytes_to_read -= skip_lines * dev->session.output_line_bytes_requested;
}
DBG(DBG_io, "%s: sublines=%d\n", __func__, sublines);
DBG(DBG_io, "%s: subbytes=%d\n", __func__, sub_bytes);
DBG(DBG_io, "%s: total_bytes_to_read=%lu\n", __func__,
(unsigned long) dev->total_bytes_to_read);
DBG(DBG_io, "%s: read_bytes_left=%d\n", __func__, read_bytes_left);
}
}
else
{
DBG(DBG_io, "%s: no flushing needed\n", __func__);
}
}
}
}