@dynlabs/react-native-image-to-webp 0.1.0

package/android/src/main/java/com/dynlabs/reactnativeimagetowebp/ReactNativeImageToWebpModule.kt

@@ -0,0 +1,258 @@
+package com.dynlabs.reactnativeimagetowebp
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.ImageDecoder
+import android.net.Uri
+import android.os.Build
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import java.io.File
+import java.io.FileOutputStream
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+class ReactNativeImageToWebpModule(reactContext: ReactApplicationContext) :
+  NativeReactNativeImageToWebpSpec(reactContext) {
+
+  private val executor: ExecutorService = Executors.newSingleThreadExecutor()
+
+  companion object {
+    init {
+      System.loadLibrary("react-native-image-to-webp")
+    }
+
+    const val NAME = NativeReactNativeImageToWebpSpec.NAME
+
+    private const val ERROR_CODE_INVALID_INPUT = "INVALID_INPUT"
+    private const val ERROR_CODE_FILE_NOT_FOUND = "FILE_NOT_FOUND"
+    private const val ERROR_CODE_DECODE_FAILED = "DECODE_FAILED"
+    private const val ERROR_CODE_ENCODE_FAILED = "ENCODE_FAILED"
+    private const val ERROR_CODE_IO_ERROR = "IO_ERROR"
+    private const val ERROR_CODE_UNSUPPORTED_FORMAT = "UNSUPPORTED_FORMAT"
+  }
+
+  // Native JNI methods
+  private external fun nativeEncodeWebP(
+    rgbaData: ByteArray,
+    width: Int,
+    height: Int,
+    quality: Int,
+    method: Int,
+    lossless: Boolean,
+    outputPath: String
+  ): Boolean
+
+  private external fun nativeGetLastError(): String
+
+  override fun convertImageToWebP(
+    options: ReadableMap,
+    promise: Promise
+  ) {
+    executor.execute {
+      try {
+        val result = convertImageToWebPInternal(options)
+        promise.resolve(result)
+      } catch (e: Exception) {
+        promise.reject(
+          when (e) {
+            is FileNotFoundException -> ERROR_CODE_FILE_NOT_FOUND
+            is IllegalArgumentException -> ERROR_CODE_INVALID_INPUT
+            is UnsupportedOperationException -> ERROR_CODE_UNSUPPORTED_FORMAT
+            else -> ERROR_CODE_DECODE_FAILED
+          },
+          e.message ?: "Unknown error",
+          e
+        )
+      }
+    }
+  }
+
+  private fun convertImageToWebPInternal(options: ReadableMap): WritableMap {
+    // Parse options
+    val inputPath = options.getString("inputPath")
+      ?: throw IllegalArgumentException("inputPath is required")
+
+    val outputPath = options.getString("outputPath")
+      ?: deriveOutputPath(inputPath)
+
+    val maxLongEdge = if (options.hasKey("maxLongEdge")) {
+      options.getDouble("maxLongEdge").toInt()
+    } else {
+      null
+    }
+
+    val quality = if (options.hasKey("quality")) {
+      options.getInt("quality")
+    } else {
+      80
+    }
+
+    val method = if (options.hasKey("method")) {
+      options.getInt("method")
+    } else {
+      3
+    }
+
+    val lossless = options.hasKey("lossless") && options.getBoolean("lossless")
+
+    // Validate
+    if (maxLongEdge != null && maxLongEdge <= 0) {
+      throw IllegalArgumentException("maxLongEdge must be positive")
+    }
+    if (quality < 0 || quality > 100) {
+      throw IllegalArgumentException("quality must be between 0 and 100")
+    }
+    if (method < 0 || method > 6) {
+      throw IllegalArgumentException("method must be between 0 and 6")
+    }
+
+    // Check input file
+    val inputFile = File(inputPath)
+    if (!inputFile.exists() || !inputFile.canRead()) {
+      throw FileNotFoundException("File not found: $inputPath")
+    }
+
+    // Decode image
+    val bitmap = decodeImage(inputFile, maxLongEdge)
+      ?: throw RuntimeException("Failed to decode image")
+
+    val width = bitmap.width
+    val height = bitmap.height
+
+    // Convert bitmap to RGBA
+    val rgbaData = bitmapToRGBA(bitmap)
+    bitmap.recycle()
+
+    // Ensure output directory exists
+    val outputFile = File(outputPath)
+    outputFile.parentFile?.mkdirs()
+
+    // Encode to WebP using native code
+    val success = nativeEncodeWebP(
+      rgbaData,
+      width,
+      height,
+      quality,
+      method,
+      lossless,
+      outputPath
+    )
+
+    if (!success) {
+      val errorMsg = nativeGetLastError()
+      throw RuntimeException("WebP encoding failed: $errorMsg")
+    }
+
+    // Get file size
+    val sizeBytes = outputFile.length()
+
+    // Return result
+    val result = Arguments.createMap()
+    result.putString("outputPath", outputPath)
+    result.putInt("width", width)
+    result.putInt("height", height)
+    result.putDouble("sizeBytes", sizeBytes.toDouble())
+
+    return result
+  }
+
+  private fun decodeImage(file: File, maxLongEdge: Int?): Bitmap? {
+    return try {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+        // Use ImageDecoder for modern Android
+        val source = ImageDecoder.createSource(file)
+        val decoder = ImageDecoder.decodeBitmap(source) { decoder, info, source ->
+          // Apply sampling if maxLongEdge is specified
+          maxLongEdge?.let { maxEdge ->
+            val originalWidth = info.size.width
+            val originalHeight = info.size.height
+            val maxDimension = maxOf(originalWidth, originalHeight)
+            if (maxDimension > maxEdge) {
+              val sampleSize = (maxDimension / maxEdge).toInt().coerceAtLeast(1)
+              decoder.setTargetSampleSize(sampleSize)
+            }
+          }
+        }
+        decoder
+      } else {
+        // Fallback to BitmapFactory
+        val options = BitmapFactory.Options().apply {
+          inJustDecodeBounds = true
+        }
+        BitmapFactory.decodeFile(file.absolutePath, options)
+
+        maxLongEdge?.let { maxEdge ->
+          val maxDimension = maxOf(options.outWidth, options.outHeight)
+          if (maxDimension > maxEdge) {
+            val sampleSize = (maxDimension / maxEdge).toInt().coerceAtLeast(1)
+            options.inSampleSize = sampleSize
+          }
+        }
+
+        options.inJustDecodeBounds = false
+        options.inPreferredConfig = Bitmap.Config.ARGB_8888
+
+        var bitmap = BitmapFactory.decodeFile(file.absolutePath, options)
+          ?: return null
+
+        // Apply EXIF orientation if needed
+        bitmap = applyExifOrientation(bitmap, file)
+
+        // Final resize if still needed (inSampleSize is approximate)
+        maxLongEdge?.let { maxEdge ->
+          val currentMax = maxOf(bitmap.width, bitmap.height)
+          if (currentMax > maxEdge) {
+            val scale = maxEdge.toFloat() / currentMax
+            val newWidth = (bitmap.width * scale).toInt()
+            val newHeight = (bitmap.height * scale).toInt()
+            val resized = Bitmap.createScaledBitmap(bitmap, newWidth, newHeight, true)
+            if (resized != bitmap) {
+              bitmap.recycle()
+              bitmap = resized
+            }
+          }
+        }
+
+        bitmap
+      }
+    } catch (e: Exception) {
+      throw RuntimeException("Failed to decode image: ${e.message}", e)
+    }
+  }
+
+  private fun applyExifOrientation(bitmap: Bitmap, file: File): Bitmap {
+    // Note: For full EXIF support, use ExifInterface
+    // For now, return bitmap as-is
+    // TODO: Implement EXIF orientation handling using android.media.ExifInterface
+    return bitmap
+  }
+
+  private fun bitmapToRGBA(bitmap: Bitmap): ByteArray {
+    val width = bitmap.width
+    val height = bitmap.height
+    val pixels = IntArray(width * height)
+    bitmap.getPixels(pixels, 0, width, 0, 0, width, height)
+
+    val rgbaData = ByteArray(width * height * 4)
+    var index = 0
+    for (pixel in pixels) {
+      rgbaData[index++] = ((pixel shr 16) and 0xFF).toByte() // R
+      rgbaData[index++] = ((pixel shr 8) and 0xFF).toByte()  // G
+      rgbaData[index++] = (pixel and 0xFF).toByte()          // B
+      rgbaData[index++] = ((pixel shr 24) and 0xFF).toByte() // A
+    }
+
+    return rgbaData
+  }
+
+  private fun deriveOutputPath(inputPath: String): String {
+    val inputFile = File(inputPath)
+    val directory = inputFile.parent
+    val filename = inputFile.nameWithoutExtension
+    return File(directory, "$filename.webp").absolutePath
+  }
+}

