Accept reduced coordinates via dw_reduced flag

Add dw_reduced field to grk_decompress_parameters. When set, decompress
window coordinates are interpreted as reduced-space and scaled to
full-resolution internally. This allows callers (e.g. GDAL) to pass
overview-level coordinates directly.

Conditional on dw_reduced:
- setDecompressRegion: scale region to full-res
- wait(): scale swath coords for TileCompletion
- getImage(): reduce composite bounds for caller
- post_decompressT2T1: reduce per-tile image bounds

Tests: add testReducedCoordsPerTile and update testReduceWithRegion.

Author: Grok Compression

grok.code-workspace

@@ -23,6 +23,9 @@
 		},
 		{
 			"path": "../tiletopia"
+		},
+		{
+			"path": "../ix"
 		}
 	],
 	"settings": {}

src/lib/core/codestream/CodingParams.cpp

@@ -181,6 +181,7 @@ void CodingParams::init(grk_decompress_parameters* parameters,
   dw_y0 = parameters->dw_y0;
   dw_x1 = parameters->dw_x1;
   dw_y1 = parameters->dw_y1;
+  dw_reduced = parameters->dw_reduced;
   asynchronous_ = parameters->asynchronous;
   simulate_synchronous_ = parameters->simulate_synchronous;
   decompressCallback_ = parameters->decompress_callback;

src/lib/core/codestream/CodingParams.h

@@ -444,6 +444,7 @@ struct CodingParams
   double dw_x1 = 0; /* decompress window right boundary*/
   double dw_y0 = 0; /* decompress window top boundary*/
   double dw_y1 = 0; /* decompress window bottom boundary*/
+  bool dw_reduced = false; /* if true, dw_x0..dw_y1 are in reduced coordinate space */
   std::unique_ptr<PPMMarker> ppmMarkers_;
   TileCodingParamsPool tcps_; /** default tile coding parameters */
   union

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

@@ -1248,6 +1248,17 @@ bool CodeStreamDecompress::setDecompressRegion(RectD region)
       region.x1 = (double)ceil(val[2] * w);
       region.y1 = (double)ceil(val[3] * h);
     }
+    else if(cp_.dw_reduced && cp_.codingParams_.dec_.reduce_ > 0)
+    {
+      // Caller passes coordinates in the reduced output space;
+      // scale up to full-resolution for internal processing.
+      uint32_t scale = 1u << cp_.codingParams_.dec_.reduce_;
+      region.x0 *= scale;
+      region.y0 *= scale;
+      region.x1 *= scale;
+      region.y1 *= scale;
+    }
+    compositeBoundsReduced_ = false;
     Rect16 tilesToDecompress;
     auto canvasRegion = Rect32((uint32_t)region.x0 + image->x0, (uint32_t)region.y0 + image->y0,
                                (uint32_t)region.x1 + image->x0, (uint32_t)region.y1 + image->y0);
