blurhash-rs 1.0.0__tar.gz

blurhash_rs-1.0.0/Cargo.lock

@@ -0,0 +1,172 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "blurhash_rs"
+version = "1.0.0"
+dependencies = [
+ "pyo3",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.178"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "portable-atomic"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab53c047fcd1a1d2a8820fe84f05d6be69e9526be40cb03b73f86b6b03e6d87d"
+dependencies = [
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b455933107de8642b4487ed26d912c2d899dec6114884214a0b3bb3be9261ea6"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c85c9cbfaddf651b1221594209aed57e9e5cff63c4d11d1feead529b872a089"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a5b10c9bf9888125d917fb4d2ca2d25c8df94c7ab5a52e13313a07e050a3b02"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03b51720d314836e53327f5871d4c0cfb4fb37cc2c4a11cc71907a86342c40f9"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "syn"
+version = "2.0.111"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df7f62577c25e07834649fc3b39fafdc597c0a3527dc1c60129201ccfcbaa50c"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"

blurhash_rs-1.0.0/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "blurhash_rs"
+version = "1.0.0"
+edition = "2024"
+readme = "README.md"
+
+[lib]
+crate-type = ["cdylib"]
+name = "blurhash_rs"
+
+[dependencies]
+pyo3 = { version = "0.27.2", features = ["extension-module"] }
+
+[profile.release]
+overflow-checks = true
+lto = true
+codegen-units = 1

blurhash_rs-1.0.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: blurhash-rs
+Version: 1.0.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: pillow>=9.0.0
+Summary: High-performance BlurHash encoder/decoder
+Keywords: blurhash,decoder,encoder,image,loading,placeholder,preview,progressive
+Author-email: Kamil Monicz <kamil@monicz.dev>
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Issues, https://github.com/Zaczero/pkgs/issues
+Project-URL: Repository, https://github.com/Zaczero/pkgs/tree/main/blurhash-rs
+
+# blurhash-rs
+
+High-performance [BlurHash](https://blurha.sh) encoder/decoder for Python.
+
+## Installation
+
+```sh
+pip install blurhash-rs
+```
+
+## Usage
+
+```py
+from PIL import Image
+from blurhash_rs import blurhash_encode, blurhash_decode
+
+with Image.open('image.jpg') as img:
+  # Reduce resolution for faster encoding
+  img.thumbnail((100, 100))
+
+  blurhash = blurhash_encode(img, x_components=4, y_components=3)
+  preview = blurhash_decode(blurhash, 32, 32)
+  preview.save("preview.png")
+```
+
+## Benchmarks
+
+### Run
+
+```sh
+benchmark.py --impl blurhash-rs -o blurhash-rs.json --rigorous
+benchmark.py --impl blurhash-python -o blurhash-python.json --rigorous
+benchmark.py --impl blurhash -o blurhash.json --rigorous
+```
+
+### Results
+
+Linux x86_64, CPython 3.14.0:
+
+#### blurhash-python vs blurhash-rs
+
+| Benchmark            | blurhash-python-1.2.2 | blurhash-rs-1.0.0       |
+|----------------------|:---------------------:|:-----------------------:|
+| encode 32x32 (4x3)   | 486 us                | 5.57 us: 87.29x faster  |
+| encode 64x64 (4x3)   | 1.91 ms               | 10.8 us: 177.73x faster |
+| encode 128x128 (4x3) | 7.59 ms               | 30.6 us: 247.76x faster |
+| decode 32x32 (4x3)   | 160 us                | 12.0 us: 13.31x faster  |
+| decode 64x64 (4x3)   | 626 us                | 34.6 us: 18.08x faster  |
+| decode 128x128 (4x3) | 2.45 ms               | 122 us: 20.08x faster   |
+| Geometric mean       | (ref)                 | 51.46x faster           |
+
+#### blurhash vs blurhash-rs
+
+| Benchmark            | blurhash-1.1.5 | blurhash-rs-1.0.0        |
+|----------------------|:--------------:|:------------------------:|
+| encode 32x32 (4x3)   | 6.00 ms        | 5.57 us: 1078.28x faster |
+| encode 64x64 (4x3)   | 24.2 ms        | 10.8 us: 2249.49x faster |
+| encode 128x128 (4x3) | 96.4 ms        | 30.6 us: 3146.95x faster |
+| decode 32x32 (4x3)   | 6.91 ms        | 12.0 us: 573.46x faster  |
+| decode 64x64 (4x3)   | 27.6 ms        | 34.6 us: 797.99x faster  |
+| decode 128x128 (4x3) | 112 ms         | 122 us: 912.88x faster   |
+| Geometric mean       | (ref)          | 1213.21x faster          |
+

blurhash_rs-1.0.0/README.md

@@ -0,0 +1,62 @@
+# blurhash-rs
+
+High-performance [BlurHash](https://blurha.sh) encoder/decoder for Python.
+
+## Installation
+
+```sh
+pip install blurhash-rs
+```
+
+## Usage
+
+```py
+from PIL import Image
+from blurhash_rs import blurhash_encode, blurhash_decode
+
+with Image.open('image.jpg') as img:
+  # Reduce resolution for faster encoding
+  img.thumbnail((100, 100))
+
+  blurhash = blurhash_encode(img, x_components=4, y_components=3)
+  preview = blurhash_decode(blurhash, 32, 32)
+  preview.save("preview.png")
+```
+
+## Benchmarks
+
+### Run
+
+```sh
+benchmark.py --impl blurhash-rs -o blurhash-rs.json --rigorous
+benchmark.py --impl blurhash-python -o blurhash-python.json --rigorous
+benchmark.py --impl blurhash -o blurhash.json --rigorous
+```
+
+### Results
+
+Linux x86_64, CPython 3.14.0:
+
+#### blurhash-python vs blurhash-rs
+
+| Benchmark            | blurhash-python-1.2.2 | blurhash-rs-1.0.0       |
+|----------------------|:---------------------:|:-----------------------:|
+| encode 32x32 (4x3)   | 486 us                | 5.57 us: 87.29x faster  |
+| encode 64x64 (4x3)   | 1.91 ms               | 10.8 us: 177.73x faster |
+| encode 128x128 (4x3) | 7.59 ms               | 30.6 us: 247.76x faster |
+| decode 32x32 (4x3)   | 160 us                | 12.0 us: 13.31x faster  |
+| decode 64x64 (4x3)   | 626 us                | 34.6 us: 18.08x faster  |
+| decode 128x128 (4x3) | 2.45 ms               | 122 us: 20.08x faster   |
+| Geometric mean       | (ref)                 | 51.46x faster           |
+
+#### blurhash vs blurhash-rs
+
+| Benchmark            | blurhash-1.1.5 | blurhash-rs-1.0.0        |
+|----------------------|:--------------:|:------------------------:|
+| encode 32x32 (4x3)   | 6.00 ms        | 5.57 us: 1078.28x faster |
+| encode 64x64 (4x3)   | 24.2 ms        | 10.8 us: 2249.49x faster |
+| encode 128x128 (4x3) | 96.4 ms        | 30.6 us: 3146.95x faster |
+| decode 32x32 (4x3)   | 6.91 ms        | 12.0 us: 573.46x faster  |
+| decode 64x64 (4x3)   | 27.6 ms        | 34.6 us: 797.99x faster  |
+| decode 128x128 (4x3) | 112 ms         | 122 us: 912.88x faster   |
+| Geometric mean       | (ref)          | 1213.21x faster          |

blurhash_rs-1.0.0/benchmark.py

@@ -0,0 +1,123 @@
+import argparse
+import sys
+
+import pyperf
+from PIL import Image
+
+
+def _pil_rgb_image_to_3d_array(img: Image.Image) -> list[list[list[int]]]:
+    data = list(img.getdata())  # type: ignore
+    pixels: list[list[list[int]]] = []
+    p = 0
+    for _y in range(img.height):
+        row: list[list[int]] = []
+        for _x in range(img.width):
+            r, g, b = data[p]
+            row.append([r, g, b])
+            p += 1
+        pixels.append(row)
+    return pixels
+
+
+def _make_gradient_image(width: int, height: int):
+    buf = bytearray(width * height * 3)
+    denom_x = max(1, width - 1)
+    denom_y = max(1, height - 1)
+    denom_xy = max(1, (width - 1) + (height - 1))
+
+    p = 0
+    for y in range(height):
+        gy = (255 * y) // denom_y
+        for x in range(width):
+            rx = (255 * x) // denom_x
+            bx = (255 * (x + y)) // denom_xy
+            buf[p + 0] = rx
+            buf[p + 1] = gy
+            buf[p + 2] = bx
+            p += 3
+
+    return Image.frombytes('RGB', (width, height), bytes(buf))
+
+
+def _run_suite(impl: str, pyperf_args: list[str]) -> int:
+    if impl == 'blurhash-python':
+        from blurhash import decode as blurhash_decode
+        from blurhash import encode as blurhash_encode
+
+        if blurhash_encode.__module__ != 'blurhash':
+            raise SystemExit(
+                'Expected blurhash-python for --impl blurhash-python, but imported a different "blurhash" package.'
+            )
+
+    elif impl == 'blurhash':
+        from blurhash import decode as blurhash_decode
+        from blurhash import encode as blurhash_encode
+
+        if blurhash_encode.__module__ != 'blurhash.blurhash':
+            raise SystemExit(
+                'Expected blurhash for --impl blurhash, but imported a different "blurhash" package.'
+            )
+
+    else:
+        from blurhash_rs import blurhash_decode, blurhash_encode
+
+    sizes = [32, 64, 128]
+    x_components = 4
+    y_components = 3
+
+    # pyperf spawns worker processes by re-running the "program". Since we
+    # parse custom CLI args ourselves, we must include them in program_args so
+    # workers can parse them too.
+    runner = pyperf.Runner(program_args=(sys.argv[0], '--impl', impl))
+    runner.parse_args(pyperf_args)
+
+    # Encode benchmarks first (so pyperf compare_to shows them grouped).
+    for size in sizes:
+        img = _make_gradient_image(size, size)
+
+        if impl == 'blurhash-python':
+            # blurhash-python closes the image it is given; avoid breaking the
+            # benchmark loop by making close() a no-op.
+            img.close = lambda: None  # type: ignore[method-assign]
+        elif impl == 'blurhash':
+            img = _pil_rgb_image_to_3d_array(img)
+
+        runner.bench_func(
+            f'encode {size}x{size} ({x_components}x{y_components})',
+            blurhash_encode,
+            img,
+            x_components,
+            y_components,
+        )
+
+    # Decode benchmarks second.
+    from blurhash_rs import blurhash_encode
+
+    for size in sizes:
+        img = _make_gradient_image(size, size)
+        h = blurhash_encode(img, x_components, y_components)
+
+        runner.bench_func(
+            f'decode {size}x{size} ({x_components}x{y_components})',
+            blurhash_decode,
+            h,
+            size,
+            size,
+        )
+
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description='BlurHash benchmark suite. Writes pyperf JSON via -o/--output.'
+    )
+    parser.add_argument(
+        '--impl', required=True, choices=['blurhash-python', 'blurhash', 'blurhash-rs']
+    )
+    args, pyperf_args = parser.parse_known_args()
+    return _run_suite(args.impl, pyperf_args)
+
+
+if __name__ == '__main__':
+    main()

blurhash_rs-1.0.0/build.rs

@@ -0,0 +1,53 @@
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+fn srgb_u8_to_linear(v: u8) -> f32 {
+    let srgb = v as f32 / 255.0;
+    if srgb <= 0.04045 {
+        srgb / 12.92
+    } else {
+        ((srgb + 0.055) / 1.055).powf(2.4)
+    }
+}
+
+fn linear_to_srgb_u8(v: f32) -> u8 {
+    let v = v.clamp(0.0, 1.0);
+    let srgb = if v < 0.0031308 {
+        v * 12.92
+    } else {
+        1.055 * v.powf(1.0 / 2.4) - 0.055
+    };
+    let value = (srgb * 255.0 + 0.5) as i32;
+    value.clamp(0, 255) as u8
+}
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    let out_dir = PathBuf::from(env::var_os("OUT_DIR").expect("OUT_DIR must be set"));
+    let dest = out_dir.join("srgb_tables.rs");
+
+    const LINEAR_TO_SRGB_LUT_LEN: usize = 4096;
+
+    let mut out = String::new();
+    out.push_str("pub const SRGB_U8_TO_LINEAR: [f32; 256] = [\n");
+    for v in 0u16..=255 {
+        let lin = srgb_u8_to_linear(v as u8);
+        out.push_str(&format!("    f32::from_bits(0x{:08x}),\n", lin.to_bits()));
+    }
+    out.push_str("];\n\n");
+
+    out.push_str(&format!(
+        "pub const LINEAR_TO_SRGB_U8: [u8; {LINEAR_TO_SRGB_LUT_LEN}] = [\n"
+    ));
+    for i in 0..LINEAR_TO_SRGB_LUT_LEN {
+        let v = i as f32 / (LINEAR_TO_SRGB_LUT_LEN - 1) as f32;
+        let srgb = linear_to_srgb_u8(v);
+        out.push_str(&format!("    {srgb},\n"));
+    }
+    out.push_str("];\n");
+
+    fs::write(dest, out).expect("Failed to write generated sRGB tables");
+}
+

blurhash_rs-1.0.0/pyproject.toml

@@ -0,0 +1,68 @@
+[project]
+name = "blurhash-rs"
+description = "High-performance BlurHash encoder/decoder"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "Kamil Monicz", email = "kamil@monicz.dev" }]
+keywords = [
+  "blurhash",
+  "decoder",
+  "encoder",
+  "image",
+  "loading",
+  "placeholder",
+  "preview",
+  "progressive"
+]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+  "Programming Language :: Rust",
+  "Topic :: Multimedia :: Graphics",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Typing :: Typed",
+]
+dependencies = ["Pillow>=9.0.0"]
+dynamic = ["version"]
+
+[project.urls]
+Issues = "https://github.com/Zaczero/pkgs/issues"
+Repository = "https://github.com/Zaczero/pkgs/tree/main/blurhash-rs"
+
+[dependency-groups]
+dev = ["pytest"]
+bench = ["blurhash-python", "pyperf"]
+bench-2 = ["blurhash", "pyperf"]
+
+[build-system]
+requires = ["maturin>=1.7,<2.0"]
+build-backend = "maturin"
+
+[tool.maturin]
+bindings = "pyo3"
+features = ["pyo3/extension-module"]
+module-name = "blurhash_rs._lib"
+python-source = "python"
+
+[tool.pyright]
+include = ["python/blurhash_rs", "tests"]
+pythonPlatform = "All"
+pythonVersion = "3.9"
+strict = ["python/blurhash_rs"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+extend = "../ruff.toml"

blurhash_rs-1.0.0/python/blurhash_rs/__init__.py

@@ -0,0 +1,53 @@
+from contextlib import nullcontext
+
+from PIL import Image
+
+from ._lib import decode_rgb, encode_rgb
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from os import PathLike
+    from typing import IO
+
+__all__ = [
+    'BlurhashDecodeError',
+    'blurhash_decode',
+    'blurhash_encode',
+]
+
+
+class BlurhashDecodeError(Exception):
+    def __init__(self, blurhash: str):
+        self.blurhash = blurhash
+
+
+def blurhash_encode(
+    image: 'Image.Image | str | bytes | PathLike[str] | PathLike[bytes] | IO[bytes]',
+    x_components: int = 4,
+    y_components: int = 3,
+) -> str:
+    with (
+        nullcontext(image)
+        if isinstance(image, Image.Image)
+        else Image.open(image) as img
+    ):
+        if img.mode != 'RGB':
+            img = img.convert('RGB')
+        width, height = img.size
+        data = img.tobytes()
+        return encode_rgb(data, width, height, x_components, y_components)
+
+
+def blurhash_decode(
+    blurhash: str,
+    width: int,
+    height: int,
+    *,
+    punch: float = 1,
+) -> Image.Image:
+    try:
+        data = decode_rgb(blurhash, width, height, punch)
+    except ValueError as e:
+        raise BlurhashDecodeError(blurhash) from e
+    else:
+        return Image.frombuffer('RGB', (width, height), data, 'raw', 'RGB', 0, 1)

blurhash_rs-1.0.0/src/base83.rs

@@ -0,0 +1,53 @@
+const CHARSET: &[u8; 83] =
+    b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~";
+
+const INVALID: u8 = 0xFF;
+
+const fn build_decode_table() -> [u8; 256] {
+    let mut table = [INVALID; 256];
+    let mut i = 0usize;
+    while i < 83 {
+        table[CHARSET[i] as usize] = i as u8;
+        i += 1;
+    }
+    table
+}
+
+const DECODE: [u8; 256] = build_decode_table();
+
+const fn build_pow83_table() -> [u32; 5] {
+    let mut out = [0u32; 5];
+    out[0] = 1;
+    let mut i = 1usize;
+    while i < out.len() {
+        out[i] = out[i - 1] * 83;
+        i += 1;
+    }
+    out
+}
+
+const POW83: [u32; 5] = build_pow83_table();
+
+pub fn decode_byte(b: u8) -> Option<u8> {
+    let v = DECODE[b as usize];
+    if v == INVALID { None } else { Some(v) }
+}
+
+pub fn decode_u32(bytes: &[u8]) -> Option<u32> {
+    let mut value = 0u32;
+    for &b in bytes {
+        let digit = decode_byte(b)? as u32;
+        value = value * 83 + digit;
+    }
+    Some(value)
+}
+
+pub fn push_base83(out: &mut Vec<u8>, value: u32, length: usize) {
+    let mut i = length;
+    while i > 0 {
+        i -= 1;
+        let divisor = POW83[i];
+        let digit = (value / divisor) % 83;
+        out.push(CHARSET[digit as usize]);
+    }
+}

blurhash_rs-1.0.0/src/cos.rs

@@ -0,0 +1,88 @@
+use std::cell::RefCell;
+use std::f32::consts::PI;
+use std::rc::Rc;
+use std::simd::Simd;
+
+pub fn precompute_cos_axis(len: usize, components: usize) -> Vec<f32> {
+    let len_f = len as f32;
+    let mut out = vec![0.0f32; len * components];
+    for p in 0..len {
+        let p_f = p as f32;
+        let row = &mut out[p * components..(p + 1) * components];
+        for c in 0..components {
+            row[c] = (PI * p_f * (c as f32) / len_f).cos();
+        }
+    }
+    out
+}
+
+thread_local! {
+    // Small caches: typical callers only ever use a handful of image sizes and
+    // component counts. A linear scan over a tiny Vec has better locality than
+    // a HashMap and avoids hashing overhead.
+    static COS_AXIS_CACHE: RefCell<Vec<((usize, usize), Rc<[f32]>)>> =
+        RefCell::new(Vec::with_capacity(1));
+    static COS_AXIS_SIMD4_CACHE: RefCell<Vec<((usize, usize), Rc<[Simd<f32, 4>]>)>> =
+        RefCell::new(Vec::with_capacity(1));
+}
+
+pub fn cos_axis_cached(len: usize, components: usize) -> Rc<[f32]> {
+    let key = (len, components);
+    COS_AXIS_CACHE.with(|cache| {
+        let mut cache = cache.borrow_mut();
+        for (k, v) in cache.iter() {
+            if *k == key {
+                return v.clone();
+            }
+        }
+
+        // Simple eviction to avoid unbounded growth in pathological cases.
+        if cache.len() >= 32 {
+            cache.clear();
+        }
+
+        let vec = precompute_cos_axis(len, components);
+        let rc: Rc<[f32]> = vec.into();
+        cache.push((key, rc.clone()));
+        rc
+    })
+}
+
+pub fn cos_axis_simd4_cached(len: usize, components: usize) -> Rc<[Simd<f32, 4>]> {
+    let key = (len, components);
+    COS_AXIS_SIMD4_CACHE.with(|cache| {
+        let mut cache = cache.borrow_mut();
+        for (k, v) in cache.iter() {
+            if *k == key {
+                return v.clone();
+            }
+        }
+
+        // Simple eviction to avoid unbounded growth in pathological cases.
+        if cache.len() >= 32 {
+            cache.clear();
+        }
+
+        let blocks = (components + 3) / 4;
+        let len_f = len as f32;
+
+        let mut out = Vec::with_capacity(len * blocks);
+        for p in 0..len {
+            let p_f = p as f32;
+            for block in 0..blocks {
+                let start = block * 4;
+                let lanes = (components - start).min(4);
+                let mut v = [0.0f32; 4];
+                for lane in 0..lanes {
+                    let c = start + lane;
+                    v[lane] = (PI * p_f * (c as f32) / len_f).cos();
+                }
+                out.push(Simd::from_array(v));
+            }
+        }
+
+        let rc: Rc<[Simd<f32, 4>]> = out.into();
+        cache.push((key, rc.clone()));
+        rc
+    })
+}

blurhash_rs-1.0.0/src/decode.rs

@@ -0,0 +1,153 @@
+use core::hint::unlikely;
+use std::simd::Simd;
+use std::simd::num::SimdFloat;
+
+use crate::base83;
+use crate::cos;
+use crate::srgb;
+
+type V4 = Simd<f32, 4>;
+
+pub type DecodeResult<T> = Result<T, &'static str>;
+
+fn sign_pow_2(v: f32) -> f32 {
+    let abs = v.abs();
+    v.signum() * abs * abs
+}
+
+pub fn decode_rgb_into(
+    blurhash: &str,
+    width: usize,
+    height: usize,
+    punch: f32,
+    out_pixels: &mut [u8],
+) -> DecodeResult<()> {
+    if unlikely(width == 0 || height == 0) {
+        return Err("Image is empty");
+    }
+    if unlikely(!punch.is_finite()) {
+        return Err("punch must be finite");
+    }
+
+    let bytes = blurhash.as_bytes();
+    if unlikely(bytes.len() < 6) {
+        return Err("blurhash is too short");
+    }
+
+    let Some(size_flag) = base83::decode_byte(bytes[0]) else {
+        return Err("blurhash is malformed");
+    };
+    let size_flag = size_flag as usize;
+    let num_y = (size_flag / 9) + 1;
+    let num_x = (size_flag % 9) + 1;
+    let num_components = num_x * num_y;
+
+    let expected_len = 4 + 2 * num_components;
+    if unlikely(bytes.len() != expected_len) {
+        return Err("blurhash length mismatch");
+    }
+
+    let Some(quantised_max_value) = base83::decode_byte(bytes[1]) else {
+        return Err("blurhash is malformed");
+    };
+    let quantised_max_value = quantised_max_value as f32;
+    let max_value = ((quantised_max_value + 1.0) / 166.0) * punch.max(1.0);
+
+    let out_len = width
+        .checked_mul(height)
+        .and_then(|v| v.checked_mul(3))
+        .ok_or("Image is too large")?;
+
+    if unlikely(out_pixels.len() != out_len) {
+        return Err("Invalid output buffer length");
+    }
+
+    let blocks = (num_x + 3) / 4;
+
+    let zero = V4::splat(0.0);
+    let mut colors_r_v = [zero; 27];
+    let mut colors_g_v = [zero; 27];
+    let mut colors_b_v = [zero; 27];
+
+    let Some(dc_value) = base83::decode_u32(&bytes[2..6]) else {
+        return Err("blurhash is malformed");
+    };
+    colors_r_v[0].as_mut_array()[0] = srgb::srgb_u8_to_linear((dc_value >> 16) as u8);
+    colors_g_v[0].as_mut_array()[0] = srgb::srgb_u8_to_linear(((dc_value >> 8) & 255) as u8);
+    colors_b_v[0].as_mut_array()[0] = srgb::srgb_u8_to_linear((dc_value & 255) as u8);
+
+    for idx in 1..num_components {
+        let start = 4 + idx * 2;
+        let Some(value) = base83::decode_u32(&bytes[start..start + 2]) else {
+            return Err("blurhash is malformed");
+        };
+
+        let quant_r = (value / (19 * 19)) as i32;
+        let quant_g = ((value / 19) % 19) as i32;
+        let quant_b = (value % 19) as i32;
+
+        let i = idx % num_x;
+        let slot = (idx / num_x) * blocks + (i / 4);
+        let lane = i % 4;
+
+        let r = sign_pow_2((quant_r as f32 - 9.0) / 9.0) * max_value;
+        let g = sign_pow_2((quant_g as f32 - 9.0) / 9.0) * max_value;
+        let b = sign_pow_2((quant_b as f32 - 9.0) / 9.0) * max_value;
+
+        colors_r_v[slot].as_mut_array()[lane] = r;
+        colors_g_v[slot].as_mut_array()[lane] = g;
+        colors_b_v[slot].as_mut_array()[lane] = b;
+    }
+
+    let cos_y = cos::cos_axis_cached(height, num_y);
+    let cos_x_simd = cos::cos_axis_simd4_cached(width, num_x);
+
+    // Separable basis:
+    //
+    //   pixel[x,y] = sum_i cos_x[x,i] * (sum_j colors[i,j] * cos_y[y,j])
+    for y in 0..height {
+        let mut row_r = [zero; 3];
+        let mut row_g = [zero; 3];
+        let mut row_b = [zero; 3];
+
+        let cos_y_row = &cos_y[y * num_y..(y + 1) * num_y];
+        for j in 0..num_y {
+            let cosy = V4::splat(cos_y_row[j]);
+            let base = j * blocks;
+
+            for k in 0..blocks {
+                let idx = base + k;
+                row_r[k] += colors_r_v[idx] * cosy;
+                row_g[k] += colors_g_v[idx] * cosy;
+                row_b[k] += colors_b_v[idx] * cosy;
+            }
+        }
+
+        let mut out_idx = y * width * 3;
+        for x in 0..width {
+            let base = x * blocks;
+            let bases = &cos_x_simd[base..base + blocks];
+
+            let mut acc_r = zero;
+            let mut acc_g = zero;
+            let mut acc_b = zero;
+            for k in 0..blocks {
+                let basis_x = bases[k];
+                acc_r += row_r[k] * basis_x;
+                acc_g += row_g[k] * basis_x;
+                acc_b += row_b[k] * basis_x;
+            }
+
+            let r = acc_r.reduce_sum();
+            let g = acc_g.reduce_sum();
+            let b = acc_b.reduce_sum();
+
+            out_pixels[out_idx + 0] = srgb::linear_to_srgb_u8(r);
+            out_pixels[out_idx + 1] = srgb::linear_to_srgb_u8(g);
+            out_pixels[out_idx + 2] = srgb::linear_to_srgb_u8(b);
+            out_idx += 3;
+        }
+    }
+
+    Ok(())
+}

blurhash_rs-1.0.0/src/encode.rs

@@ -0,0 +1,195 @@
+use core::hint::unlikely;
+use std::simd::Simd;
+
+use crate::base83;
+use crate::cos;
+use crate::srgb;
+
+type V4 = Simd<f32, 4>;
+
+pub type EncodeResult<T> = Result<T, &'static str>;
+
+fn sign_pow_05(v: f32) -> f32 {
+    v.signum() * v.abs().sqrt()
+}
+
+pub fn encode_rgb(
+    rgb: &[u8],
+    width: usize,
+    height: usize,
+    x_components: usize,
+    y_components: usize,
+) -> EncodeResult<String> {
+    if unlikely(width == 0 || height == 0) {
+        return Err("Image is empty");
+    }
+    if unlikely(x_components == 0 || x_components > 9 || y_components == 0 || y_components > 9) {
+        return Err("x_components and y_components must be in 1..=9");
+    }
+
+    let expected_len = width
+        .checked_mul(height)
+        .and_then(|v| v.checked_mul(3))
+        .ok_or("Image is too large")?;
+
+    if unlikely(rgb.len() != expected_len) {
+        return Err("Invalid RGB buffer length");
+    }
+
+    encode_rgb_impl(rgb, width, height, x_components, y_components)
+}
+
+fn encode_rgb_impl(
+    rgb: &[u8],
+    width: usize,
+    height: usize,
+    x_components: usize,
+    y_components: usize,
+) -> EncodeResult<String> {
+    let num_components = x_components * y_components;
+
+    let blocks = (x_components + 3) / 4;
+
+    let cos_y = cos::cos_axis_cached(height, y_components);
+    let cos_x_simd = cos::cos_axis_simd4_cached(width, x_components);
+
+    let zero = V4::splat(0.0);
+    let mut factors_r = [zero; 27];
+    let mut factors_g = [zero; 27];
+    let mut factors_b = [zero; 27];
+
+    // Separable basis:
+    //
+    //   C[i,j] = sum_y cos_y[y,j] * (sum_x cos_x[x,i] * pixel[x,y])
+    //
+    // This computes all coefficients in a single image scan.
+    for y in 0..height {
+        let mut row_r = [zero; 3];
+        let mut row_g = [zero; 3];
+        let mut row_b = [zero; 3];
+
+        let mut pixel = y * width * 3;
+        for x in 0..width {
+            let r = srgb::srgb_u8_to_linear(rgb[pixel + 0]);
+            let g = srgb::srgb_u8_to_linear(rgb[pixel + 1]);
+            let b = srgb::srgb_u8_to_linear(rgb[pixel + 2]);
+            pixel += 3;
+
+            let r_v = V4::splat(r);
+            let g_v = V4::splat(g);
+            let b_v = V4::splat(b);
+
+            let base = x * blocks;
+            let bases = &cos_x_simd[base..base + blocks];
+            for k in 0..blocks {
+                let basis_x = bases[k];
+                row_r[k] += basis_x * r_v;
+                row_g[k] += basis_x * g_v;
+                row_b[k] += basis_x * b_v;
+            }
+        }
+
+        let cos_y_row = &cos_y[y * y_components..(y + 1) * y_components];
+        for j in 0..y_components {
+            let cosy = V4::splat(cos_y_row[j]);
+            let base = j * blocks;
+            for k in 0..blocks {
+                let idx = base + k;
+                factors_r[idx] += row_r[k] * cosy;
+                factors_g[idx] += row_g[k] * cosy;
+                factors_b[idx] += row_b[k] * cosy;
+            }
+        }
+    }
+
+    let inv_wh = 1.0f32 / (width * height) as f32;
+    let scale_ac = inv_wh * 2.0;
+    for j in 0..y_components {
+        let base = j * blocks;
+        for block in 0..blocks {
+            let scale = if unlikely(j == 0 && block == 0) {
+                V4::from_array([inv_wh, scale_ac, scale_ac, scale_ac])
+            } else {
+                V4::splat(scale_ac)
+            };
+            let idx = base + block;
+            factors_r[idx] *= scale;
+            factors_g[idx] *= scale;
+            factors_b[idx] *= scale;
+        }
+    }
+
+    let mut maximum_value = 0.0f32;
+    for j in 0..y_components {
+        let base = j * blocks;
+        for block in 0..blocks {
+            let idx = base + block;
+            let r = factors_r[idx].to_array();
+            let g = factors_g[idx].to_array();
+            let b = factors_b[idx].to_array();
+
+            let start_lane = if j == 0 && block == 0 { 1 } else { 0 };
+            let lanes = if block + 1 == blocks {
+                x_components - block * 4
+            } else {
+                4
+            };
+            for lane in start_lane..lanes {
+                maximum_value =
+                    maximum_value.max(r[lane].abs().max(g[lane].abs()).max(b[lane].abs()));
+            }
+        }
+    }
+
+    let (quantised_max_value, maximum_value) = if num_components > 1 {
+        let quantised = ((maximum_value * 166.0 - 0.5).floor() as i32).clamp(0, 82) as u32;
+        (quantised, (quantised as f32 + 1.0) / 166.0)
+    } else {
+        (0, 1.0)
+    };
+
+    let total_len = 1 + 1 + 4 + 2 * (num_components - 1);
+    let mut out = Vec::with_capacity(total_len);
+
+    let size_flag = ((x_components - 1) + (y_components - 1) * 9) as u32;
+    base83::push_base83(&mut out, size_flag, 1);
+    base83::push_base83(&mut out, quantised_max_value, 1);
+
+    let dc_r = factors_r[0].to_array()[0];
+    let dc_g = factors_g[0].to_array()[0];
+    let dc_b = factors_b[0].to_array()[0];
+    let dc_value = ((srgb::linear_to_srgb_u8(dc_r) as u32) << 16)
+        | ((srgb::linear_to_srgb_u8(dc_g) as u32) << 8)
+        | (srgb::linear_to_srgb_u8(dc_b) as u32);
+    base83::push_base83(&mut out, dc_value, 4);
+
+    for j in 0..y_components {
+        for i in 0..x_components {
+            if j == 0 && i == 0 {
+                continue;
+            }
+
+            let block = i / 4;
+            let lane = i % 4;
+            let idx = j * blocks + block;
+
+            let r = factors_r[idx].to_array()[lane] / maximum_value;
+            let g = factors_g[idx].to_array()[lane] / maximum_value;
+            let b = factors_b[idx].to_array()[lane] / maximum_value;
+
+            let quant_r = (sign_pow_05(r) * 9.0 + 9.5).floor() as i32;
+            let quant_g = (sign_pow_05(g) * 9.0 + 9.5).floor() as i32;
+            let quant_b = (sign_pow_05(b) * 9.0 + 9.5).floor() as i32;
+
+            let quant_r = quant_r.clamp(0, 18) as u32;
+            let quant_g = quant_g.clamp(0, 18) as u32;
+            let quant_b = quant_b.clamp(0, 18) as u32;
+
+            let ac_value = quant_r * 19 * 19 + quant_g * 19 + quant_b;
+            base83::push_base83(&mut out, ac_value, 2);
+        }
+    }
+
+    // Safety: we only ever push bytes from the base83 charset.
+    Ok(unsafe { String::from_utf8_unchecked(out) })
+}

blurhash_rs-1.0.0/src/lib.rs

@@ -0,0 +1,51 @@
+#![feature(likely_unlikely)]
+#![feature(portable_simd)]
+
+mod base83;
+mod cos;
+mod decode;
+mod encode;
+mod srgb;
+
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+use pyo3::types::PyByteArray;
+
+#[pyfunction]
+fn encode_rgb(
+    rgb: &[u8],
+    width: usize,
+    height: usize,
+    x_components: usize,
+    y_components: usize,
+) -> PyResult<String> {
+    encode::encode_rgb(rgb, width, height, x_components, y_components)
+        .map_err(PyValueError::new_err)
+}
+
+#[pyfunction]
+fn decode_rgb(
+    py: Python<'_>,
+    blurhash: &str,
+    width: usize,
+    height: usize,
+    punch: f32,
+) -> PyResult<Py<PyByteArray>> {
+    let out_len = width
+        .checked_mul(height)
+        .and_then(|v| v.checked_mul(3))
+        .ok_or_else(|| PyValueError::new_err("Image is too large"))?;
+
+    let out = PyByteArray::new_with(py, out_len, |buf| {
+        decode::decode_rgb_into(blurhash, width, height, punch, buf).map_err(PyValueError::new_err)
+    })?;
+    Ok(out.unbind())
+}
+
+#[pymodule(gil_used = false)]
+#[pyo3(name = "_lib")]
+fn lib(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(encode_rgb, m)?)?;
+    m.add_function(wrap_pyfunction!(decode_rgb, m)?)?;
+    Ok(())
+}

