react-native-libyuv-resizer 0.2.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Anderson Souza
+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.

package/LibyuvResizer.podspec

@@ -0,0 +1,20 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "LibyuvResizer"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/anderson-souza/react-native-libyuv-resizer.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,188 @@
+# react-native-libyuv-resizer
+
+High-performance image resizer for React Native using libyuv (Android).
+
+## Installation
+
+```sh
+yarn add react-native-libyuv-resizer
+```
+
+## API
+
+### `resize(filePath, targetWidth, targetHeight, quality, options?): Promise<ResizeResult>`
+
+| Parameter            | Type            | Default     | Description                                                                       |
+| -------------------- | --------------- | ----------- | --------------------------------------------------------------------------------- |
+| `filePath`           | `string`        | —           | Absolute path to source image                                                     |
+| `targetWidth`        | `number`        | —           | Output width in pixels                                                            |
+| `targetHeight`       | `number`        | —           | Output height in pixels                                                           |
+| `quality`            | `number`        | —           | Compression quality `1–100`. Controls JPEG and WebP lossy level. Ignored for PNG. When `format` is omitted: `100` → PNG, else → JPEG. |
+| `options.rotation`   | `RotationAngle` | `0`         | Clockwise rotation before resize: `0 \| 90 \| 180 \| 270 \| -90 \| -180 \| -270` |
+| `options.mode`       | `ResizeMode`    | `'contain'` | How the image fits the target box: `'contain' \| 'cover' \| 'stretch'`           |
+| `options.filterMode` | `FilterMode`    | `'box'`     | Scaling filter: `'none' \| 'linear' \| 'bilinear' \| 'box'`                     |
+| `options.outputPath` | `string`        | auto        | Absolute directory path for the output file. Auto-generated in cache if omitted. |
+| `options.keepMeta`   | `boolean`       | `false`     | Copy EXIF metadata from source to output JPEG. Android only; no-op on iOS, PNG and WebP output. |
+| `options.format`     | `OutputFormat`  | derived     | Output format: `'jpeg' \| 'png' \| 'webp'`. When specified, takes precedence over the `quality`-based heuristic. WebP is Android only; iOS produces JPEG. |
+
+### Return value
+
+```ts
+interface ResizeResult {
+  path: string;   // absolute path to the resized file
+  uri: string;    // file:// URI
+  size: number;   // file size in bytes
+  name: string;   // file name
+  width: number;  // output width in pixels
+  height: number; // output height in pixels
+}
+```
+
+### Types
+
+```ts
+type RotationAngle = 0 | 90 | 180 | 270 | -90 | -180 | -270;
+type ResizeMode    = 'contain' | 'cover' | 'stretch';
+type FilterMode    = 'none' | 'linear' | 'bilinear' | 'box';
+type OutputFormat  = 'jpeg' | 'png' | 'webp';
+
+interface ResizeOptions {
+  rotation?:   RotationAngle;
+  mode?:       ResizeMode;
+  filterMode?: FilterMode;
+  outputPath?: string;
+  keepMeta?:   boolean;
+  format?:     OutputFormat;
+}
+```
+
+### Resize modes
+
+| Mode      | Behavior                                                       |
+| --------- | -------------------------------------------------------------- |
+| `contain` | Fits entirely within the target box, preserving aspect ratio   |
+| `cover`   | Fills the target box, preserving aspect ratio (may crop)       |
+| `stretch` | Stretches to exact target dimensions, ignoring aspect ratio    |
+
+### Filter modes
+
+| Mode       | Quality / Speed trade-off                              |
+| ---------- | ------------------------------------------------------ |
+| `none`     | Nearest-neighbor — fastest, lowest quality             |
+| `linear`   | Linear interpolation                                   |
+| `bilinear` | Bilinear interpolation                                 |
+| `box`      | Box filter — best quality for downscaling *(default)* |
+
+## Usage
+
+```ts
+import { resize } from 'react-native-libyuv-resizer';
+
+// Basic resize
+const result = await resize('/path/to/photo.jpg', 1280, 720, 85);
+console.log(result.path, result.width, result.height);
+
+// Resize with options
+const result = await resize('/path/to/photo.jpg', 1280, 720, 85, {
+  rotation: 90,
+  mode: 'cover',
+  filterMode: 'bilinear',
+});
+
+// Preserve EXIF metadata (GPS, camera, date) — Android only
+const result = await resize('/path/to/photo.jpg', 800, 600, 80, {
+  keepMeta: true,
+});
+
+// Custom output path
+const result = await resize('/path/to/photo.jpg', 800, 600, 80, {
+  outputPath: '/path/to/output-dir',
+});
+
+// PNG output — explicit format
+const result = await resize('/path/to/photo.jpg', 800, 600, 80, {
+  format: 'png',
+});
+console.log(result.path); // ends with .png
+
+// WebP output — smaller files than JPEG at equivalent quality (Android only)
+const result = await resize('/path/to/photo.jpg', 1280, 720, 85, {
+  format: 'webp',
+});
+console.log(result.path); // ends with .webp
+```
+
+### With react-native-image-picker
+
+```ts
+import { launchImageLibrary } from 'react-native-image-picker';
+import { resize } from 'react-native-libyuv-resizer';
+
+const picked = await launchImageLibrary({ mediaType: 'photo' });
+const asset = picked.assets?.[0];
+
+if (asset?.uri) {
+  const result = await resize(asset.uri, 800, 600, 80, {
+    mode: 'cover',
+    keepMeta: true, // preserve GPS and camera tags
+  });
+  console.log('Resized image at:', result.path);
+}
+```
+
+## format — output format
+
+The `format` option explicitly controls the output container. When omitted, the library falls back to the legacy quality-based heuristic (`quality === 100` → PNG, otherwise JPEG).
+
+| Value    | Output | `quality` effect | Platform |
+| -------- | ------ | ---------------- | -------- |
+| `'jpeg'` | JPEG | Lossy compression level | Android, iOS |
+| `'png'`  | PNG  | Ignored (lossless) | Android, iOS |
+| `'webp'` | WebP lossy | Compression level | Android only; iOS produces JPEG |
+
+**Performance note:** WebP encoding is significantly slower than JPEG (~5–15× on typical Android devices) because it runs in software with no dedicated hardware accelerator. Use `format: 'webp'` when file size matters more than encoding speed.
+
+**Format vs quality precedence:**
+
+```ts
+// format wins — output is JPEG even though quality=100
+await resize(src, 800, 600, 100, { format: 'jpeg' });
+
+// no format — quality=100 heuristic applies → PNG (backward compat)
+await resize(src, 800, 600, 100);
+```
+
+## keepMeta — EXIF preservation
+
+When `keepMeta: true`, all EXIF tags present in the source JPEG are copied to the output JPEG after encoding. This includes GPS coordinates, camera make/model, capture date, and any other tags supported by `androidx.exifinterface`.
+
+**Behavior by scenario:**
+
+| Scenario | Result |
+| --- | --- |
+| `keepMeta: true` + JPEG output | EXIF tags copied; `Orientation` reset to normal |
+| `keepMeta: true` + PNG output | No-op — PNG has no standard EXIF |
+| `keepMeta: true` + WebP output | No-op — consistent with PNG behaviour |
+| `keepMeta: true` + iOS | No-op — iOS implementation pending |
+| `keepMeta: false` (default) | No EXIF copy; identical to previous behavior |
+| Source has no EXIF | Succeeds silently — output has no EXIF |
+
+> **Note:** `Orientation` is always reset to `1` (normal) in the output, because the bitmap was decoded and re-encoded with the correct orientation already applied.
+
+## Platform notes
+
+| Platform    | Backend                      | keepMeta | WebP output |
+| ----------- | ---------------------------- | -------- | ----------- |
+| Android     | libyuv (`ARGBScale`) via NDK | ✅       | ✅ (`WEBP_LOSSY` API 30+, `WEBP` fallback) |
+| iOS         | Not yet implemented          | no-op    | no-op (produces JPEG) |
+| Web / other | Throws — native only         | —        | — |
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT

