ImageFormat: stack based interleavers

Author: Grok Compression

.vscode/launch.json

@@ -139,10 +139,11 @@
             "name": "SPOT6",
             "type": "cppdbg",
             "request": "launch",
-            "program": "/usr/bin/time",
+            //"program": "/usr/bin/time",
+            "program": "${workspaceFolder}/build/bin/core_decompress",
             "args": [
-                "-v",
-                "${workspaceFolder}/build/bin/core_decompress",
+                // "-v",
+                // "${workspaceFolder}/build/bin/core_decompress",
                 "-i",
                 "$HOME/temp/IMG_SPOT6_PMS_201305251604372_ORT_816009101_R1C1.JP2",
                 // "-o",

src/lib/codec/apps/GrkDecompress.cpp

@@ -1122,8 +1122,7 @@ int GrkDecompress::preProcess(grk_plugin_decompress_callback_info* info)
   // during decompress.
   incrementalWriteActive_ = false;
   if(storeToDisk && !parameters->single_tile_decompress && !info->init_decompressors_func &&
-     grk_image_is_post_process_no_op(info->image) &&
-     parameters->dw_y1 == 0)
+     grk_image_is_post_process_no_op(info->image) && parameters->dw_y1 == 0)
   {
     if(!writeInit(info))
       goto cleanup;

src/lib/codec/formats/JPEGFormat.h

@@ -92,6 +92,7 @@ class JPEGFormat : public ImageFormat
 {
 public:
   JPEGFormat(void);
+  ~JPEGFormat() override;
   bool writeHeader(void) override;
   bool writeImage() override;
   bool writeImageBand(uint32_t yBegin, uint32_t yEnd) override;
@@ -122,6 +123,7 @@ class JPEGFormat : public ImageFormat
    */
   struct jpeg_compress_struct cinfo;
   T const* planes[4];
+  grk::PlanarToInterleaved<T>* interleaver_;
 };
 
 template<typename T>
@@ -382,9 +384,15 @@ grk_image* JPEGFormat<T>::jpegtoimage(const char* filename, grk_cparameters* par
 template<typename T>
 JPEGFormat<T>::JPEGFormat(void)
     : success(true), buffer(nullptr), buffer32s(nullptr), color_space(JCS_UNKNOWN), adjust(0),
-      readFromStdin(false), planes{0, 0, 0}
+      readFromStdin(false), planes{0, 0, 0}, interleaver_(nullptr)
 {}
 
+template<typename T>
+JPEGFormat<T>::~JPEGFormat()
+{
+  delete interleaver_;
+}
+
 template<typename T>
 bool JPEGFormat<T>::writeHeader(void)
 {
@@ -602,22 +610,24 @@ bool JPEGFormat<T>::writeImageBand(uint32_t yBegin, uint32_t yEnd)
                   cinfo.next_scanline);
     return false;
   }
-  auto iter = grk::InterleaverFactory<T>::makeInterleaver(8);
-  if(!iter)
-    return false;
+  if(!interleaver_)
+  {
+    interleaver_ = grk::InterleaverFactory<T>::makeInterleaver(8);
+    if(!interleaver_)
+      return false;
+  }
   auto stride = image_->comps[0].stride;
   T* bandPlanes[4];
   for(uint16_t i = 0; i < image_->decompress_num_comps; ++i)
     bandPlanes[i] = (T*)image_->comps[i].data + (uint64_t)yBegin * stride;
   while(cinfo.next_scanline < yEnd)
   {
-    iter->interleave(bandPlanes, image_->decompress_num_comps, (uint8_t*)buffer,
-                     image_->decompress_width, stride, image_->decompress_width, 1, adjust);
+    interleaver_->interleave(bandPlanes, image_->decompress_num_comps, (uint8_t*)buffer,
+                             image_->decompress_width, stride, image_->decompress_width, 1, adjust);
     JSAMPROW row_pointer[1];
     row_pointer[0] = buffer;
     jpeg_write_scanlines(&cinfo, row_pointer, 1);
   }
-  delete iter;
 
   return true;
 }

src/lib/codec/formats/PNGFormat.h

@@ -40,6 +40,7 @@ class PNGFormat : public ImageFormat
 {
 public:
   PNGFormat();
+  ~PNGFormat() override;
   bool writeHeader(void) override;
   bool writeImage() override;
   bool writeImageBand(uint32_t yBegin, uint32_t yEnd) override;
@@ -62,6 +63,7 @@ class PNGFormat : public ImageFormat
   GRK_COLOR_SPACE colorSpace_;
   uint8_t prec_;
   uint16_t nr_comp_;
+  grk::PlanarToInterleaved<int32_t>* interleaver_;
 };
 
 static bool pngWarningHandlerVerbose = true;
