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

genesys: Store calibration data using correct type internally

merge-requests/129/head
Povilas Kanapickas 2019-08-17 10:53:55 +03:00
rodzic c73a7b5b06
commit 3a1163480a
5 zmienionych plików z 92 dodań i 113 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

173
backend/genesys.cc
Wyświetl plik

@ -1561,8 +1561,7 @@ static void genesys_coarse_calibration(Genesys_Device* dev, Genesys_Sensor& sens
/* Averages image data. /* Averages image data.
average_data and calibration_data are little endian 16 bit words. average_data and calibration_data are little endian 16 bit words.
*/ */
static void static void genesys_average_data(uint16_t* average_data,
genesys_average_data (uint8_t * average_data,
uint8_t * calibration_data, uint8_t * calibration_data,
uint32_t lines, uint32_t lines,
uint32_t pixel_components_per_line) uint32_t pixel_components_per_line)
@ -1581,8 +1580,7 @@ genesys_average_data (uint8_t * average_data,
1] * 256; 1] * 256;
} }
sum /= lines; sum /= lines;
*average_data++ = sum & 255; *average_data++ = sum;
*average_data++ = sum / 256;
} }
} }
@ -1604,7 +1602,7 @@ static void genesys_dark_shading_calibration(Genesys_Device* dev, const Genesys_
channels = dev->calib_channels; channels = dev->calib_channels;
uint32_t out_pixels_per_line = pixels_per_line + dev->calib_pixels_offset; uint32_t out_pixels_per_line = pixels_per_line + dev->calib_pixels_offset;
dev->average_size = channels * 2 * out_pixels_per_line; dev->average_size = channels * out_pixels_per_line;
dev->dark_average_data.clear(); dev->dark_average_data.clear();
dev->dark_average_data.resize(dev->average_size); dev->dark_average_data.resize(dev->average_size);
@ -1656,20 +1654,18 @@ static void genesys_dark_shading_calibration(Genesys_Device* dev, const Genesys_
dev->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE); dev->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE);
std::fill(dev->dark_average_data.begin(), std::fill(dev->dark_average_data.begin(),
dev->dark_average_data.begin() + dev->calib_pixels_offset * channels * 2, dev->dark_average_data.begin() + dev->calib_pixels_offset * channels, 0);
0x00);
genesys_average_data(dev->dark_average_data.data() + dev->calib_pixels_offset * channels * 2, genesys_average_data(dev->dark_average_data.data() + dev->calib_pixels_offset * channels,
calibration_data.data(), calibration_data.data(), dev->calib_lines, pixels_per_line * channels);
dev->calib_lines, pixels_per_line * channels);
if (DBG_LEVEL >= DBG_data) if (DBG_LEVEL >= DBG_data)
{ {
sanei_genesys_write_pnm_file("gl_black_shading.pnm", calibration_data.data(), 16, sanei_genesys_write_pnm_file("gl_black_shading.pnm", calibration_data.data(), 16,
channels, pixels_per_line, dev->calib_lines); channels, pixels_per_line, dev->calib_lines);
sanei_genesys_write_pnm_file("gl_black_average.pnm", dev->dark_average_data.data(), 16, sanei_genesys_write_pnm_file16("gl_black_average.pnm", dev->dark_average_data.data(),
channels, out_pixels_per_line, 1); channels, out_pixels_per_line, 1);
} }
} }
@ -1685,7 +1681,7 @@ static void genesys_dummy_dark_shading(Genesys_Device* dev, const Genesys_Sensor
DBG_HELPER(dbg); DBG_HELPER(dbg);
uint32_t pixels_per_line; uint32_t pixels_per_line;
uint8_t channels; uint8_t channels;
uint32_t x, skip, xend; uint32_t skip, xend;
int dummy1, dummy2, dummy3; /* dummy black average per channel */ int dummy1, dummy2, dummy3; /* dummy black average per channel */
pixels_per_line = dev->calib_pixels; pixels_per_line = dev->calib_pixels;
@ -1693,7 +1689,7 @@ static void genesys_dummy_dark_shading(Genesys_Device* dev, const Genesys_Sensor
uint32_t out_pixels_per_line = pixels_per_line + dev->calib_pixels_offset; uint32_t out_pixels_per_line = pixels_per_line + dev->calib_pixels_offset;
dev->average_size = channels * 2 * out_pixels_per_line; dev->average_size = channels * out_pixels_per_line;
dev->dark_average_data.clear(); dev->dark_average_data.clear();
dev->dark_average_data.resize(dev->average_size, 0); dev->dark_average_data.resize(dev->average_size, 0);
@ -1723,20 +1719,12 @@ static void genesys_dummy_dark_shading(Genesys_Device* dev, const Genesys_Sensor
dummy2 = 0; dummy2 = 0;
dummy3 = 0; dummy3 = 0;
for (x = skip + 1; x <= xend; x++) for (unsigned x = skip + 1; x <= xend; x++) {
{ dummy1 += dev->white_average_data[channels * x];
dummy1 += if (channels > 1) {
dev->white_average_data[channels * 2 * x] + dummy2 += dev->white_average_data[channels * x + 1];
256 * dev->white_average_data[channels * 2 * x + 1]; dummy3 += dev->white_average_data[channels * x + 2];
if (channels > 1) }
{
dummy2 +=
(dev->white_average_data[channels * 2 * x + 2] +
256 * dev->white_average_data[channels * 2 * x + 3]);
dummy3 +=
(dev->white_average_data[channels * 2 * x + 4] +
256 * dev->white_average_data[channels * 2 * x + 5]);
}
} }
dummy1 /= (xend - skip); dummy1 /= (xend - skip);
@ -1748,17 +1736,12 @@ static void genesys_dummy_dark_shading(Genesys_Device* dev, const Genesys_Sensor
DBG(DBG_proc, "%s: dummy1=%d, dummy2=%d, dummy3=%d \n", __func__, dummy1, dummy2, dummy3); DBG(DBG_proc, "%s: dummy1=%d, dummy2=%d, dummy3=%d \n", __func__, dummy1, dummy2, dummy3);
/* fill dark_average */ /* fill dark_average */
for (x = 0; x < out_pixels_per_line; x++) for (unsigned x = 0; x < out_pixels_per_line; x++) {
{ dev->dark_average_data[channels * 2 * x] = dummy1;
dev->dark_average_data[channels * 2 * x] = dummy1 & 0xff; if (channels > 1) {
dev->dark_average_data[channels * 2 * x + 1] = dummy1 >> 8; dev->dark_average_data[channels * 2 * x + 1] = dummy2;
if (channels > 1) dev->dark_average_data[channels * 2 * x + 2] = dummy3;
{ }
dev->dark_average_data[channels * 2 * x + 2] = dummy2 & 0xff;
dev->dark_average_data[channels * 2 * x + 3] = dummy2 >> 8;
dev->dark_average_data[channels * 2 * x + 4] = dummy3 & 0xff;
dev->dark_average_data[channels * 2 * x + 5] = dummy3 >> 8;
}
} }
} }
@ -1796,7 +1779,7 @@ static void genesys_white_shading_calibration(Genesys_Device* dev, const Genesys
uint32_t out_pixels_per_line = pixels_per_line + dev->calib_pixels_offset; uint32_t out_pixels_per_line = pixels_per_line + dev->calib_pixels_offset;
dev->white_average_data.clear(); dev->white_average_data.clear();
dev->white_average_data.resize(channels * 2 * out_pixels_per_line); dev->white_average_data.resize(channels * out_pixels_per_line);
// FIXME: the current calculation is likely incorrect on non-GL843 implementations, // FIXME: the current calculation is likely incorrect on non-GL843 implementations,
// but this needs checking // but this needs checking
@ -1832,21 +1815,21 @@ static void genesys_white_shading_calibration(Genesys_Device* dev, const Genesys
dev->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE); dev->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE);
if (DBG_LEVEL >= DBG_data) if (DBG_LEVEL >= DBG_data) {
sanei_genesys_write_pnm_file("gl_white_shading.pnm", calibration_data.data(), 16, sanei_genesys_write_pnm_file("gl_white_shading.pnm", calibration_data.data(), 16,
channels, pixels_per_line, dev->calib_lines); channels, pixels_per_line, dev->calib_lines);
}
std::fill(dev->dark_average_data.begin(), std::fill(dev->dark_average_data.begin(),
dev->dark_average_data.begin() + dev->calib_pixels_offset * channels * 2, dev->dark_average_data.begin() + dev->calib_pixels_offset * channels, 0);
0x00);
genesys_average_data (dev->white_average_data.data() + dev->calib_pixels_offset * channels * 2, genesys_average_data(dev->white_average_data.data() + dev->calib_pixels_offset * channels,
calibration_data.data(), dev->calib_lines, calibration_data.data(), dev->calib_lines, pixels_per_line * channels);
pixels_per_line * channels);
if (DBG_LEVEL >= DBG_data) if (DBG_LEVEL >= DBG_data) {
sanei_genesys_write_pnm_file("gl_white_average.pnm", dev->white_average_data.data(), 16, sanei_genesys_write_pnm_file16("gl_white_average.pnm", dev->white_average_data.data(),
channels, out_pixels_per_line, 1); channels, out_pixels_per_line, 1);
}
/* in case we haven't done dark calibration, build dummy data from white_average */ /* in case we haven't done dark calibration, build dummy data from white_average */
if (!(dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION)) if (!(dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION))
@ -1868,7 +1851,6 @@ static void genesys_dark_white_shading_calibration(Genesys_Device* dev,
DBG_HELPER_ARGS(dbg, "lines = %d", (unsigned int)dev->calib_lines); DBG_HELPER_ARGS(dbg, "lines = %d", (unsigned int)dev->calib_lines);
size_t size; size_t size;
uint32_t pixels_per_line; uint32_t pixels_per_line;
uint8_t *average_white, *average_dark;
uint8_t channels; uint8_t channels;
unsigned int x; unsigned int x;
int y; int y;
@ -1881,7 +1863,7 @@ static void genesys_dark_white_shading_calibration(Genesys_Device* dev,
uint32_t out_pixels_per_line = pixels_per_line + dev->calib_pixels_offset; uint32_t out_pixels_per_line = pixels_per_line + dev->calib_pixels_offset;
dev->average_size = channels * 2 * out_pixels_per_line; dev->average_size = channels * out_pixels_per_line;
dev->white_average_data.clear(); dev->white_average_data.clear();
dev->white_average_data.resize(dev->average_size); dev->white_average_data.resize(dev->average_size);
@ -1931,15 +1913,13 @@ static void genesys_dark_white_shading_calibration(Genesys_Device* dev,
} }
std::fill(dev->dark_average_data.begin(), std::fill(dev->dark_average_data.begin(),
dev->dark_average_data.begin() + dev->calib_pixels_offset * channels * 2, dev->dark_average_data.begin() + dev->calib_pixels_offset * channels, 0);
0x00); std::fill(dev->white_average_data.begin(),
std::fill(dev->white_average_data.begin(), dev->white_average_data.begin() + dev->calib_pixels_offset * channels, 0);
dev->white_average_data.begin() + dev->calib_pixels_offset * channels * 2,
0x00);
average_white = dev->white_average_data.data() + dev->calib_pixels_offset * channels * 2; uint16_t* average_white = dev->white_average_data.data() + dev->calib_pixels_offset * channels;
average_dark = dev->dark_average_data.data() + dev->calib_pixels_offset * channels * 2; uint16_t* average_dark = dev->dark_average_data.data() + dev->calib_pixels_offset * channels;
for (x = 0; x < pixels_per_line * channels; x++) for (x = 0; x < pixels_per_line * channels; x++)
{ {
@ -1993,21 +1973,15 @@ static void genesys_dark_white_shading_calibration(Genesys_Device* dev,
dark_sum /= dark_count; dark_sum /= dark_count;
white_sum /= white_count; white_sum /= white_count;
*average_dark++ = dark_sum & 255; *average_dark++ = dark_sum;
*average_dark++ = dark_sum >> 8; *average_white++ = white_sum;
*average_white++ = white_sum & 255;
*average_white++ = white_sum >> 8;
} }
if (DBG_LEVEL >= DBG_data) if (DBG_LEVEL >= DBG_data) {
{ sanei_genesys_write_pnm_file16("gl_white_average.pnm", dev->white_average_data.data(),
sanei_genesys_write_pnm_file("gl_white_average.pnm", channels, out_pixels_per_line, 1);
dev->white_average_data.data(), 16, channels, sanei_genesys_write_pnm_file16("gl_dark_average.pnm", dev->dark_average_data.data(),
out_pixels_per_line, 1); channels, out_pixels_per_line, 1);
sanei_genesys_write_pnm_file("gl_dark_average.pnm",
dev->dark_average_data.data(), 16, channels,
out_pixels_per_line, 1);
} }
} }
@ -2166,21 +2140,10 @@ compute_averaged_planar (Genesys_Device * dev, const Genesys_Sensor& sensor,
br = 0; br = 0;
for (i = 0; i < avgpixels; i++) for (i = 0; i < avgpixels; i++)
{ {
/* dark data */ // dark data
dk += dk += dev->dark_average_data[(x + i + pixels_per_line * j)];
(dev->dark_average_data[(x + i + // white data
pixels_per_line * j) * br += dev->white_average_data[(x + i + pixels_per_line * j)];
2] |
(dev->dark_average_data
[(x + i + pixels_per_line * j) * 2 + 1] << 8));
/* white data */
br +=
(dev->white_average_data[(x + i +
pixels_per_line * j) *
2] |
(dev->white_average_data
[(x + i + pixels_per_line * j) * 2 + 1] << 8));
} }
br /= avgpixels; br /= avgpixels;
@ -2285,13 +2248,11 @@ compute_coefficients (Genesys_Device * dev,
/* TODO if channels=1 , use filter to know the base addr */ /* TODO if channels=1 , use filter to know the base addr */
ptr = shading_data + 4 * ((x + offset) * channels + cmat[c]); ptr = shading_data + 4 * ((x + offset) * channels + cmat[c]);
/* dark data */ // dark data
dk = dev->dark_average_data[x * 2 * channels + c * 2]; dk = dev->dark_average_data[x * channels + c];
dk += 256 * dev->dark_average_data[x * 2 * channels + c * 2 + 1];
/* white data */ // white data
br = dev->white_average_data[x * 2 * channels + c * 2]; br = dev->white_average_data[x * channels + c];
br += 256 * dev->white_average_data[x * 2 * channels + c * 2 + 1];
/* compute coeff */ /* compute coeff */
val=compute_coefficient(coeff,target,br-dk); val=compute_coefficient(coeff,target,br-dk);
@ -2355,12 +2316,8 @@ compute_planar_coefficients (Genesys_Device * dev,
/* average case */ /* average case */
for(i=0;i<factor;i++) for(i=0;i<factor;i++)
{ {
dk += dk += dev->dark_average_data[((x+i) + pixels_per_line * c)];
256 * dev->dark_average_data[((x+i) + pixels_per_line * c) * 2 + 1]; br += dev->white_average_data[((x+i) + pixels_per_line * c)];
dk += dev->dark_average_data[((x+i) + pixels_per_line * c) * 2];
br +=
256 * dev->white_average_data[((x+i) + pixels_per_line * c) * 2 + 1];
br += dev->white_average_data[((x+i) + pixels_per_line * c) * 2];
} }
dk /= factor; dk /= factor;
br /= factor; br /= factor;
@ -2437,10 +2394,8 @@ compute_shifted_coefficients (Genesys_Device * dev,
for (i = 0; i < avgpixels; i++) { for (i = 0; i < avgpixels; i++) {
for (j = 0; j < channels; j++) { for (j = 0; j < channels; j++) {
br_tmp[j] += (dev->white_average_data[((x + i) * channels + j) * 2] | br_tmp[j] += dev->white_average_data[((x + i) * channels + j)];
(dev->white_average_data[((x + i) * channels + j) * 2 + 1] << 8)); dk_tmp[i] += dev->dark_average_data[((x + i) * channels + j)];
dk_tmp[i] += (dev->dark_average_data[((x + i) * channels + j) * 2] |
(dev->dark_average_data[((x + i) * channels + j) * 2 + 1] << 8));
} }
} }
for (j = 0; j < channels; j++) { for (j = 0; j < channels; j++) {
@ -3096,7 +3051,7 @@ static void genesys_sheetfed_calibration(Genesys_Device* dev, Genesys_Sensor& se
if (!(dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION)) if (!(dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION))
{ {
dev->dark_average_data.clear(); dev->dark_average_data.clear();
dev->dark_average_data.resize(dev->average_size, 0x0f); dev->dark_average_data.resize(dev->average_size, 0x0f0f);
/* XXX STEF XXX /* XXX STEF XXX
* with black point in white shading, build an average black * with black point in white shading, build an average black
* pixel and use it to fill the dark_average * pixel and use it to fill the dark_average
@ -5159,7 +5114,7 @@ probe_genesys_devices (void)
of Genesys_Calibration_Cache as is. of Genesys_Calibration_Cache as is.
*/ */
static const char* CALIBRATION_IDENT = "sane_genesys"; static const char* CALIBRATION_IDENT = "sane_genesys";
static const int CALIBRATION_VERSION = 2; static const int CALIBRATION_VERSION = 3;
bool read_calibration(std::istream& str, Genesys_Device::Calibration& calibration, bool read_calibration(std::istream& str, Genesys_Device::Calibration& calibration,
const std::string& path) const std::string& path)

4
backend/genesys_calibration.h
Wyświetl plik

@ -63,8 +63,8 @@ struct Genesys_Calibration_Cache
size_t calib_pixels = 0; size_t calib_pixels = 0;
size_t calib_channels = 0; size_t calib_channels = 0;
size_t average_size = 0; size_t average_size = 0;
std::vector<uint8_t> white_average_data; std::vector<uint16_t> white_average_data;
std::vector<uint8_t> dark_average_data; std::vector<uint16_t> dark_average_data;
bool operator==(const Genesys_Calibration_Cache& other) const bool operator==(const Genesys_Calibration_Cache& other) const
{ {

4
backend/genesys_device.h
Wyświetl plik

@ -245,8 +245,8 @@ struct Genesys_Device
// color is overridden. // color is overridden.
std::vector<uint16_t> gamma_override_tables[3]; std::vector<uint16_t> gamma_override_tables[3];
std::vector<uint8_t> white_average_data; std::vector<uint16_t> white_average_data;
std::vector<uint8_t> dark_average_data; std::vector<uint16_t> dark_average_data;
SANE_Bool already_initialized = 0; SANE_Bool already_initialized = 0;
SANE_Int scanhead_position_in_steps = 0; SANE_Int scanhead_position_in_steps = 0;

21
backend/genesys_low.cc
Wyświetl plik

@ -158,6 +158,27 @@ void sanei_genesys_write_pnm_file(const char* filename, uint8_t* data, int depth
fclose (out); fclose (out);
} }
void sanei_genesys_write_pnm_file16(const char* filename, uint16_t* data, unsigned channels,
unsigned pixels_per_line, unsigned lines)
{
DBG_HELPER_ARGS(dbg, "channels=%d, ppl=%d, lines=%d", channels,
pixels_per_line, lines);
FILE* out = std::fopen(filename, "w");
if (!out) {
throw SaneException("could not open %s for writing: %s\n", filename, strerror(errno));
}
std::fprintf(out, "P%c\n%d\n%d\n%d\n", channels == 1 ? '5' : '6',
pixels_per_line, lines, (int) pow (2, 16) - 1);
for (unsigned count = 0; count < (pixels_per_line * lines * channels); count++) {
fputc(*data >> 8, out);
fputc(*data & 0xff, out);
data++;
}
std::fclose(out);
}
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
/* Read and write RAM, registers and AFE */ /* Read and write RAM, registers and AFE */
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */

3
backend/genesys_low.h
Wyświetl plik

@ -530,6 +530,9 @@ extern void sanei_genesys_write_file(const char* filename, uint8_t* data, size_t
extern void sanei_genesys_write_pnm_file(const char* filename, uint8_t* data, int depth, extern void sanei_genesys_write_pnm_file(const char* filename, uint8_t* data, int depth,
int channels, int pixels_per_line, int lines); int channels, int pixels_per_line, int lines);
extern void sanei_genesys_write_pnm_file16(const char* filename, uint16_t* data, unsigned channels,
unsigned pixels_per_line, unsigned lines);
extern void sanei_genesys_test_buffer_empty(Genesys_Device* dev, SANE_Bool* empty); extern void sanei_genesys_test_buffer_empty(Genesys_Device* dev, SANE_Bool* empty);
extern void sanei_genesys_read_data_from_scanner(Genesys_Device* dev, uint8_t* data, size_t size); extern void sanei_genesys_read_data_from_scanner(Genesys_Device* dev, uint8_t* data, size_t size);