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

genesys: Remove legacy buffer handling code

merge-requests/340/head
Povilas Kanapickas 2020-02-16 10:41:20 +02:00
rodzic 000b28dd30
commit de7375c7bb
9 zmienionych plików z 21 dodań i 187 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

1
backend/genesys/fwd.h
Wyświetl plik

@ -74,7 +74,6 @@ class Image;
// image_buffer.h
class ImageBuffer;
class FakeBufferModel;
class ImageBufferGenesysUsb;
// image_pipeline.h

44
backend/genesys/image_buffer.cpp
Wyświetl plik

@ -89,47 +89,11 @@ bool ImageBuffer::get_data(std::size_t size, std::uint8_t* out_data)
return got_data;
}
void FakeBufferModel::push_step(std::size_t buffer_size, std::size_t row_bytes)
{
sizes_.push_back(buffer_size);
available_sizes_.push_back(0);
row_bytes_.push_back(row_bytes);
}
std::size_t FakeBufferModel::available_space() const
{
if (sizes_.empty())
throw SaneException("Model has not been setup");
return sizes_.front() - available_sizes_.front();
}
void FakeBufferModel::simulate_read(std::size_t size)
{
if (sizes_.empty()) {
throw SaneException("Model has not been setup");
}
if (available_space() < size) {
throw SaneException("Attempted to simulate read of too much memory");
}
available_sizes_.front() += size;
for (unsigned i = 1; i < sizes_.size(); ++i) {
auto avail_src = available_sizes_[i - 1];
auto avail_dst = sizes_[i] - available_sizes_[i];
auto avail = (std::min(avail_src, avail_dst) / row_bytes_[i]) * row_bytes_[i];
available_sizes_[i - 1] -= avail;
available_sizes_[i] += avail;
}
available_sizes_.back() = 0;
}
ImageBufferGenesysUsb::ImageBufferGenesysUsb(std::size_t total_size,
const FakeBufferModel& buffer_model,
std::size_t buffer_size,
ProducerCallback producer) :
remaining_size_{total_size},
buffer_model_{buffer_model},
buffer_size_{buffer_size},
producer_{producer}
{}
@ -179,7 +143,7 @@ bool ImageBufferGenesysUsb::get_data(std::size_t size, std::uint8_t* out_data)
std::size_t ImageBufferGenesysUsb::get_read_size()
{
std::size_t size = buffer_model_.available_space();
std::size_t size = buffer_size_;
// never read an odd number. exception: last read
// the chip internal counter does not count half words.
@ -195,8 +159,6 @@ std::size_t ImageBufferGenesysUsb::get_read_size()
size &= ~0xff;
}
buffer_model_.simulate_read(size);
return size;
}

23
backend/genesys/image_buffer.h
Wyświetl plik

@ -73,23 +73,6 @@ private:
std::vector<std::uint8_t> buffer_;
};
class FakeBufferModel
{
public:
FakeBufferModel() {}
void push_step(std::size_t buffer_size, std::size_t row_bytes);
std::size_t available_space() const;
void simulate_read(std::size_t size);
private:
std::vector<std::size_t> sizes_;
std::vector<std::size_t> available_sizes_;
std::vector<std::size_t> row_bytes_;
};
// This class is similar to ImageBuffer, but preserves historical peculiarities of buffer handling
// in the backend to preserve exact behavior
class ImageBufferGenesysUsb
@ -98,7 +81,7 @@ public:
using ProducerCallback = std::function<void(std::size_t size, std::uint8_t* out_data)>;
ImageBufferGenesysUsb() {}
ImageBufferGenesysUsb(std::size_t total_size, const FakeBufferModel& buffer_model,
ImageBufferGenesysUsb(std::size_t total_size, std::size_t buffer_size,
ProducerCallback producer);
std::size_t remaining_size() const { return remaining_size_; }
@ -115,12 +98,12 @@ private:
std::size_t remaining_size_ = 0;
std::size_t buffer_size_ = 0;
std::size_t buffer_offset_ = 0;
std::size_t buffer_end_ = 0;
std::vector<std::uint8_t> buffer_;
FakeBufferModel buffer_model_;
ProducerCallback producer_;
};

4
backend/genesys/image_pipeline.cpp
Wyświetl plik

@ -109,11 +109,11 @@ bool ImagePipelineNodeBufferedCallableSource::get_next_row_data(std::uint8_t* ou
ImagePipelineNodeBufferedGenesysUsb::ImagePipelineNodeBufferedGenesysUsb(
std::size_t width, std::size_t height, PixelFormat format, std::size_t total_size,
const FakeBufferModel& buffer_model, ProducerCallback producer) :
std::size_t buffer_size, ProducerCallback producer) :
width_{width},
height_{height},
format_{format},
buffer_{total_size, buffer_model, producer}
buffer_{total_size, buffer_size, producer}
{
set_remaining_bytes(total_size);
}

