react-native-fast-image 10.1.1 → 10.2.0

package/dist/thumbhash.js

@@ -0,0 +1,240 @@
+//#region src/thumbhash.ts
+const cache = /* @__PURE__ */ new Map();
+const CACHE_SIZE = 256;
+/**
+* Makes a source's `blurDataUri` from a ThumbHash, e.g. on your server, so
+* the page shows the preview without any JavaScript. Undefined for an invalid
+* hash. Works in browsers, Node and React Native.
+*
+* @example
+* ```js
+* // e.g. on your server, so the page shows the preview without any JavaScript
+* const source = { uri: photo.url, blurDataUri: thumbHashToBlurDataUri(photo.thumbhash) }
+* ```
+*/
+function thumbHashToBlurDataUri(thumbhash) {
+	if (!thumbhash) return void 0;
+	if (cache.has(thumbhash)) {
+		const uri = cache.get(thumbhash);
+		cache.delete(thumbhash);
+		cache.set(thumbhash, uri);
+		return uri;
+	}
+	const hash = base64Bytes(thumbhash);
+	const image = hash ? thumbHashToRGBA(hash) : void 0;
+	const small = image ? shrink(image.w, image.h, image.rgba, 8) : void 0;
+	const uri = small ? rgbaToDataURL(small.w, small.h, small.rgba) : void 0;
+	if (cache.size >= CACHE_SIZE) cache.delete(cache.keys().next().value);
+	cache.set(thumbhash, uri);
+	return uri;
+}
+globalThis[Symbol.for("react-native-fast-image/thumbhash")] = thumbHashToBlurDataUri;
+function shrink(w, h, rgba, max) {
+	const scale = Math.max(w, h) / max;
+	if (scale <= 1) return {
+		w,
+		h,
+		rgba
+	};
+	const sw = Math.max(1, Math.round(w / scale));
+	const sh = Math.max(1, Math.round(h / scale));
+	const out = new Uint8Array(sw * sh * 4);
+	for (let y = 0; y < sh; y++) {
+		const y0 = Math.floor(y * h / sh);
+		const y1 = Math.floor((y + 1) * h / sh);
+		for (let x = 0; x < sw; x++) {
+			const x0 = Math.floor(x * w / sw);
+			const x1 = Math.floor((x + 1) * w / sw);
+			for (let c = 0; c < 4; c++) {
+				let sum = 0;
+				for (let yy = y0; yy < y1; yy++) for (let xx = x0; xx < x1; xx++) sum += rgba[(yy * w + xx) * 4 + c];
+				out[(y * sw + x) * 4 + c] = Math.round(sum / ((y1 - y0) * (x1 - x0)));
+			}
+		}
+	}
+	return {
+		w: sw,
+		h: sh,
+		rgba: out
+	};
+}
+function base64Bytes(base64) {
+	const standard = base64.trim().replace(/-/g, "+").replace(/_/g, "/");
+	if (!/^[A-Za-z0-9+/]*=*$/.test(standard)) return void 0;
+	try {
+		const binary = atob(standard.replace(/=+$/, "") + "=".repeat((4 - standard.replace(/=+$/, "").length % 4) % 4));
+		return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+	} catch {
+		return;
+	}
+}
+function count(nx, ny) {
+	let n = 0;
+	for (let cy = 0; cy < ny; cy++) for (let cx = cy ? 0 : 1; cx * ny < nx * (ny - cy); cx++) n++;
+	return n;
+}
+function thumbHashToRGBA(hash) {
+	const { PI, min, max, cos, round } = Math;
+	if (hash.length < 5) return void 0;
+	const header24 = hash[0] | hash[1] << 8 | hash[2] << 16;
+	const header16 = hash[3] | hash[4] << 8;
+	const l_dc = (header24 & 63) / 63;
+	const p_dc = (header24 >> 6 & 63) / 31.5 - 1;
+	const q_dc = (header24 >> 12 & 63) / 31.5 - 1;
+	const l_scale = (header24 >> 18 & 31) / 31;
+	const hasAlpha = header24 >> 23;
+	const p_scale = (header16 >> 3 & 63) / 63;
+	const q_scale = (header16 >> 9 & 63) / 63;
+	const isLandscape = header16 >> 15;
+	const lx = max(3, isLandscape ? hasAlpha ? 5 : 7 : header16 & 7);
+	const ly = max(3, isLandscape ? header16 & 7 : hasAlpha ? 5 : 7);
+	const ac_start = hasAlpha ? 6 : 5;
+	const ac_count = count(lx, ly) + 2 * count(3, 3) + (hasAlpha ? count(5, 5) : 0);
+	if (hash.length < ac_start + Math.ceil(ac_count / 2)) return void 0;
+	const a_dc = hasAlpha ? (hash[5] & 15) / 15 : 1;
+	const a_scale = (hash[5] >> 4) / 15;
+	let ac_index = 0;
+	const decodeChannel = (nx, ny, scale) => {
+		const ac = [];
+		for (let cy = 0; cy < ny; cy++) for (let cx = cy ? 0 : 1; cx * ny < nx * (ny - cy); cx++) ac.push(((hash[ac_start + (ac_index >> 1)] >> ((ac_index++ & 1) << 2) & 15) / 7.5 - 1) * scale);
+		return ac;
+	};
+	const l_ac = decodeChannel(lx, ly, l_scale);
+	const p_ac = decodeChannel(3, 3, p_scale * 1.25);
+	const q_ac = decodeChannel(3, 3, q_scale * 1.25);
+	const a_ac = hasAlpha ? decodeChannel(5, 5, a_scale) : [];
+	const ratio = thumbHashToApproximateAspectRatio(hash);
+	const w = max(1, round(ratio > 1 ? 32 : 32 * ratio));
+	const h = max(1, round(ratio > 1 ? 32 / ratio : 32));
+	const rgba = new Uint8Array(w * h * 4);
+	const fx = [];
+	const fy = [];
+	for (let y = 0, i = 0; y < h; y++) for (let x = 0; x < w; x++, i += 4) {
+		let l = l_dc, p = p_dc, q = q_dc, a = a_dc;
+		for (let cx = 0, n = max(lx, hasAlpha ? 5 : 3); cx < n; cx++) fx[cx] = cos(PI / w * (x + .5) * cx);
+		for (let cy = 0, n = max(ly, hasAlpha ? 5 : 3); cy < n; cy++) fy[cy] = cos(PI / h * (y + .5) * cy);
+		for (let cy = 0, j = 0; cy < ly; cy++) for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx * ly < lx * (ly - cy); cx++, j++) l += l_ac[j] * fx[cx] * fy2;
+		for (let cy = 0, j = 0; cy < 3; cy++) for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 3 - cy; cx++, j++) {
+			const f = fx[cx] * fy2;
+			p += p_ac[j] * f;
+			q += q_ac[j] * f;
+		}
+		if (hasAlpha) for (let cy = 0, j = 0; cy < 5; cy++) for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 5 - cy; cx++, j++) a += a_ac[j] * fx[cx] * fy2;
+		const b = l - 2 / 3 * p;
+		const r = (3 * l - b + q) / 2;
+		const g = r - q;
+		rgba[i] = max(0, 255 * min(1, r));
+		rgba[i + 1] = max(0, 255 * min(1, g));
+		rgba[i + 2] = max(0, 255 * min(1, b));
+		rgba[i + 3] = max(0, 255 * min(1, a));
+	}
+	return {
+		w,
+		h,
+		rgba
+	};
+}
+function thumbHashToApproximateAspectRatio(hash) {
+	const header = hash[3];
+	const hasAlpha = hash[2] & 128;
+	const isLandscape = hash[4] & 128;
+	const lx = isLandscape ? hasAlpha ? 5 : 7 : header & 7;
+	const ly = isLandscape ? header & 7 : hasAlpha ? 5 : 7;
+	return ly ? lx / ly : 1;
+}
+function rgbaToDataURL(w, h, rgba) {
+	const row = w * 4 + 1;
+	const idat = 6 + h * (5 + row);
+	const bytes = [
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10,
+		0,
+		0,
+		0,
+		13,
+		73,
+		72,
+		68,
+		82,
+		0,
+		0,
+		w >> 8,
+		w & 255,
+		0,
+		0,
+		h >> 8,
+		h & 255,
+		8,
+		6,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		idat >>> 24,
+		idat >> 16 & 255,
+		idat >> 8 & 255,
+		idat & 255,
+		73,
+		68,
+		65,
+		84,
+		120,
+		1
+	];
+	const table = [
+		0,
+		498536548,
+		997073096,
+		651767980,
+		1994146192,
+		1802195444,
+		1303535960,
+		1342533948,
+		-306674912,
+		-267414716,
+		-690576408,
+		-882789492,
+		-1687895376,
+		-2032938284,
+		-1609899400,
+		-1111625188
+	];
+	let a = 1, b = 0;
+	for (let y = 0, i = 0, end = row - 1; y < h; y++, end += row - 1) {
+		bytes.push(y + 1 < h ? 0 : 1, row & 255, row >> 8, ~row & 255, row >> 8 ^ 255, 0);
+		for (b = (b + a) % 65521; i < end; i++) {
+			const u = rgba[i] & 255;
+			bytes.push(u);
+			a = (a + u) % 65521;
+			b = (b + a) % 65521;
+		}
+	}
+	bytes.push(b >> 8, b & 255, a >> 8, a & 255, 0, 0, 0, 0, 0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130);
+	for (let [start, end] of [[12, 29], [37, 41 + idat]]) {
+		let c = -1;
+		for (let i = start; i < end; i++) {
+			c ^= bytes[i];
+			c = c >>> 4 ^ table[c & 15];
+			c = c >>> 4 ^ table[c & 15];
+		}
+		c = ~c;
+		bytes[end++] = c >>> 24;
+		bytes[end++] = c >> 16 & 255;
+		bytes[end++] = c >> 8 & 255;
+		bytes[end++] = c & 255;
+	}
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return "data:image/png;base64," + btoa(binary);
+}
+//#endregion
+export { thumbHashToBlurDataUri };

