@pictor-sdk/video-android 0.1.0

package/android/src/main/java/dev/pictor/video/MediaStoreSave.kt

@@ -0,0 +1,419 @@
+package dev.pictor.video
+
+import android.content.ContentValues
+import android.content.Context
+import android.media.MediaExtractor
+import android.media.MediaFormat
+import android.net.Uri
+import android.provider.MediaStore
+import org.json.JSONObject
+import java.io.File
+import java.io.FileInputStream
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * Publishing a finished export to the device's media collection.
+ *
+ * ## Pending, then published — never in between
+ *
+ * A row inserted with `IS_PENDING = 1` is visible to this app and to nothing
+ * else: not the gallery, not the media scanner, not another app's picker. The
+ * bytes stream into it, the result is opened and checked, and only then does
+ * `IS_PENDING = 0` make it real. Writing a visible row and filling it
+ * afterwards would put a truncated video in the user's gallery for as long as
+ * the copy takes, and leave one there permanently if the copy failed.
+ *
+ * Every unsuccessful path deletes the row. A pending row nobody deletes is
+ * invisible and still occupies storage, which is the worst of both.
+ *
+ * ## There is no legacy branch, and that is a decision
+ *
+ * `IS_PENDING` and `RELATIVE_PATH` arrived in API 29, and this module's
+ * `minSdk` is 29 — checked, not assumed. So the pre-scoped-storage path
+ * (`WRITE_EXTERNAL_STORAGE`, a real path under `Environment`, a scanner poke)
+ * is not a branch this can reach on any supported device. It is **rejected
+ * rather than written**: an untestable branch guarding a version nobody runs is
+ * a liability, and lowering `minSdk` to make it reachable would be changing the
+ * module's support claim to justify code.
+ *
+ * ## What it will not do
+ *
+ * Delete a published item. Release is the *temporary's* business; once a row is
+ * published it belongs to the user and to the media store, and this never
+ * removes one — including on the paths that clean up after themselves.
+ */
+internal object MediaStoreSave {
+
+    /** Where a saved export lands. One folder, so a sweep can be specific. */
+    private const val RELATIVE_PATH = "Movies/Pictor"
+
+    /**
+     * The stored form of {@link RELATIVE_PATH}.
+     *
+     * MediaStore normalises a relative path to a trailing slash, so a sweep that
+     * compares against the unslashed constant matches nothing. Compared exactly
+     * rather than by prefix: `Movies/PictorOther/` starts with `Movies/Pictor`.
+     */
+    private const val RELATIVE_PATH_STORED = "Movies/Pictor/"
+
+    /**
+     * The names this writes, and only those.
+     *
+     * A file a user renamed, or one another tool put in the same folder, is not
+     * this app's to delete even while it is pending.
+     */
+    private val OWN_NAME = Regex("""^Pictor-\d{8}-\d{6}(?: \(\d+\))?\.mp4$""")
+    private const val MIME = "video/mp4"
+
+    /**
+     * Gate-only: hold inside the copy, so a kill can land there.
+     *
+     * A 3.5 MB copy is a few hundred milliseconds and `am force-stop` takes
+     * longer than that to take effect, so the stale-pending-row case — the one
+     * the startup sweep exists for — cannot be produced by timing. Inert unless
+     * the build has diagnostics: see [Diagnostics].
+     */
+    @Volatile var holdInCopy: Boolean = false
+
+    /** Cancellation, per job id, so a cancel cannot stop a different save. */
+    private val cancellations = HashMap<String, AtomicBoolean>()
+
+    private fun flagFor(jobId: String): AtomicBoolean =
+        synchronized(cancellations) { cancellations.getOrPut(jobId) { AtomicBoolean(false) } }
+
+    fun cancel(jobId: String): Boolean =
+        synchronized(cancellations) { cancellations[jobId]?.getAndSet(true) != null }
+
+    private fun forget(jobId: String) {
+        synchronized(cancellations) { cancellations.remove(jobId) }
+    }
+
+    /**
+     * A name that is the user's, and unique enough not to collide.
+     *
+     * MediaStore will disambiguate a duplicate by appending `(1)`, but relying
+     * on that makes two exports a second apart indistinguishable in a gallery.
+     * The timestamp is local because the name is read by a person.
+     */
+    private fun displayName(): String {
+        val stamp = SimpleDateFormat("yyyyMMdd-HHmmss", Locale.US).format(Date())
+        return "Pictor-$stamp.mp4"
+    }
+
+    /**
+     * Insert pending, stream, verify, publish. One call, settles once.
+     *
+     * Returns the published `content:` uri, or an error. On every unsuccessful
+     * path — including cancellation — the pending row is deleted before
+     * returning, so nothing partial survives.
+     */
+    fun save(context: Context, jobId: String, sourcePath: String): String {
+        val out = JSONObject()
+        val cancelled = flagFor(jobId)
+        val resolver = context.contentResolver
+        val source = File(sourcePath)
+        if (!source.exists() || source.length() == 0L) {
+            forget(jobId)
+            // Named, not pathed: the caller knows what it asked to save.
+            return out.put("ok", false).put("error", "the export file is no longer available").toString()
+        }
+
+        val name = displayName()
+        val values = ContentValues().apply {
+            put(MediaStore.Video.Media.DISPLAY_NAME, name)
+            put(MediaStore.Video.Media.MIME_TYPE, MIME)
+            put(MediaStore.Video.Media.RELATIVE_PATH, RELATIVE_PATH)
+            // Invisible until the bytes are there and checked.
+            put(MediaStore.Video.Media.IS_PENDING, 1)
+        }
+
+        var uri: Uri? = null
+        try {
+            if (cancelled.get()) return cleanup(resolver, null, jobId, out, "cancelled")
+            uri = resolver.insert(MediaStore.Video.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY), values)
+                ?: return cleanup(resolver, null, jobId, out, "the media collection refused a new item")
+
+            /*
+              Streamed, and checked between blocks.
+
+              A cancel that can only be observed once the copy finishes is not a
+              cancel, and a large export is seconds of copying.
+            */
+            var copied = 0L
+            resolver.openOutputStream(uri, "w")?.use { output ->
+                FileInputStream(source).use { input ->
+                    val buffer = ByteArray(256 * 1024)
+                    while (true) {
+                        if (cancelled.get()) return cleanup(resolver, uri, jobId, out, "cancelled")
+                        val read = input.read(buffer)
+                        if (read <= 0) break
+                        output.write(buffer, 0, read)
+                        copied += read
+                        if (Diagnostics.ENABLED && holdInCopy) {
+                            // Pending row inserted, bytes partly written, and
+                            // now waiting to be killed. Exactly the state a
+                            // process death leaves behind.
+                            output.flush()
+                            while (true) Thread.sleep(200)
+                        }
+                    }
+                    output.flush()
+                }
+            } ?: return cleanup(resolver, uri, jobId, out, "the media collection could not be written to")
+
+            if (copied != source.length()) {
+                // Short write with no exception: a full disk can end a stream
+                // quietly, and a row this size would play as a truncated video.
+                return cleanup(resolver, uri, jobId, out, "the file could not be written completely")
+            }
+            if (cancelled.get()) return cleanup(resolver, uri, jobId, out, "cancelled")
+
+            val probe = probe(context, uri)
+            if (!probe.optBoolean("readable", false)) {
+                return cleanup(
+                    resolver, uri, jobId, out,
+                    "the saved file could not be read back",
+                )
+            }
+
+            // Published. From here the item is the user's, and nothing in this
+            // object removes it.
+            val publish = ContentValues().apply { put(MediaStore.Video.Media.IS_PENDING, 0) }
+            resolver.update(uri, publish, null, null)
+            forget(jobId)
+            return out
+                .put("ok", true)
+                .put("uri", uri.toString())
+                .put("displayName", name)
+                .put("location", RELATIVE_PATH)
+                .put("bytes", copied)
+                .put("durationUs", probe.optLong("durationUs"))
+                .put("hasVideo", probe.optBoolean("hasVideo"))
+                .put("hasAudio", probe.optBoolean("hasAudio"))
+                .toString()
+        } catch (e: Exception) {
+            return cleanup(resolver, uri, jobId, out, describe(e))
+        }
+    }
+
+    /** Delete the pending row, then report. Never reached for a published one. */
+    private fun cleanup(
+        resolver: android.content.ContentResolver,
+        uri: Uri?,
+        jobId: String,
+        out: JSONObject,
+        reason: String,
+    ): String {
+        if (uri != null) runCatching { resolver.delete(uri, null, null) }
+        forget(jobId)
+        return out
+            .put("ok", false)
+            .put("cancelled", reason == "cancelled")
+            .put("error", reason)
+            .toString()
+    }
+
+    /**
+     * The exception's kind, never its message.
+     *
+     * A platform message routinely contains the path it failed on, and this
+     * text reaches a log and a host. `ENOSPC` arrives as an `IOException` whose
+     * message names the file.
+     */
+    private fun describe(e: Exception): String = when (e) {
+        is java.io.IOException -> "the file could not be written; the device may be out of space"
+        is SecurityException -> "permission to write to the media collection was refused"
+        else -> "saving failed (" + e.javaClass.simpleName + ")"
+    }
+
+    /** Opened through the resolver, because a `content:` uri is not a path. */
+    private fun probe(context: Context, uri: Uri): JSONObject {
+        val result = JSONObject()
+        var extractor: MediaExtractor? = null
+        try {
+            context.contentResolver.openFileDescriptor(uri, "r").use { descriptor ->
+                if (descriptor == null) return result.put("readable", false)
+                extractor = MediaExtractor()
+                extractor!!.setDataSource(descriptor.fileDescriptor)
+                var video = false
+                var audio = false
+                var durationUs = 0L
+                for (i in 0 until extractor!!.trackCount) {
+                    val format = extractor!!.getTrackFormat(i)
+                    val mime = format.getString(MediaFormat.KEY_MIME) ?: ""
+                    if (mime.startsWith("video/")) video = true
+                    if (mime.startsWith("audio/")) audio = true
+                    if (format.containsKey(MediaFormat.KEY_DURATION)) {
+                        durationUs = maxOf(durationUs, format.getLong(MediaFormat.KEY_DURATION))
+                    }
+                }
+                result.put("readable", video)
+                    .put("tracks", extractor!!.trackCount)
+                    .put("hasVideo", video)
+                    .put("hasAudio", audio)
+                    .put("durationUs", durationUs)
+            }
+        } catch (e: Exception) {
+            result.put("readable", false).put("error", e.javaClass.simpleName)
+        } finally {
+            runCatching { extractor?.release() }
+        }
+        return result
+    }
+
+    /**
+     * Remove pending rows a killed process left behind.
+     *
+     * Four conditions, all required, because this deletes things:
+     *
+     * - `IS_PENDING = 1` — a published item is never a candidate;
+     * - `OWNER_PACKAGE_NAME` is this package — not "probably ours because of
+     *   where it is";
+     * - the relative path is exactly `Movies/Pictor/` — not a prefix, since
+     *   `Movies/PictorOther/` starts with the same characters;
+     * - the display name matches the pattern this code writes.
+     *
+     * The media store's own visibility rules would hide most foreign pending
+     * rows anyway, but relying on that would make the predicate depend on a
+     * platform behaviour rather than state it. A row in this folder, with this
+     * name, that somebody else wrote is still not this app's to remove.
+     */
+    fun sweepPending(context: Context): String {
+        val resolver = context.contentResolver
+        val collection = MediaStore.Video.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY)
+        var swept = 0
+        var inspected = 0
+        var skipped = 0
+        try {
+            /*
+              Pending rows have to be asked for.
+
+              From API 30 a plain query excludes them, so the obvious
+              `IS_PENDING = 1` selection matches nothing — including the app's
+              own. Measured: a row left by a killed process was invisible to the
+              very sweep written to collect it, and the sweep reported success
+              with nothing found. `QUERY_ARG_MATCH_PENDING` is what makes them
+              visible, and only ever the caller's own.
+            */
+            val args = android.os.Bundle().apply {
+                putString(
+                    android.content.ContentResolver.QUERY_ARG_SQL_SELECTION,
+                    "${MediaStore.Video.Media.IS_PENDING} = 1",
+                )
+                putInt(MediaStore.QUERY_ARG_MATCH_PENDING, MediaStore.MATCH_INCLUDE)
+            }
+            resolver.query(
+                collection,
+                arrayOf(
+                    MediaStore.Video.Media._ID,
+                    MediaStore.Video.Media.IS_PENDING,
+                    MediaStore.Video.Media.RELATIVE_PATH,
+                    MediaStore.Video.Media.DISPLAY_NAME,
+                    MediaStore.Video.Media.OWNER_PACKAGE_NAME,
+                ),
+                args,
+                null,
+            )?.use { cursor ->
+                val idColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media._ID)
+                val pendingColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.IS_PENDING)
+                val pathColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.RELATIVE_PATH)
+                val nameColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DISPLAY_NAME)
+                val ownerColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.OWNER_PACKAGE_NAME)
+                val ours = context.packageName
+                while (cursor.moveToNext()) {
+                    inspected += 1
+                    // Each condition restated against the row, not inferred from
+                    // the selection: a query argument is easy to get wrong, and
+                    // the cost of being wrong here is deleting someone's file.
+                    if (cursor.getInt(pendingColumn) != 1) continue
+                    if (cursor.getString(ownerColumn) != ours) { skipped += 1; continue }
+                    if (cursor.getString(pathColumn) != RELATIVE_PATH_STORED) { skipped += 1; continue }
+                    if (!OWN_NAME.matches(cursor.getString(nameColumn) ?: "")) { skipped += 1; continue }
+                    val row = android.content.ContentUris.withAppendedId(collection, cursor.getLong(idColumn))
+                    if (runCatching { resolver.delete(row, null, null) }.getOrDefault(0) > 0) swept += 1
+                }
+            }
+        } catch (e: Exception) {
+            return JSONObject().put("ok", false).put("error", e.javaClass.simpleName).toString()
+        }
+        return JSONObject().put("ok", true)
+            .put("swept", swept)
+            .put("inspected", inspected)
+            // Rows seen and deliberately left: the number that proves the
+            // predicate is doing something rather than matching everything.
+            .put("skipped", skipped)
+            .toString()
+    }
+
+    /**
+     * Hand a saved video to whatever the user picks.
+     *
+     * `ACTION_SEND` with a chooser, and the **durable `content:` uri** — never
+     * the cache path the export produced. A `file:` uri would raise
+     * `FileUriExposedException` on any modern target, and even where it did not
+     * it would be a path into this app's private storage that the receiver
+     * cannot open.
+     *
+     * `FLAG_GRANT_READ_URI_PERMISSION` and nothing else. The receiver needs to
+     * read the video; it has no business writing to the user's gallery, and a
+     * write grant handed out for a share is a permission nobody asked for.
+     *
+     * The item is untouched. Sharing does not copy, rename, re-publish or
+     * release anything — the same row is offered every time.
+     */
+    fun share(context: Context, uri: String): String {
+        val target = Uri.parse(uri)
+        val send = android.content.Intent(android.content.Intent.ACTION_SEND).apply {
+            type = MIME
+            putExtra(android.content.Intent.EXTRA_STREAM, target)
+            /*
+              `ClipData` as well as the extra.
+
+              The grant travels with the clip data, and a chooser that rebuilds
+              the intent for the selected target can lose an extra-only uri —
+              which produces a receiver that is handed a uri it cannot open.
+            */
+            clipData = android.content.ClipData.newUri(context.contentResolver, "video", target)
+            addFlags(android.content.Intent.FLAG_GRANT_READ_URI_PERMISSION)
+        }
+        val chooser = android.content.Intent.createChooser(send, null).apply {
+            // The chooser is started from outside an Activity context.
+            addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK)
+            addFlags(android.content.Intent.FLAG_GRANT_READ_URI_PERMISSION)
+        }
+        val describe = JSONObject()
+            .put("action", send.action)
+            .put("type", send.type)
+            .put("uri", target.toString())
+            .put("hasClipData", send.clipData != null)
+            .put("clipUri", send.clipData?.getItemAt(0)?.uri?.toString())
+            .put("grantsRead", send.flags and android.content.Intent.FLAG_GRANT_READ_URI_PERMISSION != 0)
+            .put("grantsWrite", send.flags and android.content.Intent.FLAG_GRANT_WRITE_URI_PERMISSION != 0)
+        /*
+          No compatible app is not an error.
+
+          A device with nothing that accepts video/mp4 is unusual and possible,
+          and the saved video is untouched either way — so this reports the
+          absence and lets the UI say so.
+        */
+        val resolved = context.packageManager.queryIntentActivities(send, 0)
+        if (resolved.isEmpty()) {
+            return describe.put("ok", false).put("noTargets", true)
+                .put("error", "no app on this device can share a video").toString()
+        }
+        return try {
+            context.startActivity(chooser)
+            describe.put("ok", true).put("targets", resolved.size).toString()
+        } catch (e: Exception) {
+            describe.put("ok", false)
+                .put("error", "the share sheet could not be opened").toString()
+        }
+    }
+
+    /** Gate-only support: is this uri still readable? Used after a restart. */
+    fun readable(context: Context, uri: String): String =
+        probe(context, Uri.parse(uri)).toString()
+}

