@reekon-tools/react-native-pdf-canvas 0.1.1 → 0.2.0

package/android/src/main/java/tools/reekon/pdfcanvas/PageGeometry.java

@@ -1,45 +0,0 @@
-package tools.reekon.pdfcanvas;
-
-/**
- * A page's intrinsic size in PDF points, mirroring {@code PageGeometry} in
- * {@code src/types.ts}.
- *
- * POST-ROTATION, per that contract. {@code PdfRenderer.Page.getWidth()} already
- * is: it forwards to PDFium's {@code FPDF_GetPageWidth}, and
- * {@code CPDF_Page::UpdateDimensions} swaps the media box's width and height
- * when {@code /Rotate} is 90 or 270. So a 612x792 page carrying {@code /Rotate 90}
- * reports 792x612, and the render matrix operates in that same upright space —
- * which is why the tiling arithmetic never has to know about rotation at all.
- * {@code pageGeometryIsPostRotation} measures this rather than trusting it.
- *
- * {@link #rotationDegrees} is therefore reported as 0, NOT as the page's
- * {@code /Rotate} value: the platform pre-applies the rotation to both the
- * dimensions and the transform, so from this backend's vantage point there is no
- * residual rotation left to apply. There is also no way to read {@code /Rotate}
- * through {@code PdfRenderer} below API 35, so a non-zero value here could only
- * be invented. Reporting the truth of what the caller must do — nothing — beats
- * reporting a number the caller would then wrongly compensate for.
- */
-public final class PageGeometry {
-
-  public final int index;
-  /** Width in PDF points, after /Rotate. */
-  public final int widthPoints;
-  /** Height in PDF points, after /Rotate. */
-  public final int heightPoints;
-  /** Residual rotation the caller must still apply. Always 0 here; see above. */
-  public final int rotationDegrees;
-
-  PageGeometry(int index, int widthPoints, int heightPoints, int rotationDegrees) {
-    this.index = index;
-    this.widthPoints = widthPoints;
-    this.heightPoints = heightPoints;
-    this.rotationDegrees = rotationDegrees;
-  }
-
-  @Override
-  public String toString() {
-    return "PageGeometry{" + index + " " + widthPoints + "x" + heightPoints
-        + "pt rot=" + rotationDegrees + "}";
-  }
-}

package/android/src/main/java/tools/reekon/pdfcanvas/PdfCanvasRasterizer.java