package/ios/FastImage/FFFBoxBlur.h

@@ -0,0 +1,7 @@
+#import <CoreGraphics/CoreGraphics.h>
+
+// Blurs a bitmap context's pixels in place (8 bits per channel, 4 channels in
+// any order, premultiplied if it has alpha): a box blur of boxSize (odd)
+// three times, close to a Gaussian blur, with the edges extended outwards.
+// For blurRadius and for a source's blurDataUri.
+void FFFBoxBlur(CGContextRef context, uint32_t boxSize);

package/ios/FastImage/FFFBoxBlur.m

@@ -0,0 +1,29 @@
+#import "FFFBoxBlur.h"
+#import <Accelerate/Accelerate.h>
+
+void FFFBoxBlur(CGContextRef context, uint32_t boxSize)
+{
+    if (boxSize <= 1) {
+        return;
+    }
+    size_t height = CGBitmapContextGetHeight(context);
+    vImage_Buffer buffer = {
+        .data = CGBitmapContextGetData(context),
+        .height = height,
+        .width = CGBitmapContextGetWidth(context),
+        .rowBytes = CGBitmapContextGetBytesPerRow(context),
+    };
+    vImage_Buffer other = buffer;
+    other.data = malloc(buffer.rowBytes * height);
+    vImage_Error tempSize = vImageBoxConvolve_ARGB8888(&buffer, &other, NULL, 0, 0, boxSize, boxSize, NULL,
+                                                       kvImageGetTempBufferSize | kvImageEdgeExtend);
+    void* temp = tempSize > 0 ? malloc(tempSize) : NULL;
+    if (other.data && temp) {
+        vImageBoxConvolve_ARGB8888(&buffer, &other, temp, 0, 0, boxSize, boxSize, NULL, kvImageEdgeExtend);
+        vImageBoxConvolve_ARGB8888(&other, &buffer, temp, 0, 0, boxSize, boxSize, NULL, kvImageEdgeExtend);
+        vImageBoxConvolve_ARGB8888(&buffer, &other, temp, 0, 0, boxSize, boxSize, NULL, kvImageEdgeExtend);
+        memcpy(buffer.data, other.data, buffer.rowBytes * height);
+    }
+    free(other.data);
+    free(temp);
+}