package/android/CMakeLists.txt

@@ -0,0 +1,30 @@
+project(libyuvresizer)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME "libyuvresizer")
+set(CMAKE_CXX_STANDARD 17)
+
+find_library(LOG_LIB log)
+
+# libyuv
+add_subdirectory(../libyuv libyuv)
+
+add_library(
+    ${PACKAGE_NAME}
+    SHARED
+    src/main/cpp/LibyuvResizerModule.cpp
+)
+
+target_include_directories(
+    ${PACKAGE_NAME} PRIVATE
+    src/main/cpp
+    ../libyuv/include
+)
+
+target_link_libraries(
+    ${PACKAGE_NAME}
+    ${LOG_LIB}
+    android
+    jnigraphics
+    yuv
+)

package/android/build.gradle

@@ -0,0 +1,100 @@
+buildscript {
+  ext.LibyuvResizer = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return LibyuvResizer[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.libyuvresizer"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+
+    testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+
+    buildConfigField(
+      "boolean",
+      "IS_NEW_ARCHITECTURE_ENABLED",
+      project.hasProperty("newArchEnabled") ? project.getProperty("newArchEnabled") : "false"
+    )
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-O2 -frtti -fexceptions -Wall -fstack-protector-all"
+        abiFilters "armeabi-v7a", "x86", "x86_64", "arm64-v8a"
+        arguments "-DANDROID_STL=c++_shared",
+                  "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  packagingOptions {
+    pickFirst 'lib/*/libc++_shared.so'
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "androidx.exifinterface:exifinterface:1.3.7"
+  testImplementation "junit:junit:4.13.2"
+  androidTestImplementation "androidx.test:runner:1.6.2"
+  androidTestImplementation "androidx.test:rules:1.6.1"
+  androidTestImplementation "androidx.test.ext:junit:1.2.1"
+  androidTestImplementation "androidx.test:core:1.6.1"
+}

package/android/src/androidTest/java/com/libyuvresizer/ExifCopierTest.kt

@@ -0,0 +1,131 @@
+package com.libyuvresizer
+
+import androidx.exifinterface.media.ExifInterface
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+class ExifCopierTest {
+
+    private lateinit var cacheDir: File
+    private val tempFiles = mutableListOf<File>()
+
+    @Before
+    fun setUp() {
+        cacheDir = InstrumentationRegistry.getInstrumentation().targetContext.cacheDir
+    }
+
+    @After
+    fun tearDown() {
+        tempFiles.forEach { it.delete() }
+        tempFiles.clear()
+    }
+
+    private fun createJpegWithExif(name: String, block: ExifInterface.() -> Unit): String {
+        val path = TestFixtures.createJpeg(
+            InstrumentationRegistry.getInstrumentation().targetContext,
+            100, 100, name
+        )
+        tempFiles += File(path)
+        ExifInterface(path).apply(block).saveAttributes()
+        return path
+    }
+
+    private fun tempDest(name: String): String {
+        val f = File(cacheDir, name)
+        tempFiles += f
+        return f.absolutePath
+    }
+
+    @Test
+    fun `copy GPS tags are preserved in destination`() {
+        val src = createJpegWithExif("exif_src_gps.jpg") {
+            setAttribute(ExifInterface.TAG_GPS_LATITUDE, "48/1,51/1,29/1")
+            setAttribute(ExifInterface.TAG_GPS_LATITUDE_REF, "N")
+            setAttribute(ExifInterface.TAG_GPS_LONGITUDE, "2/1,17/1,40/1")
+            setAttribute(ExifInterface.TAG_GPS_LONGITUDE_REF, "E")
+        }
+        val dest = tempDest("exif_dst_gps.jpg")
+        TestFixtures.createJpeg(
+            InstrumentationRegistry.getInstrumentation().targetContext,
+            50, 50, "exif_dst_gps.jpg"
+        ).also { File(it).copyTo(File(dest), overwrite = true) }
+
+        ExifCopier.copy(src, dest)
+
+        val result = ExifInterface(dest)
+        assertEquals("48/1,51/1,29/1", result.getAttribute(ExifInterface.TAG_GPS_LATITUDE))
+        assertEquals("N", result.getAttribute(ExifInterface.TAG_GPS_LATITUDE_REF))
+        assertEquals("2/1,17/1,40/1", result.getAttribute(ExifInterface.TAG_GPS_LONGITUDE))
+        assertEquals("E", result.getAttribute(ExifInterface.TAG_GPS_LONGITUDE_REF))
+    }
+
+    @Test
+    fun `copy make and model are preserved`() {
+        val src = createJpegWithExif("exif_src_cam.jpg") {
+            setAttribute(ExifInterface.TAG_MAKE, "Google")
+            setAttribute(ExifInterface.TAG_MODEL, "Pixel 8")
+            setAttribute(ExifInterface.TAG_DATETIME_ORIGINAL, "2024:01:15 10:30:00")
+        }
+        val dest = tempDest("exif_dst_cam.jpg")
+        File(src).copyTo(File(dest), overwrite = true)
+
+        ExifCopier.copy(src, dest)
+
+        val result = ExifInterface(dest)
+        assertEquals("Google", result.getAttribute(ExifInterface.TAG_MAKE))
+        assertEquals("Pixel 8", result.getAttribute(ExifInterface.TAG_MODEL))
+        assertEquals("2024:01:15 10:30:00", result.getAttribute(ExifInterface.TAG_DATETIME_ORIGINAL))
+    }
+
+    @Test
+    fun `copy orientation is always reset to normal`() {
+        val src = createJpegWithExif("exif_src_rot.jpg") {
+            setAttribute(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_ROTATE_90.toString())
+        }
+        val dest = tempDest("exif_dst_rot.jpg")
+        File(src).copyTo(File(dest), overwrite = true)
+
+        ExifCopier.copy(src, dest)
+
+        val result = ExifInterface(dest)
+        assertEquals(
+            ExifInterface.ORIENTATION_NORMAL,
+            result.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_UNDEFINED)
+        )
+    }
+
+    @Test
+    fun `copy source with no EXIF succeeds without error`() {
+        val src = TestFixtures.createJpeg(
+            InstrumentationRegistry.getInstrumentation().targetContext,
+            50, 50, "exif_src_noexif.jpg"
+        ).also { tempFiles += File(it) }
+        val dest = tempDest("exif_dst_noexif.jpg")
+        File(src).copyTo(File(dest), overwrite = true)
+
+        ExifCopier.copy(src, dest)
+
+        val result = ExifInterface(dest)
+        assertNull(result.getAttribute(ExifInterface.TAG_GPS_LATITUDE))
+    }
+
+    @Test
+    fun `copy source path does not exist returns silently`() {
+        val dest = tempDest("exif_dst_silent.jpg")
+        TestFixtures.createJpeg(
+            InstrumentationRegistry.getInstrumentation().targetContext,
+            50, 50, "exif_dst_silent.jpg"
+        ).also { File(it).copyTo(File(dest), overwrite = true); tempFiles += File(it) }
+
+        // Must not throw
+        ExifCopier.copy("/nonexistent/path/source.jpg", dest)
+    }
+}

