wavelet: remove dep on tile processor

Author: Grok Compression

src/lib/core/canvas/tile/TileComponent.h

@@ -22,6 +22,7 @@
 #include "PostDecodeFilters.h"
 #include "htconfig.h"
 #include "SparseCanvas.h"
+#include "TileComponentWindow.h"
 
 const bool DEBUG_TILE_COMPONENT = false;
 

src/lib/core/scheduling/CodecScheduler.cpp

@@ -61,12 +61,11 @@ size_t ExecSingleton::numThreads_;
 namespace grk
 {
 
-ResolutionChecker::ResolutionChecker(uint16_t numComponents, ITileProcessor* tileProcessor,
-                                     bool cacheAll)
+ResolutionChecker::ResolutionChecker(uint16_t numComponents, TileComponent* comps, bool cacheAll)
 {
   for(uint16_t compno = 0; compno < numComponents; ++compno)
   {
-    auto tilec = tileProcessor->getTile()->comps_ + compno;
+    auto tilec = comps + compno;
     uint8_t resBegin =
         cacheAll ? (uint8_t)tilec->currentPacketProgressionState_.numResolutionsRead() : 0;
     uint8_t resUpperBound = tilec->nextPacketProgressionState_.numResolutionsRead();

src/lib/core/scheduling/CodecScheduler.h

@@ -22,10 +22,12 @@
 namespace grk
 {
 
+struct ITileProcessor;
+struct TileComponent;
 class ResolutionChecker
 {
 public:
-  ResolutionChecker(uint16_t numComponents, ITileProcessor* tileProcessor, bool cacheAll);
+  ResolutionChecker(uint16_t numComponents, TileComponent* comps, bool cacheAll);
 
   // Check if a specific component contains a given resolution
   bool contains(uint16_t compno, uint8_t resolution) const;

src/lib/core/scheduling/whole_tile/DecompressScheduler.cpp

@@ -123,7 +123,7 @@ bool DecompressScheduler::schedule(ITileProcessor* tileProcessor)
     resMin = std::min(resMin, resBegin);
     resMax = std::max(resMax, resUpperBound);
   }
-  ResolutionChecker rChecker(numcomps_, tileProcessor, cacheAll);
+  ResolutionChecker rChecker(numcomps_, tileProcessor->getTile()->comps_, cacheAll);
 
   for(uint16_t compno = 0; compno < numcomps_; ++compno)
   {
@@ -311,9 +311,14 @@ bool DecompressScheduler::schedule(ITileProcessor* tileProcessor)
     {
       if(waveletReverse_[compno])
         delete waveletReverse_[compno];
-      waveletReverse_[compno] =
-          new WaveletReverse(tileProcessor, tilec, compno, tilec->getWindow()->unreducedBounds(),
-                             numRes, (tcp->tccps_ + compno)->qmfbid_);
+
+      auto maxDim = std::max(tileProcessor->getCodingParams()->t_width_,
+                             tileProcessor->getCodingParams()->t_height_);
+
+      waveletReverse_[compno] = new WaveletReverse(tileProcessor->getScheduler(), tilec, compno,
+                                                   tilec->getWindow()->unreducedBounds(), numRes,
+                                                   (tcp->tccps_ + compno)->qmfbid_, maxDim,
+                                                   tileProcessor->getTCP()->wholeTileDecompress_);
 
       if(!waveletReverse_[compno]->decompress())
         return false;

src/lib/core/scheduling/whole_tile/WholeTileScheduler.cpp

@@ -19,10 +19,6 @@
 #include "TileWindow.h"
 #include "Quantizer.h"
 #include "ImageComponentFlow.h"
-namespace grk
-{
-struct ITileProcessor;
-}
 #include "ICoder.h"
 #include "CoderPool.h"
 #include "CodecScheduler.h"

src/lib/core/scheduling/window/DecompressWindowScheduler.cpp

@@ -51,6 +51,7 @@ struct ITileProcessor;
 
 #include "CodecScheduler.h"
 #include "TileComponentWindow.h"
+#include "TileComponent.h"
 #include "canvas/tile/Tile.h"
 #include "ITileProcessor.h"
 #include "CoderFactory.h"
@@ -92,7 +93,7 @@ bool DecompressWindowScheduler::schedule(ITileProcessor* tileProcessor)
     resMin = std::min(resMin, resBegin);
     resMax = std::max(resMax, resUpperBound);
   }
-  ResolutionChecker rChecker(numcomps_, tileProcessor, cacheAll);
+  ResolutionChecker rChecker(numcomps_, tileProcessor->getTile()->comps_, cacheAll);
   for(uint16_t compno = 0; compno < numcomps_; ++compno)
   {
     // schedule blocks

src/lib/core/scheduling/window/WindowScheduler.cpp

@@ -22,7 +22,8 @@
 namespace grk
 {
 struct ITileProcessor;
-}
+struct TileComponent;
+} // namespace grk
 #include "ICoder.h"
 #include "WindowScheduler.h"
 

src/lib/core/wavelet/WaveletFwd.cpp

@@ -49,7 +49,6 @@ struct ITileProcessor;
 #include "Subband.h"
 #include "Resolution.h"
 
-#include "CodecScheduler.h"
 #include "TileComponentWindow.h"
 #include "WaveletCommon.h"
 #include "WaveletReverse.h"

src/lib/core/wavelet/WaveletReverse.cpp

@@ -338,10 +338,11 @@ bool WaveletReverse::allocPoolData(size_t maxDim)
   return is_allocated_;
 }
 
-WaveletReverse::WaveletReverse(ITileProcessor* tileProcessor, TileComponent* tilec, uint16_t compno,
-                               Rect32 unreducedWindow, uint8_t numres, uint8_t qmfbid)
-    : tileProcessor_(tileProcessor), scheduler_(tileProcessor->getScheduler()), tilec_(tilec),
-      compno_(compno), unreducedWindow_(unreducedWindow), numres_(numres), qmfbid_(qmfbid)
+WaveletReverse::WaveletReverse(CodecScheduler* scheduler, TileComponent* tilec, uint16_t compno,
+                               Rect32 unreducedWindow, uint8_t numres, uint8_t qmfbid,
+                               uint32_t maxDim, bool wholeTileDecompress)
+    : scheduler_(scheduler), tilec_(tilec), compno_(compno), unreducedWindow_(unreducedWindow),
+      numres_(numres), qmfbid_(qmfbid), maxDim_(maxDim), wholeTileDecompress_(wholeTileDecompress)
 {}
 WaveletReverse::~WaveletReverse(void)
 {
@@ -833,11 +834,9 @@ bool WaveletReverse::tile_53(void)
 
 bool WaveletReverse::decompress(void)
 {
-  auto maxDim = std::max(tileProcessor_->getCodingParams()->t_width_,
-                         tileProcessor_->getCodingParams()->t_height_);
-  WaveletReverse::allocPoolData(maxDim);
+  WaveletReverse::allocPoolData(maxDim_);
 
-  if(!tileProcessor_->getTCP()->wholeTileDecompress_)
+  if(!wholeTileDecompress_)
     return decompressPartial();
 
   if(qmfbid_ == 1)

src/lib/core/wavelet/WaveletReverse.h

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "CodecScheduler.h"
 #include "WaveletCommon.h"
 
 namespace grk
@@ -96,8 +97,8 @@ struct dwt_scratch
 class WaveletReverse
 {
 public:
-  WaveletReverse(ITileProcessor* tileProcessor, TileComponent* tilec, uint16_t compno,
-                 Rect32 window, uint8_t numres, uint8_t qmfbid);
+  WaveletReverse(CodecScheduler* scheduler, TileComponent* tilec, uint16_t compno, Rect32 window,
+                 uint8_t numres, uint8_t qmfbid, uint32_t maxDim, bool wholeTileDecompress);
   ~WaveletReverse(void);
   bool decompress(void);
 
@@ -119,13 +120,14 @@ class WaveletReverse
   static bool is_allocated_;
   static std::once_flag alloc_flag_;
 
-  ITileProcessor* tileProcessor_;
-  CodecScheduler* scheduler_;
-  TileComponent* tilec_;
-  uint16_t compno_;
+  CodecScheduler* scheduler_ = nullptr;
+  TileComponent* tilec_ = nullptr;
+  uint16_t compno_ = 0;
   Rect32 unreducedWindow_;
-  uint8_t numres_;
-  uint8_t qmfbid_;
+  uint8_t numres_ = 0;
+  uint8_t qmfbid_ = 0;
+  uint32_t maxDim_ = 0;
+  bool wholeTileDecompress_ = true;
 
   // 5/3 ////////////////////////////////////////////////////////////////////////////////////
   void load_h_p0_53(int32_t* scratch, const uint32_t width, int32_t* bandL, int32_t* bandH,