package/android/src/main/java/dev/pictor/video/OverlayResources.kt

@@ -0,0 +1,169 @@
+package dev.pictor.video
+
+import android.content.Context
+import java.io.File
+import java.util.zip.CRC32
+import org.json.JSONArray
+
+/**
+ * Overlay rasters, loaded and checked **before Transformer starts**.
+ *
+ * The backend has no Skia and no fonts. It receives tightly cropped RGBA
+ * bitmaps that a renderer already produced, and its whole contribution is to put
+ * them where the scene says. Nothing here lays anything out.
+ *
+ * ## Everything is verified up front
+ *
+ * A resource that is missing, truncated, altered, duplicated, oversized or the
+ * wrong shape fails the run before an encoder exists. Discovering it mid-export
+ * means a partial file and an encoder to unwind, and — worse — a frame that
+ * quietly lacks something the timeline said was on screen. Nothing downstream
+ * can tell that from a video that never had it.
+ */
+internal class OverlayResources private constructor(
+    val entries: Map<String, Entry>,
+) {
+    class Entry(
+        val resourceId: String,
+        val overlayId: String,
+        val projectWidth: Float,
+        val projectHeight: Float,
+        val rasterWidth: Int,
+        val rasterHeight: Int,
+        /** Visual bounds in overlay-local project units. x/y may be negative. */
+        val boundsX: Float,
+        val boundsY: Float,
+        val boundsWidth: Float,
+        val boundsHeight: Float,
+        val premultiplied: Boolean,
+        val pixels: ByteArray,
+    )
+
+    class Invalid(val reason: String)
+
+    companion object {
+        /**
+         * Refuse anything larger than this per raster.
+         *
+         * A texture bigger than any GL implementation guarantees, or a sidecar
+         * large enough to be an allocation problem on its own, is a refusal
+         * rather than an out-of-memory somewhere later with no context.
+         */
+        const val MAX_DIMENSION = 4096
+        const val MAX_BYTES = 4096L * 4096L * 4L
+
+        fun parse(context: Context, json: String): Pair<OverlayResources?, Invalid?> {
+            val array = try {
+                JSONArray(json)
+            } catch (e: Exception) {
+                return null to Invalid("malformed overlay manifest: ${e.message}")
+            }
+            val entries = LinkedHashMap<String, Entry>()
+            for (i in 0 until array.length()) {
+                val o = array.optJSONObject(i)
+                    ?: return null to Invalid("overlay resource $i is not an object")
+                val resourceId = o.optString("resourceId", "")
+                if (resourceId.isEmpty()) return null to Invalid("overlay resource $i has no resourceId")
+                if (entries.containsKey(resourceId)) {
+                    return null to Invalid("duplicate overlay resourceId '$resourceId'")
+                }
+                val overlayId = o.optString("overlayId", "")
+                if (overlayId.isEmpty()) return null to Invalid("resource '$resourceId' has no overlayId")
+
+                if (o.optString("format", "") != "rgba8888") {
+                    return null to Invalid("resource '$resourceId' is not rgba8888")
+                }
+                if (o.optString("colorSpace", "") != "srgb") {
+                    return null to Invalid("resource '$resourceId' is not srgb")
+                }
+                val rw = o.optInt("rasterWidth", 0)
+                val rh = o.optInt("rasterHeight", 0)
+                if (rw <= 0 || rh <= 0) return null to Invalid("resource '$resourceId' has no raster size")
+                if (rw > MAX_DIMENSION || rh > MAX_DIMENSION) {
+                    return null to Invalid("resource '$resourceId' is ${rw}x$rh, over the $MAX_DIMENSION limit")
+                }
+                /*
+                  Bounds, not just a size.
+
+                  A stroke, a blur or a shadow draws outside the measured box, so
+                  the raster is wider than `size` and starts at a negative
+                  offset. Placing it on `size` would shift it by exactly the
+                  bleed; placing it on bounds and anchoring on `size` is the only
+                  arrangement where neither is wrong.
+                */
+                val bounds = o.optJSONObject("rasterBounds")
+                    ?: return null to Invalid("resource '$resourceId' has no rasterBounds")
+                val bx = bounds.optDouble("x", Double.NaN)
+                val by = bounds.optDouble("y", Double.NaN)
+                val bw = bounds.optDouble("width", Double.NaN)
+                val bh = bounds.optDouble("height", Double.NaN)
+                if (bx.isNaN() || by.isNaN()) {
+                    return null to Invalid("resource '$resourceId' rasterBounds origin is not finite")
+                }
+                if (bw.isNaN() || bh.isNaN() || bw <= 0 || bh <= 0) {
+                    return null to Invalid("resource '$resourceId' rasterBounds is empty")
+                }
+                val scale = o.optDouble("rasterScale", Double.NaN)
+                if (scale.isNaN() || scale <= 0) {
+                    return null to Invalid("resource '$resourceId' rasterScale is not positive")
+                }
+                // The raster must be the size its bounds and scale imply, or a
+                // fraction-of-a-pixel shift is baked into every frame.
+                val impliedW = Math.round(bw * scale).toInt()
+                val impliedH = Math.round(bh * scale).toInt()
+                if (rw != impliedW || rh != impliedH) {
+                    return null to Invalid(
+                        "resource '$resourceId' raster is ${rw}x$rh, but bounds imply ${impliedW}x$impliedH",
+                    )
+                }
+
+                val size = o.optJSONObject("size")
+                    ?: return null to Invalid("resource '$resourceId' has no project size")
+                val pw = size.optDouble("width", Double.NaN)
+                val ph = size.optDouble("height", Double.NaN)
+                if (pw.isNaN() || ph.isNaN() || pw <= 0 || ph <= 0) {
+                    return null to Invalid("resource '$resourceId' project size is not positive")
+                }
+
+                val path = o.optString("file", "")
+                if (path.isEmpty()) return null to Invalid("resource '$resourceId' has no file")
+                val file = File(path)
+                if (!file.exists()) return null to Invalid("resource '$resourceId' file is missing")
+                val declared = o.optLong("byteLength", -1)
+                val expected = rw.toLong() * rh.toLong() * 4L
+                if (declared != expected) {
+                    return null to Invalid(
+                        "resource '$resourceId' declares $declared bytes, not ${rw}x${rh}x4 = $expected",
+                    )
+                }
+                if (expected > MAX_BYTES) return null to Invalid("resource '$resourceId' exceeds the byte limit")
+                if (file.length() != expected) {
+                    // Truncated or padded: the file and the descriptor disagree
+                    // about what was produced, and neither can be trusted.
+                    return null to Invalid(
+                        "resource '$resourceId' file is ${file.length()} bytes, not $expected",
+                    )
+                }
+                val bytes = try {
+                    file.readBytes()
+                } catch (e: Exception) {
+                    return null to Invalid("resource '$resourceId' file unreadable: ${e.message}")
+                }
+                val crc = CRC32()
+                crc.update(bytes)
+                val declaredCrc = o.optLong("checksum", -1)
+                if (crc.value != declaredCrc) {
+                    return null to Invalid(
+                        "resource '$resourceId' checksum ${crc.value} does not match declared $declaredCrc",
+                    )
+                }
+                entries[resourceId] = Entry(
+                    resourceId, overlayId, pw.toFloat(), ph.toFloat(), rw, rh,
+                    bx.toFloat(), by.toFloat(), bw.toFloat(), bh.toFloat(),
+                    o.optBoolean("premultiplied", false), bytes,
+                )
+            }
+            return OverlayResources(entries) to null
+        }
+    }
+}