Phase 3: fine-grained dependency signaling via gates

Replace strict-sequencing DWT scheduling with gated approach:
- Two domains per component: T1 (free-running) and DWT (gated sequences)
- Gates created per resolution: H-DWT at res R gated on T1 blocks
  completing at that resolution (res 1 also waits for res 0 blocks)
- T1 decode callback signals gate after each block completes
- H-DWT batches submitted as gated (scx_engine_submit_gated_batch)
- V-DWT uses sequence ordering within DWT domain (no gate needed)
- DWT stripes become eligible incrementally as T1 blocks complete,
  rather than waiting for ALL T1 to finish

Also includes incidental clang-format fixes from format.sh.

Author: Grok Compression

src/lib/codec/apps/GrkCompress.cpp

@@ -941,7 +941,7 @@ GrkRC GrkCompress::parseCommandLine(int argc, const char* argv[], CompressInitPa
 
   bool xyzTransform;
   auto xyzOpt = app.add_flag("--xyz", xyzTransform,
-                              "Apply Rec.709 RGB to DCI X'Y'Z' colour transform before compression");
+                             "Apply Rec.709 RGB to DCI X'Y'Z' colour transform before compression");
 
   app.set_help_flag("-h", "Show abreviated usage");
   app.set_version_flag("-v,--version", grk_version(), "Show version");

src/lib/core/canvas/resolution/ResWindow.h

@@ -171,20 +171,20 @@ struct ResWindow
                              Buf2dAligned* bandWindowsBuffersPaddedXL,
                              Buf2dAligned* bandWindowsBuffersPaddedXH, bool useRelative)
   {
-    auto lowerRes = useRelative ? Rect32(tileCompAtLowerRes_).toRelative() : Rect32(tileCompAtLowerRes_);
+    auto lowerRes =
+        useRelative ? Rect32(tileCompAtLowerRes_).toRelative() : Rect32(tileCompAtLowerRes_);
     auto xlBounds = useRelative ? Rect32(bandWindowsBuffersPaddedXL).toRelative()
                                 : Rect32(bandWindowsBuffersPaddedXL);
     auto xhBounds = useRelative ? Rect32(bandWindowsBuffersPaddedXH).toRelative()
                                 : Rect32(bandWindowsBuffersPaddedXH);
 
     // two windows formed by horizontal pass and used as input for vertical pass
-    auto splitResWindowBounds = Rect32(resWindowBuffer->x0, xlBounds.y0,
-                                       resWindowBuffer->x1, xlBounds.y1);
+    auto splitResWindowBounds =
+        Rect32(resWindowBuffer->x0, xlBounds.y0, resWindowBuffer->x1, xlBounds.y1);
     resWindowBufferSplit[SPLIT_L] = new Buf2dAligned(splitResWindowBounds);
 
-    splitResWindowBounds =
-        Rect32(resWindowBuffer->x0, lowerRes.y1 + xhBounds.y0,
-               resWindowBuffer->x1, lowerRes.y1 + xhBounds.y1);
+    splitResWindowBounds = Rect32(resWindowBuffer->x0, lowerRes.y1 + xhBounds.y0,
+                                  resWindowBuffer->x1, lowerRes.y1 + xhBounds.y1);
     resWindowBufferSplit[SPLIT_H] = new Buf2dAligned(splitResWindowBounds);
   }
   bool alloc(bool clear)

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

