Merge pull request #427 from Tom94/small-vector

Tom94 · web-flow · commit 3071126129de · 2026-03-09T06:39:03.000+01:00
feat(channel): small buffer optimization for MultiChannelView
diff --git a/.gitmodules b/.gitmodules
@@ -106,3 +106,7 @@
 	path = dependencies/libtiff
 	url = https://github.com/Tom94/libtiff
 	shallow = true
+[submodule "dependencies/small_vector"]
+	path = dependencies/small_vector
+	url = https://github.com/gharveymn/small_vector
+	shallow = true
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -243,6 +243,7 @@ target_include_directories(tev PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/dependencies
     ${CMAKE_CURRENT_SOURCE_DIR}/dependencies/args
     ${CMAKE_CURRENT_SOURCE_DIR}/dependencies/qoi
+    ${CMAKE_CURRENT_SOURCE_DIR}/dependencies/small_vector/source/include
     ${CMAKE_CURRENT_SOURCE_DIR}/dependencies/stb
     ${CMAKE_CURRENT_SOURCE_DIR}/dependencies/tinylogger
     ${CMAKE_CURRENT_SOURCE_DIR}/dependencies/utfcpp/source
diff --git a/dependencies/small_vector b/dependencies/small_vector
@@ -0,0 +1 @@
+Subproject commit b19a9c477cad5e58f8aed59dbe9be1c30e4b9826
diff --git a/include/tev/Channel.h b/include/tev/Channel.h
@@ -22,16 +22,15 @@
 #include <tev/Common.h>
 #include <tev/Task.h>
 
-#include <nanogui/vector.h>
-
+#include <gch/small_vector.hpp>
 #include <half.h>
+#include <nanogui/vector.h>
 
 #include <memory>
 #include <ranges>
 #include <span>
 #include <string>
 #include <type_traits>
-#include <vector>
 
 namespace tev {
 
@@ -62,7 +61,7 @@ template <typename T> class ChannelView {
 public:
     ChannelView(const ChannelView<std::remove_const_t<T>>& other)
         requires(!std::is_same_v<T, std::remove_const_t<T>>)
-        : ChannelView(other.data(), other.dataStride(), other.dataOffset(), other.size()) {}
+        : ChannelView(other.data(), other.dataStride(), 0, other.size()) {}
 
     ChannelView(const ChannelView&) = default;
     ChannelView& operator=(const ChannelView&) = default;
@@ -71,14 +70,14 @@ template <typename T> class ChannelView {
     ChannelView& operator=(ChannelView&&) = default;
 
     ChannelView(T* data, size_t dataStride, size_t dataOffset, nanogui::Vector2i size) :
-        mData{data}, mDataOffset{dataOffset}, mDataStride{dataStride}, mSize{size} {}
+        mData{data + dataOffset}, mDataStride{dataStride}, mSize{size} {}
 
     std::conditional_t<std::is_same_v<T, float>, float&, float> operator[](size_t i) const & {
         if constexpr (std::is_integral_v<T>) {
-            const auto v = mData[mDataOffset + i * mDataStride];
+            const auto v = mData[i * mDataStride];
             return (float)v / (float)std::numeric_limits<T>::max();
         } else {
-            return mData[mDataOffset + i * mDataStride];
+            return mData[i * mDataStride];
         }
     }
 
@@ -90,7 +89,7 @@ template <typename T> class ChannelView {
     float operator[](int x, int y) const && { return this->operator[](x, y); }
 
     void setAt(size_t i, float value) const {
-        T& val = mData[mDataOffset + i * mDataStride];
+        T& val = mData[i * mDataStride];
         if constexpr (std::is_integral_v<T>) {
             if constexpr (std::is_signed_v<T>) {
                 val = (T)(std::clamp(value, -1.0f, 1.0f) * (float)std::numeric_limits<T>::max() + copysignf(0.5f, value));
@@ -108,12 +107,10 @@ template <typename T> class ChannelView {
 
     T* data() const & { return mData; }
 
-    size_t dataOffset() const { return mDataOffset; }
     size_t dataStride() const { return mDataStride; }
 
 private:
     T* mData = nullptr;
-    size_t mDataOffset = 0;
     size_t mDataStride = 1;
     nanogui::Vector2i mSize = {0};
 };
@@ -345,6 +342,9 @@ class Channel {
     size_t mDataStride;
 };
 
+template <typename T> using SmallRgbaVector = gch::small_vector<T, 4>; // Up to 4 channels should be stored on the stack
+inline constexpr detail::to_vector_fn<SmallRgbaVector> toSmallRgbaVector{};
+
 template <typename T> class MultiChannelView {
 public:
     MultiChannelView() = delete;
@@ -354,7 +354,10 @@ template <typename T> class MultiChannelView {
             numChannels = dataStride;
         }
 
-        mSize = size;
+        if (numChannels == 0) {
+            throw std::runtime_error{"MultiChannelView(ptr) must have at least one channel."};
+        }
+
         for (size_t c = 0; c < numChannels; ++c) {
             mChannelViews.emplace_back(data, dataStride, c, size);
         }
@@ -367,20 +370,20 @@ template <typename T> class MultiChannelView {
 
     MultiChannelView(std::span<Channel> channels)
         requires(!std::is_const_v<T>)
-        : MultiChannelView{channels | std::views::transform([](Channel& c) { return c.view<T>(); }) | to_vector} {}
+        : MultiChannelView{channels | std::views::transform([](Channel& c) { return c.view<T>(); }) | toSmallRgbaVector} {}
 
     MultiChannelView(std::span<const Channel> channels)
         requires(std::is_const_v<T>)
-        : MultiChannelView{channels | std::views::transform([](const Channel& c) { return c.view<T>(); }) | to_vector} {}
+        : MultiChannelView{channels | std::views::transform([](const Channel& c) { return c.view<T>(); }) | toSmallRgbaVector} {}
 
     MultiChannelView(std::span<const ChannelView<T>> views) : mChannelViews{views.begin(), views.end()} {
         if (mChannelViews.empty()) {
-            throw std::runtime_error{"MultiChannelView must have at least one channel."};
+            throw std::runtime_error{"MultiChannelView(span) must have at least one channel."};
         }
 
-        mSize = mChannelViews.front().size();
+        const auto s = mChannelViews.front().size();
         for (const auto& channel : mChannelViews) {
-            if (channel.size() != mSize) {
+            if (channel.size() != s) {
                 throw std::runtime_error{"All channels in a MultiChannelView must have the same size."};
             }
         }
@@ -392,8 +395,8 @@ template <typename T> class MultiChannelView {
     decltype(auto) operator[](int c, size_t i) const & { return mChannelViews[channelIdx(c)][i]; }
     decltype(auto) operator[](int c, int x, int y) const & { return mChannelViews[channelIdx(c)][x, y]; }
 
-    float operator[](int c, size_t i) const && { return mChannelViews[channelIdx(c)][i]; }
-    float operator[](int c, int x, int y) const && { return mChannelViews[channelIdx(c)][x, y]; }
+    auto operator[](int c, size_t i) const && { return mChannelViews[channelIdx(c)][i]; }
+    auto operator[](int c, int x, int y) const && { return mChannelViews[channelIdx(c)][x, y]; }
 
     void setAt(int c, size_t i, float value) const { mChannelViews[channelIdx(c)].setAt(i, value); }
     void setAt(int c, int x, int y, float value) const { mChannelViews[channelIdx(c)].setAt(x, y, value); }
@@ -402,7 +405,8 @@ template <typename T> class MultiChannelView {
         const auto& front = mChannelViews.front();
         for (size_t i = 0; i < mChannelViews.size(); ++i) {
             const auto& channel = mChannelViews[i];
-            if (channel.data() != front.data() || channel.dataOffset() != i || channel.dataStride() != front.dataStride()) {
+            const auto offset = channel.data() - front.data();
+            if (channel.data() != front.data() || offset != (ptrdiff_t)i || channel.dataStride() != front.dataStride()) {
                 return std::nullopt;
             }
         }
@@ -420,12 +424,11 @@ template <typename T> class MultiChannelView {
         return mChannelViews.front().data();
     }
 
-    nanogui::Vector2i size() const { return mSize; }
+    nanogui::Vector2i size() const { return mChannelViews.front().size(); }
     size_t nChannels() const { return mChannelViews.size(); }
 
 private:
-    std::vector<ChannelView<T>> mChannelViews;
-    nanogui::Vector2i mSize = {0};
+    SmallRgbaVector<ChannelView<T>> mChannelViews;
 };
 
 } // namespace tev
diff --git a/include/tev/Common.h b/include/tev/Common.h
@@ -257,18 +257,18 @@ namespace fs = std::filesystem;
 //       Same for fixed_chunks once std::ranges::views::chunk becomes available.
 namespace detail {
 
-struct to_vector_fn {
+template <template <typename...> class Vector> struct to_vector_fn {
     template <std::ranges::range R> friend constexpr auto operator|(R&& r, to_vector_fn) {
         using value_type = std::ranges::range_value_t<R>;
         if constexpr (std::ranges::sized_range<R>) {
-            std::vector<value_type> v;
+            Vector<value_type> v;
             v.reserve(std::ranges::size(r));
             for (auto&& e : r) {
                 v.emplace_back(static_cast<decltype(e)&&>(e));
             }
             return v;
         } else {
-            return std::vector<value_type>(std::ranges::begin(r), std::ranges::end(r));
+            return Vector<value_type>(std::ranges::begin(r), std::ranges::end(r));
         }
     }
 };
@@ -282,7 +282,7 @@ template <size_t N> struct fixed_chunks_fn {
 
 } // namespace detail
 
-inline constexpr detail::to_vector_fn to_vector{};
+inline constexpr detail::to_vector_fn<std::vector> toVector{};
 template <std::size_t N> inline constexpr detail::fixed_chunks_fn<N> fixed_chunks{};
 
 // Helper for std::visit on multiple lambdas
diff --git a/include/tev/imageio/ImageLoader.h b/include/tev/imageio/ImageLoader.h
@@ -27,6 +27,7 @@
 #include <nanogui/vector.h>
 
 #include <istream>
+#include <ranges>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
@@ -72,9 +73,9 @@ Task<void> yCbCrToRgb(MultiChannelView<float> data, int priority, nanogui::Vecto
     );
 }
 
-template <typename T, bool SRGB_TO_LINEAR = false, bool MULTIPLY_ALPHA = false>
+template <bool SRGB_TO_LINEAR = false, bool MULTIPLY_ALPHA = false, std::ranges::random_access_range T>
 Task<void> toFloat32(
-    std::span<const T> imageData,
+    T&& imageData,
     size_t numSamplesPerPixelIn,
     MultiChannelView<float> floatData,
     bool hasAlpha,
@@ -84,9 +85,10 @@ Task<void> toFloat32(
     // 0 defaults to numSamplesPerPixelIn * size.x()
     size_t numSamplesPerRowIn = 0
 ) {
-    if constexpr (std::is_integral_v<T>) {
+    using value_t = typename std::remove_cvref_t<T>::value_type;
+    if constexpr (std::is_integral_v<value_t>) {
         if (scale == 0.0f) {
-            scale = 1.0f / (((size_t)1 << (sizeof(T) * 8)) - 1);
+            scale = 1.0f / (((size_t)1 << (sizeof(value_t) * 8)) - 1);
         }
     } else {
         if (scale == 0.0f) {
diff --git a/src/HelpWindow.cpp b/src/HelpWindow.cpp
@@ -262,6 +262,7 @@ HelpWindow::HelpWindow(Widget* parent, weak_ptr<Ipc> weakIpc, function<void()> c
     addLibrary(about, "OpenEXR", "EXR image format library");
     addLibrary(about, "OpenJPEG", "JPEG 2000 image format library");
     addLibrary(about, "qoi", "QOI image format library");
+    addLibrary(about, "small_vector", "Vector with small buffer optimization");
     addLibrary(about, "stb_image(_write)", "Single-header library for loading and writing images");
     addLibrary(about, "tinylogger", "Minimal pretty-logging library");
     addLibrary(about, "UTF8-CPP", "Lightweight UTF-8 string manipulation library");
diff --git a/src/Image.cpp b/src/Image.cpp
@@ -1109,7 +1109,7 @@ Task<vector<Channel>> Image::getHdrImageData(shared_ptr<Image> reference, string
         result.emplace_back(toUpper(Channel::tail(channelNames[i])), size, EPixelFormat::F32, EPixelFormat::F32);
     }
 
-    const auto views = result | views::transform([](Channel& c) { return c.view<float>(); }) | to_vector;
+    const auto views = result | views::transform([](Channel& c) { return c.view<float>(); }) | toVector;
     const auto channels = this->channels(channelNames);
     if (!reference) {
         co_await ThreadPool::global().parallelFor(
diff --git a/src/ImageCanvas.cpp b/src/ImageCanvas.cpp
@@ -809,7 +809,7 @@ Task<shared_ptr<CanvasStatistics>> ImageCanvas::computeCanvasStatistics(
     });
 
     auto flattened = co_await image->getHdrImageData(reference, requestedChannelGroup, metric, priority);
-    const auto views = flattened | views::transform([](Channel& c) { return c.view<float>(); }) | to_vector;
+    const auto views = flattened | views::transform([](Channel& c) { return c.view<float>(); }) | toVector;
 
     const ChannelView<float>* alphaChannel = nullptr;
 
diff --git a/src/imageio/DdsImageLoader.cpp b/src/imageio/DdsImageLoader.cpp
@@ -258,7 +258,7 @@ Task<vector<ImageData>> DdsImageLoader::load(istream& iStream, const fs::path&,
     } else {
         // Ideally, we'd be able to assume that only *_SRGB format images were in sRGB space, and only they need to converted to linear.
         // However, RGB(A) DDS images tend to be in sRGB space, even those not explicitly stored in an *_SRGB format.
-        co_await toFloat32<float, true>(s, numChannels, outView, hasAlpha, priority);
+        co_await toFloat32<true>(s, numChannels, outView, hasAlpha, priority);
     }
 
     co_return result;
diff --git a/src/imageio/ImageLoader.cpp b/src/imageio/ImageLoader.cpp
@@ -234,8 +234,8 @@ Task<void> ImageLoader::resizeChannelsAsync(
         co_return;
     }
 
-    const auto srcViews = srcChannels | views::transform([](const Channel& c) { return c.view<const float>(); }) | to_vector;
-    const auto dstViews = dstChannels | views::transform([](Channel& c) { return c.view<float>(); }) | to_vector;
+    const auto srcViews = srcChannels | views::transform([](const Channel& c) { return c.view<const float>(); }) | toVector;
+    const auto dstViews = dstChannels | views::transform([](Channel& c) { return c.view<float>(); }) | toVector;
 
     const Vector2i size = srcChannels.front().size();
     const Vector2i targetSize = dstChannels.front().size();
@@ -307,7 +307,7 @@ Task<void> ImageLoader::resizeImageData(ImageData& resultData, Vector2i targetSi
 
     auto resizedChannels = resultData.channels |
         views::transform([targetSize](const Channel& c) { return Channel{c.name(), targetSize, c.pixelFormat(), c.desiredPixelFormat()}; }) |
-        to_vector;
+        toVector;
 
     co_await resizeChannelsAsync(resultData.channels, resizedChannels, targetArea, priority);
 
diff --git a/src/imageio/JpegTurboImageLoader.cpp b/src/imageio/JpegTurboImageLoader.cpp
@@ -498,16 +498,16 @@ Task<vector<ImageData>>
             numChannels, numInterleavedChannels, hasAlpha, size, EPixelFormat::F32, EPixelFormat::F16, resultData.partName, priority
         );
 
-        const auto jpegDataToFloat32Typed = [&](auto src, bool fromSrgb, const MultiChannelView<float>& dst) -> Task<void> {
+        const auto jpegDataToFloat32Typed =
+            [&](ranges::random_access_range auto&& src, bool fromSrgb, const MultiChannelView<float>& dst) -> Task<void> {
             const float scale = 1.0f / ((1 << cinfo.data_precision) - 1);
 
             const bool yCbCrConversionNeeded = cinfo.out_color_space == JCS_YCbCr && dst.nChannels() >= 3;
 
-            using T = remove_const_t<typename decltype(src)::value_type>;
             if (fromSrgb && !yCbCrConversionNeeded) {
-                co_await toFloat32<T, true>(src, numChannels, dst, hasAlpha, priority, scale);
+                co_await toFloat32<true>(src, numChannels, dst, hasAlpha, priority, scale);
             } else {
-                co_await toFloat32<T, false>(src, numChannels, dst, hasAlpha, priority, scale);
+                co_await toFloat32<false>(src, numChannels, dst, hasAlpha, priority, scale);
             }
 
             if (yCbCrConversionNeeded) {
diff --git a/src/imageio/PfmImageLoader.cpp b/src/imageio/PfmImageLoader.cpp
@@ -420,7 +420,7 @@ Task<vector<ImageData>> PfmImageLoader::load(istream& iStream, const fs::path&,
                     );
                 }
 
-                co_await toFloat32<uint32_t, true>(uintData, numChannels, dstView, hasAlpha, priority, scale);
+                co_await toFloat32<true>(uintData, numChannels, dstView, hasAlpha, priority, scale);
             } else if (bitsPerChannel == 16) {
                 const auto uintData = buf.span<uint16_t>();
                 if (shallSwapBytes) {
@@ -429,9 +429,9 @@ Task<vector<ImageData>> PfmImageLoader::load(istream& iStream, const fs::path&,
                     );
                 }
 
-                co_await toFloat32<uint16_t, true>(uintData, numChannels, dstView, hasAlpha, priority, scale);
+                co_await toFloat32<true>(uintData, numChannels, dstView, hasAlpha, priority, scale);
             } else if (bitsPerChannel == 8) {
-                co_await toFloat32<uint8_t, true>(buf.span<const uint8_t>(), numChannels, dstView, hasAlpha, priority, scale);
+                co_await toFloat32<true>(buf.span<const uint8_t>(), numChannels, dstView, hasAlpha, priority, scale);
             } else if (bitsPerChannel == 1) {
                 auto* const data = buf.data<uint8_t>();
                 co_await ThreadPool::global().parallelFor(
diff --git a/src/imageio/PngImageLoader.cpp b/src/imageio/PngImageLoader.cpp
diff --git a/src/imageio/QoiImageLoader.cpp b/src/imageio/QoiImageLoader.cpp
diff --git a/src/imageio/StbiImageLoader.cpp b/src/imageio/StbiImageLoader.cpp
diff --git a/src/imageio/TiffImageLoader.cpp b/src/imageio/TiffImageLoader.cpp
diff --git a/src/imageio/WebpImageLoader.cpp b/src/imageio/WebpImageLoader.cpp

Original file line number	Diff line number	Diff line change
`@@ -1109,7 +1109,7 @@ Task<vector<Channel>> Image::getHdrImageData(shared_ptr<Image> reference, string`
`1109`	`1109`	`result.emplace_back(toUpper(Channel::tail(channelNames[i])), size, EPixelFormat::F32, EPixelFormat::F32);`
`1110`	`1110`	`}`
`1111`	`1111`
`1112`		`- const auto views = result \| views::transform([](Channel& c) { return c.view<float>(); }) \| to_vector;`
	`1112`	`+ const auto views = result \| views::transform([](Channel& c) { return c.view<float>(); }) \| toVector;`
`1113`	`1113`	`const auto channels = this->channels(channelNames);`
`1114`	`1114`	`if (!reference) {`
`1115`	`1115`	`co_await ThreadPool::global().parallelFor(`
Original file line number	Diff line number	Diff line change
`@@ -258,7 +258,7 @@ Task<vector<ImageData>> DdsImageLoader::load(istream& iStream, const fs::path&,`
`258`	`258`	`} else {`
`259`	`259`	`// Ideally, we'd be able to assume that only *_SRGB format images were in sRGB space, and only they need to converted to linear.`
`260`	`260`	`// However, RGB(A) DDS images tend to be in sRGB space, even those not explicitly stored in an *_SRGB format.`
`261`		`- co_await toFloat32<float, true>(s, numChannels, outView, hasAlpha, priority);`
	`261`	`+ co_await toFloat32<true>(s, numChannels, outView, hasAlpha, priority);`
`262`	`262`	`}`
`263`	`263`
`264`	`264`	`co_return result;`