@@ -1439,7 +1450,25 @@ void CodeStreamDecompress::wait(grk_wait_swath* swath)
   // 1. Swath-based early return: tile data ready but NOT post-processed
   if(swath && tileCompletion_)
   {
-    bool rc = tileCompletion_->wait(swath);
+    // When caller passed reduced coordinates (dw_reduced), scale up to
+    // full-resolution for TileCompletion which uses unreduced tile grid.
+    grk_wait_swath fullResSwath = *swath;
+    uint8_t reduce = cp_.codingParams_.dec_.reduce_;
+    if(cp_.dw_reduced && reduce > 0)
+    {
+      uint32_t scale = 1u << reduce;
+      fullResSwath.x0 *= scale;
+      fullResSwath.y0 *= scale;
+      fullResSwath.x1 *= scale;
+      fullResSwath.y1 *= scale;
+    }
+    bool rc = tileCompletion_->wait(&fullResSwath);
+    // Copy output tile indices back to caller's swath
+    swath->tile_x0 = fullResSwath.tile_x0;
+    swath->tile_y0 = fullResSwath.tile_y0;
+    swath->tile_x1 = fullResSwath.tile_x1;
+    swath->tile_y1 = fullResSwath.tile_y1;
+    swath->num_tile_cols = fullResSwath.num_tile_cols;
     if(!rc)
       return;
     return;
@@ -2434,6 +2463,19 @@ GrkImage* CodeStreamDecompress::getImage()
 {
   wait(nullptr);
 
+  // Reduce image-level bounds to match component (output) coordinate space.
+  // Only when caller passed reduced coordinates (dw_reduced), the
+  // multiTileComposite_ still has unreduced canvas bounds that need reducing.
+  auto reduce = cp_.codingParams_.dec_.reduce_;
+  if(cp_.dw_reduced && reduce > 0 && !compositeBoundsReduced_)
+  {
+    multiTileComposite_->x0 = ceildivpow2<uint32_t>(multiTileComposite_->x0, reduce);
+    multiTileComposite_->y0 = ceildivpow2<uint32_t>(multiTileComposite_->y0, reduce);
+    multiTileComposite_->x1 = ceildivpow2<uint32_t>(multiTileComposite_->x1, reduce);
+    multiTileComposite_->y1 = ceildivpow2<uint32_t>(multiTileComposite_->y1, reduce);
+    compositeBoundsReduced_ = true;
+  }
+
   return multiTileComposite_.get();
 }
 GrkImage* CodeStreamDecompress::getCompositeNoWait()

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

@@ -393,6 +393,7 @@ class CodeStreamDecompress final : public CodeStream, public IDecompressor
    *
    */
   std::unique_ptr<GrkImage, RefCountedDeleter<GrkImage>> multiTileComposite_;
+  bool compositeBoundsReduced_ = false;
 
   /**
    * @brief Holds unreduced unsubsampled decompress region , if set

src/lib/core/grok.h

@@ -754,6 +754,7 @@ typedef struct _grk_decompress_params
   double dw_x1; /* decompress window right boundary*/
   double dw_y0; /* decompress window top boundary*/
   double dw_y1; /* decompress window bottom boundary*/
+  bool dw_reduced; /* if true, dw_x0..dw_y1 are in reduced (output) coordinate space */
   uint16_t tile_index; /* index of decompressed tile*/
 
   /***************************************************************************

src/lib/core/tile_processor/TileProcessor.cpp

@@ -1162,6 +1162,17 @@ void TileProcessor::post_decompressT2T1(GrkImage* scratch)
       {
         grk_unref(image_);
         image_ = scratch->extractFrom(tile_);
+        // extractFrom() sets image x0/y0/x1/y1 from unreduced tile canvas
+        // coordinates.  When caller passed reduced coordinates (dw_reduced),
+        // reduce them to match the output coordinate space.
+        uint8_t reduce = cp_->codingParams_.dec_.reduce_;
+        if(cp_->dw_reduced && reduce > 0)
+        {
+          image_->x0 = ceildivpow2<uint32_t>(image_->x0, reduce);
+          image_->y0 = ceildivpow2<uint32_t>(image_->y0, reduce);
+          image_->x1 = ceildivpow2<uint32_t>(image_->x1, reduce);
+          image_->y1 = ceildivpow2<uint32_t>(image_->y1, reduce);
+        }
       }
       else
       {

tests/GrkLRUCacheTest.cpp

@@ -883,14 +883,17 @@ static bool testReduceWithRegion()
     return false;
   }
 
-  // Decompress a sub-region at reduce=1
+  // Decompress a sub-region at reduce=1.
+  // Coordinates are in reduced output space: 64x64 reduced pixels
+  // = 128x128 full-res pixels, yielding 64x64 output.
   grk_decompress_parameters params{};
   params.core.tile_cache_strategy = GRK_TILE_CACHE_IMAGE;
   params.core.reduce = 1;
   params.dw_x0 = 0;
   params.dw_y0 = 0;
-  params.dw_x1 = 128;
-  params.dw_y1 = 128;
+  params.dw_x1 = 64;
+  params.dw_y1 = 64;
+  params.dw_reduced = true;
   params.asynchronous = true;
   params.simulate_synchronous = true;
 
@@ -919,10 +922,11 @@ static bool testReduceWithRegion()
     return false;
   }
 
-  // At reduce=1, the 128x128 region should produce ~64x64 output
+  // At reduce=1, the 64x64 reduced-space region produces ~64x64 output
   uint32_t w = img->x1 - img->x0;
   uint32_t h = img->y1 - img->y0;
-  spdlog::info("Reduce+region output: {}x{}", w, h);
+  spdlog::info("Reduce+region output: {}x{} (x0={}, y0={}, x1={}, y1={})", w, h, img->x0, img->y0, img->x1, img->y1);
+  spdlog::info("Reduce+region comps[0]: w={}, h={}", img->comps[0].w, img->comps[0].h);
 
   std::error_code ec;
   std::filesystem::remove(testFile, ec);
@@ -933,8 +937,8 @@ static bool testReduceWithRegion()
     return false;
   }
 
-  // Region is 128x128, reduce=1 → expect ~64x64
-  if(w > 128 || h > 128)
+  // Region is 64x64 in reduced space → expect ~64x64 output
+  if(w > 64 || h > 64)
   {
     spdlog::error("FAIL: Output larger than region");
     return false;
@@ -944,6 +948,94 @@ static bool testReduceWithRegion()
   return true;
 }
 
+///////////////////////////////////////////////////////////////////
+// Test 9b: Reduced-coords API for multi-tile per-tile images
+//
+// Verifies that grk_decompress_get_tile_image returns tile images
+// with x0/y0/x1/y1 in reduced coordinate space (not full-res).
+///////////////////////////////////////////////////////////////////
+static bool testReducedCoordsPerTile()
+{
+  spdlog::info("=== Test: Reduced-coords per-tile API ===");
+
+  // Create 256x256 image with 128x128 tiles (2x2 grid)
+  std::string testFile =
+      (std::filesystem::temp_directory_path() / "grk_reduced_coords_test.j2k").string();
+  if(!createTestImage(testFile, 256, 256, 128, 128, false))
+  {
+    spdlog::error("Failed to create test image");
+    return false;
+  }
+
+  // Decompress at reduce=1 (output 128x128 with 64x64 tiles)
+  grk_decompress_parameters params{};
+  params.core.tile_cache_strategy = GRK_TILE_CACHE_IMAGE;
+  params.core.reduce = 1;
+  params.core.skip_allocate_composite = true;
+  params.dw_reduced = true;
+  params.asynchronous = true;
+  params.simulate_synchronous = true;
+
+  grk_stream_params sp{};
+  safe_strcpy(sp.file, testFile.data());
+  CodecPtr codec(grk_decompress_init(&sp, &params));
+  grk_header_info hi{};
+  grk_decompress_read_header(codec.get(), &hi);
+  grk_decompress_update(&params, codec.get());
+
+  bool ok = grk_decompress(codec.get(), nullptr);
+  if(!ok)
+  {
+    spdlog::error("Decompress failed");
+    std::filesystem::remove(testFile);
+    return false;
+  }
+
+  grk_decompress_wait(codec.get(), nullptr);
+
+  // Check each tile's image coordinates are in reduced space
+  // Full-res tiles: (0,0,128,128), (128,0,256,128), (0,128,128,256), (128,128,256,256)
+  // Expected reduced: (0,0,64,64), (64,0,128,64), (0,64,64,128), (64,64,128,128)
+  struct Expected
+  {
+    uint16_t tileIndex;
+    uint32_t x0, y0, x1, y1;
+  };
+  Expected expected[] = {{0, 0, 0, 64, 64}, {1, 64, 0, 128, 64}, {2, 0, 64, 64, 128}, {3, 64, 64, 128, 128}};
+
+  for(auto& e : expected)
+  {
+    auto* tileImg = grk_decompress_get_tile_image(codec.get(), e.tileIndex, true);
+    if(!tileImg)
+    {
+      spdlog::error("FAIL: get_tile_image returned null for tile {}", e.tileIndex);
+      std::filesystem::remove(testFile);
+      return false;
+    }
+    if(tileImg->x0 != e.x0 || tileImg->y0 != e.y0 || tileImg->x1 != e.x1 || tileImg->y1 != e.y1)
+    {
+      spdlog::error("FAIL: tile {} coords ({},{},{},{}) != expected ({},{},{},{})", e.tileIndex,
+                    tileImg->x0, tileImg->y0, tileImg->x1, tileImg->y1, e.x0, e.y0, e.x1, e.y1);
+      std::filesystem::remove(testFile);
+      return false;
+    }
+    // Also verify component dimensions match reduced tile size
+    uint32_t cw = tileImg->comps[0].w;
+    uint32_t ch = tileImg->comps[0].h;
+    if(cw != (e.x1 - e.x0) || ch != (e.y1 - e.y0))
+    {
+      spdlog::error("FAIL: tile {} comp size {}x{} != expected {}x{}", e.tileIndex, cw, ch,
+                    e.x1 - e.x0, e.y1 - e.y0);
+      std::filesystem::remove(testFile);
+      return false;
+    }
+  }
+
+  std::filesystem::remove(testFile);
+  spdlog::info("PASS: Reduced-coords per-tile API");
+  return true;
+}
+
 ///////////////////////////////////////////////////////////////////
 // Test 10: All tiles via decompressTile then re-read all
 //
@@ -2541,6 +2633,10 @@ int GrkLRUCacheTest::main(int argc, char** argv)
   if(!testReduceWithRegion())
     failures++;
 
+  // Test 9b: Reduced-coords per-tile API
+  if(!testReducedCoordsPerTile())
+    failures++;
+
   // Test 10: All tiles via decompressTile then re-read
   {
     std::string interFile =