blurhash_rs-1.0.0/src/srgb.rs

@@ -0,0 +1,25 @@
+use core::hint::unlikely;
+
+include!(concat!(env!("OUT_DIR"), "/srgb_tables.rs"));
+
+pub fn srgb_u8_to_linear(v: u8) -> f32 {
+    SRGB_U8_TO_LINEAR[v as usize]
+}
+
+pub fn linear_to_srgb_u8(v: f32) -> u8 {
+    if unlikely(v <= 0.0) {
+        return 0;
+    }
+    if unlikely(v >= 1.0) {
+        return 255;
+    }
+
+    // Approximation mode: map linear -> u8 via a dense LUT.
+    //
+    // This is much faster than calling powf() per channel per pixel and is
+    // visually indistinguishable for BlurHash previews, but not byte-identical
+    // to reference implementations.
+    let len = LINEAR_TO_SRGB_U8.len();
+    let idx = ((v * (len as f32 - 1.0)) + 0.5) as usize;
+    LINEAR_TO_SRGB_U8[idx.min(len - 1)]
+}

blurhash_rs-1.0.0/tests/data/decode_known_hash_8x8.rgbhex

@@ -0,0 +1,10 @@
+# Expected decode output for blurhash: LEHV6nWB2yk8pyo0adR*.7kCMdnj
+# RGB pixels (8x8), whitespace-separated `RRGGBB` hex tokens, row-major order.
+87a4b1 8fa7b1 a1adb1 b0b2ae b5b4ab afb1ab a0acae 90a7b3
+85a2b0 8da4af 9fa9ad adada9 b2aea5 acaca6 9da8ab 8ea5b1
+809ead 889eaa 989ea3 a69e9a aa9e95 a49f98 979fa2 899fad
+7a99a8 8296a3 919096 9e8b87 a28a7f 9c8f86 919497 8598a7
+7894a2 7f909b 8d868b 9a7e76 9e7d6c 998476 8e8c8d 82929f
+7b919c 818d96 8f8585 9b7e70 a17f66 9d8471 928b87 848f99
+809097 868e92 948b85 a28a76 a98b6f a68e76 998f86 888f94
+869094 8b9091 999288 a8957e b0987a ae987e 9f9488 8c9091

