Change calling convention to const ref

Signed-off-by: Larry Gritz <lg@larrygritz.com>

Author: lgritz

src/include/OpenImageIO/image_span.h

@@ -365,7 +365,7 @@ template<typename T> using image1d_span = image_span<T, 2>;
 /// covering the same range of memory.
 template<typename T, size_t Rank>
 image_span<const std::byte>
-as_image_span_bytes(image_span<T, Rank> src) noexcept
+as_image_span_bytes(const image_span<T, Rank>& src) noexcept
 {
     return image_span<const std::byte>(
         reinterpret_cast<const std::byte*>(src.data()), src.nchannels(),
@@ -378,7 +378,7 @@ as_image_span_bytes(image_span<T, Rank> src) noexcept
 /// the same range of memory.
 template<typename T, size_t Rank>
 image_span<std::byte>
-as_image_span_writable_bytes(image_span<T, Rank> src) noexcept
+as_image_span_writable_bytes(const image_span<T, Rank>& src) noexcept
 {
     return image_span<std::byte>(reinterpret_cast<std::byte*>(src.data()),
                                  src.nchannels(), src.width(), src.height(),

src/include/OpenImageIO/imageio.h

@@ -2296,12 +2296,13 @@ class OIIO_API ImageOutput {
     ///                     y, and z).
     /// @returns            `true` upon success, or `false` upon failure.
     ///
-    virtual bool write_image(TypeDesc format, image_span<const std::byte> data);
+    virtual bool write_image(TypeDesc format,
+                             const image_span<const std::byte>& data);
 
     /// A version of `write_image()` taking an `image_span<T>`, where the type
     /// of the underlying data is `T`.  This is a convenience wrapper around
     /// the `write_image()` that takes an `image_span<const std::byte>`.
-    template<typename T> bool write_image(image_span<T> data)
+    template<typename T> bool write_image(const image_span<T>& data)
     {
         return write_image(TypeDescFromC<T>::value(),
                            as_image_span_bytes(data));
@@ -2340,13 +2341,14 @@ class OIIO_API ImageOutput {
     /// @returns            `true` upon success, or `false` upon failure.
     ///
     virtual bool write_scanline(int y, int z, TypeDesc format,
-                                image_span<const std::byte> data);
+                                const image_span<const std::byte>& data);
 
     /// A version of `write_scanline()` taking an `image_span<T>`, where the
     /// type of the underlying data is `T`.  This is a convenience wrapper
     /// around the `write_scanline()` that takes an `image_span<const
     /// std::byte>`.
-    template<typename T> bool write_scanline(int y, int z, image_span<T> data)
+    template<typename T>
+    bool write_scanline(int y, int z, const image_span<T>& data)
     {
         // reduce to type + image_span<byte>
         return write_scanline(y, z, TypeDescFromC<T>::value(),
@@ -2389,14 +2391,14 @@ class OIIO_API ImageOutput {
     /// @returns            `true` upon success, or `false` upon failure.
     ///
     virtual bool write_scanlines(int ybegin, int yend, int z, TypeDesc format,
-                                 image_span<const std::byte> data);
+                                 const image_span<const std::byte>& data);
 
     /// A version of `write_scanlines()` taking an `image_span<T>`, where the
     /// type of the underlying data is `T`.  This is a convenience wrapper
     /// around the `write_scanlines()` that takes an `image_span<const
     /// std::byte>`.
     template<typename T>
-    bool write_scanlines(int ybegin, int yend, int z, image_span<T> data)
+    bool write_scanlines(int ybegin, int yend, int z, const image_span<T>& data)
     {
         // image_span<T>: reduces to type + byte_buffer
         return write_scanlines(ybegin, yend, z, TypeDescFromC<T>::value(),
@@ -2442,13 +2444,13 @@ class OIIO_API ImageOutput {
     /// @returns            `true` upon success, or `false` upon failure.
     ///
     virtual bool write_tile(int x, int y, int z, TypeDesc format,
-                            image_span<const std::byte> data);
+                            const image_span<const std::byte>& data);
 
     /// A version of `write_tile()` taking an `image_span<T>`, where the type
     /// of the underlying data is `T`.  This is a convenience wrapper around
     /// the `write_tile()` that takes an `image_span<const std::byte>`.
     template<typename T>
-    bool write_tile(int x, int y, int z, image_span<T> data)
+    bool write_tile(int x, int y, int z, const image_span<T>& data)
     {
         return write_tile(x, y, z, TypeDescFromC<T>::value(),
                           as_image_span_bytes(data));
@@ -2495,14 +2497,14 @@ class OIIO_API ImageOutput {
     ///
     virtual bool write_tiles(int xbegin, int xend, int ybegin, int yend,
                              int zbegin, int zend, TypeDesc format,
-                             image_span<const std::byte> data);
+                             const image_span<const std::byte>& data);
 
     /// A version of `write_tiles()` taking an `image_span<T>`, where the type
     /// of the underlying data is `T`.  This is a convenience wrapper around
     /// the `write_tiles()` that takes an `image_span<const std::byte>`.
     template<typename T>
     bool write_tiles(int xbegin, int xend, int ybegin, int yend, int zbegin,
-                     int zend, image_span<T> data)
+                     int zend, const image_span<T>& data)
     {
         return write_tiles(xbegin, xend, ybegin, yend, zbegin, zend,
                            TypeDescFromC<T>::value(),
@@ -2550,15 +2552,15 @@ class OIIO_API ImageOutput {
     ///
     virtual bool write_rectangle(int xbegin, int xend, int ybegin, int yend,
                                  int zbegin, int zend, TypeDesc format,
-                                 image_span<const std::byte> data);
+                                 const image_span<const std::byte>& data);
 
     /// A version of `write_rectangle()` taking an `image_span<T>`, where the
     /// type of the underlying data is `T`.  This is a convenience wrapper
     /// around the `write_rectangle()` that takes an `image_span<const
     /// std::byte>`.
     template<typename T>
     bool write_rectangle(int xbegin, int xend, int ybegin, int yend, int zbegin,
-                         int zend, image_span<T> data)
+                         int zend, const image_span<T>& data)
     {
         return write_rectangle(xbegin, xend, ybegin, yend, zbegin, zend,
                                TypeDescFromC<T>::value(),
@@ -3141,7 +3143,7 @@ class OIIO_API ImageOutput {
     /// the pixels to the right position in the dither pattern.
     template<typename T>
     cspan<std::byte> to_native(int xbegin, int xend, int ybegin, int yend,
-                               int zbegin, int zend, image_span<T> data,
+                               int zbegin, int zend, const image_span<T>& data,
                                std::vector<unsigned char>& scratch,
                                unsigned int dither = 0, int xorigin = 0,
                                int yorigin = 0, int zorigin = 0)
@@ -3158,7 +3160,7 @@ class OIIO_API ImageOutput {
     /// `format` and an image_span of generic (std::byte) data.
     cspan<std::byte> to_native(int xbegin, int xend, int ybegin, int yend,
                                int zbegin, int zend, TypeDesc format,
-                               image_span<const std::byte> data,
+                               const image_span<const std::byte>& data,
                                std::vector<unsigned char>& scratch,
                                unsigned int dither = 0, int xorigin = 0,
                                int yorigin = 0, int zorigin = 0);
@@ -3856,7 +3858,7 @@ OIIO_API bool convert_image (int nchannels, int width, int height, int depth,
 /// Return true if ok, false if it didn't know how to do the conversion.
 template<typename SrcType, typename DstType>
 bool
-convert_image(image_span<SrcType> src, image_span<DstType> dst)
+convert_image(const image_span<SrcType>& src, const image_span<DstType>& dst)
 {
     // For now, just implement by wrapping the pointer-based version.
     OIIO_DASSERT(src.nchannels() == dst.nchannels()
@@ -3876,8 +3878,8 @@ convert_image(image_span<SrcType> src, image_span<DstType> dst)
 /// `TypeDesc`, and the spans are untyped bytes that provide the dimensions
 /// and memory layout.
 inline bool
-convert_image(image_span<const std::byte> src, TypeDesc src_type,
-              image_span<std::byte> dst, TypeDesc dst_type)
+convert_image(const image_span<const std::byte>& src, TypeDesc src_type,
+              const image_span<std::byte>& dst, TypeDesc dst_type)
 {
     // For now, just implement by wrapping the pointer-based version.
     OIIO_DASSERT(src.nchannels() == dst.nchannels()
@@ -3908,8 +3910,8 @@ OIIO_API bool parallel_convert_image (
 /// threads. The data types are taken from the spans.
 template<typename SrcType, typename DstType>
 bool
-parallel_convert_image(image_span<SrcType> src, image_span<DstType> dst,
-                       int nthreads = 0)
+parallel_convert_image(const image_span<SrcType>& src,
+                       const image_span<DstType>& dst, int nthreads = 0)
 {
     // For now, just implement by wrapping the pointer-based version.
     OIIO_DASSERT(src.nchannels() == dst.nchannels()
@@ -3927,9 +3929,9 @@ parallel_convert_image(image_span<SrcType> src, image_span<DstType> dst,
 /// threads. The data types are passed as `TypeDesc`, and the spans are
 /// untyped bytes that provide the dimensions and memory layout.
 inline bool
-parallel_convert_image(image_span<const std::byte> src, TypeDesc src_type,
-                       image_span<std::byte> dst, TypeDesc dst_type,
-                       int nthreads = 0)
+parallel_convert_image(const image_span<const std::byte>& src,
+                       TypeDesc src_type, const image_span<std::byte>& dst,
+                       TypeDesc dst_type, int nthreads = 0)
 {
     // For now, just implement by wrapping the pointer-based version.
     OIIO_DASSERT(src.nchannels() == dst.nchannels()
@@ -3995,7 +3997,8 @@ OIIO_API bool copy_image (int nchannels, int width, int height, int depth,
 /// strides. Return true if ok, false if it couldn't do it. (Reserved for
 /// future use; currently is always succeeds)
 template<typename D, size_t Drank, typename S, size_t Srank>
-bool copy_image(image_span<D, Drank> dst, image_span<S, Srank> src)
+bool copy_image(const image_span<D, Drank>& dst,
+                const image_span<S, Srank>& src)
 {
     // Arbitrary types are handled by just converting to generic byte
     // image_spans.
@@ -4005,7 +4008,8 @@ bool copy_image(image_span<D, Drank> dst, image_span<S, Srank> src)
 
 /// copy_image base case: generic span of bytes.
 OIIO_API bool
-copy_image(image_span<std::byte> dst, image_span<const std::byte> src);
+copy_image(const image_span<std::byte> &dst,
+           const image_span<const std::byte>& src);
 
 
 

src/include/imageio_pvt.h

@@ -89,7 +89,7 @@ get_default_quantize(TypeDesc format, long long& quant_min,
 /// which is either dst or src (if the strides indicated that data were
 /// already contiguous).
 OIIO_API span<const std::byte>
-contiguize(image_span<const std::byte> src, span<std::byte> dst);
+contiguize(const image_span<const std::byte>& src, span<std::byte> dst);
 
 /// Turn potentially non-contiguous-stride data (e.g. "RGBxRGBx") into
 /// contiguous-stride ("RGBRGB"), for any format or stride values

src/libOpenImageIO/imageio.cpp

@@ -734,7 +734,7 @@ _contiguize(const T* src, int nchannels, stride_t xstride, stride_t ystride,
 
 
 span<const std::byte>
-pvt::contiguize(image_span<const std::byte> src, span<std::byte> dst)
+pvt::contiguize(const image_span<const std::byte>& src, span<std::byte> dst)
 {
     // Contiguized result must fit in dst
     OIIO_DASSERT(src.size_bytes() <= dst.size_bytes());
@@ -1053,7 +1053,8 @@ copy_image(int nchannels, int width, int height, int depth, const void* src,
 
 template<typename T>
 void
-aligned_copy_image(image_span<std::byte> dst, image_span<const std::byte> src)
+aligned_copy_image(const image_span<std::byte>& dst,
+                   const image_span<const std::byte>& src)
 {
     size_t systride  = src.ystride();
     size_t dystride  = dst.ystride();
@@ -1081,7 +1082,8 @@ aligned_copy_image(image_span<std::byte> dst, image_span<const std::byte> src)
 
 
 bool
-copy_image(image_span<std::byte> dst, image_span<const std::byte> src)
+copy_image(const image_span<std::byte>& dst,
+           const image_span<const std::byte>& src)
 {
     OIIO_DASSERT(src.width() == dst.width() && src.height() == dst.height()
                  && src.depth() == dst.depth()

src/libOpenImageIO/imageoutput.cpp

@@ -112,7 +112,7 @@ ImageOutput::write_scanline(int /*y*/, int /*z*/, TypeDesc /*format*/,
 
 bool
 ImageOutput::write_scanline(int y, int z, TypeDesc format,
-                            image_span<const std::byte> data)
+                            const image_span<const std::byte>& data)
 {
     size_t sz = (format == TypeUnknown ? m_spec.pixel_bytes(true /*native*/)
                                        : format.size() * m_spec.nchannels)
@@ -154,7 +154,7 @@ ImageOutput::write_scanlines(int ybegin, int yend, int z, TypeDesc format,
 
 bool
 ImageOutput::write_scanlines(int ybegin, int yend, int z, TypeDesc format,
-                             image_span<const std::byte> data)
+                             const image_span<const std::byte>& data)
 {
     size_t sz = (format == TypeUnknown ? m_spec.pixel_bytes(true /*native*/)
                                        : format.size() * m_spec.nchannels)
@@ -186,7 +186,7 @@ ImageOutput::write_tile(int /*x*/, int /*y*/, int /*z*/, TypeDesc /*format*/,
 
 bool
 ImageOutput::write_tile(int x, int y, int z, TypeDesc format,
-                        image_span<const std::byte> data)
+                        const image_span<const std::byte>& data)
 {
     size_t sz = format == TypeUnknown
                     ? m_spec.pixel_bytes(true /*native*/)
@@ -267,7 +267,7 @@ ImageOutput::write_tiles(int xbegin, int xend, int ybegin, int yend, int zbegin,
 bool
 ImageOutput::write_tiles(int xbegin, int xend, int ybegin, int yend, int zbegin,
                          int zend, TypeDesc format,
-                         image_span<const std::byte> data)
+                         const image_span<const std::byte>& data)
 {
     // Default implementation (for now): call the old pointer+stride
     return write_tiles(xbegin, xend, ybegin, yend, zbegin, zend, format,
@@ -293,7 +293,7 @@ bool
 ImageOutput::write_rectangle(int /*xbegin*/, int /*xend*/, int /*ybegin*/,
                              int /*yend*/, int /*zbegin*/, int /*zend*/,
                              TypeDesc /*format*/,
-                             image_span<const std::byte> /*data*/)
+                             const image_span<const std::byte>& /*data*/)
 {
     return false;
 }
@@ -570,7 +570,7 @@ ImageOutput::to_native_rectangle(int xbegin, int xend, int ybegin, int yend,
 cspan<std::byte>
 ImageOutput::to_native(int xbegin, int xend, int ybegin, int yend, int zbegin,
                        int zend, TypeDesc format,
-                       image_span<const std::byte> data,
+                       const image_span<const std::byte>& data,
                        std::vector<unsigned char>& scratch, unsigned int dither,
                        int xorigin, int yorigin, int zorigin)
 {
@@ -682,7 +682,8 @@ ImageOutput::write_image(TypeDesc format, const void* data, stride_t xstride,
 
 
 bool
-ImageOutput::write_image(TypeDesc format, image_span<const std::byte> data)
+ImageOutput::write_image(TypeDesc format,
+                         const image_span<const std::byte>& data)
 {
     size_t sz = m_spec.image_bytes(/*native=*/format == TypeUnknown);
     if (sz != data.size_bytes()) {