expo-image 2.4.0 → 2.5.0-canary-20250729-d8899ae

package/CHANGELOG.md

@@ -6,11 +6,22 @@
 
 ### 🎉 New features
 
+- Add `generateThumbhashAsync` ([#38090](https://github.com/expo/expo/pull/38090) by [@Wenszel](https://github.com/Wenszel))
+- Add support for `ImageRef` source in `generateBlurhashAsync` ([#37901](https://github.com/expo/expo/pull/37901) by [@Wenszel](https://github.com/Wenszel))
+- [Android] Add generateBlurhashAsync ([#37817](https://github.com/expo/expo/pull/37817) by [@Wenszel](https://github.com/Wenszel))
+
 ### 🐛 Bug fixes
 
+- [Android] Fix animation resuming by casting image to GifDrawable. ([#37363](https://github.com/expo/expo/pull/37363) by [@Wenszel](https://github.com/Wenszel))
+- [Web] Fix `alt` as an alias for `accessibilityLabel` ([#37682](https://github.com/expo/expo/pull/37682) by [@huextrat](https://github.com/huextrat))
+- [iOS] Fix caching resized images from Photo Library. ([#38105](https://github.com/expo/expo/pull/38105) by [@jakex7](https://github.com/jakex7))
+- [iOS] Fix `generatePlaceholder` method syntax error by removing unwanted trailing comma. ([#38318](https://github.com/expo/expo/pull/38318) by [@bortolilucas](https://github.com/bortolilucas))
+
 ### 💡 Others
 
-## 2.4.0 — 2025-07-17
+### 📚 3rd party library updates
+
+## 2.4.0 - 2025-07-17
 
 ### 🎉 New features
 
@@ -21,13 +32,13 @@
 - [iOS] Speed up displaying local assets. ([#37795](https://github.com/expo/expo/pull/37795) by [@aleqsio](https://github.com/aleqsio))
 - [iOS] Fix some operation were incorrectly cancelled. ([#37987](https://github.com/expo/expo/pull/37987) by [@lukmccall](https://github.com/lukmccall))
 
-## 2.3.2 — 2025-07-01
+## 2.3.2 - 2025-07-01
 
 ### 🐛 Bug fixes
 
 - [iOS] Use specified cache type when no transformation is applied ([#37777](https://github.com/expo/expo/pull/37777) by [@jakex7](https://github.com/jakex7))
 
-## 2.3.1 — 2025-07-01
+## 2.3.1 - 2025-07-01
 
 ### 🐛 Bug fixes
 
@@ -37,17 +48,21 @@
 
 - [Android] Bumped GIF Glide plugin to 3.0.5 for Android 16KB page size support. ([#37454](https://github.com/expo/expo/pull/37454) by [@kudo](https://github.com/kudo))
 
-## 2.3.0 — 2025-06-11
+## 2.3.0 - 2025-06-11
 
 ### 🛠 Breaking changes
 
 - [iOS] `useAppleWebpCodec` has been moved from the source object to the component's prop to make it usable with the local assets. ([#37300](https://github.com/expo/expo/pull/37300) by [@tsapeta](https://github.com/tsapeta))
 
-## 2.2.1 — 2025-06-10
+### 🐛 Bug fixes
+
+- [iOS] Fix blurry images when using `tintColor` by scaling `imageThumbnailPixelSize` with screen density. ([#37235](https://github.com/expo/expo/pull/37235) by [@hirbod](https://github.com/hirbod))
+
+## 2.2.1 - 2025-06-10
 
 _This version does not introduce any user-facing changes._
 
-## 2.2.0 — 2025-06-04
+## 2.2.0 - 2025-06-04
 
 ### 🎉 New features
 
@@ -58,7 +73,7 @@ _This version does not introduce any user-facing changes._
 - Fix React Server Components support. ([#36801](https://github.com/expo/expo/pull/36801) by [@EvanBacon](https://github.com/EvanBacon))
 - [iOS] Fix PhotoLibrary assets being scaled twice. ([#36776](https://github.com/expo/expo/pull/36776) by [@alanjhughes](https://github.com/alanjhughes))
 - [iOS] Don't add transformers when unnecessary. ([#36884](https://github.com/expo/expo/pull/36884) by [@jakex7](https://github.com/jakex7))
-- [iOS] Fix blurry images when using `tintColor` by scaling `imageThumbnailPixelSize` with screen density. ([#37235](https://github.com/expo/expo/pull/37235) by [@hirbod](https://github.com/hirbod))
+- [Web] Fix `tintColor` in React 19. ([#37133](https://github.com/expo/expo/pull/37133) by [@bradleyayers](https://github.com/bradleyayers))
 
 ## 2.1.7 — 2025-05-06
 

package/android/build.gradle

@@ -8,7 +8,7 @@ android {
   namespace "expo.modules.image"
   defaultConfig {
     versionCode 1
-    versionName "2.4.0"
+    versionName "2.5.0-canary-20250729-d8899ae"
     consumerProguardFiles("proguard-rules.pro")
 
     buildConfigField("boolean", "ALLOW_GLIDE_LOGS", project.properties.get("EXPO_ALLOW_GLIDE_LOGS", "false"))

package/android/src/main/java/expo/modules/image/ExpoImageModule.kt

@@ -5,6 +5,8 @@ package expo.modules.image
 import android.graphics.Bitmap
 import android.graphics.drawable.BitmapDrawable
 import android.graphics.drawable.Drawable
+import android.util.Base64
+import androidx.core.graphics.drawable.toBitmap
 import androidx.core.graphics.drawable.toBitmapOrNull
 import androidx.core.view.doOnDetach
 import com.bumptech.glide.Glide
@@ -19,6 +21,7 @@ import com.bumptech.glide.request.target.Target
 import com.github.penfeizhou.animation.apng.APNGDrawable
 import com.github.penfeizhou.animation.gif.GifDrawable
 import com.github.penfeizhou.animation.webp.WebPDrawable
+import expo.modules.image.blurhash.BlurhashEncoder
 import expo.modules.image.enums.ContentFit
 import expo.modules.image.enums.Priority
 import expo.modules.image.records.CachePolicy
@@ -28,6 +31,7 @@ import expo.modules.image.records.DecodedSource
 import expo.modules.image.records.ImageLoadOptions
 import expo.modules.image.records.ImageTransition
 import expo.modules.image.records.SourceMap
+import expo.modules.image.thumbhash.ThumbhashEncoder
 import expo.modules.kotlin.Promise
 import expo.modules.kotlin.apifeatures.EitherType
 import expo.modules.kotlin.exception.Exceptions
@@ -36,8 +40,12 @@ import expo.modules.kotlin.functions.Queues
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 import expo.modules.kotlin.sharedobjects.SharedRef
+import expo.modules.kotlin.types.Either
 import expo.modules.kotlin.types.EitherOfThree
 import expo.modules.kotlin.types.toKClass
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.net.URL
 
 class ExpoImageModule : Module() {
   override fun definition() = ModuleDefinition {
@@ -112,6 +120,37 @@ class ExpoImageModule : Module() {
       ImageLoadTask(appContext, source, options ?: ImageLoadOptions()).load()
     }
 
+    suspend fun generatePlaceholder(
+      source: Either<URL, Image>,
+      encoder: (Bitmap) -> String
+    ): String {
+      val image = source.let {
+        if (it.`is`(Image::class)) {
+          it.get(Image::class)
+        } else {
+          ImageLoadTask(appContext, SourceMap(uri = it.get(URL::class).toString()), ImageLoadOptions()).load()
+        }
+      }
+      return withContext(Dispatchers.Default) {
+        encoder(image.ref.toBitmap())
+      }
+    }
+
+    AsyncFunction("generateBlurhashAsync") Coroutine { source: Either<URL, Image>, numberOfComponents: Pair<Int, Int> ->
+      generatePlaceholder(source) { bitmap ->
+        BlurhashEncoder.encode(bitmap, numberOfComponents)
+      }
+    }
+
+    AsyncFunction("generateThumbhashAsync") Coroutine { source: Either<URL, Image> ->
+      generatePlaceholder(source) { bitmap ->
+        Base64.encodeToString(
+          ThumbhashEncoder.encode(bitmap),
+          Base64.NO_WRAP
+        )
+      }
+    }
+
     Class(Image::class) {
       Property("width") { image: Image ->
         image.ref.intrinsicWidth

package/android/src/main/java/expo/modules/image/ExpoImageViewWrapper.kt

@@ -18,6 +18,7 @@ import com.bumptech.glide.RequestManager
 import com.bumptech.glide.load.engine.DiskCacheStrategy
 import com.bumptech.glide.load.resource.bitmap.DownsampleStrategy
 import com.bumptech.glide.request.RequestOptions
+import com.github.penfeizhou.animation.gif.GifDrawable
 import expo.modules.image.enums.ContentFit
 import expo.modules.image.enums.Priority
 import expo.modules.image.events.GlideRequestListener
@@ -169,14 +170,32 @@ class ExpoImageViewWrapper(context: Context, appContext: AppContext) : ExpoView(
   internal var cachePolicy: CachePolicy = CachePolicy.DISK
 
   fun setIsAnimating(setAnimating: Boolean) {
-    val resource = activeView.drawable
+    // Animatable animations always start from the beginning when resumed.
+    // So we check first if the resource is a GifDrawable, because it can continue
+    // from where it was paused.
+    when (val resource = activeView.drawable) {
+      is GifDrawable -> setIsAnimating(resource, setAnimating)
+      is Animatable -> setIsAnimating(resource, setAnimating)
+    }
+  }
 
-    if (resource is Animatable) {
-      if (setAnimating) {
-        resource.start()
+  private fun setIsAnimating(resource: GifDrawable, setAnimating: Boolean) {
+    if (setAnimating) {
+      if (resource.isPaused) {
+        resource.resume()
       } else {
-        resource.stop()
+        resource.start()
       }
+    } else {
+      resource.pause()
+    }
+  }
+
+  private fun setIsAnimating(resource: Animatable, setAnimating: Boolean) {
+    if (setAnimating) {
+      resource.start()
+    } else {
+      resource.stop()
     }
   }
 

package/android/src/main/java/expo/modules/image/blurhash/BlurhashDecoder.kt

@@ -74,16 +74,7 @@ object BlurhashDecoder {
     val r = colorEnc shr 16
     val g = (colorEnc shr 8) and 255
     val b = colorEnc and 255
-    return floatArrayOf(srgbToLinear(r), srgbToLinear(g), srgbToLinear(b))
-  }
-
-  private fun srgbToLinear(colorEnc: Int): Float {
-    val v = colorEnc / 255f
-    return if (v <= 0.04045f) {
-      (v / 12.92f)
-    } else {
-      ((v + 0.055f) / 1.055f).pow(2.4f)
-    }
+    return floatArrayOf(BlurhashHelpers.srgbToLinear(r), BlurhashHelpers.srgbToLinear(g), BlurhashHelpers.srgbToLinear(b))
   }
 
   private fun decodeAc(value: Int, maxAc: Float): FloatArray {

package/android/src/main/java/expo/modules/image/blurhash/BlurhashEncoder.kt

@@ -0,0 +1,112 @@
+package expo.modules.image.blurhash
+
+import android.graphics.Bitmap
+import android.graphics.Color
+import kotlin.math.*
+
+/**
+ * Rewritten in kotlin from https://github.com/woltapp/blurhash/blob/master/Swift/BlurHashEncode.swift
+ */
+object BlurhashEncoder {
+  fun encode(image: Bitmap, numberOfComponents: Pair<Int, Int>): String {
+    val pixels = IntArray(image.width * image.height)
+    image.getPixels(pixels, 0, image.width, 0, 0, image.width, image.height)
+
+    val factors = calculateBlurFactors(pixels, image.width, image.height, numberOfComponents)
+
+    val dc = factors.first()
+    val ac = factors.drop(1)
+    val hashBuilder = StringBuilder()
+
+    encodeFlag(numberOfComponents, hashBuilder)
+    val maximumValue = encodeMaximumValue(ac, hashBuilder)
+    hashBuilder.append(encode83(encodeDC(dc), 4))
+    for (factor in ac) {
+      hashBuilder.append(encode83(encodeAC(factor, maximumValue), 2))
+    }
+
+    return hashBuilder.toString()
+  }
+
+  private fun encodeFlag(numberOfComponents: Pair<Int, Int>, hashBuilder: StringBuilder) {
+    val sizeFlag = (numberOfComponents.first - 1) + (numberOfComponents.second - 1) * 9
+    hashBuilder.append(encode83(sizeFlag, 1))
+  }
+
+  private fun encodeMaximumValue(ac: List<Triple<Float, Float, Float>>, hash: StringBuilder): Float {
+    val maximumValue: Float
+    if (ac.isNotEmpty()) {
+      val actualMaximumValue = ac.maxOf { t -> max(max(abs(t.first), abs(t.second)), abs(t.third)) }
+      val quantisedMaximumValue = max(0f, min(82f, floor(actualMaximumValue * 166f - 0.5f))).toInt()
+      maximumValue = (quantisedMaximumValue + 1).toFloat() / 166f
+      hash.append(encode83(quantisedMaximumValue, 1))
+    } else {
+      maximumValue = 1f
+      hash.append(encode83(0, 1))
+    }
+    return maximumValue
+  }
+
+  private fun calculateBlurFactors(pixels: IntArray, width: Int, height: Int, numberOfComponents: Pair<Int, Int>): List<Triple<Float, Float, Float>> {
+    val factors = mutableListOf<Triple<Float, Float, Float>>()
+    for (y in 0 until numberOfComponents.second) {
+      for (x in 0 until numberOfComponents.first) {
+        val normalisation = if (x == 0 && y == 0) 1f else 2f
+        val factor = multiplyBasisFunction(pixels, width, height, x, y, normalisation)
+        factors.add(factor)
+      }
+    }
+    return factors
+  }
+
+  private fun encode83(value: Int, length: Int): String {
+    var result = ""
+    for (i in 1..length) {
+      val digit = (value / 83f.pow((length - i).toFloat())) % 83f
+      result += ENCODE_CHARACTERS[digit.toInt()]
+    }
+    return result
+  }
+
+  private const val ENCODE_CHARACTERS =
+    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~"
+
+  private fun encodeDC(value: Triple<Float, Float, Float>): Int {
+    val roundedR = BlurhashHelpers.linearTosRGB(value.first)
+    val roundedG = BlurhashHelpers.linearTosRGB(value.second)
+    val roundedB = BlurhashHelpers.linearTosRGB(value.third)
+    return (roundedR shl 16) + (roundedG shl 8) + roundedB
+  }
+
+  private fun encodeAC(value: Triple<Float, Float, Float>, maximumValue: Float): Int {
+    val quantR = max(0f, min(18f, floor(BlurhashHelpers.signPow(value.first / maximumValue, 0.5f) * 9f + 9.5f)))
+    val quantG = max(0f, min(18f, floor(BlurhashHelpers.signPow(value.second / maximumValue, 0.5f) * 9f + 9.5f)))
+    val quantB = max(0f, min(18f, floor(BlurhashHelpers.signPow(value.third / maximumValue, 0.5f) * 9f + 9.5f)))
+
+    return (quantR * 19f * 19f + quantG * 19f + quantB).toInt()
+  }
+
+  private fun multiplyBasisFunction(pixels: IntArray, width: Int, height: Int, x: Int, y: Int, normalisation: Float): Triple<Float, Float, Float> {
+    var r = 0f
+    var g = 0f
+    var b = 0f
+
+    for (j in 0 until height) {
+      for (i in 0 until width) {
+        val basis = normalisation * cos(PI.toFloat() * x * i / width) * cos(PI.toFloat() * y * j / height)
+
+        val pixel = pixels[i + j * width]
+        val pr = BlurhashHelpers.srgbToLinear(Color.red(pixel))
+        val pg = BlurhashHelpers.srgbToLinear(Color.green(pixel))
+        val pb = BlurhashHelpers.srgbToLinear(Color.blue(pixel))
+
+        r += basis * pr
+        g += basis * pg
+        b += basis * pb
+      }
+    }
+
+    val scale = 1f / (width * height)
+    return Triple(r * scale, g * scale, b * scale)
+  }
+}

package/android/src/main/java/expo/modules/image/blurhash/BlurhashHelpers.kt

@@ -0,0 +1,38 @@
+package expo.modules.image.blurhash
+
+import android.graphics.Bitmap
+import kotlin.math.*
+
+object BlurhashHelpers {
+  fun srgbToLinear(colorEnc: Int): Float {
+    val v = colorEnc / 255f
+    return if (v <= 0.04045f) {
+      (v / 12.92f)
+    } else {
+      ((v + 0.055f) / 1.055f).pow(2.4f)
+    }
+  }
+
+  fun linearTosRGB(value: Float): Int {
+    val v = max(0f, min(1f, value))
+    return if (v <= 0.0031308) {
+      (v * 12.92 * 255 + 0.5).toInt()
+    } else {
+      (1.055 * (v.pow(1f / 2.4f) - 0.055) * 255 + 0.5).toInt()
+    }
+  }
+
+  fun signPow(value: Float, exp: Float): Float {
+    return abs(value).pow(exp) * sign(value)
+  }
+
+  fun getBitsPerPixel(bitmap: Bitmap): Int {
+    return when (bitmap.config) {
+      Bitmap.Config.ARGB_8888 -> 32
+      Bitmap.Config.RGB_565 -> 16
+      Bitmap.Config.ALPHA_8 -> 8
+      Bitmap.Config.ARGB_4444 -> 16
+      else -> 0
+    }
+  }
+}

package/android/src/main/java/expo/modules/image/okhttp/GlideUrlWrapperLoader.kt

@@ -28,7 +28,7 @@ class GlideUrlWrapperLoader(
             originalResponse
               .newBuilder()
               .body(
-                ProgressResponseBody(originalResponse.body) { bytesWritten, contentLength, done ->
+                ProgressResponseBody(requireNotNull(originalResponse.body)) { bytesWritten, contentLength, done ->
                   model.progressListener?.onProgress(bytesWritten, contentLength, done)
                 }
               )

package/android/src/main/java/expo/modules/image/thumbhash/ThumbhashDecoder.kt

@@ -5,113 +5,6 @@ import android.graphics.Color
 
 // ThumbHash Java implementation (converted to kotlin) thanks to @evanw https://github.com/evanw/thumbhash
 object ThumbhashDecoder {
-  /**
-   * Encodes an RGBA image to a ThumbHash. RGB should not be premultiplied by A.
-   *
-   * @param w    The width of the input image. Must be ≤100px.
-   * @param h    The height of the input image. Must be ≤100px.
-   * @param rgba The pixels in the input image, row-by-row. Must have w*h*4 elements.
-   * @return The ThumbHash as a byte array.
-   */
-  fun rgbaToThumbHash(w: Int, h: Int, rgba: ByteArray): ByteArray {
-    // Encoding an image larger than 100x100 is slow with no benefit
-    require(!(w > 100 || h > 100)) { w.toString() + "x" + h + " doesn't fit in 100x100" }
-
-    // Determine the average color
-    var avg_r = 0f
-    var avg_g = 0f
-    var avg_b = 0f
-    var avg_a = 0f
-    var i = 0
-    var j = 0
-    while (i < w * h) {
-      val alpha = (rgba[j + 3].toInt() and 255) / 255.0f
-      avg_r += alpha / 255.0f * (rgba[j].toInt() and 255)
-      avg_g += alpha / 255.0f * (rgba[j + 1].toInt() and 255)
-      avg_b += alpha / 255.0f * (rgba[j + 2].toInt() and 255)
-      avg_a += alpha
-      i++
-      j += 4
-    }
-
-    if (avg_a > 0) {
-      avg_r /= avg_a
-      avg_g /= avg_a
-      avg_b /= avg_a
-    }
-    val hasAlpha = avg_a < w * h
-    val l_limit = if (hasAlpha) 5 else 7 // Use fewer luminance bits if there's alpha
-    val lx = Math.max(1, Math.round((l_limit * w).toFloat() / Math.max(w, h).toFloat()))
-    val ly = Math.max(1, Math.round((l_limit * h).toFloat() / Math.max(w, h).toFloat()))
-    val l = FloatArray(w * h) // luminance
-    val p = FloatArray(w * h) // yellow - blue
-    val q = FloatArray(w * h) // red - green
-    val a = FloatArray(w * h) // alpha
-
-    // Convert the image from RGBA to LPQA (composite atop the average color)
-    i = 0
-    j = 0
-    while (i < w * h) {
-      val alpha = (rgba[j + 3].toInt() and 255) / 255.0f
-      val r = avg_r * (1.0f - alpha) + alpha / 255.0f * (rgba[j].toInt() and 255)
-      val g = avg_g * (1.0f - alpha) + alpha / 255.0f * (rgba[j + 1].toInt() and 255)
-      val b = avg_b * (1.0f - alpha) + alpha / 255.0f * (rgba[j + 2].toInt() and 255)
-      l[i] = (r + g + b) / 3.0f
-      p[i] = (r + g) / 2.0f - b
-      q[i] = r - g
-      a[i] = alpha
-      i++
-      j += 4
-    }
-
-    // Encode using the DCT into DC (constant) and normalized AC (varying) terms
-    val l_channel = Channel(Math.max(3, lx), Math.max(3, ly)).encode(w, h, l)
-    val p_channel = Channel(3, 3).encode(w, h, p)
-    val q_channel = Channel(3, 3).encode(w, h, q)
-    val a_channel = if (hasAlpha) Channel(5, 5).encode(w, h, a) else null
-
-    // Write the constants
-    val isLandscape = w > h
-    val header24 = (
-      Math.round(63.0f * l_channel.dc)
-        or (Math.round(31.5f + 31.5f * p_channel.dc) shl 6)
-        or (Math.round(31.5f + 31.5f * q_channel.dc) shl 12)
-        or (Math.round(31.0f * l_channel.scale) shl 18)
-        or if (hasAlpha) 1 shl 23 else 0
-      )
-    val header16 = (
-      (if (isLandscape) ly else lx)
-        or (Math.round(63.0f * p_channel.scale) shl 3)
-        or (Math.round(63.0f * q_channel.scale) shl 9)
-        or if (isLandscape) 1 shl 15 else 0
-      )
-    val ac_start = if (hasAlpha) 6 else 5
-    val ac_count = (
-      l_channel.ac.size + p_channel.ac.size + q_channel.ac.size +
-        if (hasAlpha) a_channel!!.ac.size else 0
-      )
-    val hash = ByteArray(ac_start + (ac_count + 1) / 2)
-    hash[0] = header24.toByte()
-    hash[1] = (header24 shr 8).toByte()
-    hash[2] = (header24 shr 16).toByte()
-    hash[3] = header16.toByte()
-    hash[4] = (header16 shr 8).toByte()
-    if (hasAlpha) {
-      hash[5] = (
-        Math.round(15.0f * a_channel!!.dc)
-          or (Math.round(15.0f * a_channel.scale) shl 4)
-        ).toByte()
-    }
-
-    // Write the varying factors
-    var ac_index = 0
-    ac_index = l_channel.writeTo(hash, ac_start, ac_index)
-    ac_index = p_channel.writeTo(hash, ac_start, ac_index)
-    ac_index = q_channel.writeTo(hash, ac_start, ac_index)
-    if (hasAlpha) a_channel!!.writeTo(hash, ac_start, ac_index)
-    return hash
-  }
-
   /**
    * Decodes a ThumbHash to an RGBA image. RGB is not be premultiplied by A.
    *
@@ -302,11 +195,8 @@ object ThumbhashDecoder {
 
   class Image(var width: Int, var height: Int, var rgba: ByteArray)
   class RGBA(var r: Float, var g: Float, var b: Float, var a: Float)
-  private class Channel internal constructor(var nx: Int, var ny: Int) {
-    var dc = 0f
+  private class Channel(nx: Int, ny: Int) {
     var ac: FloatArray
-    var scale = 0f
-
     init {
       var n = 0
       for (cy in 0 until ny) {
@@ -319,32 +209,6 @@ object ThumbhashDecoder {
       ac = FloatArray(n)
     }
 
-    fun encode(w: Int, h: Int, channel: FloatArray): Channel {
-      var n = 0
-      val fx = FloatArray(w)
-      for (cy in 0 until ny) {
-        var cx = 0
-        while (cx * ny < nx * (ny - cy)) {
-          var f = 0f
-          for (x in 0 until w) fx[x] = Math.cos(Math.PI / w * cx * (x + 0.5f)).toFloat()
-          for (y in 0 until h) {
-            val fy = Math.cos(Math.PI / h * cy * (y + 0.5f)).toFloat()
-            for (x in 0 until w) f += channel[x + y * w] * fx[x] * fy
-          }
-          f /= (w * h).toFloat()
-          if (cx > 0 || cy > 0) {
-            ac[n++] = f
-            scale = Math.max(scale, Math.abs(f))
-          } else {
-            dc = f
-          }
-          cx++
-        }
-      }
-      if (scale > 0) for (i in ac.indices) ac[i] = 0.5f + 0.5f / scale * ac[i]
-      return this
-    }
-
     fun decode(hash: ByteArray, start: Int, index: Int, scale: Float): Int {
       var currentIndex = index
       for (i in ac.indices) {
@@ -354,14 +218,5 @@ object ThumbhashDecoder {
       }
       return currentIndex
     }
-
-    fun writeTo(hash: ByteArray, start: Int, index: Int): Int {
-      var currentIndex = index
-      for (v in ac) {
-        hash[start + (currentIndex shr 1)] = (hash[start + (currentIndex shr 1)].toInt() or (Math.round(15.0f * v) shl (currentIndex and 1 shl 2))).toByte()
-        currentIndex++
-      }
-      return currentIndex
-    }
   }
 }