Support interleaved CFA encoding

Author: kmilos

src/librawspeed/decoders/DngDecoder.cpp

@@ -54,6 +54,7 @@
 #include <vector>
 
 using std::map;
+using std::pair;
 using std::vector;
 
 namespace rawspeed {
@@ -385,6 +386,13 @@ void DngDecoder::decodeData(const TiffIFD* raw, uint32_t sample_format) const {
   if (raw->hasEntry(TiffTag::PREDICTOR))
     predictor = raw->getEntry(TiffTag::PREDICTOR)->getU32();
 
+  pair<uint32_t, uint32_t> interleave{1U, 1U};
+  if (raw->hasEntry(TiffTag::ROWINTERLEAVEFACTOR))
+    interleave.first = raw->getEntry(TiffTag::ROWINTERLEAVEFACTOR)->getU32();
+  if (raw->hasEntry(TiffTag::COLUMNINTERLEAVEFACTOR))
+    interleave.second =
+        raw->getEntry(TiffTag::COLUMNINTERLEAVEFACTOR)->getU32();
+
   if (mRaw->getDataType() == RawImageType::UINT16) {
     // Default white level is (2 ** BitsPerSample) - 1
     mRaw->whitePoint = implicit_cast<int>((1UL << *bps) - 1UL);
@@ -414,7 +422,7 @@ void DngDecoder::decodeData(const TiffIFD* raw, uint32_t sample_format) const {
   }
 
   AbstractDngDecompressor slices(mRaw, getTilingDescription(raw), compression,
-                                 mFixLjpeg, *bps, predictor);
+                                 mFixLjpeg, *bps, predictor, interleave);
 
   slices.slices.reserve(slices.dsc.numTiles);
 

src/librawspeed/decompressors/AbstractDngDecompressor.cpp

@@ -214,7 +214,8 @@ void AbstractDngDecompressor::decompressThread<0xcd42>() const noexcept {
   for (const auto& e :
        Array1DRef(slices.data(), implicit_cast<int>(slices.size()))) {
     try {
-      JpegXLDecompressor j(e.bs.peekBuffer(e.bs.getRemainSize()), mRaw);
+      JpegXLDecompressor j(e.bs.peekBuffer(e.bs.getRemainSize()), mRaw,
+                           mInterleave);
       j.decode(e.offX, e.offY);
     } catch (const RawDecoderException& err) {
       mRaw->setError(err.what());

src/librawspeed/decompressors/AbstractDngDecompressor.h

@@ -134,9 +134,11 @@ class AbstractDngDecompressor final : public AbstractDecompressor {
 public:
   AbstractDngDecompressor(RawImage img, const DngTilingDescription& dsc_,
                           int compression_, bool mFixLjpeg_, uint32_t mBps_,
-                          uint32_t mPredictor_)
+                          uint32_t mPredictor_,
+                          std::pair<uint32_t, uint32_t> mInterleave_)
       : mRaw(std::move(img)), dsc(dsc_), compression(compression_),
-        mFixLjpeg(mFixLjpeg_), mBps(mBps_), mPredictor(mPredictor_) {}
+        mFixLjpeg(mFixLjpeg_), mBps(mBps_), mPredictor(mPredictor_),
+        mInterleave(std::move(mInterleave_)) {}
 
   void decompress() const;
 
@@ -148,6 +150,7 @@ class AbstractDngDecompressor final : public AbstractDecompressor {
   const bool mFixLjpeg = false;
   const uint32_t mBps;
   const uint32_t mPredictor;
+  const std::pair<uint32_t, uint32_t> mInterleave;
 };
 
 } // namespace rawspeed

src/librawspeed/decompressors/JpegXLDecompressor.cpp

@@ -32,6 +32,7 @@
 #include <jxl/codestream_header.h>
 #include <jxl/decode.h>
 #include <jxl/types.h>
+#include <utility>
 #include <vector>
 
 using std::min;
@@ -46,6 +47,13 @@ void JpegXLDecompressor::decode(
   if (signature != JXL_SIG_CODESTREAM && signature != JXL_SIG_CONTAINER)
     ThrowRDE("Unable to verify JPEG XL signature");
 
+  if (mInterleave != std::pair(1U, 1U) && mInterleave != std::pair(2U, 2U))
+    ThrowRDE("Invalid interleave factors");
+
+  if (mInterleave == std::pair(2U, 2U) && mRaw->getCpp() != 1)
+    ThrowRDE(
+        "Invalid combination of interleave factors and components per pixel");
+
   JxlDecoder* decoder = JxlDecoderCreate(nullptr);
 
   if (!decoder)
@@ -129,18 +137,27 @@ void JpegXLDecompressor::decode(
 
   const Array2DRef<uint16_t> tmp(complete_buffer.data(),
                                  basicinfo.num_color_channels * basicinfo.xsize,
-                                 basicinfo.xsize);
+                                 basicinfo.ysize);
 
   // Now the image is decoded, and we copy the image data
   unsigned int copy_w = min(mRaw->dim.x - offX, basicinfo.xsize);
   unsigned int copy_h = min(mRaw->dim.y - offY, basicinfo.ysize);
 
   const Array2DRef<uint16_t> out(mRaw->getU16DataAsUncroppedArray2DRef());
   for (unsigned int row = 0; row < copy_h; row++) {
+    unsigned int rowbuf =
+        (row / mInterleave.first) +
+        (row % mInterleave.first) * (basicinfo.ysize / mInterleave.first);
     for (unsigned int col = 0; col < basicinfo.num_color_channels * copy_w;
-         col++)
+         col++) {
+      unsigned int colbuf =
+          (col / mInterleave.second) +
+          (col % mInterleave.second) *
+              ((basicinfo.num_color_channels * basicinfo.xsize) /
+               mInterleave.second);
       out(offY + row, basicinfo.num_color_channels * offX + col) =
-          tmp(row, col);
+          tmp(rowbuf, colbuf);
+    }
   }
 }
 

src/librawspeed/decompressors/JpegXLDecompressor.h

@@ -28,16 +28,19 @@
 #include "decompressors/AbstractDecompressor.h"
 #include "io/Buffer.h"
 #include <cstdint>
+#include <utility>
 
 namespace rawspeed {
 
 class JpegXLDecompressor final : public AbstractDecompressor {
   Buffer input;
   RawImage mRaw;
+  std::pair<uint32_t, uint32_t> mInterleave;
 
 public:
-  JpegXLDecompressor(Buffer bs, RawImage img)
-      : input(bs), mRaw(std::move(img)) {}
+  JpegXLDecompressor(Buffer bs, RawImage img,
+                     std::pair<uint32_t, uint32_t> interleave)
+      : input(bs), mRaw(std::move(img)), mInterleave(std::move(interleave)) {}
 
   void decode(uint32_t offsetX, uint32_t offsetY);
 };

src/librawspeed/tiff/TiffTag.h

@@ -333,6 +333,7 @@ enum class TiffTag : uint16_t {
   OPCODELIST2 = 0xC741,
   OPCODELIST3 = 0xC742,
   NOISEPROFILE = 0xC761,
+  COLUMNINTERLEAVEFACTOR = 0xCD43,
   CANONCR2SLICE = 0xC640,  // CANON CR2
   CANON_SRAWTYPE = 0xC6C5, // IFD3
   CANON_SRAWQUALITY = 0x002E,