@@ -91,9 +93,15 @@ static inline void user_error_fn([[maybe_unused]] png_structp png_ptr, png_const
 template<typename T>
 PNGFormat<T>::PNGFormat()
     : info_(nullptr), png_(nullptr), row_buf_(nullptr), row_buf_array_(nullptr), row32s_(nullptr),
-      colorSpace_(GRK_CLRSPC_UNKNOWN), prec_(0), nr_comp_(0)
+      colorSpace_(GRK_CLRSPC_UNKNOWN), prec_(0), nr_comp_(0), interleaver_(nullptr)
 {}
 
+template<typename T>
+PNGFormat<T>::~PNGFormat()
+{
+  delete interleaver_;
+}
+
 template<typename T>
 bool PNGFormat<T>::writeHeader(void)
 {
@@ -332,18 +340,20 @@ bool PNGFormat<T>::writeImageBand(uint32_t yBegin, uint32_t yEnd)
   png_bytep row_buf_cpy = row_buf_;
   int32_t adjust = image_->comps[0].sgnd ? 1 << (prec_ - 1) : 0;
   uint32_t max = std::min<uint32_t>(yEnd, maxY(image_->comps->h));
-  auto iter =
-      grk::InterleaverFactory<int32_t>::makeInterleaver(prec_ == 16 ? grk::packer16BitBE : prec_);
-  if(!iter)
-    return false;
+  if(!interleaver_)
+  {
+    interleaver_ =
+        grk::InterleaverFactory<int32_t>::makeInterleaver(prec_ == 16 ? grk::packer16BitBE : prec_);
+    if(!interleaver_)
+      return false;
+  }
   for(uint32_t y = yBegin; y < max; ++y)
   {
-    iter->interleave((T**)planes, nr_comp_, row_buf_, image_->comps[0].w, stride,
-                     image_->comps[0].w, 1, adjust);
+    interleaver_->interleave((T**)planes, nr_comp_, row_buf_, image_->comps[0].w, stride,
+                             image_->comps[0].w, 1, adjust);
 
     png_write_row(png_, row_buf_cpy);
   }
-  delete iter;
 
   return true;
 }

src/lib/codec/formats/PNMFormat.h

@@ -49,6 +49,7 @@ class PNMFormat : public ImageFormat
 {
 public:
   explicit PNMFormat(bool split);
+  ~PNMFormat() override;
   bool writeHeader(void) override;
   bool writeImage() override;
   bool writeImageBand(uint32_t yBegin, uint32_t yEnd) override;
@@ -65,6 +66,7 @@ class PNMFormat : public ImageFormat
 
 private:
   bool forceSplit;
+  grk::PlanarToInterleaved<int32_t>* interleaver_;
   bool hasAlpha(void);
   bool isOpacity(uint16_t compno);
   bool hasOpacity(void);
@@ -83,9 +85,15 @@ class PNMFormat : public ImageFormat
 };
 
 template<typename T>
-PNMFormat<T>::PNMFormat(bool split) : forceSplit(split)
+PNMFormat<T>::PNMFormat(bool split) : forceSplit(split), interleaver_(nullptr)
 {}
 
+template<typename T>
+PNMFormat<T>::~PNMFormat()
+{
+  delete interleaver_;
+}
+
 template<typename T>
 bool PNMFormat<T>::writeHeader(void)
 {
@@ -226,37 +234,48 @@ bool PNMFormat<T>::writeImageBand(uint32_t yBegin, uint32_t yEnd)
   }
   // Non-split (PPM/PAM) interleaved path
   uint16_t decompress_num_comps = image_->decompress_num_comps;
-  auto planes = std::make_unique<T*[]>(decompress_num_comps);
+  constexpr uint16_t kMaxStackComps = 4;
+  T* stackPlanes[kMaxStackComps];
+  std::unique_ptr<T*[]> heapPlanes;
+  T** planes;
+  if(decompress_num_comps <= kMaxStackComps)
+    planes = stackPlanes;
+  else
+  {
+    heapPlanes = std::make_unique<T*[]>(decompress_num_comps);
+    planes = heapPlanes.get();
+  }
   for(uint32_t i = 0U; i < decompress_num_comps; ++i)
     planes[i] = (T*)image_->comps[i].data + (uint64_t)yBegin * image_->comps[0].stride;
   GrkIOBuf packedBuf;
   T adjust = (image_->comps[0].sgnd ? 1 << (image_->decompress_prec - 1) : 0);
-  auto iter = grk::InterleaverFactory<int32_t>::makeInterleaver(
-      image_->decompress_prec > 8U ? grk::packer16BitBE : 8);
-  if(!iter)
-    return false;
+  if(!interleaver_)
+  {
+    interleaver_ = grk::InterleaverFactory<int32_t>::makeInterleaver(
+        image_->decompress_prec > 8U ? grk::packer16BitBE : 8);
+    if(!interleaver_)
+      return false;
+  }
   uint32_t h = yBegin;
   while(h < yEnd)
   {
     uint32_t stripRows = (std::min)(image_->rows_per_strip, yEnd - h);
     packedBuf = pool.get(image_->packed_row_bytes * stripRows);
-    iter->interleave(((T**)planes.get()), decompress_num_comps, packedBuf.data,
-                     image_->decompress_width, image_->comps[0].stride, image_->packed_row_bytes,
-                     stripRows, adjust);
+    interleaver_->interleave(((T**)planes), decompress_num_comps, packedBuf.data,
+                             image_->decompress_width, image_->comps[0].stride,
+                             image_->packed_row_bytes, stripRows, adjust);
     packedBuf.pooled = true;
     packedBuf.offset = orchestrator.getOffset();
     packedBuf.len = image_->packed_row_bytes * stripRows;
     packedBuf.index = orchestrator.getNumPooledRequests();
     if(!writeStripCore(0, packedBuf))
     {
-      delete iter;
       applicationOrchestratedReclaim(packedBuf);
       return false;
     }
     h += stripRows;
     applicationOrchestratedReclaim(packedBuf);
   }
-  delete iter;
   return true;
 }
 

