Add path for 12-bit JPG decoder

Some Blackmagic CinemaDNG files (Pocket Cinema Camera 4K files (3)/(4), Micro Cinema Camera (1)) use SOF1 (Extended Sequential DCT) at 12-bit precision but label tiles as TIFF compression=7 (lossless JPEG). The lossless JPEG decoder hit a DQT marker and threw "Not a valid RAW file."

On libjpeg-turbo 2.1.5, the error is now "Unsupported JPEG data precision 12" (much clearer). On systems with libjpeg-turbo 3.0+, the HAVE_JPEG_12BIT path will automatically enable full 12-bit lossy JPEG decoding.

Author: da-phil

cmake/Modules/CheckJPEGSymbols.cmake

@@ -13,6 +13,7 @@ set(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES_SAVE};${JPEG_INCLUDE_DIRS
 set(CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES_SAVE};${JPEG_LIBRARIES}")
 
 CHECK_CXX_SYMBOL_EXISTS(jpeg_mem_src "cstdio;jpeglib.h" HAVE_JPEG_MEM_SRC)
+CHECK_CXX_SYMBOL_EXISTS(jpeg12_read_scanlines "cstdio;jpeglib.h" HAVE_JPEG_12BIT)
 
 set(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES_SAVE}")
 set(CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES_SAVE}")

src/config.h.in

@@ -64,6 +64,7 @@ static_assert(RAWSPEED_LARGEPAGESIZE >= RAWSPEED_PAGESIZE,
 
 #cmakedefine HAVE_JPEG
 #cmakedefine HAVE_JPEG_MEM_SRC
+#cmakedefine HAVE_JPEG_12BIT
 
 #cmakedefine HAVE_CXX_THREAD_LOCAL
 #cmakedefine HAVE_GCC_THREAD_LOCAL

src/librawspeed/decompressors/AbstractDngDecompressor.cpp

@@ -51,6 +51,63 @@
 
 namespace rawspeed {
 
+namespace {
+
+// Some DNG files (e.g. Blackmagic CinemaDNG) use TIFF compression=7
+// (lossless JPEG) but the actual tile data contains lossy DCT JPEG
+// (SOF0/SOF1/SOF2 with DQT). Detect this by scanning the first few
+// JPEG markers in the tile stream.
+[[nodiscard]] bool tileContainsLossyJpeg(const ByteStream& bs) {
+  const auto remaining = bs.getRemainSize();
+  if (remaining < 4)
+    return false;
+
+  // Must start with JPEG SOI marker
+  if (bs.peekByte(0) != 0xFF || bs.peekByte(1) != 0xD8)
+    return false;
+
+  // Scan markers after SOI. Stop after a reasonable number of bytes.
+  const auto limit =
+      std::min(remaining, static_cast<ByteStream::size_type>(1024));
+  ByteStream::size_type pos = 2;
+
+  while (pos + 3 < limit) {
+    if (bs.peekByte(pos) != 0xFF)
+      return false; // Invalid marker - stop scanning
+
+    const uint8_t marker = bs.peekByte(pos + 1);
+
+    // DQT (quantization table) is definitive proof of lossy JPEG
+    if (marker == 0xDB) // DQT
+      return true;
+
+    // SOF0/SOF1/SOF2 = lossy DCT-based JPEG
+    if (marker == 0xC0 || marker == 0xC1 || marker == 0xC2)
+      return true;
+
+    // SOF3 = lossless - this is what compression=7 should be
+    if (marker == 0xC3)
+      return false;
+
+    // SOS = start of scan data - stop scanning
+    if (marker == 0xDA)
+      return false;
+
+    // Skip this marker segment
+    if (pos + 4 > remaining)
+      return false;
+    const uint16_t segLen = (static_cast<uint16_t>(bs.peekByte(pos + 2)) << 8) |
+                            static_cast<uint16_t>(bs.peekByte(pos + 3));
+    if (segLen < 2)
+      return false;
+    pos += 2 + segLen;
+  }
+
+  return false;
+}
+
+} // namespace
+
 template <> void AbstractDngDecompressor::decompressThread<1>() const noexcept {
 #ifdef HAVE_OPENMP
 #pragma omp for schedule(static)
@@ -116,6 +173,15 @@ template <> void AbstractDngDecompressor::decompressThread<7>() const noexcept {
   for (const auto& e :
        Array1DRef(slices.data(), implicit_cast<int>(slices.size()))) {
     try {
+#ifdef HAVE_JPEG
+      // Some cameras (e.g. Blackmagic CinemaDNG) mislabel lossy DCT JPEG
+      // tiles as compression=7 (lossless JPEG). Detect and redirect.
+      if (tileContainsLossyJpeg(e.bs)) {
+        JpegDecompressor j(e.bs.peekBuffer(e.bs.getRemainSize()), mRaw);
+        j.decode(e.offX, e.offY);
+        continue;
+      }
+#endif
       LJpegDecoder d(e.bs, mRaw);
       d.decode(e.offX, e.offY, e.width, e.height,
                iPoint2D(e.dsc.tileW, e.dsc.tileH), mFixLjpeg);

src/librawspeed/decompressors/JpegDecompressor.cpp

@@ -139,6 +139,13 @@ void JpegDecompressor::decode(uint32_t offX,
   if (JPEG_HEADER_OK != jpeg_read_header(&dinfo, static_cast<boolean>(true)))
     ThrowRDE("Unable to read JPEG header");
 
+#ifdef HAVE_JPEG_12BIT
+  if (dinfo.data_precision == 12) {
+    decode12bit(dinfo, offX, offY);
+    return;
+  }
+#endif
+
   jpeg_start_decompress(&dinfo);
   if (dinfo.output_components != static_cast<int>(mRaw->getCpp()))
     ThrowRDE("Component count doesn't match");
@@ -169,6 +176,40 @@ void JpegDecompressor::decode(uint32_t offX,
   }
 }
 
+#ifdef HAVE_JPEG_12BIT
+void JpegDecompressor::decode12bit(JpegDecompressStruct& dinfo, uint32_t offX,
+                                   uint32_t offY) {
+  jpeg12_start_decompress(&dinfo);
+  if (dinfo.output_components != static_cast<int>(mRaw->getCpp()))
+    ThrowRDE("Component count doesn't match");
+  const int row_stride = dinfo.output_width * dinfo.output_components;
+
+  std::vector<int16_t, AlignedAllocator<int16_t, 16>> complete_buffer;
+  complete_buffer.resize(dinfo.output_height * row_stride);
+
+  const Array2DRef<int16_t> tmp(&complete_buffer[0],
+                                dinfo.output_components * dinfo.output_width,
+                                dinfo.output_height, row_stride);
+
+  while (dinfo.output_scanline < dinfo.output_height) {
+    J12SAMPROW rowOut = &tmp(dinfo.output_scanline, 0);
+    if (0 == jpeg12_read_scanlines(&dinfo, &rowOut, 1))
+      ThrowRDE("JPEG Error while decompressing 12-bit image.");
+  }
+  jpeg12_finish_decompress(&dinfo);
+
+  const int copy_w = min(mRaw->dim.x - offX, dinfo.output_width);
+  const int copy_h = min(mRaw->dim.y - offY, dinfo.output_height);
+
+  const Array2DRef<uint16_t> out(mRaw->getU16DataAsUncroppedArray2DRef());
+  for (int row = 0; row < copy_h; row++) {
+    for (int col = 0; col < dinfo.output_components * copy_w; col++)
+      out(row + offY, (dinfo.output_components * offX) + col) =
+          static_cast<uint16_t>(tmp(row, col));
+  }
+}
+#endif
+
 } // namespace rawspeed
 
 #else

src/librawspeed/decompressors/JpegDecompressor.h

@@ -38,6 +38,10 @@ class JpegDecompressor final : public AbstractDecompressor {
   Buffer input;
   RawImage mRaw;
 
+#ifdef HAVE_JPEG_12BIT
+  void decode12bit(JpegDecompressStruct& dinfo, uint32_t offX, uint32_t offY);
+#endif
+
 public:
   JpegDecompressor(Buffer bs, RawImage img) : input(bs), mRaw(std::move(img)) {}