@@ -1763,25 +1763,22 @@ void CodeStreamDecompress::enqueueTileForDecompress(
 
   int32_t tileRow = tileIndex / numTileCols;
   int32_t prev = maxFetchedTileRow_.load(std::memory_order_acquire);
-  while(prev < tileRow &&
-        !maxFetchedTileRow_.compare_exchange_weak(prev, tileRow, std::memory_order_release,
-                                                  std::memory_order_acquire))
+  while(prev < tileRow && !maxFetchedTileRow_.compare_exchange_weak(
+                              prev, tileRow, std::memory_order_release, std::memory_order_acquire))
   {
   }
-  decompressQueue_->push(
-      [this, tileIndex, decompressSeq, unreducedImageBounds, postGenerator]() {
-        const auto tileProcessor = getTileProcessor(tileIndex);
-        auto* tp = dynamic_cast<TileProcessor*>(tileProcessor);
-        if(tp)
-          tp->setSelectiveFetch(true);
-        auto decompressTask = genDecompressTileTLMTask(tileProcessor, decompressSeq,
-                                                       unreducedImageBounds, postGenerator);
-        decompressTask();
-      });
+  decompressQueue_->push([this, tileIndex, decompressSeq, unreducedImageBounds, postGenerator]() {
+    const auto tileProcessor = getTileProcessor(tileIndex);
+    auto* tp = dynamic_cast<TileProcessor*>(tileProcessor);
+    if(tp)
+      tp->setSelectiveFetch(true);
+    auto decompressTask =
+        genDecompressTileTLMTask(tileProcessor, decompressSeq, unreducedImageBounds, postGenerator);
+    decompressTask();
+  });
 }
 
