raw-webgpu 0.1.0-alpha.1

package/native/build.py

@@ -0,0 +1,229 @@
+"""Compile LibRaw and DNG SDK to browser WASM with Emscripten 6.0.9."""
+
+import hashlib
+import os
+import re
+import shutil
+import subprocess
+import tarfile
+import urllib.request
+import zipfile
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+NATIVE = Path(__file__).resolve().parent
+PROJECT = NATIVE.parent
+CACHE = Path(os.environ.get("RAW_WEBGPU_CACHE", PROJECT / ".cache/native")).resolve()
+OUTPUT = PROJECT / "dist/libraw.js"
+
+
+def run(*args):
+    subprocess.run([str(arg) for arg in args], check=True)
+
+
+def download(name, url, checksum):
+    archive = CACHE / name
+    if not archive.exists():
+        urllib.request.urlretrieve(url, archive)
+    if hashlib.sha256(archive.read_bytes()).hexdigest() != checksum:
+        raise RuntimeError(f"Source checksum mismatch: {name}")
+    return archive
+
+
+def prepare_sources(root):
+    raw_archive = download(
+        "libraw.tar.gz",
+        "https://www.libraw.org/data/LibRaw-0.22.2.tar.gz",
+        "de86b035655accff8d4010f1a221fdf50d353cb7b1422ba26f14a0db92612cfa",
+    )
+    sdk_archive = download(
+        "dng-sdk.zip",
+        "https://download.adobe.com/pub/adobe/dng/dng_sdk_1_7_1_2724_20260908.zip",
+        "740fbe95c69e09e9cd17654a5e4fef2d7021254b06fd2b8c5557b79a1496b50c",
+    )
+    raw = root / "LibRaw-0.22.2"
+    sdk = root / "dng_sdk_1_7_1"
+    if not raw.exists():
+        with tarfile.open(raw_archive) as archive:
+            archive.extractall(root, filter="data")
+    if not sdk.exists():
+        with zipfile.ZipFile(sdk_archive) as archive:
+            archive.extractall(root)
+
+    # SDK 1.7.1 omits its XMP feature guard in two JPEG XL metadata blocks.
+    source = sdk / "dng_sdk/source/dng_jxl.cpp"
+    if "#if qDNGUseXMP\n\n\t\tif (includeXMP" not in source.read_text():
+        run("patch", "-d", sdk, "-p1", "-i", NATIVE / "dng-no-xmp.patch")
+    return raw, sdk
+
+
+def build_jpeg_xl(em, source, output):
+    disabled = [
+        "TOOLS",
+        "JPEGLI",
+        "JPEGLI_LIBJPEG",
+        "DOXYGEN",
+        "MANPAGES",
+        "BENCHMARK",
+        "EXAMPLES",
+        "JNI",
+        "SJPEG",
+        "OPENEXR",
+        "TCMALLOC",
+        "WASM_THREADS",
+        "TRANSCODE_JPEG",
+    ]
+    run(
+        em / "emcmake",
+        "cmake",
+        "-S",
+        source,
+        "-B",
+        output,
+        "-DBUILD_SHARED_LIBS=OFF",
+        "-DBUILD_TESTING=OFF",
+        "-DCMAKE_BUILD_TYPE=Release",
+        "-DJPEGXL_BUNDLE_LIBPNG=OFF",
+        "-DJPEGXL_ENABLE_SKCMS=ON",
+        *[f"-DJPEGXL_ENABLE_{name}=OFF" for name in disabled],
+        "-DCMAKE_CXX_FLAGS=-Oz -flto -fwasm-exceptions -msimd128",
+        "-DCMAKE_C_FLAGS=-Oz -flto -msimd128",
+    )
+    run(
+        "cmake",
+        "--build",
+        output,
+        "--parallel",
+        "6",
+        "--target",
+        "jxl_dec",
+        "jxl_threads",
+    )
+
+
+def compiler_flags(includes):
+    return [
+        "-Oz",
+        "-flto",
+        "-fwasm-exceptions",
+        "-msimd128",
+        "-fno-rtti",
+        "-fvisibility=hidden",
+        "-fwhole-program-vtables",
+        "-fvirtual-function-elimination",
+        "-std=c++17",
+        "-w",
+        "-DLIBRAW_NOTHREADS",
+        "-DLIBRAW_NO_IOSTREAMS_DATASTREAM",
+        "-DUSE_DNGSDK",
+        "-DUSE_X3FTOOLS",
+        "-DUSE_ZLIB",
+        "--use-port=zlib",
+        "--use-port=libjpeg",
+        "-DqWeb=1",
+        "-DqDNGUseXMP=0",
+        "-DqDNGXMPFiles=0",
+        "-DqDNGXMPDocOps=0",
+        "-DqDNGThreadSafe=0",
+        "-DqDNGSupportVC5=0",
+        "-DqDNGUseLibJPEG=1",
+        "-DqDNG64Bit=0",
+        "-DqDNGLittleEndian=1",
+        "-DqDNGValidate=0",
+    ] + [f"-I{path}" for path in includes]
+
+
+def build_libraries(em, root, raw, sdk, flags):
+    manifest = (raw / "Makefile.am").read_text()
+    manifest = manifest.split("lib_libraw_a_SOURCES =", 1)[1]
+    manifest = manifest.split("lib_libraw_r_a_CXXFLAGS", 1)[0]
+    sources = [raw / path for path in re.findall(r"src/[\w/]+\.cpp", manifest)]
+    excluded = {"dng_validate", "dng_xmp", "dng_xmp_sdk", "dng_update_meta"}
+    sources.extend(path for path in sdk.glob("*.cpp") if path.stem not in excluded)
+    objects = root / "objects"
+    objects.mkdir(exist_ok=True)
+
+    def compile_source(source):
+        target = objects / f"{source.stem}.o"
+        if not target.exists():
+            run(em / "em++", *flags, "-c", source, "-o", target)
+        return target
+
+    with ThreadPoolExecutor(max_workers=6) as pool:
+        compiled = list(pool.map(compile_source, sources))
+    library = root / "libraries.a"
+    run(em / "emar", "rcs", library, *compiled)
+    return library
+
+
+def link_wasm(em, flags, library, jxl):
+    OUTPUT.parent.mkdir(parents=True, exist_ok=True)
+    run(
+        em / "em++",
+        *flags,
+        *sorted(NATIVE.glob("*.cpp")),
+        library,
+        *jxl.rglob("*.a"),
+        "-o",
+        OUTPUT,
+        "-sMODULARIZE=1",
+        "-sEXPORT_ES6=1",
+        "-sENVIRONMENT=web,worker",
+        "-sINCOMING_MODULE_JS_API=instantiateWasm",
+        "-sALLOW_MEMORY_GROWTH=1",
+        "-sSTACK_SIZE=1048576",
+        "-sMAXIMUM_MEMORY=2147483648",
+        "-sFILESYSTEM=0",
+        "-sEXPORTED_FUNCTIONS=_malloc,_free",
+        "-sEXPORTED_RUNTIME_METHODS=HEAPU8,HEAPU16,HEAPU32,HEAPF64,UTF8ToString",
+        "-sASSERTIONS=0",
+    )
+
+
+def main():
+    compiler = shutil.which("em++")
+    if not compiler:
+        raise RuntimeError("Activate Emscripten 6.0.9 before running build")
+    version = subprocess.check_output([compiler, "--version"], text=True)
+    if "6.0.9" not in version:
+        raise RuntimeError("This build is pinned to Emscripten 6.0.9")
+
+    recipe = hashlib.sha256(
+        version.encode()
+        + Path(__file__).read_bytes()
+        + (NATIVE / "dng-no-xmp.patch").read_bytes()
+    ).hexdigest()
+    root = CACHE / recipe[:16]
+    root.mkdir(parents=True, exist_ok=True)
+    fingerprint = hashlib.sha256(
+        recipe.encode()
+        + b"".join(
+            path.read_bytes()
+            for path in sorted(NATIVE.iterdir())
+            if path.suffix in {".cpp", ".h"}
+        )
+    ).hexdigest()
+    stamp = root / "output.sha256"
+    if (
+        OUTPUT.exists()
+        and OUTPUT.with_suffix(".wasm").exists()
+        and stamp.exists()
+        and stamp.read_text() == fingerprint
+    ):
+        print("Native build is up to date.")
+        return
+
+    em = Path(compiler).resolve().parent
+    raw, sdk_root = prepare_sources(root)
+    sdk = sdk_root / "dng_sdk/source"
+    jxl = sdk_root / "libjxl/libjxl"
+    jxl_build = root / "jxl-build"
+    build_jpeg_xl(em, jxl, jxl_build)
+    flags = compiler_flags([raw, sdk, jxl / "lib/include", jxl_build / "lib/include"])
+    library = build_libraries(em, root, raw, sdk, flags)
+    link_wasm(em, flags, library, jxl_build)
+    stamp.write_text(fingerprint)
+
+
+if __name__ == "__main__":
+    main()