blurhash_rs-1.0.0/tests/data/small_pattern_4x3.rgbhex

@@ -0,0 +1,5 @@
+# RGB pixels (4x3)
+# Format: whitespace-separated `RRGGBB` hex tokens, row-major order.
+000000 ff0000 00ff00 0000ff
+ffff00 00ffff ff00ff ffffff
+808080 4080c0 c04080 201008

blurhash_rs-1.0.0/tests/test___init__.py

@@ -0,0 +1,112 @@
+from pathlib import Path
+
+import pytest
+from blurhash_rs import BlurhashDecodeError, blurhash_decode, blurhash_encode
+from PIL import Image
+
+
+def _assert_bytes_close(
+    actual: bytes,
+    expected: bytes,
+    *,
+    max_abs_diff: int,
+    max_mean_abs_diff: float,
+    max_different_bytes: int,
+) -> None:
+    assert len(actual) == len(expected)
+    diffs = [abs(a - b) for a, b in zip(actual, expected)]
+    assert max(diffs) <= max_abs_diff
+    assert (sum(diffs) / len(diffs)) <= max_mean_abs_diff
+    assert sum(1 for d in diffs if d) <= max_different_bytes
+
+
+_DATA_DIR = Path(__file__).resolve().parent / 'data'
+
+
+def _load_rgbhex(filename: str, *, width: int, height: int):
+    path = _DATA_DIR / filename
+    rgb: list[int] = []
+
+    for raw_line in path.read_text(encoding='utf-8').splitlines():
+        line = raw_line.split('#', 1)[0].strip()
+        if not line:
+            continue
+
+        for token in line.split():
+            token = token.strip()
+            token = token.removeprefix('0x')
+
+            if len(token) != 6:
+                raise AssertionError(f'{path}: expected RRGGBB token, got {token!r}')
+
+            try:
+                r = int(token[0:2], 16)
+                g = int(token[2:4], 16)
+                b = int(token[4:6], 16)
+            except ValueError as e:
+                raise AssertionError(
+                    f'{path}: expected RRGGBB token, got {token!r}'
+                ) from e
+
+            rgb.extend((r, g, b))
+
+    expected_len = width * height * 3
+    assert len(rgb) == expected_len, (
+        f'{path}: expected {expected_len} bytes, got {len(rgb)}'
+    )
+    return bytes(rgb)
+
+
+_SMALL_PATTERN_RGB = _load_rgbhex('small_pattern_4x3.rgbhex', width=4, height=3)
+
+
+def test_encode_1x1_red_matches_reference() -> None:
+    img = Image.new('RGB', (1, 1), (255, 0, 0))
+    assert blurhash_encode(img, 1, 1) == '00TI:j'
+
+
+def test_encode_small_pattern_matches_reference() -> None:
+    img = Image.frombytes('RGB', (4, 3), _SMALL_PATTERN_RGB)
+    assert blurhash_encode(img, 4, 3) == 'LzJkWT?SSs?F~q$um-krE0vfmJ5t'
+
+
+def test_encode_accepts_rgba_input_ignores_alpha_matches_rgb() -> None:
+    rgb = _SMALL_PATTERN_RGB
+    rgba = bytearray()
+    for i in range(0, len(rgb), 3):
+        rgba.extend((
+            rgb[i],
+            rgb[i + 1],
+            rgb[i + 2],
+            0 if (i // 3) % 2 == 0 else 255,
+        ))
+
+    img = Image.frombytes('RGBA', (4, 3), rgba)
+    assert blurhash_encode(img, 4, 3) == 'LzJkWT?SSs?F~q$um-krE0vfmJ5t'
+
+
+def test_decode_known_hash_matches_reference_bytes() -> None:
+    hash_ = 'LEHV6nWB2yk8pyo0adR*.7kCMdnj'
+    img = blurhash_decode(hash_, 8, 8)
+    assert img.mode == 'RGB'
+    assert img.size == (8, 8)
+
+    reference = _load_rgbhex('decode_known_hash_8x8.rgbhex', width=8, height=8)
+    _assert_bytes_close(
+        img.tobytes(),
+        reference,
+        max_abs_diff=2,
+        max_mean_abs_diff=0.05,
+        max_different_bytes=32,
+    )
+
+
+def test_decode_invalid_blurhash_raises() -> None:
+    with pytest.raises(BlurhashDecodeError) as excinfo:
+        blurhash_decode('not a blurhash', 8, 8)
+    assert excinfo.value.blurhash == 'not a blurhash'
+
+
+def test_decode_whitespace_suffix_raises() -> None:
+    with pytest.raises(BlurhashDecodeError):
+        blurhash_decode('LEHV6nWB2yk8pyo0adR*.7kCMdnj ', 8, 8)