package/ios/FastImage/FFFThumbHash.h

@@ -0,0 +1,24 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// A source's `thumbhash` (https://evanw.github.io/thumbhash/) decoded into the
+// placeholder it shows while its image loads: at most 32 × 32 pixels, which
+// the view scales up smoothly. Decoding takes well under a millisecond, so it
+// happens as the view picks its source; recent ones are cached by their hash.
+// Also a source's `blurDataUri`: a data uri's few pixels, scaled up to the
+// same size and blurred.
+@interface FFFThumbHash : NSObject
+
+// A source's placeholder: its blurDataUri's (PNG, JPEG, WebP, a GIF's first
+// frame; nil for one iOS doesn't decode, e.g. an SVG), or its ThumbHash's.
+// Main thread.
++ (nullable UIImage*) imageForPlaceholder: (nullable NSString*)placeholder;
+
+// The placeholder for a base64 ThumbHash (standard or url-safe, with or
+// without padding), or nil for an empty or invalid one. Main thread.
++ (nullable UIImage*) imageForThumbHash: (nullable NSString*)thumbhash;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/FastImage/FFFThumbHash.m

@@ -0,0 +1,269 @@
+#import "FFFThumbHash.h"
+#import "FFFBoxBlur.h"
+#include <math.h>
+
+// FFFThumbHashToRGBA is Evan Wallace's reference decoder
+// (https://github.com/evanw/thumbhash, thumbHashToRGBA in java/ and js/) in C,
+// with a check that the hash is long enough for what its header says it
+// holds:
+//
+// Copyright (c) 2023 Evan Wallace
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+// How many AC factors a channel of nx × ny has.
+static int FFFThumbHashCount(int nx, int ny) {
+    int n = 0;
+    for (int cy = 0; cy < ny; cy++)
+        for (int cx = cy > 0 ? 0 : 1; cx * ny < nx * (ny - cy); cx++)
+            n++;
+    return n;
+}
+
+static void FFFThumbHashDecodeChannel(const uint8_t* hash, int start, int* index, int nx, int ny, float scale, float* ac) {
+    int n = FFFThumbHashCount(nx, ny);
+    for (int i = 0; i < n; i++) {
+        int data = hash[start + (*index >> 1)] >> ((*index & 1) << 2);
+        ac[i] = ((float) (data & 15) / 7.5f - 1.0f) * scale;
+        (*index)++;
+    }
+}
+
+static uint8_t FFFThumbHashChannel(float value) {
+    return (uint8_t) fmaxf(0, roundf(255.0f * fminf(1, value)));
+}
+
+// The hash decoded as unpremultiplied RGBA (malloc'd, the caller frees it),
+// with its width and height, or NULL if it's too short.
+static uint8_t* FFFThumbHashToRGBA(const uint8_t* hash, NSUInteger length, int* width, int* height) {
+    if (length < 5) {
+        return NULL;
+    }
+    // Read the constants
+    int header24 = hash[0] | (hash[1] << 8) | (hash[2] << 16);
+    int header16 = hash[3] | (hash[4] << 8);
+    float l_dc = (float) (header24 & 63) / 63.0f;
+    float p_dc = (float) ((header24 >> 6) & 63) / 31.5f - 1.0f;
+    float q_dc = (float) ((header24 >> 12) & 63) / 31.5f - 1.0f;
+    float l_scale = (float) ((header24 >> 18) & 31) / 31.0f;
+    BOOL hasAlpha = (header24 >> 23) != 0;
+    float p_scale = (float) ((header16 >> 3) & 63) / 63.0f;
+    float q_scale = (float) ((header16 >> 9) & 63) / 63.0f;
+    BOOL isLandscape = (header16 >> 15) != 0;
+    int lx = MAX(3, isLandscape ? (hasAlpha ? 5 : 7) : header16 & 7);
+    int ly = MAX(3, isLandscape ? header16 & 7 : (hasAlpha ? 5 : 7));
+    int ac_start = hasAlpha ? 6 : 5;
+    int l_count = FFFThumbHashCount(lx, ly);
+    int pq_count = FFFThumbHashCount(3, 3);
+    int a_count = hasAlpha ? FFFThumbHashCount(5, 5) : 0;
+    if (length < (NSUInteger) (ac_start + (l_count + 2 * pq_count + a_count + 1) / 2)) {
+        return NULL;
+    }
+    float a_dc = hasAlpha ? (float) (hash[5] & 15) / 15.0f : 1.0f;
+    float a_scale = hasAlpha ? (float) ((hash[5] >> 4) & 15) / 15.0f : 0;
+
+    // Read the varying factors (boost saturation by 1.25x to compensate for quantization)
+    float l_ac[64], p_ac[16], q_ac[16], a_ac[32];
+    int ac_index = 0;
+    FFFThumbHashDecodeChannel(hash, ac_start, &ac_index, lx, ly, l_scale, l_ac);
+    FFFThumbHashDecodeChannel(hash, ac_start, &ac_index, 3, 3, p_scale * 1.25f, p_ac);
+    FFFThumbHashDecodeChannel(hash, ac_start, &ac_index, 3, 3, q_scale * 1.25f, q_ac);
+    if (hasAlpha) {
+        FFFThumbHashDecodeChannel(hash, ac_start, &ac_index, 5, 5, a_scale, a_ac);
+    }
+
+    // Decode using the DCT into RGB
+    int ratio_lx = isLandscape ? (hasAlpha ? 5 : 7) : header16 & 7;
+    int ratio_ly = isLandscape ? header16 & 7 : (hasAlpha ? 5 : 7);
+    float ratio = ratio_ly > 0 ? (float) ratio_lx / (float) ratio_ly : 1;
+    int w = MAX(1, (int) roundf(ratio > 1.0f ? 32.0f : 32.0f * ratio));
+    int h = MAX(1, (int) roundf(ratio > 1.0f ? 32.0f / ratio : 32.0f));
+    uint8_t* rgba = malloc((size_t) w * h * 4);
+    if (!rgba) {
+        return NULL;
+    }
+    int cx_stop = MAX(lx, hasAlpha ? 5 : 3);
+    int cy_stop = MAX(ly, hasAlpha ? 5 : 3);
+    float fx[8], fy[8];
+    for (int y = 0, i = 0; y < h; y++) {
+        for (int x = 0; x < w; x++, i += 4) {
+            float l = l_dc, p = p_dc, q = q_dc, a = a_dc;
+
+            // Precompute the coefficients
+            for (int cx = 0; cx < cx_stop; cx++)
+                fx[cx] = (float) cos(M_PI / w * (x + 0.5f) * cx);
+            for (int cy = 0; cy < cy_stop; cy++)
+                fy[cy] = (float) cos(M_PI / h * (y + 0.5f) * cy);
+
+            // Decode L
+            for (int cy = 0, j = 0; cy < ly; cy++) {
+                float fy2 = fy[cy] * 2.0f;
+                for (int cx = cy > 0 ? 0 : 1; cx * ly < lx * (ly - cy); cx++, j++)
+                    l += l_ac[j] * fx[cx] * fy2;
+            }
+
+            // Decode P and Q
+            for (int cy = 0, j = 0; cy < 3; cy++) {
+                float fy2 = fy[cy] * 2.0f;
+                for (int cx = cy > 0 ? 0 : 1; cx < 3 - cy; cx++, j++) {
+                    float f = fx[cx] * fy2;
+                    p += p_ac[j] * f;
+                    q += q_ac[j] * f;
+                }
+            }
+
+            // Decode A
+            if (hasAlpha)
+                for (int cy = 0, j = 0; cy < 5; cy++) {
+                    float fy2 = fy[cy] * 2.0f;
+                    for (int cx = cy > 0 ? 0 : 1; cx < 5 - cy; cx++, j++)
+                        a += a_ac[j] * fx[cx] * fy2;
+                }
+
+            // Convert to RGB
+            float b = l - 2.0f / 3.0f * p;
+            float r = (3.0f * l - b + q) / 2.0f;
+            float g = r - q;
+            rgba[i] = FFFThumbHashChannel(r);
+            rgba[i + 1] = FFFThumbHashChannel(g);
+            rgba[i + 2] = FFFThumbHashChannel(b);
+            rgba[i + 3] = FFFThumbHashChannel(a);
+        }
+    }
+    *width = w;
+    *height = h;
+    return rgba;
+}
+
+// A blurDataUri's image scaled so its longer side is 32 px (a ThumbHash's
+// size) and blurred by about half of one of its pixels, so that a few pixels
+// scale up smoothly instead of in steps: a box blur three times each way
+// (about a Gaussian), on premultiplied colors, the edges extended outwards.
+static UIImage* FFFBlurredPreview(UIImage* image) {
+    CGImageRef source = image.CGImage;
+    if (!source) {
+        return nil;
+    }
+    size_t width = CGImageGetWidth(source), height = CGImageGetHeight(source);
+    if (width == 0 || height == 0) {
+        return nil;
+    }
+    float scale = 32.0f / MAX(width, height);
+    int w = MAX(1, (int) lroundf(width * scale)), h = MAX(1, (int) lroundf(height * scale));
+    int radius = MAX(1, (int) lroundf(scale / 2));
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
+    CGContextRef context = CGBitmapContextCreate(NULL, w, h, 8, w * 4, colorSpace,
+                                                 kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
+    CGColorSpaceRelease(colorSpace);
+    if (!context) {
+        return nil;
+    }
+    CGContextSetInterpolationQuality(context, kCGInterpolationHigh);
+    CGContextDrawImage(context, CGRectMake(0, 0, w, h), source);
+    FFFBoxBlur(context, 2 * radius + 1);
+    CGImageRef blurred = CGBitmapContextCreateImage(context);
+    CGContextRelease(context);
+    if (!blurred) {
+        return nil;
+    }
+    UIImage* result = [UIImage imageWithCGImage: blurred scale: 1 orientation: UIImageOrientationUp];
+    CGImageRelease(blurred);
+    return result;
+}
+
+@implementation FFFThumbHash
+
++ (NSCache<NSString*, UIImage*>*) cache {
+    static NSCache* cache;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        cache = [NSCache new];
+        // Recent placeholders, at most 4 KB each.
+        cache.countLimit = 256;
+    });
+    return cache;
+}
+
++ (UIImage*) imageForPlaceholder: (NSString*)placeholder {
+    if ([placeholder rangeOfString: @"data:" options: NSCaseInsensitiveSearch | NSAnchoredSearch].location == NSNotFound) {
+        return [self imageForThumbHash: placeholder];
+    }
+    UIImage* cached = [[self cache] objectForKey: placeholder];
+    if (cached) {
+        return cached;
+    }
+    NSURL* url = [NSURL URLWithString: placeholder];
+    NSData* data = url ? [NSData dataWithContentsOfURL: url] : nil;
+    UIImage* decoded = data ? [UIImage imageWithData: data scale: 1] : nil;
+    UIImage* image = decoded ? FFFBlurredPreview(decoded) : nil;
+    if (image) {
+        [[self cache] setObject: image forKey: placeholder];
+    }
+    return image;
+}
+
++ (UIImage*) imageForThumbHash: (NSString*)thumbhash {
+    if (thumbhash.length == 0) {
+        return nil;
+    }
+    UIImage* cached = [[self cache] objectForKey: thumbhash];
+    if (cached) {
+        return cached;
+    }
+    NSMutableString* base64 = [[thumbhash stringByTrimmingCharactersInSet: [NSCharacterSet whitespaceAndNewlineCharacterSet]] mutableCopy];
+    [base64 replaceOccurrencesOfString: @"-" withString: @"+" options: 0 range: NSMakeRange(0, base64.length)];
+    [base64 replaceOccurrencesOfString: @"_" withString: @"/" options: 0 range: NSMakeRange(0, base64.length)];
+    while (base64.length % 4 != 0) {
+        [base64 appendString: @"="];
+    }
+    NSData* hash = [[NSData alloc] initWithBase64EncodedString: base64 options: 0];
+    if (!hash) {
+        return nil;
+    }
+    int width = 0, height = 0;
+    uint8_t* rgba = FFFThumbHashToRGBA(hash.bytes, hash.length, &width, &height);
+    if (!rgba) {
+        return nil;
+    }
+    // Premultiplied, as Core Graphics draws it.
+    for (int i = 0; i < width * height * 4; i += 4) {
+        int alpha = rgba[i + 3];
+        rgba[i] = (uint8_t) ((rgba[i] * alpha + 127) / 255);
+        rgba[i + 1] = (uint8_t) ((rgba[i + 1] * alpha + 127) / 255);
+        rgba[i + 2] = (uint8_t) ((rgba[i + 2] * alpha + 127) / 255);
+    }
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
+    CGContextRef context = CGBitmapContextCreate(rgba, width, height, 8, width * 4, colorSpace,
+                                                 kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
+    CGImageRef cgImage = context ? CGBitmapContextCreateImage(context) : NULL;
+    if (context) {
+        CGContextRelease(context);
+    }
+    CGColorSpaceRelease(colorSpace);
+    free(rgba);
+    if (!cgImage) {
+        return nil;
+    }
+    UIImage* image = [UIImage imageWithCGImage: cgImage scale: 1 orientation: UIImageOrientationUp];
+    CGImageRelease(cgImage);
+    [[self cache] setObject: image forKey: thumbhash];
+    return image;
+}
+
+@end

package/ios/FastImage/FFFastImageView.h

@@ -32,7 +32,13 @@ typedef NS_ENUM(NSInteger, FFFObjectFit) {
 // Several sources (2 or more) of the same image at different sizes: the view
 // loads the one whose size is closest to its own.
 @property (nonatomic, copy) NSArray<FFFastImageSource *> *sources;
-@property (nonatomic, strong) UIImage *defaultSource;
+// The `placeholder` prop.
+@property (nonatomic, strong) UIImage *placeholder;
+// The `sourcePlaceholders` prop, by the source's index (an empty string for
+// none; one for a single source): the picked source's ThumbHash or
+// blurDataUri (a data uri) shows instead of placeholder. JS sends them apart
+// from the sources, so a new one for the same image doesn't load it again.
+@property (nonatomic, copy) NSArray<NSString *> *sourcePlaceholders;
 @property (nonatomic, strong) UIColor *imageColor;
 // When it changes, the next image doesn't replace the current one: the view
 // clears first (for views reused for other content, like list rows).