package/native/calibration.cpp

@@ -0,0 +1,136 @@
+#include "dng_camera_profile.h"
+#include "dng_color_space.h"
+#include "dng_color_spec.h"
+#include "dng_host.h"
+#include "dng_ifd.h"
+#include "dng_info.h"
+#include "dng_lens_correction.h"
+#include "dng_negative.h"
+#include "dng_opcode_list.h"
+#include "dng_stream.h"
+#include "dng_temperature.h"
+#include "raw.h"
+#include <cmath>
+#include <libraw/libraw.h>
+#include <memory>
+#include <stdexcept>
+#include <string>
+
+// Reads the DNG vignette opcode into source->vignette: five polynomial coefficients, then the
+// origin and per-axis scale that map pixel centers to the radius the polynomial expects.
+static void read_vignette(Raw *source, const dng_opcode &opcode) {
+    const auto &params = static_cast<const dng_opcode_FixVignetteRadial &>(opcode).Params();
+    for (int k = 0; k < 5; ++k) {
+        source->vignette[k] = params.fParams[k];
+    }
+    double cx = source->width * params.fCenter.h, cy = source->height * params.fCenter.v;
+    double aspect = source->negative->PixelAspectRatio();
+    double radius =
+        std::hypot(std::max(cx, source->width - cx), std::max(cy, source->height - cy) / aspect);
+    source->vignette[5] = -cx / radius;
+    source->vignette[6] = -cy / (aspect * radius);
+    source->vignette[7] = 1 / radius;
+    source->vignette[8] = 1 / (aspect * radius);
+}
+
+void prepare_calibration(Raw *source, void *bytes, unsigned length) {
+    auto &raw = source->decoder;
+    source->negative.Reset(source->host.Make_dng_negative());
+
+    if (source->info) {
+        // DNG carries its own camera profiles; also check the opcodes the GPU path cannot apply.
+        dng_stream stream(bytes, length);
+        auto &info = *source->info;
+        source->negative->Parse(source->host, stream, info);
+        source->negative->PostParse(source->host, stream, info);
+
+        const auto &ifd = *info.fIFD[info.fMainIndex];
+        source->opcodes[0] = ifd.fOpcodeList1Count;
+        source->opcodes[1] = ifd.fOpcodeList2Count;
+        source->opcodes[2] = ifd.fOpcodeList3Count;
+        const uint64 offsets[] = {ifd.fOpcodeList1Offset, ifd.fOpcodeList2Offset,
+                                  ifd.fOpcodeList3Offset};
+        bool hasVignette = false;
+        bool needsPreparation = ifd.fBlackLevelDeltaHCount || ifd.fBlackLevelDeltaVCount;
+        for (unsigned stage = 0; stage < 3; ++stage) {
+            if (!source->opcodes[stage]) {
+                continue;
+            }
+            dng_opcode_list list(stage + 1);
+            list.Parse(source->host, stream, source->opcodes[stage], offsets[stage]);
+            for (unsigned i = 0; i < list.Count(); ++i) {
+                const auto &opcode = list.Entry(i);
+                if (stage == 2 && opcode.OpcodeID() == dngOpcode_FixVignetteRadial &&
+                    !hasVignette) {
+                    read_vignette(source, opcode);
+                    hasVignette = true;
+                } else if (!opcode.Optional()) {
+                    needsPreparation = true;
+                }
+            }
+        }
+        if (needsPreparation) {
+            prepare_dng_pixels(source, bytes, length);
+        }
+    } else if (raw.imgdata.idata.colors == 3) {
+        // Other formats: wrap LibRaw's camera matrix as a single D65 profile.
+        source->negative->SetColorChannels(3);
+        AutoPtr<dng_camera_profile> profile(new dng_camera_profile);
+        dng_matrix matrix(3, 3);
+        for (int row = 0; row < 3; ++row) {
+            for (int col = 0; col < 3; ++col) {
+                matrix[row][col] = raw.imgdata.color.cam_xyz[row][col];
+            }
+        }
+        profile->SetColorMatrix1(matrix);
+        profile->SetCalibrationIlluminant1(21); // D65 calibration in LibRaw camera tables.
+        source->negative->AddProfile(profile);
+    }
+
+    // The as-shot multipliers give the camera neutral, which the profile turns into chromaticity.
+    if (source->negative->ProfileCount()) {
+        source->color = std::make_unique<dng_color_spec>(*source->negative,
+                                                         &source->negative->ProfileByIndex(0));
+        dng_vector neutral(source->color->Channels());
+        bool valid = true;
+        for (unsigned c = 0; c < neutral.Count(); ++c) {
+            float multiplier = raw.imgdata.color.cam_mul[c];
+            valid &= multiplier > 0 && std::isfinite(multiplier);
+            neutral[c] = multiplier > 0 ? 1.0 / multiplier : 1.0;
+        }
+        if (!valid) {
+            // LibRaw supplies daylight multipliers when the file has no usable camera neutral.
+            source->daylightBalance = true;
+            for (unsigned c = 0; c < neutral.Count(); ++c) {
+                float multiplier = raw.imgdata.color.pre_mul[c];
+                if (!(multiplier > 0) || !std::isfinite(multiplier)) {
+                    throw std::runtime_error("RAW file has no usable white balance calibration");
+                }
+                neutral[c] = 1.0 / multiplier;
+            }
+        }
+        source->asShotXY = source->color->NeutralToXY(neutral);
+        source->asShot = dng_temperature(source->asShotXY);
+    }
+    if (!source->color || !(source->asShot.Temperature() > 0)) {
+        throw std::runtime_error("RAW camera calibration is not supported");
+    }
+}
+
+// A zero temperature selects the exact as-shot chromaticity.
+double *calibrate(Raw *source, double temperature, double tint) {
+    source->color->SetWhiteXY(temperature > 0 ? dng_temperature(temperature, tint).Get_xy_coord()
+                                              : source->asShotXY);
+    const auto &white = source->color->CameraWhite();
+    auto matrix = dng_space_Rec2020_Linear::Get().MatrixFromPCS() * source->color->CameraToPCS();
+
+    // Gains neutralize the camera white; the matrix folds it back in, so gains then matrix equals
+    // the SDK's camera-to-Rec.2020 transform while still exposing the white balance.
+    for (int c = 0; c < 3; ++c) {
+        source->calibration[c] = 1.0 / white[c];
+        for (int r = 0; r < 3; ++r) {
+            source->calibration[3 + r * 3 + c] = matrix[r][c] * white[c];
+        }
+    }
+    return source->calibration;
+}