package/android/src/androidTest/java/com/libyuvresizer/FakePromise.kt

@@ -0,0 +1,71 @@
+package com.libyuvresizer
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.WritableMap
+
+class FakePromise : Promise {
+  var result: Any? = null
+    private set
+  var errorCode: String? = null
+    private set
+  var errorMessage: String? = null
+    private set
+
+  private var _resolved = false
+  val resolved: Boolean get() = _resolved
+  val rejected: Boolean get() = errorCode != null
+
+  override fun resolve(value: Any?) {
+    result = value
+    _resolved = true
+  }
+
+  override fun reject(code: String?, message: String?) {
+    errorCode = code
+    errorMessage = message
+  }
+
+  override fun reject(code: String?, throwable: Throwable?) {
+    errorCode = code
+    errorMessage = throwable?.message
+  }
+
+  override fun reject(code: String?, message: String?, throwable: Throwable?) {
+    errorCode = code
+    errorMessage = message
+  }
+
+  override fun reject(code: String?, userInfo: WritableMap) {
+    errorCode = code
+  }
+
+  override fun reject(code: String?, throwable: Throwable?, userInfo: WritableMap) {
+    errorCode = code
+    errorMessage = throwable?.message
+  }
+
+  override fun reject(code: String?, message: String?, userInfo: WritableMap) {
+    errorCode = code
+    errorMessage = message
+  }
+
+  override fun reject(code: String?, message: String?, throwable: Throwable?, userInfo: WritableMap?) {
+    errorCode = code
+    errorMessage = message
+  }
+
+  override fun reject(throwable: Throwable) {
+    errorCode = "E_UNKNOWN"
+    errorMessage = throwable.message
+  }
+
+  override fun reject(throwable: Throwable, userInfo: WritableMap) {
+    errorCode = "E_UNKNOWN"
+    errorMessage = throwable.message
+  }
+
+  override fun reject(message: String) {
+    errorCode = "E_UNKNOWN"
+    errorMessage = message
+  }
+}

