Update upstream source from tag 'upstream/1.0.31'

Update to upstream version '1.0.31'
with Debian dir aa7a39fe56343f5e164eec83783f4c923a394865

1 files changed, 17 insertions, 110 deletions

diff --git a/backend/genesys/image_buffer.cpp b/backend/genesys/image_buffer.cpp
index 07c6987..c4f8019 100644
--- a/backend/genesys/image_buffer.cpp
+++ b/backend/genesys/image_buffer.cpp
@@ -45,13 +45,13 @@
 
 #include "image_buffer.h"
 #include "image.h"
+#include "utilities.h"
 
 namespace genesys {
 
 ImageBuffer::ImageBuffer(std::size_t size, ProducerCallback producer) :
     producer_{producer},
-    size_{size},
-    buffer_offset_{size}
+    size_{size}
 {
     buffer_.resize(size_);
 }
@@ -81,123 +81,30 @@ bool ImageBuffer::get_data(std::size_t size, std::uint8_t* out_data)
     bool got_data = true;
     do {
         buffer_offset_ = 0;
-        got_data &= producer_(size_, buffer_.data());
 
-        copy_buffer();
-    } while(out_data < out_data_end && got_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,
-                                             ProducerCallback producer) :
-    remaining_size_{total_size},
-    buffer_model_{buffer_model},
-    producer_{producer}
-{}
+        std::size_t size_to_read = size_;
+        if (remaining_size_ != BUFFER_SIZE_UNSET) {
+            size_to_read = std::min<std::uint64_t>(size_to_read, remaining_size_);
+            remaining_size_ -= size_to_read;
+        }
 
-bool ImageBufferGenesysUsb::get_data(std::size_t size, std::uint8_t* out_data)
-{
-    const std::uint8_t* out_data_end = out_data + size;
+        std::size_t aligned_size_to_read = size_to_read;
+        if (remaining_size_ == 0 && last_read_multiple_ != BUFFER_SIZE_UNSET) {
+            aligned_size_to_read = align_multiple_ceil(size_to_read, last_read_multiple_);
+        }
 
-    auto copy_buffer = [&]()
-    {
-        std::size_t bytes_copy = std::min<std::size_t>(out_data_end - out_data, available());
-        std::memcpy(out_data, buffer_.data() + buffer_offset_, bytes_copy);
-        out_data += bytes_copy;
-        buffer_offset_ += bytes_copy;
-    };
+        got_data &= producer_(aligned_size_to_read, buffer_.data());
+        curr_size_ = size_to_read;
 
-    // first, read remaining data from buffer
-    if (available() > 0) {
         copy_buffer();
-    }
-
-    if (out_data == out_data_end) {
-        return true;
-    }
-
-    // now the buffer is empty and there's more data to be read
-    do {
-        if (remaining_size_ == 0)
-            return false;
 
-        auto bytes_to_read = get_read_size();
-        buffer_offset_ = 0;
-        buffer_end_ = bytes_to_read;
-        buffer_.resize(bytes_to_read);
-
-        producer_(bytes_to_read, buffer_.data());
-
-        if (remaining_size_ < bytes_to_read) {
-            remaining_size_ = 0;
-        } else {
-            remaining_size_ -= bytes_to_read;
+        if (remaining_size_ == 0 && out_data < out_data_end) {
+            got_data = false;
         }
 
-        copy_buffer();
-    } while(out_data < out_data_end);
-    return true;
-}
-
-std::size_t ImageBufferGenesysUsb::get_read_size()
-{
-    std::size_t size = buffer_model_.available_space();
+    } while (out_data < out_data_end && got_data);
 
-    // never read an odd number. exception: last read
-    // the chip internal counter does not count half words.
-    size &= ~1;
-
-    // Some setups need the reads to be multiples of 256 bytes
-    size &= ~0xff;
-
-    if (remaining_size_ < size) {
-        size = remaining_size_;
-        /*round up to a multiple of 256 bytes */
-        size += (size & 0xff) ? 0x100 : 0x00;
-        size &= ~0xff;
-    }
-
-    buffer_model_.simulate_read(size);
-
-    return size;
+    return got_data;
 }
 
 } // namespace genesys