package/native/direct.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "dng_ifd.h"
+#include "dng_stream.h"
+
+// Byte offset of the image data when it can be used straight from the file: one uncompressed
+// strip, native-sized samples, no predictor. Zero otherwise.
+inline uint32 uncompressed_offset(const dng_ifd &ifd, dng_stream &stream) {
+    if (ifd.fCompression != 1 || ifd.fPredictor != 1 || ifd.fPlanarConfiguration != 1 ||
+        ifd.fFillOrder != 1 || !ifd.fUsesStrips || ifd.fTileOffsetsCount != 1 ||
+        ifd.fTileByteCountsCount != 1 ||
+        (ifd.fBitsPerSample[0] != 8 && ifd.fBitsPerSample[0] != 16 &&
+         ifd.fBitsPerSample[0] != 32)) {
+        return 0;
+    }
+
+    stream.SetReadPosition(ifd.fTileOffsetsOffset);
+    const auto offset = stream.TagValue_uint64(ifd.fTileOffsetsType);
+    stream.SetReadPosition(ifd.fTileByteCountsOffset);
+    const auto count = stream.TagValue_uint64(ifd.fTileByteCountsType);
+
+    const uint64 bytes = uint64(ifd.fImageWidth) * ifd.fImageLength * ifd.fSamplesPerPixel *
+                         (ifd.fBitsPerSample[0] / 8);
+    if (offset > stream.Length() || bytes > stream.Length() - offset || count < bytes ||
+        offset > UINT32_MAX) {
+        return 0;
+    }
+    return uint32(offset);
+}