package/android/src/main/java/com/dynlabs/reactnativeimagetowebp/ReactNativeImageToWebpPackage.kt

@@ -0,0 +1,33 @@
+package com.dynlabs.reactnativeimagetowebp
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class ReactNativeImageToWebpPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == ReactNativeImageToWebpModule.NAME) {
+      ReactNativeImageToWebpModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[ReactNativeImageToWebpModule.NAME] = ReactModuleInfo(
+        ReactNativeImageToWebpModule.NAME,
+        ReactNativeImageToWebpModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/cpp/ImageToWebP.cpp

@@ -0,0 +1,132 @@
+#include "ImageToWebP.h"
+#include <fstream>
+#include <vector>
+#include <cstring>
+
+// libwebp includes (uncomment after vendoring libwebp)
+#ifdef WEBP_AVAILABLE
+#include "webp/encode.h"
+#include "webp/mux.h"
+#endif
+
+WebPEncodeResult encodeWebP(
+    const uint8_t* rgbaData,
+    uint32_t width,
+    uint32_t height,
+    const WebPEncodeOptions& options,
+    const std::string& outputPath) {
+  WebPEncodeResult result;
+  result.width = width;
+  result.height = height;
+
+#ifdef WEBP_AVAILABLE
+  // Initialize WebP config
+  WebPConfig config;
+  if (!WebPConfigInit(&config)) {
+    result.success = false;
+    result.errorMessage = "Failed to initialize WebP config";
+    return result;
+  }
+
+  // Apply preset
+  WebPPreset preset = WEBP_PRESET_DEFAULT;
+  if (options.lossless) {
+    preset = WEBP_PRESET_DEFAULT; // Will be overridden by lossless flag
+  }
+  
+  if (!WebPConfigPreset(&config, preset, options.quality)) {
+    result.success = false;
+    result.errorMessage = "Failed to configure WebP preset";
+    return result;
+  }
+
+  // Override with options
+  config.quality = static_cast<float>(options.quality);
+  config.method = options.method;
+  config.lossless = options.lossless ? 1 : 0;
+  config.exact = options.exact ? 1 : 0;
+  
+  // Thread level (if supported)
+  #ifdef WEBP_USE_THREAD
+  config.thread_level = options.threadLevel;
+  #endif
+
+  // Validate config
+  if (!WebPValidateConfig(&config)) {
+    result.success = false;
+    result.errorMessage = "Invalid WebP config";
+    return result;
+  }
+
+  // Initialize picture
+  WebPPicture picture;
+  if (!WebPPictureInit(&picture)) {
+    result.success = false;
+    result.errorMessage = "Failed to initialize WebP picture";
+    return result;
+  }
+
+  picture.width = static_cast<int>(width);
+  picture.height = static_cast<int>(height);
+  picture.use_argb = options.lossless ? 1 : 0; // Use ARGB for lossless
+
+  // Import RGBA data
+  if (!WebPPictureImportRGBA(&picture, rgbaData, static_cast<int>(width * 4))) {
+    WebPPictureFree(&picture);
+    result.success = false;
+    result.errorMessage = "Failed to import RGBA data";
+    return result;
+  }
+
+  // Setup memory writer for output
+  WebPMemoryWriter writer;
+  WebPMemoryWriterInit(&writer);
+  picture.writer = WebPMemoryWriterWrite;
+  picture.custom_ptr = &writer;
+
+  // Encode
+  if (!WebPEncode(&config, &picture)) {
+    WebPMemoryWriterClear(&writer);
+    WebPPictureFree(&picture);
+    result.success = false;
+    result.errorMessage = std::string("WebP encoding failed: ") + std::to_string(picture.error_code);
+    return result;
+  }
+
+  // Write to file
+  std::ofstream outFile(outputPath, std::ios::binary);
+  if (!outFile.is_open()) {
+    WebPMemoryWriterClear(&writer);
+    WebPPictureFree(&picture);
+    result.success = false;
+    result.errorMessage = "Failed to open output file for writing";
+    return result;
+  }
+
+  outFile.write(reinterpret_cast<const char*>(writer.mem), writer.size);
+  if (!outFile.good()) {
+    WebPMemoryWriterClear(&writer);
+    WebPPictureFree(&picture);
+    result.success = false;
+    result.errorMessage = "Failed to write WebP data to file";
+    return result;
+  }
+  outFile.close();
+
+  // Set result
+  result.success = true;
+  result.sizeBytes = writer.size;
+
+  // Cleanup
+  WebPMemoryWriterClear(&writer);
+  WebPPictureFree(&picture);
+  
+  return result;
+#else
+  // Placeholder until libwebp is vendored
+  result.success = false;
+  result.errorMessage = "libwebp not yet integrated. Please vendor libwebp sources to cpp/vendor/libwebp/ and define WEBP_AVAILABLE.";
+  
+  return result;
+#endif
+}

package/cpp/ImageToWebP.h

@@ -0,0 +1,41 @@
+#ifndef IMAGE_TO_WEBP_H
+#define IMAGE_TO_WEBP_H
+
+#include <cstdint>
+#include <string>
+
+struct WebPEncodeOptions {
+  int quality = 80;
+  int method = 3;
+  bool lossless = false;
+  bool stripMetadata = true;
+  int threadLevel = 1;
+  bool exact = false;
+};
+
+struct WebPEncodeResult {
+  bool success = false;
+  std::string errorMessage;
+  uint32_t width = 0;
+  uint32_t height = 0;
+  size_t sizeBytes = 0;
+};
+
+/**
+ * Encode RGBA image data to WebP format.
+ *
+ * @param rgbaData Pointer to RGBA pixel data (width * height * 4 bytes)
+ * @param width Image width in pixels
+ * @param height Image height in pixels
+ * @param options Encoding options
+ * @param outputPath Path to write the WebP file
+ * @return Result containing success status, dimensions, and file size
+ */
+WebPEncodeResult encodeWebP(
+    const uint8_t* rgbaData,
+    uint32_t width,
+    uint32_t height,
+    const WebPEncodeOptions& options,
+    const std::string& outputPath);
+
+#endif // IMAGE_TO_WEBP_H

package/cpp/README.md

@@ -0,0 +1,21 @@
+# C++ Shared Code
+
+This directory contains shared C++ code for WebP encoding using libwebp.
+
+## libwebp Vendor Setup
+
+To set up libwebp:
+
+1. Download libwebp source (>= 1.6.0) from https://github.com/webmproject/libwebp
+2. Extract to `cpp/vendor/libwebp/`
+3. The build systems (CMake for Android, CocoaPods for iOS) will compile libwebp as a static library
+
+## Structure
+
+- `ImageToWebP.h` / `ImageToWebP.cpp`: C++ wrapper around libwebp encoding API
+- `vendor/libwebp/`: Vendored libwebp source (to be added)
+
+## Build Integration
+
+- **Android**: CMakeLists.txt includes libwebp sources and links statically
+- **iOS**: Podspec includes libwebp sources and compiles with the module

package/cpp/SETUP.md

@@ -0,0 +1,71 @@
+# libwebp Setup Guide
+
+This library uses [libwebp](https://github.com/webmproject/libwebp) (>= 1.6.0) for WebP encoding.
+
+## Quick Setup
+
+**You only need to vendor libwebp sources - everything else is already configured!**
+
+### Option 1: Use the Script (Recommended)
+
+**Windows (PowerShell):**
+```powershell
+.\scripts\vendor-libwebp.ps1
+```
+
+**macOS/Linux:**
+```bash
+chmod +x scripts/vendor-libwebp.sh
+./scripts/vendor-libwebp.sh
+```
+
+**Or via yarn:**
+```bash
+yarn vendor:libwebp
+```
+
+### Option 2: Manual Setup
+
+```bash
+cd cpp
+git clone https://github.com/webmproject/libwebp.git vendor/libwebp
+cd vendor/libwebp
+git checkout v1.6.0
+cd ../../..
+```
+
+## What Happens Next
+
+Once libwebp is vendored:
+
+1. **Build files auto-detect libwebp** - Both iOS (`ReactNativeImageToWebp.podspec`) and Android (`CMakeLists.txt`) automatically detect and include libwebp sources if they exist at `cpp/vendor/libwebp/src`
+
+2. **C++ code is ready** - The implementation in `cpp/ImageToWebP.cpp` is already complete and will compile once libwebp is present (it's behind `#ifdef WEBP_AVAILABLE`)
+
+3. **Build flags are set** - Release flags (`-O3 -DNDEBUG`) and `WEBP_AVAILABLE` macro are automatically configured
+
+## Verification
+
+After vendoring, verify libwebp is detected:
+
+- **iOS**: Run `pod install` in `example/ios` - you should see libwebp sources included
+- **Android**: Build will show "libwebp found, including sources" message
+
+## Current Status
+
+✅ Build files configured (auto-detect libwebp)  
+✅ C++ implementation ready (behind `#ifdef WEBP_AVAILABLE`)  
+✅ Compiler flags configured  
+⏳ **You need to:** Vendor libwebp sources (run the script above)
+
+## Implementation Details
+
+The `cpp/ImageToWebP.cpp` file uses libwebp's advanced API:
+
+1. `WebPConfigInit()` and `WebPConfigPreset()` for configuration
+2. `WebPPictureInit()` and `WebPPictureImportRGBA()` for image data
+3. `WebPMemoryWriter` for output buffering
+4. `WebPEncode()` for encoding
+5. Proper cleanup of all libwebp structures
+
+See libwebp documentation: https://developers.google.com/speed/webp/docs/api

package/ios/ReactNativeImageToWebp.h

@@ -0,0 +1,5 @@
+#import <ReactNativeImageToWebpSpec/ReactNativeImageToWebpSpec.h>
+
+@interface ReactNativeImageToWebp : NSObject <NativeReactNativeImageToWebpSpec>
+
+@end