fixed

Author: Grok Compression

src/lib/codec/apps/GrkDecompress.cpp

@@ -1114,14 +1114,19 @@ int GrkDecompress::preProcess(grk_plugin_decompress_callback_info* info)
       goto cleanup;
     }
   }
-  // 3a. initialize writer before decompress so it's ready for incremental output
-  if(!writeInit(info))
-    goto cleanup;
-  // enable incremental band writing when postProcess is a no-op
+  // 3a. initialize writer before decompress so it's ready for incremental output.
+  // Only call writeInit early when postProcess is a no-op, so we can write header
+  // and enable incremental band writes.  When post-processing is needed, defer
+  // writeInit until after decompress (postProcess) so that the library's
+  // io_buffer_callback (strip write) doesn't write raw/unprocessed strips
+  // during decompress.
   incrementalWriteActive_ = false;
   if(storeToDisk && !parameters->single_tile_decompress && !info->init_decompressors_func &&
-     grk_image_is_post_process_no_op(info->image))
+     grk_image_is_post_process_no_op(info->image) &&
+     parameters->dw_y1 == 0)
   {
+    if(!writeInit(info))
+      goto cleanup;
     // write header early — metadata is already final since postProcess is a no-op
     if(!writeHeader(info))
       goto cleanup;
@@ -1267,37 +1272,38 @@ int GrkDecompress::postProcess(grk_plugin_decompress_callback_info* info)
   }
   if(storeToDisk)
   {
-    // GPU decode path: format was not initialized during preProcess
-    // (writeInit was skipped because grk_decompress was not called).
-    // Initialize the format now with the bridge image that has actual data.
-    if(info->decompress_flags & GRK_DECODE_POST_T1 &&
-       fmt->getWriteState() == IMAGE_FORMAT_UNWRITTEN)
+    // Update the format's image pointer in case it changed (e.g. single tile decompress
+    // replaces info->image after writeInit was called in preProcess)
+    fmt->setImage(image);
+    // Initialize the format if not already done.  writeInit is deferred to postProcess
+    // when post-processing is needed, so the library's io_buffer_callback (strip write)
+    // doesn't write raw/unprocessed strips during decompress.
+    if(fmt->getWriteState() == IMAGE_FORMAT_UNWRITTEN)
     {
-      // Set decompress output fields on the bridge image
-      if(image->numcomps > 0)
+      if(info->decompress_flags & GRK_DECODE_POST_T1)
       {
-        if(image->decompress_prec == 0)
-        {
-          image->decompress_prec = image->comps[0].prec;
-          image->decompress_width = image->comps[0].w;
-          image->decompress_height = image->comps[0].h;
-          image->decompress_num_comps = image->numcomps;
-          image->decompress_colour_space = image->color_space;
-        }
-        if(image->packed_row_bytes == 0)
+        // GPU decode path: set decompress output fields on the bridge image
+        if(image->numcomps > 0)
         {
-          uint16_t ncmp = image->numcomps;
-          uint8_t prec = image->comps[0].prec;
-          image->packed_row_bytes = ((uint64_t)image->comps[0].w * ncmp * prec + 7U) / 8U;
+          if(image->decompress_prec == 0)
+          {
+            image->decompress_prec = image->comps[0].prec;
+            image->decompress_width = image->comps[0].w;
+            image->decompress_height = image->comps[0].h;
+            image->decompress_num_comps = image->numcomps;
+            image->decompress_colour_space = image->color_space;
+          }
+          if(image->packed_row_bytes == 0)
+          {
+            uint16_t ncmp = image->numcomps;
+            uint8_t prec = image->comps[0].prec;
+            image->packed_row_bytes = ((uint64_t)image->comps[0].w * ncmp * prec + 7U) / 8U;
+          }
+          if(image->rows_per_strip == 0)
+            image->rows_per_strip = std::min((uint32_t)32, image->comps[0].h);
         }
-        if(image->rows_per_strip == 0)
-          image->rows_per_strip = std::min((uint32_t)32, image->comps[0].h);
       }
-      if(!fmt->writeInit(
-             image, outfile ? std::string(outfile) : "",
-             info->cod_format == GRK_FMT_TIF ? info->decompressor_parameters->compression : 0,
-             info->decompressor_parameters->num_threads ? info->decompressor_parameters->num_threads
-                                                        : std::thread::hardware_concurrency()))
+      if(!writeInit(info))
       {
         spdlog::error("Outfile {} not generated", outfile ? std::string(outfile) : "");
         goto cleanup;

src/lib/codec/formats/IImageFormat.h

@@ -26,9 +26,10 @@
  *
  */
 const uint32_t IMAGE_FORMAT_UNWRITTEN = 1;
-const uint32_t IMAGE_FORMAT_HEADER_WRITTEN = 2;
-const uint32_t IMAGE_FORMAT_PIXELS_WRITTEN = 4;
-const uint32_t IMAGE_FORMAT_ERROR = 8;
+const uint32_t IMAGE_FORMAT_INITIALIZED = 2;
+const uint32_t IMAGE_FORMAT_HEADER_WRITTEN = 4;
+const uint32_t IMAGE_FORMAT_PIXELS_WRITTEN = 8;
+const uint32_t IMAGE_FORMAT_ERROR = 16;
 
 /**
  * @class IImageReader

src/lib/codec/formats/ImageFormat.cpp

@@ -75,6 +75,7 @@ bool ImageFormat::writeInit(grk_image* image, const std::string& filename,
   compressionLevel_ = compression_level;
   fileName_ = filename;
   image_ = image;
+  writeState_ = IMAGE_FORMAT_INITIALIZED;
 
   return true;
 }

src/lib/codec/formats/TIFFFormat.h

@@ -641,6 +641,20 @@ class TIFFFormat : public ImageFormat
   bool writeImageBand(uint32_t yBegin, uint32_t yEnd) override;
   bool supportsIncrementalBandWrite(void) const override
   {
+    // Subsampled YCbCr TIFF packs luma+chroma into strips; incremental band
+    // writes produce many small strips instead of one strip per rows_per_strip,
+    // changing the TIFF structure.
+    if(image_)
+    {
+      if(!image_->upsample && !image_->force_rgb)
+      {
+        for(uint32_t i = 0; i < image_->decompress_num_comps; ++i)
+        {
+          if(image_->comps[i].dx != 1 || image_->comps[i].dy != 1)
+            return false;
+        }
+      }
+    }
     return true;
   }
   /***

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

@@ -238,17 +238,23 @@ bool CodeStreamDecompress::decompress(grk_plugin_tile* tile)
     auto compositeBounds = multiTileComposite_->getBounds();
     uint32_t regionY0 = ceildivpow2<uint32_t>(compositeBounds.y0, reduce);
     uint32_t regionY1 = ceildivpow2<uint32_t>(compositeBounds.y1, reduce);
-    uint32_t reducedTileHeight = ceildivpow2<uint32_t>(cp_.t_height_, reduce);
-    uint32_t reducedTy0 = ceildivpow2<uint32_t>(cp_.ty0_, reduce);
+    uint32_t unreducedTy0 = cp_.ty0_;
+    uint32_t unreducedTileHeight = cp_.t_height_;
+    uint32_t unreducedRegionY1 = compositeBounds.y1;
     tileCompletion_ = std::make_unique<TileCompletion>(
         tileCache_.get(), unreducedBounds, cp_.t_width_, cp_.t_height_,
-        [this, regionY0, regionY1, reducedTileHeight, reducedTy0](uint16_t tileIndexBegin,
-                                                                   uint16_t) {
+        [this, regionY0, regionY1, unreducedTy0, unreducedTileHeight, unreducedRegionY1,
+         reduce](uint16_t tileIndexBegin, uint16_t) {
           uint16_t numTileCols = tileCompletion_->getNumTileCols();
           uint16_t tileY = tileIndexBegin / numTileCols;
-          uint32_t tileGlobalYBegin = reducedTy0 + (uint32_t)tileY * reducedTileHeight;
-          uint32_t tileGlobalYEnd =
-              std::min(reducedTy0 + ((uint32_t)tileY + 1) * reducedTileHeight, regionY1);
+          // Compute exact reduced-resolution tile Y extents using ceildivpow2
+          // on unreduced coordinates, since DWT reduction is not uniformly divisible
+          uint32_t unreducedTileYBegin = unreducedTy0 + (uint32_t)tileY * unreducedTileHeight;
+          uint32_t unreducedTileYEnd =
+              std::min(unreducedTy0 + ((uint32_t)tileY + 1) * unreducedTileHeight,
+                       unreducedRegionY1);
+          uint32_t tileGlobalYBegin = ceildivpow2<uint32_t>(unreducedTileYBegin, reduce);
+          uint32_t tileGlobalYEnd = ceildivpow2<uint32_t>(unreducedTileYEnd, reduce);
           uint32_t yBegin = std::max(tileGlobalYBegin, regionY0) - regionY0;
           uint32_t yEnd = std::min(tileGlobalYEnd, regionY1) - regionY0;
           if(yEnd <= yBegin)

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

@@ -189,6 +189,10 @@ void CodeStreamDecompress::postReadHeader(void)
   if(headerRead_)
   {
     setDecompressRegion(RectD(cp_.dw_x0, cp_.dw_y0, cp_.dw_x1, cp_.dw_y1));
+    // Refresh decompress_width/height/etc. now that region bounds are applied.
+    // Without this, formats that write headers before decompress() see stale
+    // full-image dimensions instead of the (possibly reduced) region dimensions.
+    multiTileComposite_->postReadHeader(&cp_);
 
     if(cp_.asynchronous_ && cp_.simulate_synchronous_)
     {

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

@@ -105,6 +105,11 @@ bool FileFormatJP2Decompress::readHeader(grk_header_info* header_info)
     }
     image = codeStream->getCompositeNoWait();
     image->validateICC();
+    // Update decompress_colour_space after validateICC may have changed color_space
+    // (e.g. to GRK_CLRSPC_ICC).  postReadHeader() ran before validateICC, so
+    // decompress_colour_space still holds the old value.  Writers that emit
+    // headers before decompress() rely on this being current.
+    image->decompress_colour_space = image->color_space;
 
     // check RGB subsampling
     if(image->color_space == GRK_CLRSPC_SRGB)

src/lib/core/util/GrkImage.cpp

@@ -468,8 +468,25 @@ bool GrkImage::isPostProcessNoOp(void) const
   // convertPrecision
   if(precision)
     return false;
-  if(decompress_fmt == GRK_FMT_JPG && comps[0].prec < 8 && numcomps > 1)
-    return false;
+  if(decompress_fmt == GRK_FMT_JPG)
+  {
+    uint8_t prec = comps[0].prec;
+    if(prec < 8 && numcomps > 1)
+      return false;
+    if((prec > 1) && (prec < 8) && ((prec == 6) || ((prec & 1) == 1)))
+      return false;
+  }
+  if(decompress_fmt == GRK_FMT_PNG)
+  {
+    uint8_t prec = comps[0].prec;
+    uint16_t nr_comp = numcomps > 4 ? 4 : numcomps;
+    if(prec > 8 && prec < 16)
+      return false;
+    if(prec < 8 && nr_comp > 1)
+      return false;
+    if((prec > 1) && (prec < 8) && ((prec == 6) || ((prec & 1) == 1)))
+      return false;
+  }
   // execUpsample
   if(upsample)
   {