2019-09-13 07:38:04 +00:00
|
|
|
/* sane - Scanner Access Now Easy.
|
|
|
|
|
|
|
|
Copyright (C) 2019 Povilas Kanapickas <povilas@radix.lt>
|
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define DEBUG_DECLARE_ONLY
|
|
|
|
|
2019-10-01 05:42:08 +00:00
|
|
|
#include "image_pipeline.h"
|
|
|
|
#include "image.h"
|
|
|
|
#include "low.h"
|
2019-10-17 19:30:26 +00:00
|
|
|
#include <cmath>
|
2019-09-13 07:38:04 +00:00
|
|
|
#include <numeric>
|
|
|
|
|
2019-10-02 09:01:28 +00:00
|
|
|
namespace genesys {
|
|
|
|
|
2019-09-13 07:38:04 +00:00
|
|
|
ImagePipelineNode::~ImagePipelineNode() {}
|
|
|
|
|
2019-09-16 06:34:11 +00:00
|
|
|
std::size_t ImagePipelineNodeBytesSource::consume_remaining_bytes(std::size_t bytes)
|
|
|
|
{
|
|
|
|
if (bytes > remaining_bytes_) {
|
|
|
|
bytes = remaining_bytes_;
|
|
|
|
}
|
|
|
|
remaining_bytes_ -= bytes;
|
|
|
|
return bytes;
|
|
|
|
}
|
|
|
|
|
2019-10-01 12:41:25 +00:00
|
|
|
bool ImagePipelineNodeCallableSource::get_next_row_data(std::uint8_t* out_data)
|
|
|
|
{
|
|
|
|
bool got_data = producer_(get_row_bytes(), out_data);
|
|
|
|
if (!got_data)
|
|
|
|
eof_ = true;
|
|
|
|
return got_data;
|
|
|
|
}
|
|
|
|
|
2019-09-13 07:38:04 +00:00
|
|
|
ImagePipelineNodeBufferedCallableSource::ImagePipelineNodeBufferedCallableSource(
|
|
|
|
std::size_t width, std::size_t height, PixelFormat format, std::size_t input_batch_size,
|
|
|
|
ProducerCallback producer) :
|
|
|
|
width_{width},
|
|
|
|
height_{height},
|
|
|
|
format_{format},
|
|
|
|
buffer_{input_batch_size, producer}
|
|
|
|
{
|
2019-09-16 06:34:11 +00:00
|
|
|
set_remaining_bytes(height_ * get_row_bytes());
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodeBufferedCallableSource::get_next_row_data(std::uint8_t* out_data)
|
2019-09-13 07:38:04 +00:00
|
|
|
{
|
|
|
|
if (curr_row_ >= get_height()) {
|
|
|
|
DBG(DBG_warn, "%s: reading out of bounds. Row %zu, height: %zu\n", __func__,
|
|
|
|
curr_row_, get_height());
|
2019-09-16 06:34:10 +00:00
|
|
|
eof_ = true;
|
2019-09-16 06:34:09 +00:00
|
|
|
return false;
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
2019-09-16 06:34:11 +00:00
|
|
|
|
|
|
|
bool got_data = true;
|
|
|
|
|
|
|
|
auto row_bytes = get_row_bytes();
|
|
|
|
auto bytes_to_ask = consume_remaining_bytes(row_bytes);
|
|
|
|
if (bytes_to_ask < row_bytes) {
|
|
|
|
got_data = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
got_data &= buffer_.get_data(bytes_to_ask, out_data);
|
2019-09-13 07:38:04 +00:00
|
|
|
curr_row_++;
|
2019-09-16 06:34:10 +00:00
|
|
|
if (!got_data) {
|
|
|
|
eof_ = true;
|
|
|
|
}
|
2019-09-16 06:34:09 +00:00
|
|
|
return got_data;
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
2019-09-13 07:38:05 +00:00
|
|
|
|
|
|
|
ImagePipelineNodeBufferedGenesysUsb::ImagePipelineNodeBufferedGenesysUsb(
|
|
|
|
std::size_t width, std::size_t height, PixelFormat format, std::size_t total_size,
|
|
|
|
const FakeBufferModel& buffer_model, ProducerCallback producer) :
|
|
|
|
width_{width},
|
|
|
|
height_{height},
|
|
|
|
format_{format},
|
|
|
|
buffer_{total_size, buffer_model, producer}
|
2019-09-16 06:34:11 +00:00
|
|
|
{
|
|
|
|
set_remaining_bytes(total_size);
|
|
|
|
}
|
2019-09-13 07:38:05 +00:00
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodeBufferedGenesysUsb::get_next_row_data(std::uint8_t* out_data)
|
2019-09-13 07:38:05 +00:00
|
|
|
{
|
2019-09-16 06:34:11 +00:00
|
|
|
if (remaining_bytes() != buffer_.remaining_size() + buffer_.available()) {
|
|
|
|
buffer_.set_remaining_size(remaining_bytes() - buffer_.available());
|
|
|
|
}
|
|
|
|
bool got_data = true;
|
|
|
|
|
|
|
|
std::size_t row_bytes = get_row_bytes();
|
|
|
|
std::size_t ask_bytes = consume_remaining_bytes(row_bytes);
|
|
|
|
if (ask_bytes < row_bytes) {
|
|
|
|
got_data = false;
|
|
|
|
}
|
|
|
|
got_data &= buffer_.get_data(ask_bytes, out_data);
|
2019-09-16 06:34:10 +00:00
|
|
|
if (!got_data) {
|
|
|
|
eof_ = true;
|
|
|
|
}
|
|
|
|
return got_data;
|
2019-09-13 07:38:05 +00:00
|
|
|
}
|
|
|
|
|
2019-09-13 07:38:04 +00:00
|
|
|
ImagePipelineNodeArraySource::ImagePipelineNodeArraySource(std::size_t width, std::size_t height,
|
|
|
|
PixelFormat format,
|
|
|
|
std::vector<std::uint8_t> data) :
|
|
|
|
width_{width},
|
|
|
|
height_{height},
|
|
|
|
format_{format},
|
|
|
|
data_{std::move(data)},
|
|
|
|
next_row_{0}
|
|
|
|
{
|
2019-09-16 06:34:11 +00:00
|
|
|
auto size = get_row_bytes() * height_;
|
|
|
|
if (data_.size() < size) {
|
2019-09-13 07:38:04 +00:00
|
|
|
throw SaneException("The given array is too small (%zu bytes). Need at least %zu",
|
2019-09-16 06:34:11 +00:00
|
|
|
data_.size(), size);
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
2019-09-16 06:34:11 +00:00
|
|
|
set_remaining_bytes(size);
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodeArraySource::get_next_row_data(std::uint8_t* out_data)
|
2019-09-13 07:38:04 +00:00
|
|
|
{
|
|
|
|
if (next_row_ >= height_) {
|
2019-09-16 06:34:11 +00:00
|
|
|
eof_ = true;
|
2019-09-16 06:34:09 +00:00
|
|
|
return false;
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
2019-09-16 06:34:11 +00:00
|
|
|
bool got_data = true;
|
|
|
|
|
|
|
|
auto row_bytes = get_row_bytes();
|
|
|
|
auto bytes_to_ask = consume_remaining_bytes(row_bytes);
|
|
|
|
if (bytes_to_ask < row_bytes) {
|
|
|
|
got_data = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::memcpy(out_data, data_.data() + get_row_bytes() * next_row_, bytes_to_ask);
|
2019-09-13 07:38:04 +00:00
|
|
|
next_row_++;
|
2019-09-16 06:34:11 +00:00
|
|
|
|
|
|
|
if (!got_data) {
|
|
|
|
eof_ = true;
|
|
|
|
}
|
|
|
|
return got_data;
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-09-16 06:34:08 +00:00
|
|
|
ImagePipelineNodeImageSource::ImagePipelineNodeImageSource(const Image& source) :
|
|
|
|
source_{source}
|
|
|
|
{}
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodeImageSource::get_next_row_data(std::uint8_t* out_data)
|
2019-09-16 06:34:08 +00:00
|
|
|
{
|
|
|
|
if (next_row_ >= get_height()) {
|
2019-09-16 06:34:09 +00:00
|
|
|
return false;
|
2019-09-16 06:34:08 +00:00
|
|
|
}
|
|
|
|
std::memcpy(out_data, source_.get_row_ptr(next_row_), get_row_bytes());
|
|
|
|
next_row_++;
|
2019-09-16 06:34:09 +00:00
|
|
|
return true;
|
2019-09-16 06:34:08 +00:00
|
|
|
}
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodeFormatConvert::get_next_row_data(std::uint8_t* out_data)
|
2019-09-13 07:38:04 +00:00
|
|
|
{
|
|
|
|
auto src_format = source_.get_format();
|
|
|
|
if (src_format == dst_format_) {
|
2019-09-16 06:34:09 +00:00
|
|
|
return source_.get_next_row_data(out_data);
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
buffer_.clear();
|
|
|
|
buffer_.resize(source_.get_row_bytes());
|
2019-09-16 06:34:09 +00:00
|
|
|
bool got_data = source_.get_next_row_data(buffer_.data());
|
2019-09-13 07:38:04 +00:00
|
|
|
|
|
|
|
convert_pixel_row_format(buffer_.data(), src_format, out_data, dst_format_, get_width());
|
2019-09-16 06:34:09 +00:00
|
|
|
return got_data;
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ImagePipelineNodeDesegment::ImagePipelineNodeDesegment(ImagePipelineNode& source,
|
|
|
|
std::size_t output_width,
|
|
|
|
const std::vector<unsigned>& segment_order,
|
2019-09-13 12:37:33 +00:00
|
|
|
std::size_t segment_pixels,
|
2019-09-13 07:38:04 +00:00
|
|
|
std::size_t interleaved_lines,
|
|
|
|
std::size_t pixels_per_chunk) :
|
|
|
|
source_(source),
|
|
|
|
output_width_{output_width},
|
|
|
|
segment_order_{segment_order},
|
2019-09-13 12:37:33 +00:00
|
|
|
segment_pixels_{segment_pixels},
|
2019-09-13 07:38:04 +00:00
|
|
|
interleaved_lines_{interleaved_lines},
|
|
|
|
pixels_per_chunk_{pixels_per_chunk},
|
|
|
|
buffer_{get_row_bytes()}
|
|
|
|
{
|
2019-09-13 12:37:33 +00:00
|
|
|
DBG_HELPER_ARGS(dbg, "segment_count=%zu, segment_size=%zu, interleaved_lines=%zu, "
|
|
|
|
"pixels_per_shunk=%zu", segment_order.size(), segment_pixels,
|
|
|
|
interleaved_lines, pixels_per_chunk);
|
|
|
|
|
2019-09-13 07:38:04 +00:00
|
|
|
if (source_.get_height() % interleaved_lines_ > 0) {
|
|
|
|
throw SaneException("Height is not a multiple of the number of lines to interelave %zu/%zu",
|
|
|
|
source_.get_height(), interleaved_lines_);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ImagePipelineNodeDesegment::ImagePipelineNodeDesegment(ImagePipelineNode& source,
|
|
|
|
std::size_t output_width,
|
|
|
|
std::size_t segment_count,
|
2019-09-13 12:37:33 +00:00
|
|
|
std::size_t segment_pixels,
|
2019-09-13 07:38:04 +00:00
|
|
|
std::size_t interleaved_lines,
|
|
|
|
std::size_t pixels_per_chunk) :
|
|
|
|
source_(source),
|
|
|
|
output_width_{output_width},
|
2019-09-13 12:37:33 +00:00
|
|
|
segment_pixels_{segment_pixels},
|
2019-09-13 07:38:04 +00:00
|
|
|
interleaved_lines_{interleaved_lines},
|
|
|
|
pixels_per_chunk_{pixels_per_chunk},
|
|
|
|
buffer_{source_.get_row_bytes()}
|
|
|
|
{
|
|
|
|
DBG_HELPER_ARGS(dbg, "segment_count=%zu, segment_size=%zu, interleaved_lines=%zu, "
|
2019-09-13 12:37:33 +00:00
|
|
|
"pixels_per_shunk=%zu", segment_count, segment_pixels, interleaved_lines,
|
2019-09-13 07:38:04 +00:00
|
|
|
pixels_per_chunk);
|
|
|
|
|
|
|
|
segment_order_.resize(segment_count);
|
|
|
|
std::iota(segment_order_.begin(), segment_order_.end(), 0);
|
|
|
|
}
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodeDesegment::get_next_row_data(uint8_t* out_data)
|
2019-09-13 07:38:04 +00:00
|
|
|
{
|
2019-09-16 06:34:09 +00:00
|
|
|
bool got_data = true;
|
|
|
|
|
2019-09-13 07:38:04 +00:00
|
|
|
buffer_.clear();
|
|
|
|
for (std::size_t i = 0; i < interleaved_lines_; ++i) {
|
|
|
|
buffer_.push_back();
|
2019-09-16 06:34:09 +00:00
|
|
|
got_data &= source_.get_next_row_data(buffer_.get_row_ptr(i));
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
if (!buffer_.is_linear()) {
|
|
|
|
throw SaneException("Buffer is not linear");
|
|
|
|
}
|
|
|
|
|
|
|
|
auto format = get_format();
|
|
|
|
auto segment_count = segment_order_.size();
|
|
|
|
|
|
|
|
const std::uint8_t* in_data = buffer_.get_row_ptr(0);
|
|
|
|
|
|
|
|
std::size_t groups_count = output_width_ / (segment_order_.size() * pixels_per_chunk_);
|
|
|
|
|
|
|
|
for (std::size_t igroup = 0; igroup < groups_count; ++igroup) {
|
|
|
|
for (std::size_t isegment = 0; isegment < segment_count; ++isegment) {
|
|
|
|
auto input_offset = igroup * pixels_per_chunk_;
|
2019-09-13 12:37:33 +00:00
|
|
|
input_offset += segment_pixels_ * segment_order_[isegment];
|
2019-09-13 07:38:04 +00:00
|
|
|
auto output_offset = (igroup * segment_count + isegment) * pixels_per_chunk_;
|
|
|
|
|
|
|
|
for (std::size_t ipixel = 0; ipixel < pixels_per_chunk_; ++ipixel) {
|
|
|
|
auto pixel = get_raw_pixel_from_row(in_data, input_offset + ipixel, format);
|
|
|
|
set_raw_pixel_to_row(out_data, output_offset + ipixel, pixel, format);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-09-16 06:34:09 +00:00
|
|
|
return got_data;
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ImagePipelineNodeDeinterleaveLines::ImagePipelineNodeDeinterleaveLines(
|
|
|
|
ImagePipelineNode& source, std::size_t interleaved_lines, std::size_t pixels_per_chunk) :
|
|
|
|
ImagePipelineNodeDesegment(source, source.get_width() * interleaved_lines,
|
2019-09-13 12:37:33 +00:00
|
|
|
interleaved_lines, source.get_width(),
|
2019-09-13 07:38:04 +00:00
|
|
|
interleaved_lines, pixels_per_chunk)
|
|
|
|
{}
|
|
|
|
|
2019-09-13 14:04:00 +00:00
|
|
|
ImagePipelineNodeSwap16BitEndian::ImagePipelineNodeSwap16BitEndian(ImagePipelineNode& source) :
|
|
|
|
source_(source),
|
|
|
|
needs_swapping_{false}
|
|
|
|
{
|
|
|
|
if (get_pixel_format_depth(source_.get_format()) == 16) {
|
|
|
|
needs_swapping_ = true;
|
|
|
|
} else {
|
|
|
|
DBG(DBG_info, "%s: this pipeline node does nothing for non 16-bit formats", __func__);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodeSwap16BitEndian::get_next_row_data(std::uint8_t* out_data)
|
2019-09-13 14:04:00 +00:00
|
|
|
{
|
2019-09-16 06:34:09 +00:00
|
|
|
bool got_data = source_.get_next_row_data(out_data);
|
2019-09-13 14:04:00 +00:00
|
|
|
if (needs_swapping_) {
|
|
|
|
std::size_t pixels = get_row_bytes() / 2;
|
|
|
|
for (std::size_t i = 0; i < pixels; ++i) {
|
|
|
|
std::swap(*out_data, *(out_data + 1));
|
|
|
|
out_data += 2;
|
|
|
|
}
|
|
|
|
}
|
2019-09-16 06:34:09 +00:00
|
|
|
return got_data;
|
2019-09-13 14:04:00 +00:00
|
|
|
}
|
|
|
|
|
2019-09-13 07:38:04 +00:00
|
|
|
ImagePipelineNodeMergeMonoLines::ImagePipelineNodeMergeMonoLines(ImagePipelineNode& source,
|
|
|
|
ColorOrder color_order) :
|
|
|
|
source_(source),
|
|
|
|
buffer_(source_.get_row_bytes())
|
|
|
|
{
|
|
|
|
DBG_HELPER_ARGS(dbg, "color_order %d", static_cast<unsigned>(color_order));
|
|
|
|
|
|
|
|
output_format_ = get_output_format(source_.get_format(), color_order);
|
|
|
|
}
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodeMergeMonoLines::get_next_row_data(std::uint8_t* out_data)
|
2019-09-13 07:38:04 +00:00
|
|
|
{
|
2019-09-16 06:34:09 +00:00
|
|
|
bool got_data = true;
|
|
|
|
|
2019-09-13 07:38:04 +00:00
|
|
|
buffer_.clear();
|
|
|
|
for (unsigned i = 0; i < 3; ++i) {
|
|
|
|
buffer_.push_back();
|
2019-09-16 06:34:09 +00:00
|
|
|
got_data &= source_.get_next_row_data(buffer_.get_row_ptr(i));
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const auto* row0 = buffer_.get_row_ptr(0);
|
|
|
|
const auto* row1 = buffer_.get_row_ptr(1);
|
|
|
|
const auto* row2 = buffer_.get_row_ptr(2);
|
|
|
|
|
|
|
|
auto format = source_.get_format();
|
|
|
|
|
|
|
|
for (std::size_t x = 0, width = get_width(); x < width; ++x) {
|
|
|
|
std::uint16_t ch0 = get_raw_channel_from_row(row0, x, 0, format);
|
|
|
|
std::uint16_t ch1 = get_raw_channel_from_row(row1, x, 0, format);
|
|
|
|
std::uint16_t ch2 = get_raw_channel_from_row(row2, x, 0, format);
|
|
|
|
set_raw_channel_to_row(out_data, x, 0, ch0, output_format_);
|
|
|
|
set_raw_channel_to_row(out_data, x, 1, ch1, output_format_);
|
|
|
|
set_raw_channel_to_row(out_data, x, 2, ch2, output_format_);
|
|
|
|
}
|
2019-09-16 06:34:09 +00:00
|
|
|
return got_data;
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
PixelFormat ImagePipelineNodeMergeMonoLines::get_output_format(PixelFormat input_format,
|
|
|
|
ColorOrder order)
|
|
|
|
{
|
|
|
|
switch (input_format) {
|
|
|
|
case PixelFormat::I1: {
|
|
|
|
if (order == ColorOrder::RGB) {
|
|
|
|
return PixelFormat::RGB111;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PixelFormat::I8: {
|
|
|
|
if (order == ColorOrder::RGB) {
|
|
|
|
return PixelFormat::RGB888;
|
|
|
|
}
|
|
|
|
if (order == ColorOrder::BGR) {
|
|
|
|
return PixelFormat::BGR888;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PixelFormat::I16: {
|
|
|
|
if (order == ColorOrder::RGB) {
|
|
|
|
return PixelFormat::RGB161616;
|
|
|
|
}
|
|
|
|
if (order == ColorOrder::BGR) {
|
|
|
|
return PixelFormat::BGR161616;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
throw SaneException("Unsupported format combidation %d %d",
|
|
|
|
static_cast<unsigned>(input_format),
|
|
|
|
static_cast<unsigned>(order));
|
|
|
|
}
|
|
|
|
|
|
|
|
ImagePipelineNodeSplitMonoLines::ImagePipelineNodeSplitMonoLines(ImagePipelineNode& source) :
|
|
|
|
source_(source),
|
|
|
|
next_channel_{0}
|
|
|
|
{
|
|
|
|
output_format_ = get_output_format(source_.get_format());
|
|
|
|
}
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodeSplitMonoLines::get_next_row_data(std::uint8_t* out_data)
|
2019-09-13 07:38:04 +00:00
|
|
|
{
|
2019-09-16 06:34:09 +00:00
|
|
|
bool got_data = true;
|
|
|
|
|
2019-09-13 07:38:04 +00:00
|
|
|
if (next_channel_ == 0) {
|
|
|
|
buffer_.resize(source_.get_row_bytes());
|
2019-09-16 06:34:09 +00:00
|
|
|
got_data &= source_.get_next_row_data(buffer_.data());
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const auto* row = buffer_.data();
|
|
|
|
auto format = source_.get_format();
|
|
|
|
|
|
|
|
for (std::size_t x = 0, width = get_width(); x < width; ++x) {
|
|
|
|
std::uint16_t ch = get_raw_channel_from_row(row, x, next_channel_, format);
|
|
|
|
set_raw_channel_to_row(out_data, x, 0, ch, output_format_);
|
|
|
|
}
|
|
|
|
next_channel_ = (next_channel_ + 1) % 3;
|
2019-09-16 06:34:09 +00:00
|
|
|
|
|
|
|
return got_data;
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
PixelFormat ImagePipelineNodeSplitMonoLines::get_output_format(PixelFormat input_format)
|
|
|
|
{
|
|
|
|
switch (input_format) {
|
|
|
|
case PixelFormat::RGB111: return PixelFormat::I1;
|
|
|
|
case PixelFormat::RGB888:
|
|
|
|
case PixelFormat::BGR888: return PixelFormat::I8;
|
|
|
|
case PixelFormat::RGB161616:
|
|
|
|
case PixelFormat::BGR161616: return PixelFormat::I16;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
throw SaneException("Unsupported input format %d", static_cast<unsigned>(input_format));
|
|
|
|
}
|
|
|
|
|
|
|
|
ImagePipelineNodeComponentShiftLines::ImagePipelineNodeComponentShiftLines(
|
|
|
|
ImagePipelineNode& source, unsigned shift_r, unsigned shift_g, unsigned shift_b) :
|
|
|
|
source_(source),
|
|
|
|
buffer_{source.get_row_bytes()}
|
|
|
|
{
|
|
|
|
DBG_HELPER_ARGS(dbg, "shifts={%d, %d, %d}", shift_r, shift_g, shift_b);
|
|
|
|
|
|
|
|
switch (source.get_format()) {
|
|
|
|
case PixelFormat::RGB111:
|
|
|
|
case PixelFormat::RGB888:
|
|
|
|
case PixelFormat::RGB161616: {
|
|
|
|
channel_shifts_ = { shift_r, shift_g, shift_b };
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PixelFormat::BGR888:
|
|
|
|
case PixelFormat::BGR161616: {
|
|
|
|
channel_shifts_ = { shift_b, shift_g, shift_r };
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
throw SaneException("Unsupported input format %d",
|
|
|
|
static_cast<unsigned>(source.get_format()));
|
|
|
|
}
|
|
|
|
extra_height_ = *std::max_element(channel_shifts_.begin(), channel_shifts_.end());
|
|
|
|
}
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodeComponentShiftLines::get_next_row_data(std::uint8_t* out_data)
|
2019-09-13 07:38:04 +00:00
|
|
|
{
|
2019-09-16 06:34:09 +00:00
|
|
|
bool got_data = true;
|
|
|
|
|
2019-09-13 07:38:04 +00:00
|
|
|
if (!buffer_.empty()) {
|
|
|
|
buffer_.pop_front();
|
|
|
|
}
|
|
|
|
while (buffer_.height() < extra_height_ + 1) {
|
|
|
|
buffer_.push_back();
|
2019-09-16 06:34:09 +00:00
|
|
|
got_data &= source_.get_next_row_data(buffer_.get_back_row_ptr());
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
auto format = get_format();
|
|
|
|
const auto* row0 = buffer_.get_row_ptr(channel_shifts_[0]);
|
|
|
|
const auto* row1 = buffer_.get_row_ptr(channel_shifts_[1]);
|
|
|
|
const auto* row2 = buffer_.get_row_ptr(channel_shifts_[2]);
|
|
|
|
|
|
|
|
for (std::size_t x = 0, width = get_width(); x < width; ++x) {
|
|
|
|
std::uint16_t ch0 = get_raw_channel_from_row(row0, x, 0, format);
|
|
|
|
std::uint16_t ch1 = get_raw_channel_from_row(row1, x, 1, format);
|
|
|
|
std::uint16_t ch2 = get_raw_channel_from_row(row2, x, 2, format);
|
|
|
|
set_raw_channel_to_row(out_data, x, 0, ch0, format);
|
|
|
|
set_raw_channel_to_row(out_data, x, 1, ch1, format);
|
|
|
|
set_raw_channel_to_row(out_data, x, 2, ch2, format);
|
|
|
|
}
|
2019-09-16 06:34:09 +00:00
|
|
|
return got_data;
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ImagePipelineNodePixelShiftLines::ImagePipelineNodePixelShiftLines(
|
|
|
|
ImagePipelineNode& source, const std::vector<std::size_t>& shifts) :
|
|
|
|
source_(source),
|
|
|
|
pixel_shifts_{shifts},
|
|
|
|
buffer_{get_row_bytes()}
|
|
|
|
{
|
|
|
|
DBG_HELPER(dbg);
|
|
|
|
DBG(DBG_proc, "%s: shifts={", __func__);
|
|
|
|
for (auto el : pixel_shifts_) {
|
|
|
|
DBG(DBG_proc, " %zu", el);
|
|
|
|
}
|
|
|
|
DBG(DBG_proc, " }\n");
|
|
|
|
|
|
|
|
if (pixel_shifts_.size() > MAX_SHIFTS) {
|
|
|
|
throw SaneException("Unsupported number of shift configurations %zu", pixel_shifts_.size());
|
|
|
|
}
|
|
|
|
|
|
|
|
extra_height_ = *std::max_element(pixel_shifts_.begin(), pixel_shifts_.end());
|
|
|
|
}
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodePixelShiftLines::get_next_row_data(std::uint8_t* out_data)
|
2019-09-13 07:38:04 +00:00
|
|
|
{
|
2019-09-16 06:34:09 +00:00
|
|
|
bool got_data = true;
|
|
|
|
|
2019-09-13 07:38:04 +00:00
|
|
|
if (!buffer_.empty()) {
|
|
|
|
buffer_.pop_front();
|
|
|
|
}
|
|
|
|
while (buffer_.height() < extra_height_ + 1) {
|
|
|
|
buffer_.push_back();
|
2019-09-16 06:34:09 +00:00
|
|
|
got_data &= source_.get_next_row_data(buffer_.get_back_row_ptr());
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
auto format = get_format();
|
|
|
|
auto shift_count = pixel_shifts_.size();
|
|
|
|
|
|
|
|
std::array<std::uint8_t*, MAX_SHIFTS> rows;
|
|
|
|
|
|
|
|
for (std::size_t irow = 0; irow < shift_count; ++irow) {
|
|
|
|
rows[irow] = buffer_.get_row_ptr(pixel_shifts_[irow]);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (std::size_t x = 0, width = get_width(); x < width;) {
|
|
|
|
for (std::size_t irow = 0; irow < shift_count && x < width; irow++, x++) {
|
|
|
|
RawPixel pixel = get_raw_pixel_from_row(rows[irow], x, format);
|
|
|
|
set_raw_pixel_to_row(out_data, x, pixel, format);
|
|
|
|
}
|
|
|
|
}
|
2019-09-16 06:34:09 +00:00
|
|
|
return got_data;
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ImagePipelineNodeExtract::ImagePipelineNodeExtract(ImagePipelineNode& source,
|
|
|
|
std::size_t offset_x, std::size_t offset_y,
|
|
|
|
std::size_t width, std::size_t height) :
|
|
|
|
source_(source),
|
|
|
|
offset_x_{offset_x},
|
|
|
|
offset_y_{offset_y},
|
|
|
|
width_{width},
|
|
|
|
height_{height}
|
|
|
|
{
|
|
|
|
cached_line_.resize(source_.get_row_bytes());
|
|
|
|
}
|
|
|
|
|
|
|
|
ImagePipelineNodeExtract::~ImagePipelineNodeExtract() {}
|
|
|
|
|
2019-09-13 14:04:02 +00:00
|
|
|
ImagePipelineNodeScaleRows::ImagePipelineNodeScaleRows(ImagePipelineNode& source,
|
|
|
|
std::size_t width) :
|
|
|
|
source_(source),
|
|
|
|
width_{width}
|
|
|
|
{
|
|
|
|
cached_line_.resize(source_.get_row_bytes());
|
|
|
|
}
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodeScaleRows::get_next_row_data(std::uint8_t* out_data)
|
2019-09-13 14:04:02 +00:00
|
|
|
{
|
|
|
|
auto src_width = source_.get_width();
|
|
|
|
auto dst_width = width_;
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool got_data = source_.get_next_row_data(cached_line_.data());
|
2019-09-13 14:04:02 +00:00
|
|
|
|
|
|
|
const auto* src_data = cached_line_.data();
|
|
|
|
auto format = get_format();
|
|
|
|
auto channels = get_pixel_channels(format);
|
|
|
|
|
|
|
|
if (src_width > dst_width) {
|
|
|
|
// average
|
|
|
|
std::uint32_t counter = src_width / 2;
|
|
|
|
unsigned src_x = 0;
|
|
|
|
for (unsigned dst_x = 0; dst_x < dst_width; dst_x++) {
|
|
|
|
unsigned avg[3] = {0, 0, 0};
|
|
|
|
unsigned count = 0;
|
|
|
|
while (counter < src_width && src_x < src_width) {
|
|
|
|
counter += dst_width;
|
|
|
|
|
|
|
|
for (unsigned c = 0; c < channels; c++) {
|
|
|
|
avg[c] += get_raw_channel_from_row(src_data, src_x, c, format);
|
|
|
|
}
|
|
|
|
|
|
|
|
src_x++;
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
counter -= src_width;
|
|
|
|
|
|
|
|
for (unsigned c = 0; c < channels; c++) {
|
|
|
|
set_raw_channel_to_row(out_data, dst_x, c, avg[c] / count, format);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// interpolate and copy pixels
|
|
|
|
std::uint32_t counter = dst_width / 2;
|
|
|
|
unsigned dst_x = 0;
|
|
|
|
|
|
|
|
for (unsigned src_x = 0; src_x < src_width; src_x++) {
|
|
|
|
unsigned avg[3] = {0, 0, 0};
|
|
|
|
for (unsigned c = 0; c < channels; c++) {
|
|
|
|
avg[c] += get_raw_channel_from_row(src_data, src_x, c, format);
|
|
|
|
}
|
|
|
|
while ((counter < dst_width || src_x + 1 == src_width) && dst_x < dst_width) {
|
|
|
|
counter += src_width;
|
|
|
|
|
|
|
|
for (unsigned c = 0; c < channels; c++) {
|
|
|
|
set_raw_channel_to_row(out_data, dst_x, c, avg[c], format);
|
|
|
|
}
|
|
|
|
dst_x++;
|
|
|
|
}
|
|
|
|
counter -= dst_width;
|
|
|
|
}
|
|
|
|
}
|
2019-09-16 06:34:09 +00:00
|
|
|
return got_data;
|
2019-09-13 14:04:02 +00:00
|
|
|
}
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodeExtract::get_next_row_data(std::uint8_t* out_data)
|
2019-09-13 07:38:04 +00:00
|
|
|
{
|
2019-09-16 06:34:09 +00:00
|
|
|
bool got_data = true;
|
|
|
|
|
2019-09-13 07:38:04 +00:00
|
|
|
while (current_line_ < offset_y_) {
|
2019-09-16 06:34:09 +00:00
|
|
|
got_data &= source_.get_next_row_data(cached_line_.data());
|
2019-09-13 07:38:04 +00:00
|
|
|
current_line_++;
|
|
|
|
}
|
|
|
|
if (current_line_ >= offset_y_ + source_.get_height()) {
|
|
|
|
std::fill(out_data, out_data + get_row_bytes(), 0);
|
|
|
|
current_line_++;
|
2019-09-16 06:34:09 +00:00
|
|
|
return got_data;
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
// now we're sure that the following holds:
|
|
|
|
// offset_y_ <= current_line_ < offset_y_ + source_.get_height())
|
2019-09-16 06:34:09 +00:00
|
|
|
got_data &= source_.get_next_row_data(cached_line_.data());
|
2019-09-13 07:38:04 +00:00
|
|
|
|
|
|
|
auto format = get_format();
|
|
|
|
auto x_src_width = source_.get_width() > offset_x_ ? source_.get_width() - offset_x_ : 0;
|
|
|
|
x_src_width = std::min(x_src_width, width_);
|
|
|
|
auto x_pad_after = width_ > x_src_width ? width_ - x_src_width : 0;
|
|
|
|
|
|
|
|
if (get_pixel_format_depth(format) < 8) {
|
|
|
|
// we need to copy pixels one-by-one as there's no per-bit addressing
|
|
|
|
for (std::size_t i = 0; i < x_src_width; ++i) {
|
|
|
|
auto pixel = get_raw_pixel_from_row(cached_line_.data(), i + offset_x_, format);
|
|
|
|
set_raw_pixel_to_row(out_data, i, pixel, format);
|
|
|
|
}
|
|
|
|
for (std::size_t i = 0; i < x_pad_after; ++i) {
|
|
|
|
set_raw_pixel_to_row(out_data, i + x_src_width, RawPixel{}, format);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
std::size_t bpp = get_pixel_format_depth(format) / 8;
|
|
|
|
if (x_src_width > 0) {
|
|
|
|
std::memcpy(out_data, cached_line_.data() + offset_x_ * bpp,
|
|
|
|
x_src_width * bpp);
|
|
|
|
}
|
|
|
|
if (x_pad_after > 0) {
|
|
|
|
std::fill(out_data + x_src_width * bpp,
|
|
|
|
out_data + (x_src_width + x_pad_after) * bpp, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
current_line_++;
|
2019-09-16 06:34:09 +00:00
|
|
|
|
|
|
|
return got_data;
|
2019-09-13 07:38:04 +00:00
|
|
|
}
|
|
|
|
|
2019-09-18 00:54:52 +00:00
|
|
|
ImagePipelineNodeCalibrate::ImagePipelineNodeCalibrate(ImagePipelineNode& source,
|
|
|
|
const std::vector<std::uint16_t>& bottom,
|
|
|
|
const std::vector<std::uint16_t>& top) :
|
|
|
|
source_{source}
|
|
|
|
{
|
|
|
|
auto size = std::min(bottom.size(), top.size());
|
|
|
|
offset_.reserve(size);
|
|
|
|
multiplier_.reserve(size);
|
|
|
|
|
|
|
|
for (std::size_t i = 0; i < size; ++i) {
|
|
|
|
offset_.push_back(bottom[i] / 65535.0f);
|
|
|
|
multiplier_.push_back(65535.0f / (top[i] - bottom[i]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ImagePipelineNodeCalibrate::get_next_row_data(std::uint8_t* out_data)
|
|
|
|
{
|
|
|
|
bool ret = source_.get_next_row_data(out_data);
|
|
|
|
|
|
|
|
auto format = get_format();
|
|
|
|
auto depth = get_pixel_format_depth(format);
|
|
|
|
std::size_t max_value = 1;
|
|
|
|
switch (depth) {
|
|
|
|
case 8: max_value = 255; break;
|
|
|
|
case 16: max_value = 65535; break;
|
|
|
|
default:
|
|
|
|
throw SaneException("Unsupported depth for calibration %d", depth);
|
|
|
|
}
|
|
|
|
unsigned channels = get_pixel_channels(format);
|
|
|
|
|
|
|
|
std::size_t max_calib_i = offset_.size();
|
|
|
|
std::size_t curr_calib_i = 0;
|
|
|
|
|
|
|
|
for (std::size_t x = 0, width = get_width(); x < width && curr_calib_i < max_calib_i; ++x) {
|
|
|
|
for (unsigned ch = 0; ch < channels && curr_calib_i < max_calib_i; ++ch) {
|
|
|
|
std::int32_t value = get_raw_channel_from_row(out_data, x, ch, format);
|
|
|
|
|
|
|
|
float value_f = static_cast<float>(value) / max_value;
|
|
|
|
value_f = (value_f - offset_[curr_calib_i]) * multiplier_[curr_calib_i];
|
|
|
|
value_f = std::round(value_f * max_value);
|
|
|
|
value = clamp<std::int32_t>(static_cast<std::int32_t>(value_f), 0, max_value);
|
|
|
|
set_raw_channel_to_row(out_data, x, ch, value, format);
|
|
|
|
|
|
|
|
curr_calib_i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-09-13 14:04:03 +00:00
|
|
|
ImagePipelineNodeDebug::ImagePipelineNodeDebug(ImagePipelineNode& source,
|
|
|
|
const std::string& path) :
|
|
|
|
source_(source),
|
|
|
|
path_{path},
|
|
|
|
buffer_{source_.get_row_bytes()}
|
|
|
|
{}
|
|
|
|
|
|
|
|
ImagePipelineNodeDebug::~ImagePipelineNodeDebug()
|
|
|
|
{
|
|
|
|
catch_all_exceptions(__func__, [&]()
|
|
|
|
{
|
|
|
|
if (buffer_.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
auto format = get_format();
|
|
|
|
buffer_.linearize();
|
|
|
|
sanei_genesys_write_pnm_file(path_.c_str(), buffer_.get_front_row_ptr(),
|
|
|
|
get_pixel_format_depth(format),
|
|
|
|
get_pixel_channels(format),
|
|
|
|
get_width(), buffer_.height());
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-09-16 06:34:09 +00:00
|
|
|
bool ImagePipelineNodeDebug::get_next_row_data(std::uint8_t* out_data)
|
2019-09-13 14:04:03 +00:00
|
|
|
{
|
|
|
|
buffer_.push_back();
|
2019-09-16 06:34:09 +00:00
|
|
|
bool got_data = source_.get_next_row_data(out_data);
|
2019-09-13 14:04:03 +00:00
|
|
|
std::memcpy(buffer_.get_back_row_ptr(), out_data, get_row_bytes());
|
2019-09-16 06:34:09 +00:00
|
|
|
return got_data;
|
2019-09-13 14:04:03 +00:00
|
|
|
}
|
|
|
|
|
2019-09-13 07:38:04 +00:00
|
|
|
std::size_t ImagePipelineStack::get_input_width() const
|
|
|
|
{
|
|
|
|
ensure_node_exists();
|
|
|
|
return nodes_.front()->get_width();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::size_t ImagePipelineStack::get_input_height() const
|
|
|
|
{
|
|
|
|
ensure_node_exists();
|
|
|
|
return nodes_.front()->get_height();
|
|
|
|
}
|
|
|
|
|
|
|
|
PixelFormat ImagePipelineStack::get_input_format() const
|
|
|
|
{
|
|
|
|
ensure_node_exists();
|
|
|
|
return nodes_.front()->get_format();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::size_t ImagePipelineStack::get_input_row_bytes() const
|
|
|
|
{
|
|
|
|
ensure_node_exists();
|
|
|
|
return nodes_.front()->get_row_bytes();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::size_t ImagePipelineStack::get_output_width() const
|
|
|
|
{
|
|
|
|
ensure_node_exists();
|
|
|
|
return nodes_.back()->get_width();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::size_t ImagePipelineStack::get_output_height() const
|
|
|
|
{
|
|
|
|
ensure_node_exists();
|
|
|
|
return nodes_.back()->get_height();
|
|
|
|
}
|
|
|
|
|
|
|
|
PixelFormat ImagePipelineStack::get_output_format() const
|
|
|
|
{
|
|
|
|
ensure_node_exists();
|
|
|
|
return nodes_.back()->get_format();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::size_t ImagePipelineStack::get_output_row_bytes() const
|
|
|
|
{
|
|
|
|
ensure_node_exists();
|
|
|
|
return nodes_.back()->get_row_bytes();
|
|
|
|
}
|
|
|
|
|
|
|
|
void ImagePipelineStack::ensure_node_exists() const
|
|
|
|
{
|
|
|
|
if (nodes_.empty()) {
|
|
|
|
throw SaneException("The pipeline does not contain any nodes");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-13 14:04:03 +00:00
|
|
|
void ImagePipelineStack::clear()
|
|
|
|
{
|
|
|
|
// we need to destroy the nodes back to front, so that the destructors still have valid
|
|
|
|
// references to sources
|
|
|
|
for (auto it = nodes_.rbegin(); it != nodes_.rend(); ++it) {
|
|
|
|
it->reset();
|
|
|
|
}
|
|
|
|
nodes_.clear();
|
|
|
|
}
|
|
|
|
|
2019-09-13 07:38:04 +00:00
|
|
|
std::vector<std::uint8_t> ImagePipelineStack::get_all_data()
|
|
|
|
{
|
|
|
|
auto row_bytes = get_output_row_bytes();
|
|
|
|
auto height = get_output_height();
|
|
|
|
|
|
|
|
std::vector<std::uint8_t> ret;
|
|
|
|
ret.resize(row_bytes * height);
|
|
|
|
|
|
|
|
for (std::size_t i = 0; i < height; ++i) {
|
|
|
|
get_next_row_data(ret.data() + row_bytes * i);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
2019-09-17 14:20:58 +00:00
|
|
|
|
|
|
|
Image ImagePipelineStack::get_image()
|
|
|
|
{
|
|
|
|
auto height = get_output_height();
|
|
|
|
|
|
|
|
Image ret;
|
|
|
|
ret.resize(get_output_width(), height, get_output_format());
|
|
|
|
|
|
|
|
for (std::size_t i = 0; i < height; ++i) {
|
|
|
|
get_next_row_data(ret.get_row_ptr(i));
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
2019-10-02 09:01:28 +00:00
|
|
|
|
|
|
|
} // namespace genesys
|