src/lib/codec/formats/TIFFFormat.h

@@ -687,6 +687,7 @@ class TIFFFormat : public ImageFormat
   size_t units;
   grk_io_callback grkReclaimCallback_;
   void* grkReclaimUserData_;
+  grk::PlanarToInterleaved<T>* interleaver_;
 };
 
 #ifdef GRK_CUSTOM_TIFF_IO
@@ -756,13 +757,14 @@ TIFF* TIFFFormat<T>::MyTIFFOpen(const char* name, const char* mode)
 template<typename T>
 TIFFFormat<T>::TIFFFormat()
     : tif_(nullptr), chroma_subsample_x(1), chroma_subsample_y(1), units(0),
-      grkReclaimCallback_(nullptr), grkReclaimUserData_(nullptr)
+      grkReclaimCallback_(nullptr), grkReclaimUserData_(nullptr), interleaver_(nullptr)
 
 {}
 
 template<typename T>
 TIFFFormat<T>::~TIFFFormat()
 {
+  delete interleaver_;
   if(tif_)
     TIFFClose(tif_);
 }
@@ -1085,8 +1087,25 @@ bool TIFFFormat<T>::writeImageBand(uint32_t yBegin, uint32_t yEnd)
   }
   bool success = false;
   uint16_t numcomps = image_->decompress_num_comps;
-  auto planes = std::make_unique<T*[]>(numcomps);
-  auto planesBegin = std::make_unique<T*[]>(numcomps);
+  constexpr uint16_t kMaxStackComps = 4;
+  T* stackPlanes[kMaxStackComps];
+  T* stackPlanesBegin[kMaxStackComps];
+  std::unique_ptr<T*[]> heapPlanes;
+  std::unique_ptr<T*[]> heapPlanesBegin;
+  T** planes;
+  T** planesBegin;
+  if(numcomps <= kMaxStackComps)
+  {
+    planes = stackPlanes;
+    planesBegin = stackPlanesBegin;
+  }
+  else
+  {
+    heapPlanes = std::make_unique<T*[]>(numcomps);
+    heapPlanesBegin = std::make_unique<T*[]>(numcomps);
+    planes = heapPlanes.get();
+    planesBegin = heapPlanesBegin.get();
+  }
   GrkIOBuf packedBuf;
 
   if(isFinalOutputSubsampled(image_))
@@ -1169,28 +1188,27 @@ bool TIFFFormat<T>::writeImageBand(uint32_t yBegin, uint32_t yEnd)
     {
       planes[i] = (T*)image_->comps[i].data + (uint64_t)yBegin * image_->comps[0].stride;
     }
-    auto iter = grk::InterleaverFactory<T>::makeInterleaver(image_->decompress_prec);
-    if(!iter)
-      goto cleanup;
+    if(!interleaver_)
+    {
+      interleaver_ = grk::InterleaverFactory<T>::makeInterleaver(image_->decompress_prec);
+      if(!interleaver_)
+        goto cleanup;
+    }
     uint32_t h = yBegin;
     while(h < yEnd)
     {
       uint32_t stripRows = (std::min)(image_->rows_per_strip, yEnd - h);
       packedBuf = pool.get(image_->packed_row_bytes * stripRows);
-      iter->interleave(((T**)planes.get()), numcomps, packedBuf.data, image_->decompress_width,
-                       image_->comps[0].stride, image_->packed_row_bytes, stripRows, 0);
+      interleaver_->interleave(planes, numcomps, packedBuf.data, image_->decompress_width,
+                               image_->comps[0].stride, image_->packed_row_bytes, stripRows, 0);
       packedBuf.pooled = true;
       packedBuf.offset = orchestrator.getOffset();
       packedBuf.len = image_->packed_row_bytes * stripRows;
       packedBuf.index = orchestrator.getNumPooledRequests();
       if(!writeStripCore(0, packedBuf))
-      {
-        delete iter;
         goto cleanup;
-      }
       h += stripRows;
     }
-    delete iter;
   }
   success = true;
 cleanup: