react-native-nitro-image-pipeline 1.3.2 → 1.5.0

package/android/src/main/java/com/margelo/nitro/nitroimagepipeline/HybridNitroImagePipeline.kt

@@ -1,6 +1,7 @@
 package com.margelo.nitro.nitroimagepipeline
 
 import android.content.Context
+import android.graphics.Bitmap
 import androidx.core.graphics.drawable.toBitmap
 import coil3.BitmapImage
 import coil3.ColorImage
@@ -26,12 +27,15 @@ import com.margelo.nitro.core.Promise
 import com.margelo.nitro.image.HybridImage
 import com.margelo.nitro.image.HybridImageSpec
 import com.margelo.nitro.nitroimagepipeline.transform.BlurTransformation
+import com.margelo.nitro.nitroimagepipeline.transform.HardwareBitmapTransformation
 import com.margelo.nitro.nitroimagepipeline.transform.ResizeTransformation
 import kotlin.math.roundToInt
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
 import okio.Path.Companion.toOkioPath
@@ -44,82 +48,27 @@ class HybridNitroImagePipeline : HybridNitroImagePipelineSpec() {
   private val imageLoader: ImageLoader
     get() = getOrCreateImageLoader(context)
 
-  override fun loadImage(url: String, options: Options?): Promise<HybridImageSpec> = Promise.async {
-    val blur = options?.blur?.toFloat() ?: 0f
-    val resize =
-        options?.resize?.let { r ->
-          val width = r.width.roundToInt()
-          val height = r.height.roundToInt()
-          if (width > 0 && height > 0) width to height else null
-        }
-    val transformations = buildList {
-      // Resize first: blur sigma and corner radii are in pixels of the bitmap
-      // they run on, so they must see the final size.
-      resize?.let { (width, height) -> add(ResizeTransformation(width, height)) }
-      if (blur > 0f) add(BlurTransformation(context, blur))
-      options
-          ?.cornerRadius
-          ?.match(
-              first = { radius ->
-                if (radius > 0.0) add(RoundedCornersTransformation(radius.toFloat()))
-              },
-              second = { radii ->
-                // RoundedCornersTransformation rejects negative radii; treat them as square.
-                val topLeft = (radii.topLeft?.toFloat() ?: 0f).coerceAtLeast(0f)
-                val topRight = (radii.topRight?.toFloat() ?: 0f).coerceAtLeast(0f)
-                val bottomLeft = (radii.bottomLeft?.toFloat() ?: 0f).coerceAtLeast(0f)
-                val bottomRight = (radii.bottomRight?.toFloat() ?: 0f).coerceAtLeast(0f)
-                if (topLeft > 0f || topRight > 0f || bottomLeft > 0f || bottomRight > 0f) {
-                  add(RoundedCornersTransformation(topLeft, topRight, bottomLeft, bottomRight))
-                }
-              },
-          )
-    }
-    val request =
-        ImageRequest.Builder(context)
-            .data(url)
-            .apply {
-              when (options?.cache) {
-                CacheOption.MEMORY -> {
-                  memoryCachePolicy(CachePolicy.ENABLED)
-                  diskCachePolicy(CachePolicy.DISABLED)
-                }
-                CacheOption.DISK -> {
-                  memoryCachePolicy(CachePolicy.DISABLED)
-                  diskCachePolicy(CachePolicy.ENABLED)
-                }
-                CacheOption.NONE -> {
-                  memoryCachePolicy(CachePolicy.DISABLED)
-                  diskCachePolicy(CachePolicy.DISABLED)
-                }
-                null -> Unit // Coil defaults: both enabled
-              }
-              // Ask the decoder for the target size so a large source is
-              // subsampled near it instead of decoded at full resolution;
-              // ResizeTransformation then makes the size exact.
-              resize?.let { (width, height) ->
-                size(width, height)
-                scale(Scale.FILL)
-              }
-            }
-            .allowHardware(true)
-            .transformations(transformations)
-            .build()
+  init {
+    // Build the shared loader now, on a background thread, instead of on
+    // whichever thread the first request happens to run on. Creating it
+    // builds a CronetEngine, an OkHttpClient and the disk cache — well over
+    // a frame's worth of work — and the first `PipelineImageLoader` request
+    // would otherwise do that on the main thread.
+    (NitroModules.applicationContext as? Context)?.let { warmUpImageLoader(it) }
+  }
 
-    when (val result = imageLoader.execute(request)) {
+  override fun loadImage(url: String, options: Options?): Promise<HybridImageSpec> = Promise.async {
+    when (val result = imageLoader.execute(buildRequest(context, url, options))) {
       is ErrorResult -> throw result.throwable
-      is SuccessResult -> {
-        val bitmap =
-            when (val img = result.image) {
-              is BitmapImage -> img.bitmap
-              is DrawableImage -> img.drawable.toBitmap()
-              else -> throw Error("Unsupported image type: ${img.javaClass.simpleName}")
-            }
-        HybridImage(bitmap)
-      }
+      is SuccessResult -> HybridImage(bitmapOf(result))
     }
   }
 
+  override fun createImageLoader(
+      url: String,
+      options: ViewOptions?,
+  ): com.margelo.nitro.image.HybridImageLoaderSpec = PipelineImageLoader(context, url, options)
+
   // Preloading warms the disk cache only: the memory cache is skipped and the
   // decode step is replaced with a no-op (Coil's documented preload pattern),
   // so prefetching N URLs costs network + disk I/O instead of N full-resolution
@@ -151,12 +100,23 @@ class HybridNitroImagePipeline : HybridNitroImagePipelineSpec() {
         if (sigma <= 0f) {
           hybridImage
         } else {
-          val blurred =
-              BlurTransformation(context, sigma).transform(hybridImage.bitmap, Size.ORIGINAL)
+          val blurred = BlurTransformation(sigma).transform(hybridImage.bitmap, Size.ORIGINAL)
           HybridImage(blurred)
         }
       }
 
+  override fun setMemoryCacheLimit(bytes: Double) {
+    require(bytes >= 0 && bytes.isFinite()) {
+      "Memory cache limit must be a non-negative, finite number of bytes (got $bytes)"
+    }
+    imageLoader.memoryCache?.apply {
+      maxSize = bytes.toLong()
+      // Setting maxSize only affects future inserts; evict down to it now so
+      // the call frees memory immediately.
+      trimToSize(bytes.toLong())
+    }
+  }
+
   override fun clearCache(): Promise<Unit> = Promise.async {
     imageLoader.memoryCache?.clear()
     // DiskCache.clear() does file I/O; keep it off the JS thread but await
@@ -170,12 +130,131 @@ class HybridNitroImagePipeline : HybridNitroImagePipelineSpec() {
     // must be shared across all HybridNitroImagePipeline instances.
     @Volatile private var sharedImageLoader: ImageLoader? = null
 
-    private fun getOrCreateImageLoader(context: Context): ImageLoader =
+    /**
+     * The [ImageRequest] for [url] with [options] applied — shared by [loadImage] and
+     * [PipelineImageLoader] so both hit the same caches with identical cache keys.
+     *
+     * With [hardwareResult], a transformed result is converted to a hardware bitmap before it is
+     * cached (see [HardwareBitmapTransformation]). Only for callers that draw the result: its
+     * pixels cannot be read back, and its cache key differs from the software one.
+     */
+    internal fun buildRequest(
+        context: Context,
+        url: String,
+        options: Options?,
+        hardwareResult: Boolean = false,
+    ): ImageRequest {
+      val blur = options?.blur?.toFloat() ?: 0f
+      val resize =
+          options?.resize?.let { r ->
+            val width = r.width.roundToInt()
+            val height = r.height.roundToInt()
+            if (width > 0 && height > 0) width to height else null
+          }
+      val roundedCorners: RoundedCornersTransformation? =
+          options
+              ?.cornerRadius
+              ?.match(
+                  first = { radius ->
+                    if (radius > 0.0) RoundedCornersTransformation(radius.toFloat()) else null
+                  },
+                  second = { radii ->
+                    // RoundedCornersTransformation rejects negative radii; treat them as square.
+                    val topLeft = (radii.topLeft?.toFloat() ?: 0f).coerceAtLeast(0f)
+                    val topRight = (radii.topRight?.toFloat() ?: 0f).coerceAtLeast(0f)
+                    val bottomLeft = (radii.bottomLeft?.toFloat() ?: 0f).coerceAtLeast(0f)
+                    val bottomRight = (radii.bottomRight?.toFloat() ?: 0f).coerceAtLeast(0f)
+                    if (topLeft > 0f || topRight > 0f || bottomLeft > 0f || bottomRight > 0f) {
+                      RoundedCornersTransformation(topLeft, topRight, bottomLeft, bottomRight)
+                    } else {
+                      null
+                    }
+                  },
+              )
+      val transformations = buildList {
+        // Resize first: blur sigma and corner radii are in pixels of the bitmap
+        // they run on, so they must see the final size. Coil's
+        // RoundedCornersTransformation already scale-fills and center-crops
+        // to the request size (`resize`, when set) as part of its own draw,
+        // so with rounded corners and no blur the explicit resize would only
+        // add an intermediate bitmap — and the radii still apply to the final
+        // size, because that is the size its output has.
+        if (resize != null && (blur > 0f || roundedCorners == null)) {
+          add(ResizeTransformation(resize.first, resize.second))
+        }
+        if (blur > 0f) add(BlurTransformation(blur))
+        roundedCorners?.let { add(it) }
+        // Without transformations Coil decodes straight to a hardware bitmap
+        // already (allowHardware below); only a transformed result needs the
+        // explicit upload.
+        if (hardwareResult && isNotEmpty() && HardwareBitmapTransformation.isSupported) {
+          add(HardwareBitmapTransformation.instance)
+        }
+      }
+      return ImageRequest.Builder(context)
+          .data(url)
+          .apply {
+            when (options?.cache) {
+              CacheOption.MEMORY -> {
+                memoryCachePolicy(CachePolicy.ENABLED)
+                diskCachePolicy(CachePolicy.DISABLED)
+              }
+              CacheOption.DISK -> {
+                memoryCachePolicy(CachePolicy.DISABLED)
+                diskCachePolicy(CachePolicy.ENABLED)
+              }
+              CacheOption.NONE -> {
+                memoryCachePolicy(CachePolicy.DISABLED)
+                diskCachePolicy(CachePolicy.DISABLED)
+              }
+              null -> Unit // Coil defaults: both enabled
+            }
+            // Ask the decoder for the target size so a large source is
+            // subsampled near it instead of decoded at full resolution;
+            // ResizeTransformation then makes the size exact.
+            resize?.let { (width, height) ->
+              size(width, height)
+              scale(Scale.FILL)
+            }
+          }
+          .allowHardware(true)
+          .transformations(transformations)
+          .build()
+    }
+
+    /** The decoded bitmap of a successful load. */
+    internal fun bitmapOf(result: SuccessResult): Bitmap =
+        when (val img = result.image) {
+          is BitmapImage -> img.bitmap
+          is DrawableImage -> img.drawable.toBitmap()
+          else -> throw Error("Unsupported image type: ${img.javaClass.simpleName}")
+        }
+
+    internal fun getOrCreateImageLoader(context: Context): ImageLoader =
         sharedImageLoader
             ?: synchronized(this) {
               sharedImageLoader ?: createImageLoader(context).also { sharedImageLoader = it }
             }
 
+    /**
+     * The shared loader, creating it on [Dispatchers.IO] if it doesn't exist yet. Use this from
+     * main-thread coroutines: once the loader exists this returns synchronously (so memory-cache
+     * hits stay synchronous), and until then the expensive creation runs off the main thread.
+     */
+    internal suspend fun awaitImageLoader(context: Context): ImageLoader =
+        sharedImageLoader ?: withContext(Dispatchers.IO) { getOrCreateImageLoader(context) }
+
+    /** Starts creating the shared loader on a background thread, if it doesn't exist yet. */
+    private fun warmUpImageLoader(context: Context) {
+      if (sharedImageLoader != null) return
+      CoroutineScope(Dispatchers.IO).launch {
+        // Warm-up only: an uncaught exception here would take the process
+        // down. If creation fails, `sharedImageLoader` stays null and the
+        // next request retries it and surfaces the error itself.
+        runCatching { getOrCreateImageLoader(context) }
+      }
+    }
+
     private fun createImageLoader(context: Context): ImageLoader {
       val okHttpClient =
           OkHttpClient.Builder()

package/android/src/main/java/com/margelo/nitro/nitroimagepipeline/PipelineImageLoader.kt

@@ -0,0 +1,177 @@
+package com.margelo.nitro.nitroimagepipeline
+
+import android.content.Context
+import android.util.Log
+import android.view.View
+import android.widget.ImageView
+import androidx.annotation.Keep
+import coil3.request.ErrorResult
+import coil3.request.SuccessResult
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.image.HybridImage
+import com.margelo.nitro.image.HybridImageLoaderSpec
+import com.margelo.nitro.image.HybridImageSpec
+import com.margelo.nitro.image.HybridImageView
+import com.margelo.nitro.image.HybridNitroImageViewSpec
+import kotlin.coroutines.resume
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
+
+/**
+ * An `ImageLoader` (react-native-nitro-image) backed by the shared pipeline.
+ *
+ * `<NativeNitroImage image={loader} />` drives it entirely natively: the view calls [requestImage]
+ * when it attaches to the window and [dropImage] when it detaches. The load runs at the view's
+ * laid-out size with no JS round trips, and detaching cancels the request and releases the bitmap —
+ * the decoded image stays in the shared memory/disk caches, so re-attaching (list recycling) is
+ * instant.
+ *
+ * [ViewOptions] values are in points (dp); this class converts them to the pixel-based [Options] of
+ * the shared request builder using the display density, so cache keys match an equivalent
+ * `loadImage` call. View sizes are already physical pixels on Android, so only blur and corner
+ * radii need scaling.
+ */
+@DoNotStrip
+@Keep
+class PipelineImageLoader(
+    private val context: Context,
+    private val url: String,
+    private val options: ViewOptions?,
+) : HybridImageLoaderSpec() {
+  // Per-view in-flight work, keyed by the view's identity, so a loader shared
+  // between several views cancels only the right request. Confined to the
+  // main thread — the view calls requestImage/dropImage there.
+  private val jobs = HashMap<HybridNitroImageViewSpec, Job>()
+  private val mainScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+
+  /** An explicit `resize` override (pixels), when set and valid. */
+  private val explicitResize: ResizeOptions?
+    get() = options?.resize?.takeIf { it.width > 0 && it.height > 0 }
+
+  /**
+   * The point-based [ViewOptions] as pixel-based [Options], resolved against the display [scale]
+   * and the target size in pixels.
+   */
+  private fun pixelOptions(scale: Float, resize: ResizeOptions?): Options {
+    val cornerRadius =
+        options
+            ?.cornerRadius
+            ?.match(
+                first = { radius -> Variant_Double_CornerRadii.create(radius * scale) },
+                second = { radii ->
+                  Variant_Double_CornerRadii.create(
+                      CornerRadii(
+                          topLeft = radii.topLeft?.times(scale),
+                          topRight = radii.topRight?.times(scale),
+                          bottomLeft = radii.bottomLeft?.times(scale),
+                          bottomRight = radii.bottomRight?.times(scale),
+                      )
+                  )
+                },
+            )
+    return Options(
+        blur = options?.blur?.times(scale),
+        cache = options?.cache,
+        cornerRadius = cornerRadius,
+        resize = resize,
+    )
+  }
+
+  override fun loadImage(): Promise<HybridImageSpec> = Promise.async {
+    // No view to measure here: use the explicit resize if given, and the
+    // display density for the point-based options.
+    val scale = context.resources.displayMetrics.density
+    val request =
+        HybridNitroImagePipeline.buildRequest(context, url, pixelOptions(scale, explicitResize))
+    when (val result = HybridNitroImagePipeline.getOrCreateImageLoader(context).execute(request)) {
+      is ErrorResult -> throw result.throwable
+      is SuccessResult -> HybridImage(HybridNitroImagePipeline.bitmapOf(result))
+    }
+  }
+
+  override fun requestImage(forView: HybridNitroImageViewSpec) {
+    val view = forView as? HybridImageView ?: return
+    val imageView = view.imageView
+    jobs[forView]?.cancel()
+    val job = mainScope.launch {
+      // Views attach before they are laid out, so the size may not be
+      // known yet — wait for the first non-empty layout.
+      val resize = explicitResize ?: measuredSize(imageView)
+      val scale = imageView.resources.displayMetrics.density
+      // The result is only ever drawn here, so a transformed one is cached as
+      // a hardware bitmap: no texture upload per view that shows it.
+      val request =
+          HybridNitroImagePipeline.buildRequest(
+              context,
+              url,
+              pixelOptions(scale, resize),
+              hardwareResult = true,
+          )
+      // Synchronous once the shared loader exists; otherwise its (slow)
+      // creation runs on a background thread instead of here on main.
+      val loader = HybridNitroImagePipeline.awaitImageLoader(context)
+      val result = loader.execute(request)
+      // Cancellation normally surfaces as a CancellationException at the
+      // suspension point above, but make it explicit: a job that was
+      // dropped or replaced while the result was in flight must never
+      // touch the view.
+      if (!isActive) return@launch
+      when (result) {
+        is SuccessResult -> imageView.setImageBitmap(HybridNitroImagePipeline.bitmapOf(result))
+        // Deliberately no URL in the message — signed URLs and query
+        // tokens must not leak into consuming apps' Logcat.
+        is ErrorResult -> Log.w(TAG, "Failed to load image", result.throwable)
+      }
+    }
+    jobs[forView] = job
+    job.invokeOnCompletion { if (jobs[forView] === job) jobs.remove(forView) }
+  }
+
+  override fun dropImage(forView: HybridNitroImageViewSpec) {
+    val view = forView as? HybridImageView ?: return
+    jobs.remove(forView)?.cancel()
+    view.imageView.setImageDrawable(null)
+  }
+
+  /** The view's laid-out size in pixels, suspending until it has one. */
+  private suspend fun measuredSize(view: ImageView): ResizeOptions {
+    if (view.width > 0 && view.height > 0) {
+      return ResizeOptions(view.width.toDouble(), view.height.toDouble())
+    }
+    return suspendCancellableCoroutine { continuation ->
+      val listener =
+          object : View.OnLayoutChangeListener {
+            override fun onLayoutChange(
+                v: View,
+                left: Int,
+                top: Int,
+                right: Int,
+                bottom: Int,
+                oldLeft: Int,
+                oldTop: Int,
+                oldRight: Int,
+                oldBottom: Int,
+            ) {
+              val width = right - left
+              val height = bottom - top
+              if (width > 0 && height > 0) {
+                v.removeOnLayoutChangeListener(this)
+                continuation.resume(ResizeOptions(width.toDouble(), height.toDouble()))
+              }
+            }
+          }
+      view.addOnLayoutChangeListener(listener)
+      continuation.invokeOnCancellation { view.removeOnLayoutChangeListener(listener) }
+    }
+  }
+
+  companion object {
+    private const val TAG = "PipelineImageLoader"
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitroimagepipeline/transform/BlurTransformation.kt

@@ -1,36 +1,27 @@
-@file:Suppress("DEPRECATION")
-
 package com.margelo.nitro.nitroimagepipeline.transform
 
-import android.content.Context
 import android.graphics.Bitmap
-import android.graphics.Paint
-import android.renderscript.Allocation
-import android.renderscript.Element
-import android.renderscript.RenderScript
-import android.renderscript.ScriptIntrinsicBlur
-import androidx.core.graphics.applyCanvas
-import androidx.core.graphics.scale
+import android.graphics.Canvas
 import coil3.size.Size
 import coil3.transform.Transformation
-import kotlin.math.ceil
-import kotlin.math.max
 
 /**
  * Gaussian blur of standard deviation [sigma], measured in *source image pixels*.
  *
  * The unit is the point of this class: the same sigma on the same source file produces the same
- * result here and on iOS. It is deliberately not a "radius" — RenderScript, CoreImage and React
+ * result here and on iOS. It is deliberately not a "radius" — CoreImage, RenderScript and React
  * Native's `blurRadius` each define radius differently, which is why blurs never matched across
  * platforms.
  *
+ * The kernel is `android/src/main/cpp/GaussianBlur.cpp`, a port of the iOS one: three box-blur
+ * passes whose widths are solved for the requested sigma, clamping at the image edges. There is no
+ * upper bound on sigma and no downscaling — `bun run verify:blur` measures both kernels against
+ * each other.
+ *
  * For reference, React Native's `<Image blurRadius={n} />` halves its input before convolving, so
  * `blurRadius={n}` is roughly `sigma = n / 2`.
  */
-class BlurTransformation(
-    private val context: Context,
-    private val sigma: Float,
-) : Transformation() {
+class BlurTransformation(private val sigma: Float) : Transformation() {
 
   init {
     require(sigma > 0f && sigma.isFinite()) { "sigma must be > 0." }
@@ -39,79 +30,43 @@ class BlurTransformation(
   override val cacheKey = "${BlurTransformation::class.java.name}-$sigma"
 
   override suspend fun transform(input: Bitmap, size: Size): Bitmap {
-    // ScriptIntrinsicBlur's `radius` maps to a Gaussian sigma of 0.4 * radius + 0.6, and radius is
-    // capped at 25 — so a single pass tops out at sigma ~10.6px. Larger blurs are reached by
-    // blurring a downscaled copy: scaling down by `s`, blurring with sigma/s and scaling back up
-    // multiplies the effective sigma by `s`. A blur is a low-pass filter, so the detail the
-    // downscale drops is detail the blur was going to remove anyway. Downscale only as far as the
-    // sigma ceiling forces, which keeps small blurs pixel-exact.
-    val sampling = max(1f, sigma / MAX_SIGMA)
-    val scaledWidth = ceil(input.width / sampling).toInt().coerceAtLeast(1)
-    val scaledHeight = ceil(input.height / sampling).toInt().coerceAtLeast(1)
-    // Rounding to whole pixels shifts the scale slightly; derive the sigma from the scale actually
-    // applied rather than the requested one.
-    val scaleX = scaledWidth.toFloat() / input.width
-    val scaleY = scaledHeight.toFloat() / input.height
-    val scaledSigma = sigma * max(scaleX, scaleY)
-    val radius = ((scaledSigma - SIGMA_INTERCEPT) / SIGMA_SLOPE).coerceIn(MIN_RADIUS, MAX_RADIUS)
-
-    val paint = Paint(Paint.ANTI_ALIAS_FLAG or Paint.FILTER_BITMAP_FLAG)
-    val softwareInput =
-        if (input.config == Bitmap.Config.HARDWARE) input.copy(Bitmap.Config.ARGB_8888, false)
-        else input
-    val softwareConfig = softwareInput.config ?: Bitmap.Config.ARGB_8888
-
-    val output = Bitmap.createBitmap(scaledWidth, scaledHeight, softwareConfig)
-    output.applyCanvas {
-      scale(scaleX, scaleY)
-      drawBitmap(softwareInput, 0f, 0f, paint)
-    }
-
-    var script: RenderScript? = null
-    var tmpIn: Allocation? = null
-    var tmpOut: Allocation? = null
-    var blur: ScriptIntrinsicBlur? = null
-    try {
-      script = RenderScript.create(context)
-      tmpIn =
-          Allocation.createFromBitmap(
-              script,
-              output,
-              Allocation.MipmapControl.MIPMAP_NONE,
-              Allocation.USAGE_SCRIPT,
-          )
-      tmpOut = Allocation.createTyped(script, tmpIn.type)
-      blur = ScriptIntrinsicBlur.create(script, Element.U8_4(script))
-      blur.setRadius(radius)
-      blur.setInput(tmpIn)
-      blur.forEach(tmpOut)
-      tmpOut.copyTo(output)
-    } finally {
-      script?.destroy()
-      tmpIn?.destroy()
-      tmpOut?.destroy()
-      blur?.destroy()
-    }
-
-    return if (scaledWidth == input.width && scaledHeight == input.height) output
-    else output.scale(input.width, input.height)
+    // The kernel blurs in place, on premultiplied ARGB_8888 pixels. A plain
+    // copy is the cheapest way to get a mutable bitmap of that layout — also
+    // from a hardware bitmap, which a software canvas could not draw. Only a
+    // non-premultiplied input goes through a canvas, which converts it.
+    val output =
+        if (
+            input.config == Bitmap.Config.HARDWARE ||
+                (input.config == Bitmap.Config.ARGB_8888 &&
+                    (input.isPremultiplied || !input.hasAlpha()))
+        ) {
+          input.copy(Bitmap.Config.ARGB_8888, true) ?: error("Bitmap.copy returned null")
+        } else {
+          Bitmap.createBitmap(input.width, input.height, Bitmap.Config.ARGB_8888).also {
+            Canvas(it).drawBitmap(input, 0f, 0f, null)
+          }
+        }
+    check(nativeBlur(output, sigma)) { "Native blur failed (see logcat)." }
+    return output
   }
 
   override fun equals(other: Any?): Boolean {
     if (this === other) return true
-    return other is BlurTransformation && context == other.context && sigma == other.sigma
+    return other is BlurTransformation && sigma == other.sigma
   }
 
-  override fun hashCode(): Int = 31 * context.hashCode() + sigma.hashCode()
+  override fun hashCode(): Int = sigma.hashCode()
 
   override fun toString() = "BlurTransformation(sigma=$sigma)"
 
   private companion object {
-    // sigma = 0.4 * radius + 0.6, per RenderScript's ScriptIntrinsicBlur.
-    const val SIGMA_SLOPE = 0.4f
-    const val SIGMA_INTERCEPT = 0.6f
-    const val MIN_RADIUS = 0.01f
-    const val MAX_RADIUS = 25f
-    const val MAX_SIGMA = SIGMA_SLOPE * MAX_RADIUS + SIGMA_INTERCEPT
+    init {
+      // Nitro loads the library at module registration, but the transformation
+      // must not depend on that order; loadLibrary is idempotent.
+      System.loadLibrary("NitroImagePipeline")
+    }
+
+    /** Blurs [bitmap] (mutable ARGB_8888) in place. Returns false on failure. */
+    @JvmStatic private external fun nativeBlur(bitmap: Bitmap, sigma: Float): Boolean
   }
 }

package/android/src/main/java/com/margelo/nitro/nitroimagepipeline/transform/HardwareBitmapTransformation.kt

@@ -0,0 +1,45 @@
+package com.margelo.nitro.nitroimagepipeline.transform
+
+import android.graphics.Bitmap
+import android.os.Build
+import coil3.size.Size
+import coil3.transform.Transformation
+
+/**
+ * Uploads the transformed bitmap to a [Bitmap.Config.HARDWARE] bitmap (API 26+), so that is what
+ * the memory cache holds and the view draws.
+ *
+ * Coil decodes straight to a hardware bitmap when a request has no transformations, but with any
+ * (resize, blur, rounded corners) the decode and the transformations run on software bitmaps and
+ * the software result is what gets cached. Every view showing it then costs a texture upload (and,
+ * with the pixels kept for the bitmap, a copy in RAM). Appending this transformation converts the
+ * result once, on the transformation thread, and it stays converted in the cache.
+ *
+ * A hardware bitmap's pixels are not readable, so this must only be added by callers that draw the
+ * result — `PipelineImageLoader.requestImage` — never by `loadImage`, whose `HybridImage` needs
+ * readable pixels for `toArrayBuffer`/`toBase64`. The extra cache key keeps the two paths' cache
+ * entries apart.
+ *
+ * Below API 26, or if the upload fails, the software bitmap is passed through unchanged.
+ */
+class HardwareBitmapTransformation private constructor() : Transformation() {
+
+  override val cacheKey = HardwareBitmapTransformation::class.java.name
+
+  override suspend fun transform(input: Bitmap, size: Size): Bitmap {
+    if (!isSupported || input.config == Bitmap.Config.HARDWARE) return input
+    // Performance-only: a failed upload (null, or an allocation/driver
+    // exception) must not fail the request, so fall back to the software
+    // bitmap either way.
+    return runCatching { input.copy(Bitmap.Config.HARDWARE, false) }.getOrNull() ?: input
+  }
+
+  override fun toString() = "HardwareBitmapTransformation"
+
+  companion object {
+    val isSupported: Boolean
+      get() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O
+
+    val instance = HardwareBitmapTransformation()
+  }
+}