3
backend/genesys/image_pipeline.h
Wyświetl plik

@ -157,8 +157,7 @@ public:
ImagePipelineNodeBufferedGenesysUsb(std::size_t width, std::size_t height,
PixelFormat format, std::size_t total_size,
const FakeBufferModel& buffer_model,
ProducerCallback producer);
std::size_t buffer_size, ProducerCallback producer);
std::size_t get_width() const override { return width_; }
std::size_t get_height() const override { return height_; }

87
backend/genesys/low.cpp
Wyświetl plik

@ -790,70 +790,9 @@ static unsigned align_int_up(unsigned num, unsigned alignment)
return num;
}
void compute_session_buffer_sizes(AsicType asic, ScanSession& s)
std::size_t compute_session_buffer_sizes(const ScanSession& s)
{
size_t line_bytes = s.output_line_bytes;
size_t line_bytes_stagger = s.output_line_bytes;
if (asic != AsicType::GL646) {
// BUG: this is historical artifact and should be removed. Note that buffer sizes affect
// how often we request the scanner for data and thus change the USB traffic.
line_bytes_stagger =
multiply_by_depth_ceil(s.optical_pixels, s.params.depth) * s.params.channels;
}
struct BufferConfig {
size_t* result_size = nullptr;
size_t lines = 0;
size_t lines_mult = 0;
size_t max_size = 0; // does not apply if 0
size_t stagger_lines = 0;
BufferConfig() = default;
BufferConfig(std::size_t* rs, std::size_t l, std::size_t lm, std::size_t ms,
std::size_t sl) :
result_size{rs},
lines{l},
lines_mult{lm},
max_size{ms},
stagger_lines{sl}
{}
};
std::array<BufferConfig, 4> configs;
if (asic == AsicType::GL124 || asic == AsicType::GL843) {
configs = { {
{ &s.buffer_size_read, 32, 1, 0, s.max_color_shift_lines + s.num_staggered_lines },
{ &s.buffer_size_lines, 32, 1, 0, s.max_color_shift_lines + s.num_staggered_lines },
{ &s.buffer_size_shrink, 16, 1, 0, 0 },
{ &s.buffer_size_out, 8, 1, 0, 0 },
} };
} else if (asic == AsicType::GL841) {
size_t max_buf = sanei_genesys_get_bulk_max_size(asic);
configs = { {
{ &s.buffer_size_read, 8, 2, max_buf, s.max_color_shift_lines + s.num_staggered_lines },
{ &s.buffer_size_lines, 8, 2, max_buf, s.max_color_shift_lines + s.num_staggered_lines },
{ &s.buffer_size_shrink, 8, 1, max_buf, 0 },
{ &s.buffer_size_out, 8, 1, 0, 0 },
} };
} else {
configs = { {
{ &s.buffer_size_read, 16, 1, 0, s.max_color_shift_lines + s.num_staggered_lines },
{ &s.buffer_size_lines, 16, 1, 0, s.max_color_shift_lines + s.num_staggered_lines },
{ &s.buffer_size_shrink, 8, 1, 0, 0 },
{ &s.buffer_size_out, 8, 1, 0, 0 },
} };
}
for (BufferConfig& config : configs) {
size_t buf_size = line_bytes * config.lines;
if (config.max_size > 0 && buf_size > config.max_size) {
buf_size = (config.max_size / line_bytes) * line_bytes;
}
buf_size *= config.lines_mult;
buf_size += line_bytes_stagger * config.stagger_lines;
*config.result_size = buf_size;
}
return s.output_line_bytes * (32 + s.max_color_shift_lines + s.num_staggered_lines);
}
void compute_session_pipeline(const Genesys_Device* dev, ScanSession& s)
@ -1177,7 +1116,7 @@ void compute_session(const Genesys_Device* dev, ScanSession& s, const Genesys_Se
s.output_total_bytes_raw = s.output_line_bytes_raw * s.output_line_count;
s.output_total_bytes = s.output_line_bytes * s.output_line_count;
compute_session_buffer_sizes(dev->model->asic_type, s);
s.buffer_size_read = compute_session_buffer_sizes(s);
compute_session_pipeline(dev, s);
compute_session_pixel_offsets(dev, s, sensor);
@ -1230,24 +1169,6 @@ static std::size_t get_usb_buffer_read_size(AsicType asic, const ScanSession& se
}
}
static FakeBufferModel get_fake_usb_buffer_model(const ScanSession& session)
{
FakeBufferModel model;
model.push_step(session.buffer_size_read, 1);
if (session.pipeline_needs_reorder) {
model.push_step(session.buffer_size_lines, session.output_line_bytes);
}
if (session.pipeline_needs_ccd) {
model.push_step(session.buffer_size_shrink, session.output_line_bytes);
}
if (session.pipeline_needs_shrink) {
model.push_step(session.buffer_size_out, session.output_line_bytes);
}
return model;
}
void build_image_pipeline(Genesys_Device* dev, const Genesys_Sensor& sensor,
const ScanSession& session)
{
@ -1293,7 +1214,7 @@ void build_image_pipeline(Genesys_Device* dev, const Genesys_Sensor& sensor,
dev->pipeline.push_first_node<ImagePipelineNodeBufferedGenesysUsb>(
width, lines, format, read_bytes_left_after_deseg,
get_fake_usb_buffer_model(session), read_data_from_usb);
session.buffer_size_read, read_data_from_usb);
}
if (DBG_LEVEL >= DBG_io2) {

6
backend/genesys/settings.cpp
Wyświetl plik

@ -125,9 +125,6 @@ bool ScanSession::operator==(const ScanSession& other) const
output_segment_pixel_group_count == other.output_segment_pixel_group_count &&
output_segment_start_offset == other.output_segment_start_offset &&
buffer_size_read == other.buffer_size_read &&
buffer_size_lines == other.buffer_size_lines &&
buffer_size_shrink == other.buffer_size_shrink &&
buffer_size_out == other.buffer_size_out &&
enable_ledadd == other.enable_ledadd &&
use_host_side_calib == other.use_host_side_calib &&
pipeline_needs_reorder == other.pipeline_needs_reorder &&
@ -163,9 +160,6 @@ std::ostream& operator<<(std::ostream& out, const ScanSession& session)
<< " output_segment_pixel_group_count: "
<< session.output_segment_pixel_group_count << '\n'
<< " buffer_size_read: " << session.buffer_size_read << '\n'
<< " buffer_size_read: " << session.buffer_size_lines << '\n'
<< " buffer_size_shrink: " << session.buffer_size_shrink << '\n'
<< " buffer_size_out: " << session.buffer_size_out << '\n'
<< " enable_ledadd: " << session.enable_ledadd << '\n'
<< " use_host_side_calib: " << session.use_host_side_calib << '\n'
<< " filters: "

8
backend/genesys/settings.h
Wyświetl plik

@ -300,11 +300,8 @@ struct ScanSession {
// Currently it's always zero.
unsigned output_segment_start_offset = 0;
// the sizes of the corresponding buffers
// the size of the read buffer.
size_t buffer_size_read = 0;
size_t buffer_size_lines = 0;
size_t buffer_size_shrink = 0;
size_t buffer_size_out = 0;
// whether to enable ledadd functionality
bool enable_ledadd = false;
@ -363,9 +360,6 @@ void serialize(Stream& str, ScanSession& x)
serialize(str, x.output_segment_pixel_group_count);
serialize(str, x.output_segment_start_offset);
serialize(str, x.buffer_size_read);
serialize(str, x.buffer_size_lines);
serialize(str, x.buffer_size_shrink);
serialize(str, x.buffer_size_out);
serialize(str, x.enable_ledadd);
serialize(str, x.use_host_side_calib);
serialize(str, x.pipeline_needs_reorder);

32
testsuite/backend/genesys/tests_image_pipeline.cpp
Wyświetl plik

@ -42,29 +42,17 @@ void test_image_buffer_genesys_usb()
requests.push_back(x);
};
FakeBufferModel model;
model.push_step(453120, 1);
model.push_step(56640, 3540);
ImageBufferGenesysUsb buffer{1086780, model, on_read_usb};
ImageBufferGenesysUsb buffer{1086780, 453120, on_read_usb};
std::vector<std::uint8_t> dummy;
dummy.resize(1086780);
ASSERT_TRUE(buffer.get_data(453120, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(453120, dummy.data()));
ASSERT_TRUE(buffer.get_data(180550, dummy.data()));
std::vector<std::size_t> expected = {
453120, 56576, 56576, 56576, 56832, 56576, 56576, 56576, 56832, 56576, 56576, 56576, 11008
453120, 453120, 180736
};
ASSERT_EQ(requests, expected);
}
@ -79,25 +67,19 @@ void test_image_buffer_genesys_usb_capped_remaining_bytes()
requests.push_back(x);
};
FakeBufferModel model;
model.push_step(453120, 1);
model.push_step(56640, 3540);
ImageBufferGenesysUsb buffer{1086780, model, on_read_usb};
ImageBufferGenesysUsb buffer{1086780, 453120, on_read_usb};
std::vector<std::uint8_t> dummy;
dummy.resize(1086780);
ASSERT_TRUE(buffer.get_data(453120, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(56640, dummy.data()));
ASSERT_TRUE(buffer.get_data(453120, dummy.data()));
buffer.set_remaining_size(10000);
ASSERT_FALSE(buffer.get_data(56640, dummy.data()));
std::vector<std::size_t> expected = {
// note that the sizes are rounded-up to 256 bytes
453120, 56576, 56576, 56576, 56832, 10240
453120, 453120, 10240
};
ASSERT_EQ(requests, expected);
}