refactor: simplify TLM vs non-TLM logic

Author: Grok Compression

src/lib/core/codestream/decompress/CodeStreamDecompress.cpp

@@ -316,84 +316,81 @@ bool CodeStreamDecompress::decompressImpl(std::set<uint16_t> pendingTiles)
   if(pendingTiles.empty())
     return true;
 
-  // synchronous batch init
-  if(doTileBatching() && !cp_.hasTLM())
-  {
-    batchTileUnscheduledSequential_ = (uint16_t)pendingTiles.size();
-    batchTileScheduleHeadroomSequential_ =
-        batchTileHeadroomIncrement(batchTileInitialRows_, batchTileUnscheduledSequential_);
-    batchTileScheduledRows_ = batchTileInitialRows_;
-  }
-
-  // prepare for different types of decompression
+  // prepare for differential decompression
   if(doDifferential)
   {
     differentialUpdate(scratchImage_.get());
+    for(auto& tileIndex : pendingTiles)
+    {
+      auto cacheEntry = tileCache_->get(tileIndex);
+      auto tileProcessor = cacheEntry->processor;
+      if(!tileProcessor->differentialUpdate(headerImage_->getBounds()))
+        return false;
+      if(!schedule(tileProcessor, true))
+        return false;
+    }
+    return true;
   }
-  else if(cp_.hasTLM())
+
+  // one-time dispatch initialization
+  if(!decompressStart_)
   {
-    // a) begin network fetch
-    auto generator = [this](ITileProcessor* tp) {
-      return postMultiTile(tp); // Return the result directly
-    };
+    if(cp_.hasTLM())
+      decompressStart_ = [this](auto& pt) { return startTLMDecompress(pt); };
+    else
+      decompressStart_ = [this](auto& pt) { return startSequentialDecompress(pt); };
+  }
 
-    if(fetchByTile(pendingTiles, scratchImage_->getBounds(), generator))
-      return true;
+  return decompressStart_(pendingTiles);
+}
 
-    // b) prepare for TLM decompress
-    tilePartFetchFlat_ = std::make_shared<TPFetchSeq>();
-    tilePartFetchByTile_ =
-        std::make_shared<std::unordered_map<uint16_t, std::shared_ptr<TPFetchSeq>>>();
-    TPFetchSeq::genCollections(&cp_.tlmMarkers_->getTileParts(), pendingTiles, tilePartFetchFlat_,
-                               tilePartFetchByTile_);
-  }
-  else
-  {
-    // a) begin network fetch
-    auto fetcher = stream_->getFetcher();
-    if(stream_->getFetcher())
-    {
-      auto chunkSize = cp_.t_width_ * cp_.t_height_;
-      chunkBuffer_ = std::make_shared<ChunkBuffer<>>(chunkSize, markerCache_->getTileStreamStart(),
-                                                     fetcher->size());
-      fetcher->fetchChunks(chunkBuffer_);
-      stream_->setChunkBuffer(chunkBuffer_);
-    }
+bool CodeStreamDecompress::startTLMDecompress(std::set<uint16_t>& pendingTiles)
+{
+  // begin network fetch
+  auto generator = [this](ITileProcessor* tp) { return postMultiTile(tp); };
 
-    // b) prepare for sequential decompress
-    decompressSequentialPrepare();
-  }
+  if(fetchByTile(pendingTiles, scratchImage_->getBounds(), generator))
+    return true;
 
-  // schedule decompression
+  // prepare TLM decompress
+  tilePartFetchFlat_ = std::make_shared<TPFetchSeq>();
+  tilePartFetchByTile_ =
+      std::make_shared<std::unordered_map<uint16_t, std::shared_ptr<TPFetchSeq>>>();
+  TPFetchSeq::genCollections(&cp_.tlmMarkers_->getTileParts(), pendingTiles, tilePartFetchFlat_,
+                             tilePartFetchByTile_);
 
-  // 1. differential decompression
-  if(doDifferential)
+  // start decompress worker
+  decompressWorker_ = std::thread([this, pendingTiles]() { decompressTLM(pendingTiles); });
+  return true;
+}
+
+bool CodeStreamDecompress::startSequentialDecompress(std::set<uint16_t>& pendingTiles)
+{
+  // batch init
+  if(doTileBatching())
   {
-    for(auto& tileIndex : pendingTiles)
-    {
-      if(doDifferential)
-      {
-        auto cacheEntry = tileCache_->get(tileIndex);
-        auto tileProcessor = cacheEntry->processor;
-        if(!tileProcessor->differentialUpdate(headerImage_->getBounds()))
-        {
-          return false;
-        }
+    batchTileUnscheduledSequential_ = (uint16_t)pendingTiles.size();
+    batchTileScheduleHeadroomSequential_ =
+        batchTileHeadroomIncrement(batchTileInitialRows_, batchTileUnscheduledSequential_);
+    batchTileScheduledRows_ = batchTileInitialRows_;
+  }
 
-        if(!schedule(tileProcessor, true))
-          return false;
-      }
-    }
-    return true;
+  // begin network fetch
+  auto fetcher = stream_->getFetcher();
+  if(fetcher)
+  {
+    auto chunkSize = cp_.t_width_ * cp_.t_height_;
+    chunkBuffer_ = std::make_shared<ChunkBuffer<>>(chunkSize, markerCache_->getTileStreamStart(),
+                                                   fetcher->size());
+    fetcher->fetchChunks(chunkBuffer_);
+    stream_->setChunkBuffer(chunkBuffer_);
   }
 
-  std::function<void()> task;
-  if(cp_.hasTLM())
-    task = [this, pendingTiles]() { decompressTLM(pendingTiles); };
-  else
-    task = [this, pendingTiles]() { decompressSequential(pendingTiles); };
+  // prepare sequential decompress
+  decompressSequentialPrepare();
 
-  decompressWorker_ = std::thread(task);
+  // start decompress worker
+  decompressWorker_ = std::thread([this, pendingTiles]() { decompressSequential(pendingTiles); });
   return true;
 }
 

src/lib/core/codestream/decompress/CodeStreamDecompress.h

@@ -321,6 +321,9 @@ class CodeStreamDecompress final : public CodeStream, public IDecompressor
   void decompressSequential(const std::set<uint16_t>& pendingTiles);
   void decompressTLM(const std::set<uint16_t>& pendingTiles);
 
+  bool startTLMDecompress(std::set<uint16_t>& pendingTiles);
+  bool startSequentialDecompress(std::set<uint16_t>& pendingTiles);
+
   bool doTileBatching(void);
 
   /**
@@ -465,6 +468,8 @@ class CodeStreamDecompress final : public CodeStream, public IDecompressor
 
   std::thread decompressWorker_;
 
+  std::function<bool(std::set<uint16_t>&)> decompressStart_;
+
   std::shared_ptr<ChunkBuffer<>> chunkBuffer_;
 
   // Compressed chunk cache: stores fetched compressed data for re-decompression