python-libphash 1.2.0__tar.gz → 1.4.0__tar.gz

python_libphash-1.4.0/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: python-libphash
+Version: 1.4.0
+Summary: High-performance perceptual hashing library (CFFI bindings)
+Author-email: gudoshnikovn <gudoshnikov-na@yandex.ru>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/gudoshnikovn/python-libphash
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cffi>=1.15.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
+Provides-Extra: benchmark
+Requires-Dist: imagehash; extra == "benchmark"
+Requires-Dist: Pillow; extra == "benchmark"
+Requires-Dist: pandas; extra == "benchmark"
+Requires-Dist: tabulate; extra == "benchmark"
+Requires-Dist: scikit-learn; extra == "benchmark"
+Requires-Dist: tqdm; extra == "benchmark"
+Requires-Dist: numpy; extra == "benchmark"
+Dynamic: license-file
+
+# python-libphash
+
+High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/libphash), a C library for perceptual image hashing.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+## Overview
+
+`libphash` provides multiple algorithms to generate "perceptual hashes" of images. Unlike cryptographic hashes (like MD5 or SHA256), perceptual hashes change only slightly if the image is resized, compressed, or has minor color adjustments. This makes them ideal for finding duplicate or similar images.
+
+### Supported Algorithms
+
+*   **64-bit Hashes (uint64):**
+    *   `ahash`: Average Hash
+    *   `dhash`: Difference Hash
+    *   `phash`: Perceptual Hash (DCT based)
+    *   `whash`: Wavelet Hash
+    *   `mhash`: Median Hash
+    *   `color_hash`: Packed 42-bit HSV-based color hash (compatible with `imagehash.colorhash`).
+*   **Digest Hashes (Multi-byte):**
+    *   `bmh`: Block Mean Hash (256-bit digest).
+    *   `color_moments_hash`: Statistical color distribution digest (mean, variance, skewness, kurtosis).
+    *   `radial_hash`: Rotation-invariant Fourier-Mellin transform digest.
+
+## Installation
+
+### Prerequisites
+*   A C compiler (GCC/Clang or MSVC)
+*   Python 3.8 or higher
+
+### Install from PyPI
+```bash
+pip install python-libphash
+# or using uv
+uv add python-libphash
+```
+
+### Install from source
+```bash
+git clone --recursive https://github.com/yourusername/python-libphash.git
+cd python-libphash
+pip install .
+# or using uv
+uv pip install .
+```
+
+## Quick Start
+
+### Quick Start (CLI)
+You can quickly compute a hash from the command line after installation:
+```bash
+python -m libphash.utils --path photo.jpg --method phash
+```
+
+### Basic Usage
+```python
+from libphash import ImageContext, HashMethod, hamming_distance
+
+# Use the context manager for automatic memory management
+with ImageContext("photo.jpg") as ctx:
+    # Get standard 64-bit hashes
+    phash_val = ctx.phash
+    dhash_val = ctx.dhash
+    
+    print(f"pHash: {phash_val:016x}")
+    print(f"dHash: {dhash_val:016x}")
+
+# Compare two images
+from libphash import compare_images
+distance = compare_images("image1.jpg", "image2.jpg", method=HashMethod.PHASH)
+print(f"Hamming Distance: {distance}")
+```
+
+### Customizing Algorithms & Performance
+Fine-tune hashing algorithms for specific use cases. Note that hashes generated with different parameters are **not comparable**.
+
+*   **Ultra-Fast Image Decoding**: `libphash` bundles high-performance decoders for JPEG, PNG, and WebP. It uses `libjpeg-turbo` (TurboJPEG API), `libpng`/`spng`, and `libwebp` with SIMD acceleration (SSE/NEON/AVX2). Image data is loaded via `mmap()` for zero-copy I/O between the file system and the decoder.
+    *   **Fallback**: Automatically falls back to `stb_image` for other formats or if bundled decoders are disabled.
+
+```python
+with ImageContext("photo.jpg") as ctx:
+    # pHash (DCT) resolution
+    ctx.set_phash_params(dct_size=32, reduction_size=8)
+    
+    # Radial Hash precision
+    ctx.set_radial_params(projections=40, samples=128)
+    
+    # Block-based hashes (BMH) grid resolution
+    ctx.set_block_params(block_size=16)
+    
+    # Wavelet Hash (wHash) Mode: "fast" (default) or "full"
+    ctx.set_whash_mode("full")
+    
+    # Custom Grayscale weights (R, G, B)
+    ctx.set_gray_weights(38, 75, 15)
+    
+    print(f"Custom pHash: {ctx.phash:016x}")
+```
+
+### Working with Digests (Advanced Hashes)
+Algorithms like Radial Hash or Color Hash return a `Digest` object instead of a single integer.
+
+```python
+with ImageContext("photo.jpg") as ctx:
+    digest = ctx.radial_hash
+    print(f"Digest size: {digest.size} bytes")
+    print(f"Raw data: {digest.data.hex()}")
+
+# Comparing digests
+with ImageContext("photo_v2.jpg") as ctx2:
+    digest2 = ctx2.radial_hash
+    
+    # Hamming distance for bit-wise comparison
+    h_dist = digest.distance_hamming(digest2)
+    
+    # L2 (Euclidean) distance for similarity
+    l2_dist = digest.distance_l2(digest2)
+```
+
+## API Reference
+
+### `ImageContext`
+The main class for loading images and computing hashes.
+*   `__init__(path=None, bytes_data=None)`: Load an image from a file path or memory.
+*   `set_gamma(gamma: float)`: Set gamma correction.
+*   `set_gray_weights(r, g, b)`: Set custom RGB weights for grayscale conversion.
+*   `set_phash_params(dct_size, reduction_size)`: Configure pHash DCT resolution.
+*   `set_radial_params(projections, samples)`: Configure Radial Hash precision.
+*   `set_block_params(block_size)`: Configure BMH/mHash grid resolution.
+*   `set_whash_mode(mode="fast")`: Use "fast" (median) or "full" (ImageHash accurate 2D DWT).
+*   **Properties**: `ahash`, `dhash`, `phash`, `whash`, `mhash` (returns `int`).
+*   **Properties**: `bmh`, `color_hash`, `radial_hash` (returns `Digest`).
+
+### `Digest`
+*   `data`: The raw `bytes` of the hash.
+*   `size`: Length of the hash in bytes.
+*   `distance_hamming(other)`: Calculates bit-wise distance.
+*   `distance_l2(other)`: Calculates Euclidean distance.
+
+### Utilities
+*   `hamming_distance(h1: int, h2: int)`: Returns the number of differing bits between two 64-bit integers.
+*   `ph_can_use_libjpeg()`: Returns `True` if `libjpeg-turbo` is enabled.
+*   `ph_can_use_libpng()`: Returns `True` if `libpng` or `spng` is enabled.
+*   `get_hash(path, method)`: Quick way to get a hash without manual context management.
+*   `compare_images(path1, path2, method)`: Returns the Hamming distance between two image files.
+
+## Performance
+Since the core logic is implemented in C and uses SIMD-accelerated decoders (SSE4.2, AVX2, NEON), `libphash` is significantly faster than pure-Python alternatives.
+
+*   **JPEG Decoding**: ~2.0x–6.0x faster than Pillow (TurboJPEG API).
+*   **PNG Decoding**: ~1.3x faster than Pillow (spng/libpng).
+*   **WebP Decoding**: ~2.5x faster than Pillow (Native `libwebp`).
+*   **Zero-Copy**: Uses `mmap()` to avoid kernel-user space copies.
+
+| Algorithm | imagehash (Pillow) | libphash (Native) | Speedup |
+| :--- | :--- | :--- | :--- |
+| **pHash** (JPEG) | 0.4506s | 0.0667s | **6.76x** |
+| **wHash** (JPEG) | 3.2750s | 0.0650s | **50.39x** |
+| **pHash** (WebP) | 0.3298s | 0.1240s | **2.66x** |
+| **wHash** (WebP) | 2.0520s | 0.1197s | **17.14x** |
+
+## License
+This project is licensed under the MIT License - see the LICENSE file for details.
+