package/native/dng-no-xmp.patch

@@ -0,0 +1,34 @@
+--- a/dng_sdk/source/dng_jxl.cpp
++++ b/dng_sdk/source/dng_jxl.cpp
+@@ -1536,6 +1536,7 @@
+ 			} // exif
+ 			
+ 		// XMP.
++#if qDNGUseXMP
+ 
+ 		if (includeXMP && metadata && metadata->GetXMP ())
+ 			{
+@@ -1574,6 +1575,7 @@
+ 				}
+ 
+ 			} // xmp
++#endif
+ 
+ 		// IPTC.
+ 
+@@ -3809,6 +3811,7 @@
+ 									 const std::vector<uint8> &data)
+ 	{
+ 	
++	#if qDNGUseXMP
+ 	#if qDNGValidate
+ 
+ 	if (gVerbose)
+@@ -3874,6 +3877,7 @@
+ 
+ 		}
+ 	
++#endif
+ 	}
+ 
+ /*****************************************************************************/

package/native/dng.cpp

@@ -0,0 +1,42 @@
+// The SDK owns mandatory DNG corrections and their ordering. This compatibility path starts
+// from the original file so LibRaw's linearization and black subtraction cannot run twice.
+#include "dng_image.h"
+#include "dng_pixel_buffer.h"
+#include "dng_tag_types.h"
+#include "raw.h"
+#include <algorithm>
+#include <stdexcept>
+
+void prepare_dng_pixels(Raw *source, void *bytes, unsigned length) {
+    dng_stream stream(bytes, length);
+    auto &negative = *source->negative;
+    negative.ReadStage1Image(source->host, stream, *source->info);
+    negative.BuildStage2Image(source->host);
+    negative.BuildStage3Image(source->host);
+    const auto &image = *negative.Stage3Image();
+    if (image.Planes() != 3) {
+        throw std::runtime_error("DNG preparation did not produce three-channel camera RGB");
+    }
+    source->width = image.Bounds().W();
+    source->height = image.Bounds().H();
+    source->prepared.resize(size_t(source->width) * source->height * 4);
+    dng_pixel_buffer buffer;
+    buffer.fArea = image.Bounds();
+    buffer.fPlane = 0;
+    buffer.fPlanes = 3;
+    buffer.fRowStep = source->width * 4;
+    buffer.fColStep = 4;
+    buffer.fPlaneStep = 1;
+    buffer.fPixelType = ttFloat;
+    buffer.fPixelSize = sizeof(float);
+    buffer.fData = source->prepared.data();
+    image.Get(buffer);
+    AutoPtr<dng_image> empty;
+    negative.SetStage3Image(empty); // Keep calibration, release the SDK pixel allocation.
+    source->cpuPrepared = true;
+    source->mosaic = 0;
+    source->originalOffset = 0;
+    source->white = 1;
+    std::fill_n(source->black, 4, 0);
+    std::fill_n(source->vignette, 9, 0); // Stage 3 already applied the opcode list.
+}