@@ -1,564 +0,0 @@
-package tools.reekon.pdfcanvas;
-
-import android.graphics.Bitmap;
-import android.graphics.Color;
-import android.graphics.Matrix;
-import android.graphics.pdf.PdfRenderer;
-
-import java.io.Closeable;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-
-import tools.reekon.pdfcanvas.jsi.PdfCanvasPixelBridge;
-
-/**
- * The Android page rasterizer. Plain Android — {@code PdfRenderer},
- * {@code Bitmap}, {@code ParcelFileDescriptor} — and NOTHING from React Native
- * or Nitro, so it can be proven on a bare emulator with
- * {@code ./gradlew connectedDebugAndroidTest} and no app around it.
- *
- * Shaped to serve {@code RasterizerHandle} in {@code src/types.ts}:
- * {@code pageCount}, {@code pageGeometry(index)}, {@code render(request, signal)},
- * {@code close()}. The binding in {@code src/reactnative} is a marshalling layer
- * over this and adds no behaviour.
- *
- * <h3>How a tile is drawn</h3>
- *
- * {@code setScale(s, s); postTranslate(-x*s, -y*s)} — spike S1, finding 1,
- * MEASURED on API 24, 31 and 33: a tile rendered with that matrix is
- * pixel-identical to the same region cropped out of a full-page render
- * (0/262144 mismatching pixels, max channel delta 1) on all three. A translate
- * that puts the page origin OUTSIDE the destination bitmap is honoured exactly,
- * which is the only reason tiling on the platform renderer is possible at all;
- * had it failed, Android would have gone straight to vendored PDFium.
- *
- * S1 finding 2, also measured: cost tracks DESTINATION BITMAP AREA, not page
- * area or scale. An ARCH-D tile at 8x costs the same as at 1x, so the engine
- * clips rather than rasterizing the page and discarding most of it. That is what
- * makes a viewport-sized detail raster constant in zoom.
- */
-public final class PdfCanvasRasterizer implements Closeable {
-
-  /** Surfaced as {@code PageRasterizer.id}, so a bug report names the backend. */
-  public static final String ID = "android-pdfrenderer";
-
-  /**
-   * Refuse absurd rasters instead of dying on {@code OutOfMemoryError}.
-   *
-   * 64 Mpx is 256 MB at 4 bytes per pixel — already past what a mid-tier device
-   * will hand out in one allocation, so anything above it is a planner bug, and
-   * a named error against a raster key is a far better diagnostic than a process
-   * death with no key attached. The TS policy has its own, much lower, ceilings
-   * ({@code maxRasterPixels}); this is the backstop for a request that reaches
-   * here anyway.
-   */
-  public static final int MAX_RASTER_PIXELS = 64_000_000;
-
-  private final PdfRendererPool pool;
-  private final PageGeometry[] pages;
-  private final File spooled;
-  private volatile boolean closed;
-
-  private PdfCanvasRasterizer(PdfRendererPool pool, PageGeometry[] pages, File spooled) {
-    this.pool = pool;
-    this.pages = pages;
-    this.spooled = spooled;
-  }
-
-  /* ---------------------------------------------------------------- *
-   * Opening
-   * ---------------------------------------------------------------- */
-
-  /**
-   * @param password must be null. Kept in the signature because the TS
-   *     {@code PdfSource} carries one and dropping it here would make the
-   *     backend silently ignore it; {@link PdfRendererPool#open} rejects a
-   *     non-null value with {@code unsupported} and says why.
-   * @param poolSize number of concurrent renders to allow, clamped to
-   *     [1, {@link PdfRendererPool#MAX_POOL_SIZE}].
-   */
-  public static PdfCanvasRasterizer openFile(File file, String password, int poolSize)
-      throws PdfRasterException {
-    return open(file, password, poolSize, null);
-  }
-
-  /**
-   * Spools bytes to a file first, because {@code PdfRenderer} requires a
-   * SEEKABLE descriptor — it reads through a seek-and-read callback, so a pipe
-   * or a socket is not an option and neither is anything streamed. The spooled
-   * file is deleted by {@link #close()}.
-   */
-  public static PdfCanvasRasterizer openBytes(
-      File spoolDir, byte[] data, String password, int poolSize) throws PdfRasterException {
-    if (data == null || data.length == 0) {
-      throw new PdfRasterException(PdfErrorCode.CORRUPT, "Document data is empty.");
-    }
-    File spool;
-    try {
-      if (!spoolDir.exists() && !spoolDir.mkdirs()) {
-        throw new IOException("Could not create " + spoolDir.getAbsolutePath());
-      }
-      spool = File.createTempFile("pdfcanvas-", ".pdf", spoolDir);
-      try (FileOutputStream out = new FileOutputStream(spool)) {
-        out.write(data);
-      }
-    } catch (IOException e) {
-      throw new PdfRasterException(
-          PdfErrorCode.BACKEND_FAILURE, "Could not spool document data to disk.", e);
-    }
-    try {
-      return open(spool, password, poolSize, spool);
-    } catch (PdfRasterException e) {
-      // The spool is ours; nothing else will ever delete it if open() fails.
-      //noinspection ResultOfMethodCallIgnored
-      spool.delete();
-      throw e;
-    }
-  }
-
-  private static PdfCanvasRasterizer open(
-      File file, String password, int poolSize, File spooled) throws PdfRasterException {
-    PdfRendererPool pool = PdfRendererPool.open(file, password, poolSize);
-    try {
-      // Every page's geometry is probed ONCE, here. The contract says
-      // pageGeometry() is cheap and "must not load a page", and the only way to
-      // learn a page's size through PdfRenderer is to open it — so the loading
-      // happens at open() and pageGeometry() becomes an array read.
-      // pageGeometryIsPrecomputedAtOpenNotLoadedOnDemand pins that by asking for
-      // geometry AFTER close(), when every PdfRenderer is shut: a lazy
-      // implementation would throw or crash there, and it reads a page it never
-      // asked about before the close so a lazily-cached page 0 cannot pass by
-      // accident. (This comment previously named a pageGeometryDoesNotOpenAPage
-      // test, which does not exist, and described a leased-out-pool setup that
-      // is not what the real test does.)
-      PageGeometry[] pages = probeGeometry(pool);
-      return new PdfCanvasRasterizer(pool, pages, spooled);
-    } catch (PdfRasterException | RuntimeException e) {
-      pool.close();
-      throw e;
-    }
-  }
-
-  private static PageGeometry[] probeGeometry(PdfRendererPool pool)
-      throws PdfRasterException {
-    int count = pool.pageCount();
-    PageGeometry[] pages = new PageGeometry[count];
-    PdfRenderer renderer = pool.lease();
-    try {
-      for (int i = 0; i < count; i++) {
-        PdfRenderer.Page page = null;
-        try {
-          page = renderer.openPage(i);
-          // getWidth()/getHeight() are already post-/Rotate; see PageGeometry.
-          pages[i] = new PageGeometry(i, page.getWidth(), page.getHeight(), 0);
-        } catch (RuntimeException e) {
-          throw new PdfRasterException(
-              PdfErrorCode.CORRUPT, "Could not read page " + i + ".", e);
-        } finally {
-          if (page != null) {
-            page.close();
-          }
-        }
-      }
-    } finally {
-      pool.release(renderer);
-    }
-    return pages;
-  }
-
-  /* ---------------------------------------------------------------- *
-   * Cheap accessors
-   * ---------------------------------------------------------------- */
-
-  public int pageCount() {
-    return pages.length;
-  }
-
-  /** An array read. See the note in {@link #open}. */
-  public PageGeometry pageGeometry(int index) throws PdfRasterException {
-    if (index < 0 || index >= pages.length) {
-      throw new PdfRasterException(
-          PdfErrorCode.NOT_FOUND,
-          "Document has " + pages.length + " pages; asked for " + index + ".");
-    }
-    return pages[index];
-  }
-
-  /** How many renders can genuinely be in flight at once. */
-  public int poolSize() {
-    return pool.size();
-  }
-
-  /**
-   * Whether this device draws a page carrying {@code /Rotate} upright.
-   *
-   * NOT a formality: on API 24 it does not — the dimensions swap but the content
-   * is drawn unrotated and clipped, so a rotated page comes back wrong with no
-   * error anywhere. There is nothing this backend can do about it, because
-   * {@code PdfRenderer} exposes no way to read a page's {@code /Rotate} value
-   * below API 35 and so no way to compensate. What it CAN do is say so, which is
-   * what this is for: a host can fall back to another backend, or warn, instead
-   * of silently showing a sheared drawing. See {@link PdfPlatformQuirks}.
-   */
-  public static PdfPlatformQuirks.RotationSupport rotationSupport(File scratchDir) {
-    return PdfPlatformQuirks.rotationSupport(scratchDir);
-  }
-
-  /* ---------------------------------------------------------------- *
-   * Rendering
-   * ---------------------------------------------------------------- */
-
-  /**
-   * The heap form: the pixels come back in {@code RasterPixels.bytes}.
-   *
-   * This is what every caller that wants to READ pixels uses, and it is the only
-   * form the instrumented suite exercises for correctness.
-   */
-  public RasterPixels render(RasterRequest request, RasterCancellation signal)
-      throws PdfRasterException {
-    return render(request, signal, RasterPixels.NO_SLOT);
-  }
-
-  /**
-   * The one-copy form: the finished raster is written straight into native
-   * memory under {@code slot} and never touches the Java heap.
-   *
-   * DELETES, per tile, one {@code new byte[byteCount]} on ART's large-object
-   * space and one full-raster memcpy out of it. What is left is the single copy
-   * out of the {@code Bitmap}'s own pixels, which the heap form pays as well.
-   *
-   * <h3>The result may be heap-backed anyway, and callers must handle that</h3>
-   *
-   * {@code PdfCanvasPixelBridge.nativeStoreFromBitmap} is allowed to REFUSE — no
-   * native memory to be had, a stride the NDK reports differently from the
-   * Bitmap, a slot id already occupied — and every refusal falls through to the
-   * heap path, because a slower correct tile beats a lost one. So check
-   * {@link RasterPixels#isInNativeSlot()} on the way out rather than assuming.
-   * When it is false, {@code slot} holds nothing and there is nothing to release.
-   *
-   * <h3>What is released, and where</h3>
-   *
-   * Nothing, on the happy path: the slot is taken exactly once by JS. This
-   * method DOES release it on the one abandon path it owns — a cancellation
-   * observed after the draw finished, which is the post-render check in
-   * {@link #renderLeased}. Every abandon path AFTER this method returns belongs
-   * to the caller, and {@code PdfCanvasModule.render} closes them with a
-   * {@code finally} that releases unless the slot was handed to the promise.
-   *
-   * @param slot a slot id from a per-process monotonic counter. Must not be
-   *     {@link RasterPixels#NO_SLOT}, and must not be an id already in use — the
-   *     native side refuses a collision rather than overwriting, since an
-   *     overwrite hands one raster's memory to another raster's take.
-   */
-  public RasterPixels renderToNativeSlot(
-      RasterRequest request, RasterCancellation signal, long slot)
-      throws PdfRasterException {
-    if (slot == RasterPixels.NO_SLOT) {
-      throw new PdfRasterException(
-          PdfErrorCode.BACKEND_FAILURE,
-          "renderToNativeSlot needs a real slot id; " + RasterPixels.NO_SLOT
-              + " is reserved for heap-backed rasters.");
-    }
-    return render(request, signal, slot);
-  }
-
-  private RasterPixels render(RasterRequest request, RasterCancellation signal, long slot)
-      throws PdfRasterException {
-    RasterCancellation.throwIfCancelled(signal, "before start");
-    requireOpen();
-
-    // Validates the page index before anything expensive is allocated or leased.
-    pageGeometry(request.page);
-
-    if (!(request.scale > 0f) || Float.isInfinite(request.scale)) {
-      throw new PdfRasterException(
-          PdfErrorCode.BACKEND_FAILURE, "Scale must be finite and positive: " + request.scale);
-    }
-    if (!(request.docWidth > 0f) || !(request.docHeight > 0f)) {
-      throw new PdfRasterException(
-          PdfErrorCode.BACKEND_FAILURE,
-          "Doc rect has no area: " + request.docWidth + "x" + request.docHeight);
-    }
-
-    int pxW = request.pixelWidth();
-    int pxH = request.pixelHeight();
-    long pixels = (long) pxW * (long) pxH;
-    if (pixels > MAX_RASTER_PIXELS) {
-      throw new PdfRasterException(
-          PdfErrorCode.OUT_OF_MEMORY,
-          "Refused a " + pxW + "x" + pxH + " raster (" + pixels + " pixels > "
-              + MAX_RASTER_PIXELS + ").");
-    }
-
-    PdfRenderer renderer = pool.lease();
-    // The lease can block for the length of another render, so this is the check
-    // that actually saves work when a raster is superseded mid-queue.
-    try {
-      RasterCancellation.throwIfCancelled(signal, "after pool wait");
-      requireOpen();
-      return renderLeased(renderer, request, pxW, pxH, signal, slot);
-    } finally {
-      pool.release(renderer);
-    }
-  }
-
-  private RasterPixels renderLeased(
-      PdfRenderer renderer,
-      RasterRequest request,
-      int pxW,
-      int pxH,
-      RasterCancellation signal,
-      long slot)
-      throws PdfRasterException {
-    PdfRenderer.Page page = null;
-    Bitmap bitmap = null;
-    try {
-      page = renderer.openPage(request.page);
-      bitmap = createBitmap(pxW, pxH);
-
-      // S1 finding 3, MEASURED: render() does NOT clear the destination. A
-      // bitmap arrives from createBitmap already zeroed, so 'transparent' would
-      // survive without this call — but writing it explicitly is what makes the
-      // two backgrounds one decision instead of one decision and one accident,
-      // and it is required for the reuse path the moment bitmaps get pooled.
-      bitmap.eraseColor(
-          request.background == RasterRequest.BACKGROUND_TRANSPARENT
-              ? Color.TRANSPARENT
-              : Color.WHITE);
-
-      Matrix matrix = tileMatrix(request);
-
-      RasterCancellation.throwIfCancelled(signal, "before render");
-      // Uninterruptible from here to the next statement. See RasterCancellation.
-      page.render(bitmap, null, matrix, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY);
-
-      RasterPixels out = extract(bitmap, pxW, pxH, slot);
-
-      // Post-check. This saves no drawing — the pixels above are already
-      // finished — it only stops a superseded raster being handed back and
-      // ingested into Skia, which is the expensive half on the JS side.
-      //
-      // THE RELEASE IS NOT OPTIONAL. `out` is dropped on the floor when this
-      // throws, and a heap-backed raster is simply collected — but a
-      // slot-backed one has already been published to the native map, where
-      // nothing else will ever look for it. A superseded epoch produces a
-      // stream of these, so leaking here is megabytes per gesture, freed only
-      // by the next reload. The check stays AFTER extract rather than moving
-      // in front of it so that the cancel window it covers does not shrink.
-      try {
-        RasterCancellation.throwIfCancelled(signal, "after render");
-      } catch (PdfRasterException e) {
-        out.release();
-        throw e;
-      }
-      return out;
-    } catch (IllegalStateException e) {
-      // openPage's documented failure when a page is already open on this
-      // renderer. Reaching it means the lease discipline broke, so say that
-      // rather than reporting a generic backend failure.
-      throw new PdfRasterException(
-          PdfErrorCode.BACKEND_FAILURE,
-          "PdfRenderer refused page " + request.page
-              + " — a page was already open on this renderer, which means the "
-              + "pool leased it twice.",
-          e);
-    } catch (IllegalArgumentException e) {
-      throw new PdfRasterException(
-          PdfErrorCode.NOT_FOUND, "No page " + request.page + " in this document.", e);
-    } finally {
-      if (bitmap != null) {
-        // The pixels have been copied out; holding the Bitmap alive until the GC
-        // notices costs pxW*pxH*4 of native heap per raster in flight.
-        bitmap.recycle();
-      }
-      if (page != null) {
-        page.close();
-      }
-    }
-  }
-
-  /**
-   * The S1 matrix. {@code scale} is used EXACTLY as requested rather than being
-   * re-derived from the rounded pixel size ({@code pxW / docWidth}).
-   *
-   * That choice matters: it is what makes two rasters requested at the same
-   * scale agree pixel-for-pixel wherever they overlap, which is the property the
-   * cache and the overlapping detail pieces depend on. Re-deriving would instead
-   * make each raster cover its doc rect to the last sub-pixel, at the cost of
-   * every pair of neighbours being drawn at imperceptibly different scales. At
-   * most half a pixel of the far edge goes undrawn, and it is left showing the
-   * background fill.
-   *
-   * PINNED BY {@code rastersAtTheSameScaleAgreeWhereTheyOverlap}, which asks for
-   * two rects at 4x whose pixel widths round in OPPOSITE directions (512.5 up to
-   * 513, 512.4 down to 512) and requires them to agree over the overlap. NOT by
-   * the S1 equivalence test, which this comment used to name: its rects are 400
-   * and 128 points at 4x, both landing on exact pixel counts, so a re-derived
-   * scale comes out to exactly 4 for both and that test cannot tell the two
-   * implementations apart.
-   */
-  private static Matrix tileMatrix(RasterRequest request) {
-    Matrix matrix = new Matrix();
-    matrix.setScale(request.scale, request.scale);
-    matrix.postTranslate(-request.docX * request.scale, -request.docY * request.scale);
-    return matrix;
-  }
-
-  private static Bitmap createBitmap(int pxW, int pxH) throws PdfRasterException {
-    try {
-      // MUTABLE ARGB_8888 is not a preference, it is the platform's rule:
-      // PdfRenderer.render throws IllegalArgumentException on an immutable
-      // bitmap and on any config other than ARGB_8888. createBitmap returns a
-      // mutable bitmap, so there is nothing further to assert here.
-      return Bitmap.createBitmap(pxW, pxH, Bitmap.Config.ARGB_8888);
-    } catch (OutOfMemoryError e) {
-      // Caught, not propagated. An OOM on one oversized raster is recoverable —
-      // the cache drops it and the planner asks for less — whereas letting the
-      // Error escape takes the whole JS thread's promise chain with it.
-      throw new PdfRasterException(
-          PdfErrorCode.OUT_OF_MEMORY,
-          "Could not allocate a " + pxW + "x" + pxH + " ARGB_8888 bitmap ("
-              + ((long) pxW * pxH * 4L) + " bytes).",
-          e);
-    }
-  }
-
-  /**
-   * Bitmap -> pixels, with the stride the platform actually used.
-   *
-   * TWO DESTINATIONS. With {@code slot == RasterPixels.NO_SLOT} this is the
-   * original: a {@code byte[]} on the Java heap, filled by
-   * {@code copyPixelsToBuffer}. With a real slot it tries native memory first
-   * and falls back to that same heap path on any refusal, so the heap path is
-   * never dead code and never diverges — it is what the base64 transport, every
-   * pixel-reading caller and the whole instrumented suite still use.
-   *
-   * Everything below about stride, premultiplication and byte order is true of
-   * BOTH, because both copy the identical bytes out of the identical bitmap: the
-   * native path's memcpy from {@code AndroidBitmap_lockPixels} and Skia's memcpy
-   * inside {@code nativeCopyPixelsToBuffer} read the same
-   * {@code bitmap.getPixels()} address for the same {@code getByteCount()}
-   * length. (Byte ORDER never enters it — {@code copyPixelsToBuffer} into a
-   * {@code ByteBuffer} is a raw memcpy and ignores the buffer's
-   * {@code order()}. That would NOT be true of an {@code IntBuffer}.)
-   *
-   * {@code copyPixelsToBuffer} is a raw copy of the bitmap's pixel memory:
-   * {@code getByteCount()} is {@code getRowBytes() * getHeight()}, so any row
-   * padding is copied through and {@code getRowBytes()} is the honest
-   * {@code rowBytes}. Assuming {@code width * 4} here would not fail — it would
-   * SHEAR the image by one pixel per row on any padded allocation, which reads
-   * as a plausible skew rather than an error.
-   *
-   * On the three levels measured that shear is unreachable, and the comment used
-   * to imply otherwise: {@code Bitmap.createBitmap} allocates at
-   * {@code SkImageInfo::minRowBytes()}, i.e. exactly {@code width * 4}, so the
-   * assumption and the reading agree at every width tested.
-   * {@code rowBytesIsReportedNotAssumed} pins the reported value against the
-   * platform's own stride and says so in its own comment; the padded path is
-   * exercised in vitest against the fake backend. Reading the value is still the
-   * right call — it costs nothing and it is correct on a device that pads.
-   *
-   * The bytes are PREMULTIPLIED. Bitmaps are premultiplied by default and this
-   * code never calls {@code setPremultiplied(false)} — doing so would make a
-   * {@code background: 'transparent'} raster composite wrongly rather than
-   * visibly fail.
-   *
-   * The TS side DECLARES that rather than assuming it: {@code ANDROID_ALPHA} in
-   * {@code src/rasterizer/android.ts} sets {@code RasterPixels.alpha} to
-   * {@code 'premultiplied'} and {@code ingest.ts} maps it to
-   * {@code AlphaType.Premul}. It is a constant there, not a field of the wire
-   * result, because it is a property of {@code Bitmap} and cannot vary per
-   * render. It is NOT a global default — PDFium and pdf.js both emit STRAIGHT
-   * alpha, so the other backends declare the opposite.
-   */
-  private static RasterPixels extract(Bitmap bitmap, int pxW, int pxH, long slot)
-      throws PdfRasterException {
-    int rowBytes = bitmap.getRowBytes();
-    int byteCount = bitmap.getByteCount();
-    // FIRST, and before either destination is allocated. Both paths copy exactly
-    // byteCount bytes and both would shear on a bad stride, so this cannot move
-    // inside one of the branches.
-    if (rowBytes < pxW * 4 || byteCount < rowBytes * pxH) {
-      throw new PdfRasterException(
-          PdfErrorCode.BACKEND_FAILURE,
-          "Bitmap reported an impossible layout: " + pxW + "x" + pxH
-              + " rowBytes=" + rowBytes + " byteCount=" + byteCount + ".");
-    }
-
-    // THE ONE-COPY PATH. Tried first when a slot was asked for, and every
-    // failure mode of it is a `false` that falls through to the heap path below
-    // — including running out of native memory, which is why the OUT_OF_MEMORY
-    // mapping still comes from the Java allocation and not from here.
-    //
-    // `isLoaded()` is checked rather than assumed: every method on the bridge is
-    // `native`, so on a build with no libpdfcanvasjsi.so this call is an
-    // UnsatisfiedLinkError, not a false.
-    if (slot != RasterPixels.NO_SLOT && PdfCanvasPixelBridge.isLoaded()) {
-      boolean stored;
-      try {
-        stored =
-            PdfCanvasPixelBridge.nativeStoreFromBitmap(slot, bitmap, pxW, pxH, byteCount);
-      } catch (Throwable t) {
-        // The JNI method reports every failure of its OWN as a false. What can
-        // still arrive as a throwable is a Java exception raised by the platform
-        // calls it makes on the way — {@code AndroidBitmap_getInfo} and
-        // {@code AndroidBitmap_lockPixels} may leave one pending, and a JNI
-        // method that returns while an exception is pending throws it at the
-        // caller regardless of the value it returned. Either way the answer is
-        // the same and it is the point of this catch: fall through to the heap.
-        // Letting it escape would abandon a raster that IS already drawn in
-        // exchange for nothing.
-        stored = false;
-      }
-      if (stored) {
-        return RasterPixels.inNativeSlot(
-            slot, pxW, pxH, rowBytes, RasterPixels.FORMAT_RGBA_8888);
-      }
-    }
-
-    byte[] out;
-    try {
-      out = new byte[byteCount];
-    } catch (OutOfMemoryError e) {
-      throw new PdfRasterException(
-          PdfErrorCode.OUT_OF_MEMORY,
-          "Could not allocate " + byteCount + " bytes for raster pixels.", e);
-    }
-    // ByteBuffer.wrap starts at position 0, and copyPixelsToBuffer ADVANCES the
-    // position by byteCount as it copies. Nothing downstream reads the buffer —
-    // `out` is indexed from 0 — and a fresh wrapper is made every call, so no
-    // rewind is needed and none is implied. A REUSED buffer would need one.
-    bitmap.copyPixelsToBuffer(ByteBuffer.wrap(out));
-    return new RasterPixels(out, pxW, pxH, rowBytes, RasterPixels.FORMAT_RGBA_8888);
-  }
-
-  /* ---------------------------------------------------------------- *
-   * Teardown
-   * ---------------------------------------------------------------- */
-
-  private void requireOpen() throws PdfRasterException {
-    if (closed || pool.isClosed()) {
-      throw new PdfRasterException(
-          PdfErrorCode.BACKEND_FAILURE, "Document handle is closed.");
-    }
-  }
-
-  @Override
-  public void close() {
-    if (closed) {
-      return;
-    }
-    closed = true;
-    pool.close();
-    if (spooled != null) {
-      //noinspection ResultOfMethodCallIgnored
-      spooled.delete();
-    }
-  }
-
-  public boolean isClosed() {
-    return closed;
-  }
-}