python_libphash-1.4.0/README.md

@@ -0,0 +1,165 @@
+# python-libphash
+
+High-performance Python bindings for [libphash](https://github.com/gudoshnikovn/libphash), a C library for perceptual image hashing.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+## Overview
+
+`libphash` provides multiple algorithms to generate "perceptual hashes" of images. Unlike cryptographic hashes (like MD5 or SHA256), perceptual hashes change only slightly if the image is resized, compressed, or has minor color adjustments. This makes them ideal for finding duplicate or similar images.
+
+### Supported Algorithms
+
+*   **64-bit Hashes (uint64):**
+    *   `ahash`: Average Hash
+    *   `dhash`: Difference Hash
+    *   `phash`: Perceptual Hash (DCT based)
+    *   `whash`: Wavelet Hash
+    *   `mhash`: Median Hash
+    *   `color_hash`: Packed 42-bit HSV-based color hash (compatible with `imagehash.colorhash`).
+*   **Digest Hashes (Multi-byte):**
+    *   `bmh`: Block Mean Hash (256-bit digest).
+    *   `color_moments_hash`: Statistical color distribution digest (mean, variance, skewness, kurtosis).
+    *   `radial_hash`: Rotation-invariant Fourier-Mellin transform digest.
+
+## Installation
+
+### Prerequisites
+*   A C compiler (GCC/Clang or MSVC)
+*   Python 3.8 or higher
+
+### Install from PyPI
+```bash
+pip install python-libphash
+# or using uv
+uv add python-libphash
+```
+
+### Install from source
+```bash
+git clone --recursive https://github.com/yourusername/python-libphash.git
+cd python-libphash
+pip install .
+# or using uv
+uv pip install .
+```
+
+## Quick Start
+
+### Quick Start (CLI)
+You can quickly compute a hash from the command line after installation:
+```bash
+python -m libphash.utils --path photo.jpg --method phash
+```
+
+### Basic Usage
+```python
+from libphash import ImageContext, HashMethod, hamming_distance
+
+# Use the context manager for automatic memory management
+with ImageContext("photo.jpg") as ctx:
+    # Get standard 64-bit hashes
+    phash_val = ctx.phash
+    dhash_val = ctx.dhash
+    
+    print(f"pHash: {phash_val:016x}")
+    print(f"dHash: {dhash_val:016x}")
+
+# Compare two images
+from libphash import compare_images
+distance = compare_images("image1.jpg", "image2.jpg", method=HashMethod.PHASH)
+print(f"Hamming Distance: {distance}")
+```
+
+### Customizing Algorithms & Performance
+Fine-tune hashing algorithms for specific use cases. Note that hashes generated with different parameters are **not comparable**.
+
+*   **Ultra-Fast Image Decoding**: `libphash` bundles high-performance decoders for JPEG, PNG, and WebP. It uses `libjpeg-turbo` (TurboJPEG API), `libpng`/`spng`, and `libwebp` with SIMD acceleration (SSE/NEON/AVX2). Image data is loaded via `mmap()` for zero-copy I/O between the file system and the decoder.
+    *   **Fallback**: Automatically falls back to `stb_image` for other formats or if bundled decoders are disabled.
+
+```python
+with ImageContext("photo.jpg") as ctx:
+    # pHash (DCT) resolution
+    ctx.set_phash_params(dct_size=32, reduction_size=8)
+    
+    # Radial Hash precision
+    ctx.set_radial_params(projections=40, samples=128)
+    
+    # Block-based hashes (BMH) grid resolution
+    ctx.set_block_params(block_size=16)
+    
+    # Wavelet Hash (wHash) Mode: "fast" (default) or "full"
+    ctx.set_whash_mode("full")
+    
+    # Custom Grayscale weights (R, G, B)
+    ctx.set_gray_weights(38, 75, 15)
+    
+    print(f"Custom pHash: {ctx.phash:016x}")
+```
+
+### Working with Digests (Advanced Hashes)
+Algorithms like Radial Hash or Color Hash return a `Digest` object instead of a single integer.
+
+```python
+with ImageContext("photo.jpg") as ctx:
+    digest = ctx.radial_hash
+    print(f"Digest size: {digest.size} bytes")
+    print(f"Raw data: {digest.data.hex()}")
+
+# Comparing digests
+with ImageContext("photo_v2.jpg") as ctx2:
+    digest2 = ctx2.radial_hash
+    
+    # Hamming distance for bit-wise comparison
+    h_dist = digest.distance_hamming(digest2)
+    
+    # L2 (Euclidean) distance for similarity
+    l2_dist = digest.distance_l2(digest2)
+```
+
+## API Reference
+
+### `ImageContext`
+The main class for loading images and computing hashes.
+*   `__init__(path=None, bytes_data=None)`: Load an image from a file path or memory.
+*   `set_gamma(gamma: float)`: Set gamma correction.
+*   `set_gray_weights(r, g, b)`: Set custom RGB weights for grayscale conversion.
+*   `set_phash_params(dct_size, reduction_size)`: Configure pHash DCT resolution.
+*   `set_radial_params(projections, samples)`: Configure Radial Hash precision.
+*   `set_block_params(block_size)`: Configure BMH/mHash grid resolution.
+*   `set_whash_mode(mode="fast")`: Use "fast" (median) or "full" (ImageHash accurate 2D DWT).
+*   **Properties**: `ahash`, `dhash`, `phash`, `whash`, `mhash` (returns `int`).
+*   **Properties**: `bmh`, `color_hash`, `radial_hash` (returns `Digest`).
+
+### `Digest`
+*   `data`: The raw `bytes` of the hash.
+*   `size`: Length of the hash in bytes.
+*   `distance_hamming(other)`: Calculates bit-wise distance.
+*   `distance_l2(other)`: Calculates Euclidean distance.
+
+### Utilities
+*   `hamming_distance(h1: int, h2: int)`: Returns the number of differing bits between two 64-bit integers.
+*   `ph_can_use_libjpeg()`: Returns `True` if `libjpeg-turbo` is enabled.
+*   `ph_can_use_libpng()`: Returns `True` if `libpng` or `spng` is enabled.
+*   `get_hash(path, method)`: Quick way to get a hash without manual context management.
+*   `compare_images(path1, path2, method)`: Returns the Hamming distance between two image files.
+
+## Performance
+Since the core logic is implemented in C and uses SIMD-accelerated decoders (SSE4.2, AVX2, NEON), `libphash` is significantly faster than pure-Python alternatives.
+
+*   **JPEG Decoding**: ~2.0x–6.0x faster than Pillow (TurboJPEG API).
+*   **PNG Decoding**: ~1.3x faster than Pillow (spng/libpng).
+*   **WebP Decoding**: ~2.5x faster than Pillow (Native `libwebp`).
+*   **Zero-Copy**: Uses `mmap()` to avoid kernel-user space copies.
+
+| Algorithm | imagehash (Pillow) | libphash (Native) | Speedup |
+| :--- | :--- | :--- | :--- |
+| **pHash** (JPEG) | 0.4506s | 0.0667s | **6.76x** |
+| **wHash** (JPEG) | 3.2750s | 0.0650s | **50.39x** |
+| **pHash** (WebP) | 0.3298s | 0.1240s | **2.66x** |
+| **wHash** (WebP) | 2.0520s | 0.1197s | **17.14x** |
+
+## License
+This project is licensed under the MIT License - see the LICENSE file for details.
+

python_libphash-1.4.0/native/libphash/.github/workflows/ci.yml

@@ -0,0 +1,67 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Install Dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y cmake clang libpng-dev libjpeg-dev libwebp-dev zlib1g-dev
+
+    - name: Configure CMake
+      run: cmake -B build -DPHASH_BUILD_TESTS=ON
+
+    - name: Build
+      run: cmake --build build --config Release
+
+    - name: Run Tests
+      run: cd build && ctest --output-on-failure
+
+  benchmark:
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout PR branch
+      uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Install Dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y cmake libpng-dev libjpeg-dev libwebp-dev zlib1g-dev
+
+    - name: Build
+      run: |
+        cmake -B build -DPHASH_BUILD_TESTS=ON
+        cmake --build build --config Release
+
+    - name: Run Benchmarks
+      run: |
+        cd build
+        echo "### Performance Benchmark" > ../benchmark_report.md
+        echo '```text' >> ../benchmark_report.md
+        ./test_benchmark smoke >> ../benchmark_report.md
+        echo '```' >> ../benchmark_report.md
+        cat ../benchmark_report.md >> $GITHUB_STEP_SUMMARY
+
+    - name: Post Performance Report
+      uses: thollander/actions-comment-pull-request@v2
+      with:
+        filePath: benchmark_report.md
+        comment_tag: performance_report

python_libphash-1.4.0/native/libphash/.gitignore

@@ -0,0 +1,37 @@
+# Object files and libraries
+*.o
+*.a
+*.so
+*.dylib
+*.dll
+obj/
+
+# Executables (Tests)
+test_*
+!tests/**/test_*.c
+!tests/**/*.h
+
+# IDEs and Editors
+.vscode/
+.idea/
+*.swp
+*.swo
+.DS_Store
+
+# Build artifacts
+dist/
+build/
+.cache/
+
+# Test images (if generated)
+tests/output_*.jpeg
+
+# Coverage and GCov data
+docs/coverage/
+*.gcda
+*.gcno
+*.gcov
+src/*.gcda
+src/*.gcno
+src/**/*.gcda
+src/**/*.gcno

python_libphash-1.4.0/native/libphash/.gitmodules

@@ -0,0 +1,12 @@
+[submodule "vendor/libjpeg-turbo"]
+	path = vendor/libjpeg-turbo
+	url = https://github.com/libjpeg-turbo/libjpeg-turbo.git
+[submodule "vendor/libpng"]
+	path = vendor/libpng
+	url = https://github.com/pnggroup/libpng.git
+[submodule "vendor/spng"]
+	path = vendor/spng
+	url = https://github.com/randy408/libspng.git
+[submodule "vendor/libwebp"]
+	path = vendor/libwebp
+	url = https://github.com/webmproject/libwebp.git

python_libphash-1.4.0/native/libphash/CMakeLists.txt

@@ -0,0 +1,151 @@
+cmake_minimum_required(VERSION 3.10)
+project(libphash VERSION 1.9.0 LANGUAGES C)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# --- Options ---
+option(PHASH_BUILD_TESTS "Build tests" ON)
+option(PHASH_BUILD_SHARED "Build shared library" OFF)
+option(PHASH_USE_TURBOJPEG "Use bundled libjpeg-turbo for fast JPEG decoding" ON)
+option(PHASH_USE_LIBPNG "Use bundled libpng for fast PNG decoding" ON)
+option(PHASH_USE_WEBP "Use external libwebp for WebP decoding" ON)
+option(PHASH_OPTIMIZE_NATIVE "Optimize for host CPU architecture (-march=native)" OFF)
+
+# --- Compiler Flags ---
+include(CheckCCompilerFlag)
+
+if(MSVC)
+    add_compile_options(/W3 /O2)
+else()
+    add_compile_options(-Wall -Wextra -O3 -fPIC)
+    
+    if(PHASH_OPTIMIZE_NATIVE)
+        add_compile_options(-march=native)
+    else()
+        # Architecture specific optimizations
+        if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64")
+            add_compile_options(-msse4.2)
+            # Dynamically check for AVX2 support and apply ONLY to common.c
+            check_c_compiler_flag("-mavx2" COMPILER_SUPPORTS_AVX2)
+            if(COMPILER_SUPPORTS_AVX2)
+                set_source_files_properties(src/hashes/common.c PROPERTIES COMPILE_OPTIONS "-mavx2")
+                set_source_files_properties(src/hashes/color_hsv.c PROPERTIES COMPILE_OPTIONS "-ffast-math")
+            endif()
+        elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64")
+            add_compile_options(-march=armv8-a+simd)
+        endif()
+    endif()
+endif()
+
+# --- Library ---
+file(GLOB_RECURSE SOURCES "src/*.c")
+
+if(PHASH_BUILD_SHARED)
+    add_library(phash SHARED ${SOURCES})
+    target_compile_definitions(phash PRIVATE LIBPHASH_EXPORTS)
+else()
+    add_library(phash STATIC ${SOURCES})
+endif()
+
+target_include_directories(phash PUBLIC 
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+    $<INSTALL_INTERFACE:include>
+)
+
+target_link_libraries(phash PRIVATE m)
+
+if(UNIX AND NOT APPLE)
+    target_link_libraries(phash PRIVATE dl)
+endif()
+
+# --- Bundled libjpeg-turbo (TurboJPEG API) ---
+if(PHASH_USE_TURBOJPEG)
+    # libjpeg-turbo doesn't like add_subdirectory, so we point to pre-built lib
+    find_library(TURBOJPEG_LIB NAMES turbojpeg turbojpeg-static
+                 PATHS ${CMAKE_CURRENT_SOURCE_DIR}/vendor/libjpeg-turbo/build)
+    if(TURBOJPEG_LIB)
+        target_compile_definitions(phash PRIVATE PH_USE_TURBOJPEG)
+        target_link_libraries(phash PRIVATE ${TURBOJPEG_LIB})
+        target_include_directories(phash PRIVATE 
+            ${CMAKE_CURRENT_SOURCE_DIR}/vendor/libjpeg-turbo/src
+            ${CMAKE_CURRENT_SOURCE_DIR}/vendor/libjpeg-turbo/build
+        )
+    else()
+        message(WARNING "libturbojpeg.a not found in vendor/libjpeg-turbo/build. Falling back to stb_image.")
+    endif()
+endif()
+
+# --- Bundled libpng ---
+if(PHASH_USE_LIBPNG)
+    target_compile_definitions(phash PRIVATE PH_USE_LIBPNG)
+    set(PNG_SHARED OFF CACHE BOOL "" FORCE)
+    set(PNG_STATIC ON CACHE BOOL "" FORCE)
+    set(PNG_TESTS OFF CACHE BOOL "" FORCE)
+    set(PNG_HARDWARE_OPTIMIZATIONS ON CACHE BOOL "" FORCE)
+    # libpng works mostly OK with add_subdirectory
+    add_subdirectory(vendor/libpng EXCLUDE_FROM_ALL)
+    target_link_libraries(phash PRIVATE png_static z)
+    target_include_directories(phash PRIVATE 
+        ${CMAKE_CURRENT_SOURCE_DIR}/vendor/libpng
+        ${CMAKE_CURRENT_BINARY_DIR}/vendor/libpng
+    )
+endif()
+
+# --- Bundled spng ---
+if(PHASH_USE_SPNG)
+    target_compile_definitions(phash PRIVATE PH_USE_SPNG)
+    add_library(spng_static STATIC vendor/spng/spng/spng.c)
+    target_include_directories(spng_static PUBLIC vendor/spng/spng)
+    target_link_libraries(phash PRIVATE spng_static z)
+    target_include_directories(phash PRIVATE vendor/spng/spng)
+endif()
+
+# --- Bundled libwebp ---
+if(PHASH_USE_WEBP)
+    target_compile_definitions(phash PRIVATE PH_USE_WEBP)
+    
+    # Configure libwebp build (minimal decoder only)
+    set(WEBP_BUILD_ANIM_UTILS OFF CACHE BOOL "" FORCE)
+    set(WEBP_BUILD_CWEBP OFF CACHE BOOL "" FORCE)
+    set(WEBP_BUILD_DWEBP OFF CACHE BOOL "" FORCE)
+    set(WEBP_BUILD_GIF2WEBP OFF CACHE BOOL "" FORCE)
+    set(WEBP_BUILD_IMG2WEBP OFF CACHE BOOL "" FORCE)
+    set(WEBP_BUILD_VWEBP OFF CACHE BOOL "" FORCE)
+    set(WEBP_BUILD_WEBPINFO OFF CACHE BOOL "" FORCE)
+    set(WEBP_BUILD_LIBWEBPMUX OFF CACHE BOOL "" FORCE)
+    set(WEBP_BUILD_WEBPMUX OFF CACHE BOOL "" FORCE)
+    set(WEBP_BUILD_EXTRAS OFF CACHE BOOL "" FORCE)
+    set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
+    set(WEBP_LINK_STATIC ON CACHE BOOL "" FORCE)
+
+    add_subdirectory(vendor/libwebp EXCLUDE_FROM_ALL)
+    
+    # We only need the decoder part for phash
+    target_link_libraries(phash PRIVATE webpdecoder)
+    target_include_directories(phash PRIVATE 
+        ${CMAKE_CURRENT_SOURCE_DIR}/vendor/libwebp/src
+    )
+endif()
+# --- Tests ---
+if(PHASH_BUILD_TESTS)
+    target_compile_definitions(phash PRIVATE PH_TESTING)
+    enable_testing()
+    file(GLOB TEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/tests/src/test_*.c")
+    foreach(test_src ${TEST_SOURCES})
+        get_filename_component(test_name ${test_src} NAME_WE)
+        add_executable(${test_name} ${test_src})
+        target_link_libraries(${test_name} PRIVATE phash)
+        target_include_directories(${test_name} PRIVATE 
+            ${CMAKE_CURRENT_SOURCE_DIR}/src
+            ${CMAKE_CURRENT_SOURCE_DIR}/tests/src
+        )
+        target_compile_definitions(${test_name} PRIVATE 
+            TEST_DATA_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}/tests/data\"
+            PH_TESTING
+        )
+        add_test(NAME ${test_name} COMMAND $<TARGET_FILE:${test_name}>)
+    endforeach()
+
+    # Add benchmark as a smoke test (verifies loading and hashing works)
+    add_test(NAME benchmark_smoke COMMAND $<TARGET_FILE:test_benchmark> hash ${CMAKE_CURRENT_SOURCE_DIR}/tests/data/photo.jpeg 10)
+endif()