-void CodeStreamDecompress::buildSelectiveTileParts(uint16_t tileIndex,
-                                                   const TileHeaderResult& hdr,
+void CodeStreamDecompress::buildSelectiveTileParts(uint16_t tileIndex, const TileHeaderResult& hdr,
                                                    const TPSEQ_VEC& allTileParts, uint8_t reduce)
 {
   auto numComps = headerImage_->numcomps;
@@ -1949,11 +1946,10 @@ void CodeStreamDecompress::buildSelectiveTileParts(uint16_t tileIndex,
   }
 }
 
-std::vector<std::pair<uint16_t, std::shared_ptr<TPFetchSeq>>>
-    CodeStreamDecompress::reusePhase1Data(
-        std::shared_ptr<std::set<uint16_t>>& selectiveFetchTiles,
-        const std::unordered_map<uint16_t, TileHeaderResult>& headerResults,
-        const TPSEQ_VEC& allTileParts)
+std::vector<std::pair<uint16_t, std::shared_ptr<TPFetchSeq>>> CodeStreamDecompress::reusePhase1Data(
+    std::shared_ptr<std::set<uint16_t>>& selectiveFetchTiles,
+    const std::unordered_map<uint16_t, TileHeaderResult>& headerResults,
+    const TPSEQ_VEC& allTileParts)
 {
   std::vector<std::pair<uint16_t, std::shared_ptr<TPFetchSeq>>> prefetchedTiles;
 
@@ -2122,9 +2118,8 @@ bool CodeStreamDecompress::fetchByTileSelective(
   // Create modified tile-part info for Phase 1 fetch.
   // For contiguous progressions, estimate the needed data size and fetch that
   // directly, eliminating the need for a second round-trip in most cases.
-  double pixelRatio = (contiguousProgression && reduce > 0)
-                          ? (1.0 / std::pow(4.0, reduce)) * 2.0
-                          : 0.0;
+  double pixelRatio =
+      (contiguousProgression && reduce > 0) ? (1.0 / std::pow(4.0, reduce)) * 2.0 : 0.0;
 
   TPSEQ_VEC headerTileParts(allTileParts.size());
   for(auto tileIndex : slated)
@@ -2139,8 +2134,8 @@ bool CodeStreamDecompress::fetchByTileSelective(
       uint32_t fetchLen;
       if(contiguousProgression && reduce > 0)
       {
-        uint64_t estimated = std::max<uint64_t>(
-            headerFetchSize, (uint64_t)(part->length_ * pixelRatio));
+        uint64_t estimated =
+            std::max<uint64_t>(headerFetchSize, (uint64_t)(part->length_ * pixelRatio));
         fetchLen = (uint32_t)std::min<uint64_t>(estimated, part->length_);
       }
       else
@@ -2259,64 +2254,64 @@ bool CodeStreamDecompress::fetchByTileSelective(
 
   if(!selectiveFetchTiles->empty())
   {
-  installFetchThrottle(fetcher);
-
-  fetchByTileFutures_.push_back(fetcher->fetchTiles(
-      selectiveTileParts_, *selectiveFetchTiles, nullptr,
-      [this, numTileCols, unreducedImageBounds, postGenerator, selectiveFetchTiles,
-       disjointTiles](size_t requestIndex, TileFetchContext* context) {
-        auto& tilePart = (*context->requests_)[requestIndex];
-        auto tileIndex = tilePart->tileIndex_;
-        auto& tilePartSeq = (*context->tilePartFetchByTile_)[tileIndex];
+    installFetchThrottle(fetcher);
 
-        if(!disjointTiles->count(tileIndex))
-        {
-          // Contiguous case: create MemStream per entry (standard path)
-          tilePart->stream_ =
-              std::unique_ptr<IStream>(memStreamCreate(tilePart->data_.get(), tilePart->length_,
-                                                       false, nullptr, stream_->getFormat(), true));
-        }
+    fetchByTileFutures_.push_back(fetcher->fetchTiles(
+        selectiveTileParts_, *selectiveFetchTiles, nullptr,
+        [this, numTileCols, unreducedImageBounds, postGenerator, selectiveFetchTiles,
+         disjointTiles](size_t requestIndex, TileFetchContext* context) {
+          auto& tilePart = (*context->requests_)[requestIndex];
+          auto tileIndex = tilePart->tileIndex_;
+          auto& tilePartSeq = (*context->tilePartFetchByTile_)[tileIndex];
 
-        if(tilePartSeq->incrementFetchCount() == tilePartSeq->size())
-        {
-          std::shared_ptr<TPFetchSeq> decompressSeq;
+          if(!disjointTiles->count(tileIndex))
+          {
+            // Contiguous case: create MemStream per entry (standard path)
+            tilePart->stream_ = std::unique_ptr<IStream>(
+                memStreamCreate(tilePart->data_.get(), tilePart->length_, false, nullptr,
+                                stream_->getFormat(), true));
+          }
 
-          if(disjointTiles->count(tileIndex))
+          if(tilePartSeq->incrementFetchCount() == tilePartSeq->size())
           {
-            // Disjoint case: assemble header + data ranges into single buffer
-            // Entry 0 = header (with SOT), entries 1..N = data ranges
-            uint64_t totalSize = 0;
-            for(size_t i = 0; i < tilePartSeq->size(); ++i)
-              totalSize += (*tilePartSeq)[i]->length_;
-
-            auto assembled = std::make_unique<uint8_t[]>(totalSize);
-            uint64_t pos = 0;
-            for(size_t i = 0; i < tilePartSeq->size(); ++i)
+            std::shared_ptr<TPFetchSeq> decompressSeq;
+
+            if(disjointTiles->count(tileIndex))
+            {
+              // Disjoint case: assemble header + data ranges into single buffer
+              // Entry 0 = header (with SOT), entries 1..N = data ranges
+              uint64_t totalSize = 0;
+              for(size_t i = 0; i < tilePartSeq->size(); ++i)
+                totalSize += (*tilePartSeq)[i]->length_;
+
+              auto assembled = std::make_unique<uint8_t[]>(totalSize);
+              uint64_t pos = 0;
+              for(size_t i = 0; i < tilePartSeq->size(); ++i)
+              {
+                auto& tp = (*tilePartSeq)[i];
+                if(tp->data_)
+                  std::memcpy(assembled.get() + pos, tp->data_.get(), tp->length_);
+                pos += tp->length_;
+              }
+
+              // Create single-entry TPFetchSeq with assembled data
+              decompressSeq = std::make_shared<TPFetchSeq>();
+              auto assembledFetch = std::make_shared<TPFetch>(0, totalSize, tileIndex);
+              assembledFetch->data_ = std::move(assembled);
+              assembledFetch->stream_ = std::unique_ptr<IStream>(
+                  memStreamCreate(assembledFetch->data_.get(), totalSize, false, nullptr,
+                                  stream_->getFormat(), true));
+              decompressSeq->SharedPtrSeq<TPFetch>::push_back(assembledFetch);
+            }
+            else
             {
-              auto& tp = (*tilePartSeq)[i];
-              if(tp->data_)
-                std::memcpy(assembled.get() + pos, tp->data_.get(), tp->length_);
-              pos += tp->length_;
+              decompressSeq = tilePartSeq;
             }
 
-            // Create single-entry TPFetchSeq with assembled data
-            decompressSeq = std::make_shared<TPFetchSeq>();
-            auto assembledFetch = std::make_shared<TPFetch>(0, totalSize, tileIndex);
-            assembledFetch->data_ = std::move(assembled);
-            assembledFetch->stream_ = std::unique_ptr<IStream>(
-                memStreamCreate(assembledFetch->data_.get(), totalSize, false, nullptr,
-                                stream_->getFormat(), true));
-            decompressSeq->SharedPtrSeq<TPFetch>::push_back(assembledFetch);
-          }
-          else
-          {
-            decompressSeq = tilePartSeq;
+            enqueueTileForDecompress(tileIndex, decompressSeq, numTileCols, unreducedImageBounds,
+                                     postGenerator);
           }
-
-          enqueueTileForDecompress(tileIndex, decompressSeq, numTileCols, unreducedImageBounds,
-                                  postGenerator);
-        }
-      }));
+        }));
   } // if(!selectiveFetchTiles->empty())
 
   return true;

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

@@ -508,10 +508,10 @@ class CodeStreamDecompress final : public CodeStream, public IDecompressor
    * @param unreducedImageBounds  unreduced image bounds for decompress tasks
    * @param postGenerator     factory for post-decompress callbacks
    */
-  void enqueueTileForDecompress(
-      uint16_t tileIndex, std::shared_ptr<TPFetchSeq> decompressSeq, uint16_t numTileCols,
-      Rect32 unreducedImageBounds,
-      std::function<std::function<void()>(ITileProcessor*)> postGenerator);
+  void
+      enqueueTileForDecompress(uint16_t tileIndex, std::shared_ptr<TPFetchSeq> decompressSeq,
+                               uint16_t numTileCols, Rect32 unreducedImageBounds,
+                               std::function<std::function<void()>(ITileProcessor*)> postGenerator);
 
   /**
    * @brief Build selective tile-part entries for a single tile.
@@ -548,10 +548,10 @@ class CodeStreamDecompress final : public CodeStream, public IDecompressor
    * @param allTileParts         full tile-part info from TLM
    * @return vector of tiles with pre-built decompression sequences
    */
-  std::vector<std::pair<uint16_t, std::shared_ptr<TPFetchSeq>>> reusePhase1Data(
-      std::shared_ptr<std::set<uint16_t>>& selectiveFetchTiles,
-      const std::unordered_map<uint16_t, TileHeaderResult>& headerResults,
-      const TPSEQ_VEC& allTileParts);
+  std::vector<std::pair<uint16_t, std::shared_ptr<TPFetchSeq>>>
+      reusePhase1Data(std::shared_ptr<std::set<uint16_t>>& selectiveFetchTiles,
+                      const std::unordered_map<uint16_t, TileHeaderResult>& headerResults,
+                      const TPSEQ_VEC& allTileParts);
 
   /**
    * @brief Install fetch throttle on the given fetcher.

src/lib/core/fileformat/decompress/FileFormatMJ2Decompress.cpp

@@ -555,8 +555,7 @@ void FileFormatMJ2Decompress::stsc_decompact(mj2_tk* tk)
                    samples_per_chunk, (uint32_t)tk->samples_.size());
       return;
     }
-    auto num_chunks = (uint32_t)ceil((double)tk->samples_.size() /
-                                     (double)samples_per_chunk);
+    auto num_chunks = (uint32_t)ceil((double)tk->samples_.size() / (double)samples_per_chunk);
     for(uint32_t k = 0; k < num_chunks; k++)
     {
       mj2_chunk chunk;