@pictor-sdk/video-android 0.1.0

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

@@ -0,0 +1,662 @@
+package dev.pictor.video
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import org.json.JSONArray
+import org.json.JSONObject
+import kotlin.math.abs
+
+/**
+ * Decoded **display-space** frames, for the gate's pixel floor.
+ *
+ * `MediaMetadataRetriever` returns frames with the container's rotation already
+ * applied, which is the only space in which "does this look the same" is a
+ * meaningful question. Comparing stored dimensions instead is how a 1080×1920
+ * file carrying a rotation flag and a 1920×1080 file with the orientation baked
+ * in look like a difference when they display identically — the exact ambiguity
+ * that stalled the first run of this gate.
+ *
+ * Nothing here encodes or exports. It reads files back and reports numbers.
+ */
+internal object GateFrames {
+
+    /** What one file looks like, in display space. */
+    private class Reader(context: Context, uri: String) : AutoCloseable {
+        val mmr = MediaMetadataRetriever()
+
+        init {
+            if (uri.startsWith("/")) {
+                mmr.setDataSource(uri)
+            } else {
+                mmr.setDataSource(context, Uri.parse(uri))
+            }
+        }
+
+        fun meta(key: Int): String = mmr.extractMetadata(key) ?: ""
+
+        fun frameAt(us: Long): Bitmap? =
+            mmr.getFrameAtTime(us, MediaMetadataRetriever.OPTION_CLOSEST)
+
+        override fun close() {
+            runCatching { mmr.release() }
+        }
+    }
+
+    /**
+     * Compare two files at `timestampsUs`, in display space.
+     *
+     * Returns per-timestamp statistics rather than a verdict: the threshold is
+     * the caller's to freeze, and freezing it here would be choosing it after
+     * seeing the numbers.
+     */
+    fun compare(
+        context: Context,
+        leftUri: String,
+        rightUri: String,
+        timestampsUs: LongArray,
+    ): String {
+        val out = JSONObject()
+        try {
+            Reader(context, leftUri).use { left ->
+                Reader(context, rightUri).use { right ->
+                    out.put("leftDisplay", describe(left))
+                    out.put("rightDisplay", describe(right))
+                    val samples = JSONArray()
+                    var worstMax = 0
+                    var worstMeanTimesThousand = 0L
+                    for (us in timestampsUs) {
+                        val a = left.frameAt(us)
+                        val b = right.frameAt(us)
+                        val sample = JSONObject().put("timeUs", us)
+                        if (a == null || b == null) {
+                            sample.put("error", "no frame")
+                        } else if (a.width != b.width || a.height != b.height) {
+                            // A real difference, and not one a tolerance can
+                            // absorb: the two do not display at the same size.
+                            sample.put("error", "display size ${a.width}x${a.height} vs ${b.width}x${b.height}")
+                        } else {
+                            val stats = diff(a, b)
+                            sample.put("width", a.width).put("height", a.height)
+                            sample.put("maxDelta", stats.maxDelta)
+                            sample.put("meanDelta", stats.meanDelta)
+                            sample.put("differingPermille", stats.differingPermille)
+                            if (stats.maxDelta > worstMax) worstMax = stats.maxDelta
+                            val meanK = (stats.meanDelta * 1000).toLong()
+                            if (meanK > worstMeanTimesThousand) worstMeanTimesThousand = meanK
+                        }
+                        a?.recycle()
+                        b?.recycle()
+                        samples.put(sample)
+                    }
+                    out.put("samples", samples)
+                    out.put("worstMaxDelta", worstMax)
+                    out.put("worstMeanDelta", worstMeanTimesThousand / 1000.0)
+                    out.put("ok", true)
+                }
+            }
+        } catch (e: Exception) {
+            out.put("ok", false).put("error", "${e.javaClass.simpleName}: ${e.message}")
+        }
+        return out.toString()
+    }
+
+    private fun describe(reader: Reader): JSONObject {
+        // Stored dimensions *and* the rotation, so display space can be derived
+        // rather than guessed — and a first frame, which is display space by
+        // construction.
+        val storedW = reader.meta(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)
+        val storedH = reader.meta(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)
+        val rotation = reader.meta(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION)
+        val first = reader.frameAt(0)
+        val json = JSONObject()
+            .put("storedWidth", storedW)
+            .put("storedHeight", storedH)
+            .put("rotationDegrees", rotation)
+            .put("durationMs", reader.meta(MediaMetadataRetriever.METADATA_KEY_DURATION))
+            .put("frameCount", reader.meta(MediaMetadataRetriever.METADATA_KEY_VIDEO_FRAME_COUNT))
+            .put("colorStandard", reader.meta(MediaMetadataRetriever.METADATA_KEY_COLOR_STANDARD))
+            .put("colorRange", reader.meta(MediaMetadataRetriever.METADATA_KEY_COLOR_RANGE))
+            .put("colorTransfer", reader.meta(MediaMetadataRetriever.METADATA_KEY_COLOR_TRANSFER))
+            .put("hasAudio", reader.meta(MediaMetadataRetriever.METADATA_KEY_HAS_AUDIO))
+            .put("displayWidth", first?.width ?: 0)
+            .put("displayHeight", first?.height ?: 0)
+        first?.recycle()
+        return json
+    }
+
+    /**
+     * Mean colour of a central region, per timestamp, in display space.
+     *
+     * Deliberately dumb: it reports numbers and draws no conclusion. Which
+     * source a colour implies, and which frame of it, is arithmetic the
+     * TypeScript oracle owns — native computing that would be exactly the
+     * timeline knowledge this architecture keeps out of it.
+     *
+     * The region avoids the burned-in label, so text pixels cannot pull the
+     * mean around.
+     */
+    fun sample(context: Context, uri: String, timestampsUs: LongArray): String {
+        val out = JSONObject()
+        try {
+            Reader(context, uri).use { reader ->
+                out.put("display", describe(reader))
+                val samples = JSONArray()
+                for (us in timestampsUs) {
+                    val bitmap = reader.frameAt(us)
+                    val sample = JSONObject().put("timeUs", us)
+                    if (bitmap == null) {
+                        sample.put("error", "no frame")
+                    } else {
+                        val w = bitmap.width
+                        val h = bitmap.height
+                        // Lower-middle: below the label, inside the field.
+                        val x0 = w / 4
+                        val y0 = h / 2
+                        val cw = w / 2
+                        val ch = h / 3
+                        val row = IntArray(cw)
+                        var r = 0L
+                        var g = 0L
+                        var b = 0L
+                        for (y in y0 until y0 + ch) {
+                            bitmap.getPixels(row, 0, cw, x0, y, cw, 1)
+                            for (p in row) {
+                                r += (p shr 16) and 0xff
+                                g += (p shr 8) and 0xff
+                                b += p and 0xff
+                            }
+                        }
+                        val n = cw.toLong() * ch.toLong()
+                        sample.put("r", r.toDouble() / n)
+                        sample.put("g", g.toDouble() / n)
+                        sample.put("b", b.toDouble() / n)
+                        bitmap.recycle()
+                    }
+                    samples.put(sample)
+                }
+                out.put("samples", samples).put("ok", true)
+            }
+        } catch (e: Exception) {
+            out.put("ok", false).put("error", e.javaClass.simpleName + ": " + e.message)
+        }
+        return out.toString()
+    }
+
+    /**
+     * Every sample timestamp, per track, read from the container.
+     *
+     * `MediaMetadataRetriever` reports a frame *count* and a whole-file
+     * duration, neither of which can distinguish a held tail frame from a
+     * correctly-timed one, or a gap from a slow rate. The muxed sample
+     * timestamps can: they are exactly what was written.
+     *
+     * As with everything else here, it reports and concludes nothing. Whether an
+     * interval is a gap, a duplicate or expected slow-motion resampling is a
+     * judgement the TypeScript oracle makes against a rate it declared first.
+     */
+    fun tracks(context: Context, uri: String): String {
+        val out = JSONObject()
+        val extractor = android.media.MediaExtractor()
+        try {
+            if (uri.startsWith("/")) {
+                extractor.setDataSource(uri)
+            } else {
+                extractor.setDataSource(context, Uri.parse(uri), null)
+            }
+            val tracks = JSONArray()
+            val count = extractor.trackCount
+            val mimes = arrayOfNulls<String>(count)
+            val counts = IntArray(count)
+            val firsts = LongArray(count) { -1L }
+            val lasts = LongArray(count) { -1L }
+            val videoTimes = HashMap<Int, JSONArray>()
+            for (i in 0 until count) {
+                val format = extractor.getTrackFormat(i)
+                mimes[i] = format.getString(android.media.MediaFormat.KEY_MIME) ?: ""
+                // Every track selected, one pass, sorted by the reader itself.
+                // Selecting and seeking per track made an empty audio track and
+                // an unseekable one indistinguishable; reading the interleaved
+                // stream and asking which track each sample belongs to cannot
+                // confuse the two.
+                extractor.selectTrack(i)
+                if (mimes[i]!!.startsWith("video/")) videoTimes[i] = JSONArray()
+            }
+            extractor.seekTo(0, android.media.MediaExtractor.SEEK_TO_PREVIOUS_SYNC)
+            while (true) {
+                val track = extractor.sampleTrackIndex
+                if (track < 0) break
+                val t = extractor.sampleTime
+                if (counts[track] == 0) firsts[track] = t
+                lasts[track] = t
+                videoTimes[track]?.put(t)
+                counts[track] += 1
+                if (!extractor.advance()) break
+            }
+            for (i in 0 until count) {
+                val format = extractor.getTrackFormat(i)
+                val track = JSONObject()
+                    .put("index", i)
+                    .put("mime", mimes[i])
+                    .put(
+                        "formatDurationUs",
+                        if (format.containsKey(android.media.MediaFormat.KEY_DURATION)) {
+                            format.getLong(android.media.MediaFormat.KEY_DURATION)
+                        } else {
+                            -1L
+                        },
+                    )
+                    .put("sampleCount", counts[i])
+                    .put("firstPtsUs", firsts[i])
+                    .put("lastPtsUs", lasts[i])
+                videoTimes[i]?.let { track.put("timestampsUs", it) }
+                tracks.put(track)
+            }
+            out.put("tracks", tracks).put("ok", true)
+        } catch (e: Exception) {
+            out.put("ok", false).put("error", e.javaClass.simpleName + ": " + e.message)
+        } finally {
+            runCatching { extractor.release() }
+        }
+        return out.toString()
+    }
+
+    /**
+     * A checksum per compressed video sample, without decoding.
+     *
+     * Transmuxing must move the encoded bytes and change only timestamps and
+     * container metadata. Comparing decoded pixels cannot show that: a re-encode
+     * that happens to look identical would pass, and this gate exists to tell
+     * those apart. So the payload itself is checksummed.
+     */
+    fun sampleHashes(context: Context, uri: String): String {
+        val out = JSONObject()
+        val extractor = android.media.MediaExtractor()
+        try {
+            if (uri.startsWith("/")) {
+                extractor.setDataSource(uri)
+            } else {
+                extractor.setDataSource(context, Uri.parse(uri), null)
+            }
+            var video = -1
+            for (i in 0 until extractor.trackCount) {
+                val mime = extractor.getTrackFormat(i).getString(android.media.MediaFormat.KEY_MIME) ?: ""
+                if (mime.startsWith("video/")) { video = i; break }
+            }
+            /*
+              An audio-only file is a legitimate input here.
+
+              The audio timeline intermediate has no video track, and refusing it
+              made the payload comparison unreadable — it reported "no audio
+              hashes" for the one file that was nothing but audio.
+            */
+            /*
+              One interleaved pass over every track.
+
+              Selecting and seeking per track reads nothing when a track's first
+              sample has a negative timestamp, which AAC's encoder delay routinely
+              produces -- the audio hashes came back empty for exactly the files
+              that had audio. Reading the stream as the extractor orders it and
+              asking which track each sample belongs to cannot make that mistake.
+            */
+            for (i in 0 until extractor.trackCount) extractor.selectTrack(i)
+            extractor.seekTo(0, android.media.MediaExtractor.SEEK_TO_PREVIOUS_SYNC)
+            val buffer = java.nio.ByteBuffer.allocate(4 * 1024 * 1024)
+
+            val hashes = JSONArray()
+            val sizes = JSONArray()
+            val times = JSONArray()
+            val audioHashes = JSONArray()
+            val audioSizes = JSONArray()
+            val audioTimes = JSONArray()
+            val whole = java.util.zip.CRC32()
+            val beatEpoch = ExportHeartbeat.currentEpoch()
+            var beatCounter = 0
+            while (true) {
+                val track = extractor.sampleTrackIndex
+                if (track < 0) break
+                val t = extractor.sampleTime
+                buffer.clear()
+                val read = extractor.readSampleData(buffer, 0)
+                // Provenance hashing reads the whole file, and measured at
+                // 0.1x it was the longest unbeaten stretch of an entire export
+                // — 5.5 s of silence in a pipeline that was working perfectly.
+                // Conformance work beats too, so a gate run does not look
+                // stalled — but production does not run it at all, so the
+                // threshold is not measured against it.
+                beatCounter += 1
+                if (beatCounter % 64 == 0) ExportHeartbeat.beat("muxBatch", beatEpoch)
+                if (read <= 0) break
+                val bytes = ByteArray(read)
+                buffer.position(0)
+                buffer.get(bytes, 0, read)
+                val crc = java.util.zip.CRC32()
+                crc.update(bytes, 0, read)
+                if (track == video) {
+                    whole.update(bytes, 0, read)
+                    hashes.put(crc.value)
+                    sizes.put(read)
+                    times.put(t)
+                } else {
+                    audioHashes.put(crc.value)
+                    audioSizes.put(read)
+                    audioTimes.put(t)
+                }
+                if (!extractor.advance()) break
+            }
+            out.put("sampleHashes", hashes)
+                .put("sampleSizes", sizes)
+                .put("timestampsUs", times)
+                .put("audioHashes", audioHashes)
+                .put("audioSizes", audioSizes)
+                .put("audioTimestampsUs", audioTimes)
+                .put("payloadCrc", whole.value)
+                .put("ok", true)
+        } catch (e: Exception) {
+            out.put("ok", false).put("error", e.javaClass.simpleName + ": " + e.message)
+        } finally {
+            runCatching { extractor.release() }
+        }
+        return out.toString()
+    }
+
+    /**
+     * Geometry and colour, separated.
+     *
+     * A maximum channel delta is close to useless around a transformed edge: one
+     * row of pixels landing on the far side of a boundary between a bright source
+     * and a black background produces a delta of 255 while the picture is right.
+     * So the frame is split into a **mask** — where the transformed source landed
+     * — and the colour inside it, and each is measured on its own terms.
+     *
+     * Reports numbers only. Which of them constitute a pass is the caller's
+     * predeclared business.
+     */
+    fun geometry(
+        context: Context,
+        leftUri: String,
+        leftUs: Long,
+        rightUri: String,
+        rightUs: Long,
+        maskThreshold: Int,
+    ): String {
+        val out = JSONObject()
+        try {
+            Reader(context, leftUri).use { l ->
+                Reader(context, rightUri).use { r ->
+                    val a = l.frameAt(leftUs)
+                    val b = r.frameAt(rightUs)
+                    if (a == null || b == null) return out.put("ok", false).put("error", "no frame").toString()
+                    if (a.width != b.width || a.height != b.height) {
+                        return out.put("ok", false)
+                            .put("error", "size ${a.width}x${a.height} vs ${b.width}x${b.height}")
+                            .toString()
+                    }
+                    val w = a.width
+                    val h = a.height
+                    val pa = IntArray(w * h)
+                    val pb = IntArray(w * h)
+                    a.getPixels(pa, 0, w, 0, 0, w, h)
+                    b.getPixels(pb, 0, w, 0, 0, w, h)
+                    a.recycle()
+                    b.recycle()
+
+                    val ma = BooleanArray(w * h)
+                    val mb = BooleanArray(w * h)
+                    var aBox = intArrayOf(w, h, -1, -1)
+                    var bBox = intArrayOf(w, h, -1, -1)
+                    var areaA = 0L
+                    var areaB = 0L
+                    for (y in 0 until h) {
+                        for (x in 0 until w) {
+                            val i = y * w + x
+                            if (maskValue(pa[i]) > maskThreshold) {
+                                ma[i] = true; areaA++
+                                if (x < aBox[0]) aBox[0] = x
+                                if (y < aBox[1]) aBox[1] = y
+                                if (x > aBox[2]) aBox[2] = x
+                                if (y > aBox[3]) aBox[3] = y
+                            }
+                            if (maskValue(pb[i]) > maskThreshold) {
+                                mb[i] = true; areaB++
+                                if (x < bBox[0]) bBox[0] = x
+                                if (y < bBox[1]) bBox[1] = y
+                                if (x > bBox[2]) bBox[2] = x
+                                if (y > bBox[3]) bBox[3] = y
+                            }
+                        }
+                    }
+                    var inter = 0L
+                    var union = 0L
+                    for (i in 0 until w * h) {
+                        if (ma[i] && mb[i]) inter++
+                        if (ma[i] || mb[i]) union++
+                    }
+                    /*
+                      An empty union is not a perfect match.
+
+                      Two frames that both drew nothing agree completely and mean
+                      nothing, and IoU over an empty set is whatever the guard
+                      says it is. Four transform cases once "passed" at 1000
+                      permille while rendering black, which is the shape of
+                      failure this refuses to report as success.
+                    */
+                    if (union == 0L) {
+                        return out.put("ok", false)
+                            .put("error", "empty union: neither frame drew a footprint")
+                            .put("maskAreaLeft", areaA).put("maskAreaRight", areaB)
+                            .toString()
+                    }
+
+                    /*
+                      Interior only: the intersection, eroded by one pixel.
+
+                      An edge pixel is a blend of source and background whose
+                      value depends on exactly where the boundary fell, so it
+                      reports colour error for what is really sub-pixel geometry.
+                      Eroding separates the two questions instead of letting one
+                      answer the other.
+                    */
+                    var interiorPixels = 0L
+                    var sumErr = 0L
+                    var maxErr = 0
+                    var differing = 0L
+                    for (y in 1 until h - 1) {
+                        for (x in 1 until w - 1) {
+                            val i = y * w + x
+                            if (!(ma[i] && mb[i])) continue
+                            if (!(ma[i - 1] && ma[i + 1] && ma[i - w] && ma[i + w])) continue
+                            if (!(mb[i - 1] && mb[i + 1] && mb[i - w] && mb[i + w])) continue
+                            val p = pa[i]
+                            val q = pb[i]
+                            val dr = abs(((p shr 16) and 0xff) - ((q shr 16) and 0xff))
+                            val dg = abs(((p shr 8) and 0xff) - ((q shr 8) and 0xff))
+                            val db = abs((p and 0xff) - (q and 0xff))
+                            val worst = maxOf(dr, dg, db)
+                            if (worst > maxErr) maxErr = worst
+                            sumErr += (dr + dg + db).toLong()
+                            if (worst > 8) differing++
+                            interiorPixels++
+                        }
+                    }
+
+                    // Edge displacement, as how far the footprints' bounds moved.
+                    var edge = 0
+                    if (aBox[2] >= 0 && bBox[2] >= 0) {
+                        for (k in 0 until 4) edge = maxOf(edge, abs(aBox[k] - bBox[k]))
+                    }
+
+                    out.put("ok", true)
+                        .put("width", w).put("height", h)
+                        .put("maskAreaLeft", areaA).put("maskAreaRight", areaB)
+                        .put("intersection", inter).put("union", union)
+                        .put("iouPermille", if (union == 0L) 1000 else ((inter * 1000) / union).toInt())
+                        .put("symmetricDifference", union - inter)
+                        .put("bboxLeft", JSONArray().put(aBox[0]).put(aBox[1]).put(aBox[2]).put(aBox[3]))
+                        .put("bboxRight", JSONArray().put(bBox[0]).put(bBox[1]).put(bBox[2]).put(bBox[3]))
+                        .put("edgeDisplacementPx", edge)
+                        .put("interiorPixels", interiorPixels)
+                        .put("interiorMeanError", if (interiorPixels == 0L) 0.0 else sumErr.toDouble() / (interiorPixels * 3))
+                        .put("interiorMaxError", maxErr)
+                        .put(
+                            "interiorDifferingPermille",
+                            if (interiorPixels == 0L) 0 else ((differing * 1000) / interiorPixels).toInt(),
+                        )
+                }
+            }
+        } catch (e: Exception) {
+            out.put("ok", false).put("error", e.javaClass.simpleName + ": " + e.message)
+        }
+        return out.toString()
+    }
+
+    /** One decoded frame as base64 PNG, in display space. */
+    fun framePng(context: Context, uri: String, timeUs: Long): String {
+        val out = JSONObject()
+        try {
+            Reader(context, uri).use { reader ->
+                val bitmap = reader.frameAt(timeUs)
+                    ?: return out.put("ok", false).put("error", "no frame").toString()
+                val stream = java.io.ByteArrayOutputStream()
+                bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
+                out.put("ok", true)
+                    .put("width", bitmap.width)
+                    .put("height", bitmap.height)
+                    .put("png", android.util.Base64.encodeToString(stream.toByteArray(), android.util.Base64.NO_WRAP))
+                bitmap.recycle()
+            }
+        } catch (e: Exception) {
+            out.put("ok", false).put("error", e.javaClass.simpleName + ": " + e.message)
+        }
+        return out.toString()
+    }
+
+    /**
+     * Mask test: the brightest channel, not luminance.
+     *
+     * Luminance weights blue at 11%, so a blue-only source at value 93 scores 13
+     * — indistinguishable from black at any usable threshold, and the mask
+     * collapsed to the burned-in text instead of the source's footprint. The
+     * question here is "is there source here at all", and the strongest channel
+     * answers it without caring which channel carries the signal.
+     */
+    /**
+     * Mean and extremes over caller-chosen rectangles.
+     *
+     * The fixed centre region [sample] uses is wrong for a transformed clip: it
+     * straddles the footprint edge, so it averages source pixels with cleared
+     * ones and the recovered source frame reads low. The caller knows where the
+     * footprint is — it has the corner oracle — so it passes the rectangles and
+     * this reports what is in them.
+     *
+     * `max - min` per channel is returned as well as the mean, because a region
+     * that is supposed to be uniform and is not is a different failure from one
+     * whose average is off.
+     */
+    fun probe(context: Context, uri: String, probesJson: String): String {
+        val out = JSONObject()
+        try {
+            val probes = JSONArray(probesJson)
+            Reader(context, uri).use { reader ->
+                val results = JSONArray()
+                var lastUs = Long.MIN_VALUE
+                var bitmap: Bitmap? = null
+                for (i in 0 until probes.length()) {
+                    val p = probes.getJSONObject(i)
+                    val us = p.getLong("timeUs")
+                    if (us != lastUs) {
+                        bitmap?.recycle()
+                        bitmap = reader.frameAt(us)
+                        lastUs = us
+                    }
+                    val bm = bitmap
+                    val entry = JSONObject().put("timeUs", us)
+                        .put("x", p.getInt("x")).put("y", p.getInt("y"))
+                        .put("w", p.getInt("w")).put("h", p.getInt("h"))
+                    if (bm == null) {
+                        results.put(entry.put("error", "no frame")); continue
+                    }
+                    val x0 = p.getInt("x").coerceIn(0, bm.width - 1)
+                    val y0 = p.getInt("y").coerceIn(0, bm.height - 1)
+                    val w = p.getInt("w").coerceIn(1, bm.width - x0)
+                    val h = p.getInt("h").coerceIn(1, bm.height - y0)
+                    val row = IntArray(w)
+                    var r = 0L; var g = 0L; var b = 0L
+                    var rMin = 255; var gMin = 255; var bMin = 255
+                    var rMax = 0; var gMax = 0; var bMax = 0
+                    for (y in y0 until y0 + h) {
+                        bm.getPixels(row, 0, w, x0, y, w, 1)
+                        for (px in row) {
+                            val pr = (px shr 16) and 0xff
+                            val pg = (px shr 8) and 0xff
+                            val pb = px and 0xff
+                            r += pr; g += pg; b += pb
+                            if (pr < rMin) rMin = pr
+                            if (pg < gMin) gMin = pg
+                            if (pb < bMin) bMin = pb
+                            if (pr > rMax) rMax = pr
+                            if (pg > gMax) gMax = pg
+                            if (pb > bMax) bMax = pb
+                        }
+                    }
+                    val n = w.toLong() * h.toLong()
+                    results.put(
+                        entry.put("r", r.toDouble() / n).put("g", g.toDouble() / n).put("b", b.toDouble() / n)
+                            .put("rMin", rMin).put("gMin", gMin).put("bMin", bMin)
+                            .put("rMax", rMax).put("gMax", gMax).put("bMax", bMax)
+                            .put("pixels", n),
+                    )
+                }
+                bitmap?.recycle()
+                out.put("probes", results).put("ok", true)
+            }
+        } catch (e: Exception) {
+            out.put("ok", false).put("error", e.javaClass.simpleName + ": " + e.message)
+        }
+        return out.toString()
+    }
+
+    private fun maskValue(p: Int): Int {
+        val r = (p shr 16) and 0xff
+        val g = (p shr 8) and 0xff
+        val b = p and 0xff
+        return maxOf(r, maxOf(g, b))
+    }
+
+    private class Stats(val maxDelta: Int, val meanDelta: Double, val differingPermille: Int)
+
+    private fun diff(a: Bitmap, b: Bitmap): Stats {
+        val w = a.width
+        val h = a.height
+        val rowA = IntArray(w)
+        val rowB = IntArray(w)
+        var max = 0
+        var sum = 0L
+        var differing = 0L
+        var total = 0L
+        for (y in 0 until h) {
+            a.getPixels(rowA, 0, w, 0, y, w, 1)
+            b.getPixels(rowB, 0, w, 0, y, w, 1)
+            for (x in 0 until w) {
+                val p = rowA[x]
+                val q = rowB[x]
+                val dr = abs(((p shr 16) and 0xff) - ((q shr 16) and 0xff))
+                val dg = abs(((p shr 8) and 0xff) - ((q shr 8) and 0xff))
+                val db = abs((p and 0xff) - (q and 0xff))
+                if (dr > max) max = dr
+                if (dg > max) max = dg
+                if (db > max) max = db
+                sum += dr + dg + db
+                if (dr != 0 || dg != 0 || db != 0) differing += 1
+                total += 3
+            }
+        }
+        val pixels = w.toLong() * h.toLong()
+        return Stats(
+            maxDelta = max,
+            meanDelta = if (total == 0L) 0.0 else sum.toDouble() / total.toDouble(),
+            differingPermille = if (pixels == 0L) 0 else ((differing * 1000) / pixels).toInt(),
+        )
+    }
+}