Fix deadlock in band-callback backpressure for reduced images

The incremental band-write callback's empty-row handler used a
strict in-order check (tileY == nextBandTileY_) with an early
return. When Taskflow completed tile rows out of order — common
with tiny tiles from high resolution reduction (-r 4 on a
5-resolution image) — empty rows finishing before prior rows
silently lost their nextBandTileY_ advancement. This left the
parser thread's backpressure loop (bandDrainCV_.wait_for)
spinning forever, blocking decompressWorker_ and causing the
main thread to hang on join().

Replace the early-return path with sentinel entries in
pendingBands_. The existing drain loop now processes empty rows
in order alongside non-empty ones, skipping compositing and
the band callback but still advancing nextBandTileY_ and
waking the parser thread. This handles out-of-order row
completion correctly regardless of scheduling order.

Reproduces ~30-50% of the time on p1_06.j2k with -r 4;
verified fixed over 150 consecutive iterations with zero
hangs.

Author: Grok Compression

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

@@ -258,73 +258,71 @@ bool CodeStreamDecompress::decompress(grk_plugin_tile* tile)
           // for the current tile row
           uint32_t yBegin = 0;
           uint32_t yEnd = std::min(tileGlobalYEnd, regionY1) - std::max(tileGlobalYBegin, regionY0);
-          if(yEnd <= yBegin)
-          {
-            // Empty tile row (e.g. zero pixels after resolution reduction).
-            // Still advance nextBandTileY_ so backpressure unblocks.
-            std::lock_guard<std::mutex> lock(bandOrderMutex_);
-            if(tileY == nextBandTileY_)
-              nextBandTileY_ = tileY + 1;
-            bandDrainCV_.notify_one();
-            return;
-          }
 
           uint16_t tileX0 = tileIndexBegin % numTileCols;
           uint16_t numSlatedCols = (uint16_t)tilesToDecompress_.getSlatedTileRect().width();
 
           // All compositing, band writing, and strip advancing must be serialized
           // to prevent races on the shared strip buffer.
+          // Empty rows (yEnd <= yBegin) are inserted as sentinels so the drain
+          // loop processes them in order — an early-return would lose the
+          // advancement when an empty row completes before a prior row.
           std::lock_guard<std::mutex> lock(bandOrderMutex_);
           pendingBands_[tileY] = {yBegin, yEnd, tileX0, numSlatedCols};
           while(pendingBands_.count(nextBandTileY_))
           {
             auto& band = pendingBands_[nextBandTileY_];
 
-            // Check if any tile in this row already wrote strip output directly
-            bool stripOutputHandled = false;
-            for(uint16_t col = 0; col < band.numCols; col++)
-            {
-              uint16_t tileIndex =
-                  static_cast<uint16_t>(nextBandTileY_ * numTileCols + (band.tileX0 + col));
-              auto cacheEntry = tileCache_->get(tileIndex);
-              if(cacheEntry && cacheEntry->processor &&
-                 cacheEntry->processor->isStripOutputWritten())
-              {
-                stripOutputHandled = true;
-                break;
-              }
-            }
-
-            if(!stripOutputHandled)
+            // Skip compositing and callback for empty rows (zero pixels
+            // after resolution reduction).
+            if(band.yEnd > band.yBegin)
             {
-              // Composite all tiles in this row into the strip buffer
+              // Check if any tile in this row already wrote strip output directly
+              bool stripOutputHandled = false;
               for(uint16_t col = 0; col < band.numCols; col++)
               {
                 uint16_t tileIndex =
                     static_cast<uint16_t>(nextBandTileY_ * numTileCols + (band.tileX0 + col));
                 auto cacheEntry = tileCache_->get(tileIndex);
-                if(!cacheEntry || !cacheEntry->processor)
-                  continue;
-                auto tileImage = cacheEntry->processor->getImage();
-                if(tileImage)
+                if(cacheEntry && cacheEntry->processor &&
+                   cacheEntry->processor->isStripOutputWritten())
                 {
-                  if(!scratchImage_->composite(tileImage))
-                    success_ = false;
+                  stripOutputHandled = true;
+                  break;
                 }
               }
 
-              if(!ioBandCallback_(band.yBegin, band.yEnd, scratchImage_.get(), ioBandUserData_))
-                success_ = false;
-            }
+              if(!stripOutputHandled)
+              {
+                // Composite all tiles in this row into the strip buffer
+                for(uint16_t col = 0; col < band.numCols; col++)
+                {
+                  uint16_t tileIndex =
+                      static_cast<uint16_t>(nextBandTileY_ * numTileCols + (band.tileX0 + col));
+                  auto cacheEntry = tileCache_->get(tileIndex);
+                  if(!cacheEntry || !cacheEntry->processor)
+                    continue;
+                  auto tileImage = cacheEntry->processor->getImage();
+                  if(tileImage)
+                  {
+                    if(!scratchImage_->composite(tileImage))
+                      success_ = false;
+                  }
+                }
 
-            // Release tile processors for this completed row
-            for(uint16_t col = 0; col < band.numCols; col++)
-            {
-              uint16_t tileIndex =
-                  static_cast<uint16_t>(nextBandTileY_ * numTileCols + (band.tileX0 + col));
-              tileCache_->releaseForSwath(tileIndex);
+                if(!ioBandCallback_(band.yBegin, band.yEnd, scratchImage_.get(), ioBandUserData_))
+                  success_ = false;
+              }
+
+              // Release tile processors for this completed row
+              for(uint16_t col = 0; col < band.numCols; col++)
+              {
+                uint16_t tileIndex =
+                    static_cast<uint16_t>(nextBandTileY_ * numTileCols + (band.tileX0 + col));
+                tileCache_->releaseForSwath(tileIndex);
+              }
+              MemoryManager::releaseFreedPages();
             }
-            MemoryManager::releaseFreedPages();
 
             pendingBands_.erase(nextBandTileY_);