package/native/pixels.cpp

@@ -0,0 +1,213 @@
+#include "direct.h"
+#include "dng_info.h"
+#include "raw.h"
+#include <memory>
+#include <stdexcept>
+
+static void check(int code) {
+    if (code) {
+        throw std::runtime_error(libraw_strerror(code));
+    }
+}
+
+static void parse_dng(Raw *source, void *bytes, unsigned length) {
+    dng_stream stream(bytes, length);
+    auto info = std::make_unique<dng_info>();
+    info->Parse(source->host, stream);
+    info->PostParse(source->host);
+    if (!info->IsValidDNG()) {
+        throw std::runtime_error("Unsupported DNG metadata");
+    }
+    source->info = std::move(info);
+}
+
+// Byte offset of a DNG mosaic the GPU can read as-is: unsigned 16-bit little-endian Bayer in one
+// uncompressed strip, uncropped, with no linearization table or stage-1/2 opcodes. Zero otherwise.
+static unsigned direct_bayer(Raw *source, void *bytes, unsigned length) {
+    const auto &data = source->decoder.imgdata;
+    if (!source->info || source->info->fBigEndian || data.idata.filters <= 1000 ||
+        data.sizes.top_margin || data.sizes.left_margin) {
+        return 0;
+    }
+
+    const auto &ifd = *source->info->fIFD[source->info->fMainIndex];
+    if (ifd.fBitsPerSample[0] != 16 || ifd.fSamplesPerPixel != 1 || ifd.fSampleFormat[0] != 1 ||
+        ifd.fPhotometricInterpretation != 32803 || ifd.fLinearizationTableCount ||
+        ifd.fOpcodeList1Count || ifd.fOpcodeList2Count || ifd.fImageWidth != data.sizes.width ||
+        ifd.fImageLength != data.sizes.height ||
+        ifd.fActiveArea != dng_rect(ifd.fImageLength, ifd.fImageWidth)) {
+        return 0;
+    }
+
+    // A Uint16Array view over the file needs an even offset.
+    dng_stream stream(bytes, length);
+    const auto offset = uncompressed_offset(ifd, stream);
+    return offset % 2 ? 0 : offset;
+}
+
+// Failure here selects LibRaw preparation; malformed files still report decoder errors.
+struct GpuLayoutUnsupported : std::runtime_error {
+    using std::runtime_error::runtime_error;
+};
+
+static void describe_pixels(Raw *source) {
+    auto &raw = source->decoder;
+    auto &idata = raw.imgdata.idata;
+    auto &levels = raw.imgdata.color;
+    auto &sizes = raw.imgdata.sizes;
+    if ((!source->cpuPrepared && idata.filters && idata.filters != 9 && idata.filters < 1000) ||
+        (!source->cpuPrepared && (sizes.iwidth != sizes.width || sizes.iheight != sizes.height))) {
+        throw GpuLayoutUnsupported("This RAW mosaic is not supported by the GPU pipeline");
+    }
+    if (source->cpuPrepared) {
+        idata.filters = 0; // Demosaiced samples are camera RGB from here on.
+    }
+
+    source->cfaSize = idata.filters == 9 ? 6 : 2;
+
+    // LibRaw stores a spatial black pattern of cblack[4] rows by cblack[5] columns from cblack[6].
+    // A pattern must fold into one black level per CFA color, or a single value for RGB.
+    unsigned blackRows = levels.cblack[4], blackCols = levels.cblack[5];
+    if ((blackRows && blackCols) &&
+        ((idata.filters && (blackRows > source->cfaSize || blackCols > source->cfaSize)) ||
+         (!idata.filters && (blackRows != 1 || blackCols != 1)))) {
+        throw GpuLayoutUnsupported(
+            "This RAW black calibration is not supported by the GPU pipeline");
+    }
+
+    source->width = sizes.width;
+    source->height = sizes.height;
+    if (sizes.width < 3 || sizes.height < 3) {
+        throw GpuLayoutUnsupported("RAW image is too small for the GPU pipeline");
+    }
+    source->flip = sizes.flip;
+    source->mosaic = idata.filters ? 1 : 0;
+
+    bool seen[4] = {};
+    unsigned counts[3] = {};
+    unsigned cells = source->mosaic ? source->cfaSize * source->cfaSize : 4;
+    for (unsigned p = 0; p < cells; ++p) {
+        unsigned y = p / source->cfaSize, x = p % source->cfaSize;
+        unsigned channel = source->mosaic ? raw.COLOR(y, x) : p;
+        source->cfa[p] = channel;
+        double black = levels.black + levels.cblack[channel];
+        if (blackRows && blackCols) {
+            black += levels.cblack[6 + (y % blackRows) * blackCols + x % blackCols];
+        }
+        if (seen[channel] && source->black[channel] != black) {
+            throw GpuLayoutUnsupported("Spatial RAW black calibration requires CPU preparation");
+        }
+        seen[channel] = true;
+        source->black[channel] = black;
+        if (black >= levels.maximum) {
+            throw std::runtime_error("Invalid RAW black and white calibration");
+        }
+        if (source->mosaic) {
+            counts[channel == 3 ? 1 : channel]++;
+        }
+    }
+    if (source->mosaic) {
+        if (!counts[0] || !counts[1] || !counts[2]) {
+            throw GpuLayoutUnsupported("The mosaic must contain red, green and blue samples");
+        }
+        // The 2x2 fast shader uses MHC's diagonal Bayer filters.
+        if (source->cfaSize == 2 && (counts[0] != 1 || counts[1] != 2 || counts[2] != 1 ||
+                                     ((source->cfa[0] == 1 || source->cfa[0] == 3) !=
+                                      (source->cfa[3] == 1 || source->cfa[3] == 3)))) {
+            throw GpuLayoutUnsupported("Non-Bayer 2x2 mosaic requires CPU preparation");
+        }
+        for (unsigned y = 0; y < 12; ++y) {
+            for (unsigned x = 0; x < source->cfaSize; ++x) {
+                if (raw.COLOR(y, x) != source->cfa[(y % source->cfaSize) * source->cfaSize + x]) {
+                    throw GpuLayoutUnsupported("Non-periodic mosaic requires CPU preparation");
+                }
+            }
+        }
+    }
+    source->white = levels.maximum;
+}
+
+static void prepare_camera_rgb(Raw *source) {
+    auto &raw = source->decoder;
+    if (source->originalOffset) {
+        check(raw.unpack());
+    }
+    auto &options = raw.imgdata.params;
+    options.no_auto_scale = 1;
+    options.no_auto_bright = 1;
+    options.adjust_maximum_thr = 0;
+    options.output_color = 0;
+    options.gamm[0] = options.gamm[1] = 1;
+    options.use_fuji_rotate = 1;
+    check(raw.dcraw_process());
+    source->cpuPrepared = true;
+    source->originalOffset = 0;
+}
+
+void prepare_pixels(Raw *source, void *bytes, unsigned length) {
+    auto &raw = source->decoder;
+    check(raw.open_buffer(bytes, length));
+    source->sensorMosaic = raw.imgdata.idata.filters != 0;
+    raw.imgdata.rawparams.options &= ~LIBRAW_RAWOPTIONS_CONVERTFLOAT_TO_INT;
+    if (raw.imgdata.idata.dng_version) {
+        parse_dng(source, bytes, length);
+    }
+
+    // A mosaic usable straight from the file skips LibRaw's unpacking.
+    source->originalOffset = direct_bayer(source, bytes, length);
+    if (!source->originalOffset) {
+        check(raw.unpack());
+    }
+    if (raw.imgdata.idata.colors != 3 || raw.imgdata.color.as_shot_wb_applied ||
+        raw.is_floating_point()) {
+        throw std::runtime_error("This RAW sensor layout is not supported by the GPU pipeline");
+    }
+
+    // Choose how the samples reach the GPU. LibRaw's filters value is 9 for X-Trans, above 1000
+    // for a 2x2 Bayer pattern and zero for full-color images.
+    source->cpuPrepared = raw.is_fuji_rotated() || raw.imgdata.idata.is_foveon || raw.is_sraw() ||
+                          raw.is_nikon_sraw();
+    if (source->originalOffset) {
+        raw.imgdata.sizes.iwidth = raw.imgdata.sizes.width;
+        raw.imgdata.sizes.iheight = raw.imgdata.sizes.height;
+    } else if (source->cpuPrepared) {
+        prepare_camera_rgb(source);
+    } else if (raw.imgdata.idata.dng_version && raw.imgdata.idata.filters > 1000 &&
+               raw.imgdata.rawdata.raw_image && raw.imgdata.sizes.top_margin == 0 &&
+               raw.imgdata.sizes.left_margin == 0 &&
+               raw.imgdata.sizes.raw_pitch == raw.imgdata.sizes.width * 2 &&
+               raw.imgdata.sizes.raw_height == raw.imgdata.sizes.height) {
+        // Standard uncropped DNG can keep LibRaw's single-channel allocation.
+        raw.imgdata.sizes.iwidth = raw.imgdata.sizes.width;
+        raw.imgdata.sizes.iheight = raw.imgdata.sizes.height;
+    } else {
+        check(raw.raw2image_ex(0));
+    }
+
+    try {
+        describe_pixels(source);
+    } catch (const GpuLayoutUnsupported &) {
+        if (source->cpuPrepared) {
+            throw;
+        }
+        prepare_camera_rgb(source);
+        describe_pixels(source);
+    }
+}
+
+void pack_pixels(Raw *source) {
+    auto &raw = source->decoder;
+    if (source->prepared.empty() && source->mosaic && raw.imgdata.image) {
+        // Preserve LibRaw's camera-specific preparation, then pack its sparse image in place.
+        // Every write lands at or before the sample it read, so a forward walk is safe.
+        auto *packed = reinterpret_cast<unsigned short *>(raw.imgdata.image);
+        for (unsigned y = 0; y < source->height; ++y) {
+            for (unsigned x = 0; x < source->width; ++x) {
+                unsigned i = y * source->width + x;
+                packed[i] =
+                    raw.imgdata.image[i][source->cfa[(y % source->cfaSize) * source->cfaSize +
+                                                     x % source->cfaSize]];
+            }
+        }
+    }
+}