package/android/src/androidTest/java/com/libyuvresizer/FakeReactContext.kt

@@ -0,0 +1,55 @@
+package com.libyuvresizer
+
+import android.content.Context
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.CatalystInstance
+import com.facebook.react.bridge.JavaScriptContextHolder
+import com.facebook.react.bridge.JavaScriptModule
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder
+
+@Suppress("UNCHECKED_CAST")
+class FakeReactContext(context: Context) : ReactApplicationContext(context) {
+
+  override fun <T : JavaScriptModule> getJSModule(jsInterface: Class<T>): T =
+    throw UnsupportedOperationException()
+
+  override fun <T : NativeModule> hasNativeModule(nativeModuleInterface: Class<T>): Boolean = false
+
+  override fun getNativeModules(): MutableCollection<NativeModule> = mutableListOf()
+
+  override fun <T : NativeModule> getNativeModule(nativeModuleInterface: Class<T>): T? = null
+
+  override fun getNativeModule(moduleName: String): NativeModule? = null
+
+  override fun getCatalystInstance(): CatalystInstance =
+    throw UnsupportedOperationException()
+
+  override fun hasActiveCatalystInstance(): Boolean = false
+
+  override fun hasActiveReactInstance(): Boolean = false
+
+  override fun hasCatalystInstance(): Boolean = false
+
+  override fun hasReactInstance(): Boolean = false
+
+  override fun destroy() {}
+
+  override fun handleException(e: Exception) {
+    throw RuntimeException(e)
+  }
+
+  override fun isBridgeless(): Boolean = false
+
+  override fun getJavaScriptContextHolder(): JavaScriptContextHolder? = null
+
+  override fun getJSCallInvokerHolder(): CallInvokerHolder? = null
+
+  override fun getFabricUIManager(): UIManager? = null
+
+  override fun getSourceURL(): String? = null
+
+  override fun registerSegment(segmentId: Int, path: String, callback: Callback) {}
+}