@stefanmartin/expo-video-watermark 0.2.0

package/.eslintrc.js

@@ -0,0 +1,5 @@
+module.exports = {
+  root: true,
+  extends: ['universe/native', 'universe/web'],
+  ignorePatterns: ['build'],
+};

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Stefan Martin
+
+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/README.md

@@ -0,0 +1,52 @@
+# expo-video-watermark
+
+An Expo native module for adding watermark images to videos on iOS and Android.
+
+## Installation
+
+```bash
+npx expo install @stefanmartin/expo-video-watermark
+```
+
+## Usage
+
+```typescript
+import ExpoVideoWatermark from '@stefanmartin/expo-video-watermark';
+
+// Add a watermark to a video
+const outputPath = await ExpoVideoWatermark.watermarkVideo(
+  '/path/to/source/video.mp4',
+  '/path/to/watermark.png',
+  '/path/to/output/video.mp4'
+);
+
+console.log('Watermarked video saved to:', outputPath);
+```
+
+## API
+
+### `watermarkVideo(videoPath, imagePath, outputPath)`
+
+Adds a watermark image onto a video and writes the result to the specified output path.
+
+**Parameters:**
+
+| Name | Type | Description |
+|------|------|-------------|
+| `videoPath` | `string` | Local filesystem path to the source MP4 video |
+| `imagePath` | `string` | Local filesystem path to the PNG watermark image |
+| `outputPath` | `string` | Local filesystem path where the output MP4 should be written |
+
+**Returns:** `Promise<string>` - Resolves with the output path on success.
+
+## Platform Support
+
+| Platform | Supported |
+|----------|-----------|
+| iOS | Yes |
+| Android | Yes |
+| Web | No |
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,58 @@
+apply plugin: 'com.android.library'
+
+group = 'expo.modules.videowatermark'
+version = '0.1.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useExpoPublishing()
+
+// If you want to use the managed Android SDK versions from expo-modules-core, set this to true.
+// The Android SDK versions will be bumped from time to time in SDK releases and may introduce breaking changes in your module code.
+// Most of the time, you may like to manage the Android SDK versions yourself.
+def useManagedAndroidSdkVersions = false
+if (useManagedAndroidSdkVersions) {
+  useDefaultAndroidSdkVersions()
+} else {
+  buildscript {
+    // Simple helper that allows the root project to override versions declared by this library.
+    ext.safeExtGet = { prop, fallback ->
+      rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+  }
+  project.android {
+    compileSdkVersion safeExtGet("compileSdkVersion", 36)
+    defaultConfig {
+      minSdkVersion safeExtGet("minSdkVersion", 33)
+      targetSdkVersion safeExtGet("targetSdkVersion", 36)
+    }
+  }
+}
+
+android {
+  namespace "expo.modules.videowatermark"
+  defaultConfig {
+    versionCode 1
+    versionName "0.1.0"
+  }
+  lintOptions {
+    abortOnError false
+  }
+
+  // Media3 Transformer + effect dependencies for watermarking (replacing FFmpeg)
+}
+
+dependencies {
+  def media3_version = "1.9.1"
+
+  // Core Editing & Transformation (What you have, updated)
+  implementation "androidx.media3:media3-transformer:$media3_version"
+  implementation "androidx.media3:media3-effect:$media3_version"
+  implementation "androidx.media3:media3-common-ktx:$media3_version"
+
+  // Recommended for API 33+ Workflows:
+  implementation "androidx.media3:media3-exoplayer:$media3_version" // For real-time preview
+  implementation "androidx.media3:media3-muxer:$media3_version"       // High-performance MP4/fragmented MP4 output
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

package/android/src/main/java/expo/modules/videowatermark/ExpoVideoWatermarkModule.kt

@@ -0,0 +1,167 @@
+package expo.modules.videowatermark
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.media.MediaMetadataRetriever
+import android.os.Handler
+import android.os.Looper
+import androidx.annotation.OptIn
+import androidx.media3.common.MediaItem
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.effect.BitmapOverlay
+import androidx.media3.effect.OverlayEffect
+import androidx.media3.effect.OverlaySettings
+import androidx.media3.transformer.Composition
+import androidx.media3.transformer.EditedMediaItem
+import androidx.media3.transformer.Effects
+import androidx.media3.transformer.ExportException
+import androidx.media3.transformer.ExportResult
+import androidx.media3.transformer.Transformer
+import com.google.common.collect.ImmutableList
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.io.File
+
+class ExpoVideoWatermarkModule : Module() {
+  private val context: Context
+    get() = appContext.reactContext ?: throw Exceptions.AppContextLost()
+
+  @OptIn(UnstableApi::class)
+  override fun definition() = ModuleDefinition {
+    Name("ExpoVideoWatermark")
+
+    AsyncFunction("watermarkVideo") { videoPath: String, imagePath: String, outputPath: String, promise: Promise ->
+      processWatermark(videoPath, imagePath, outputPath, promise)
+    }
+  }
+
+  @OptIn(UnstableApi::class)
+  private fun processWatermark(
+    videoPath: String,
+    imagePath: String,
+    outputPath: String,
+    promise: Promise
+  ) {
+    // Strip file:// prefix if present
+    val cleanVideoPath = videoPath.removePrefix("file://")
+    val cleanImagePath = imagePath.removePrefix("file://")
+    val cleanOutputPath = outputPath.removePrefix("file://")
+
+    // Validate video file exists
+    val videoFile = File(cleanVideoPath)
+    if (!videoFile.exists()) {
+      promise.reject("VIDEO_NOT_FOUND", "Video file not found at path: $cleanVideoPath", null)
+      return
+    }
+
+    // Validate image file exists
+    val imageFile = File(cleanImagePath)
+    if (!imageFile.exists()) {
+      promise.reject("IMAGE_NOT_FOUND", "Watermark image not found at path: $cleanImagePath", null)
+      return
+    }
+
+    // Load the watermark bitmap
+    val watermarkBitmap: Bitmap? = BitmapFactory.decodeFile(cleanImagePath)
+    if (watermarkBitmap == null) {
+      promise.reject("IMAGE_DECODE_ERROR", "Failed to decode image at: $cleanImagePath", null)
+      return
+    }
+
+    // Ensure output directory exists
+    val outputFile = File(cleanOutputPath)
+    outputFile.parentFile?.mkdirs()
+
+    // Remove existing output file if present
+    if (outputFile.exists()) {
+      outputFile.delete()
+    }
+
+    // Get video dimensions to calculate scale
+    val retriever = MediaMetadataRetriever()
+    try {
+      retriever.setDataSource(cleanVideoPath)
+    } catch (e: Exception) {
+      promise.reject("VIDEO_METADATA_ERROR", "Failed to read video metadata: ${e.message}", e)
+      return
+    }
+
+    val videoWidth = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)?.toFloatOrNull() ?: 0f
+    val videoHeight = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)?.toFloatOrNull() ?: 0f
+    retriever.release()
+
+    if (videoWidth <= 0 || videoHeight <= 0) {
+      promise.reject("VIDEO_METADATA_ERROR", "Failed to get video dimensions", null)
+      return
+    }
+
+    // Calculate scale to make watermark span full video width, maintaining aspect ratio
+    val watermarkWidth = watermarkBitmap.width.toFloat()
+    val scale = videoWidth / watermarkWidth
+
+    // Create overlay settings for full-width bottom positioning
+    // In Media3, coordinates are normalized: (0,0) is center
+    // x range [-1, 1] (left to right), y range [-1, 1] (bottom to top)
+    val overlaySettings = OverlaySettings.Builder()
+      .setScale(scale, scale)  // Scale uniformly to match video width
+      .setOverlayFrameAnchor(0f, -1f)  // Anchor at bottom-center of watermark
+      .setBackgroundFrameAnchor(0f, -1f)  // Position at very bottom of video
+      .build()
+
+    // Create the bitmap overlay
+    val bitmapOverlay = BitmapOverlay.createStaticBitmapOverlay(
+      watermarkBitmap,
+      overlaySettings
+    )
+
+    // Create overlay effect
+    val overlayEffect = OverlayEffect(ImmutableList.of(bitmapOverlay))
+
+    // Create effects with video overlay
+    val effects = Effects(
+      /* audioProcessors= */ listOf(),
+      /* videoEffects= */ listOf(overlayEffect)
+    )
+
+    // Create media item from video
+    val mediaItem = MediaItem.fromUri("file://$cleanVideoPath")
+
+    // Create edited media item with effects
+    val editedMediaItem = EditedMediaItem.Builder(mediaItem)
+      .setEffects(effects)
+      .build()
+
+    // Handler for main thread callbacks
+    val mainHandler = Handler(Looper.getMainLooper())
+
+    // Build and start transformer
+    mainHandler.post {
+      val transformer = Transformer.Builder(context)
+        .addListener(object : Transformer.Listener {
+          override fun onCompleted(composition: Composition, exportResult: ExportResult) {
+            watermarkBitmap.recycle()
+            promise.resolve(cleanOutputPath)
+          }
+
+          override fun onError(
+            composition: Composition,
+            exportResult: ExportResult,
+            exportException: ExportException
+          ) {
+            watermarkBitmap.recycle()
+            promise.reject(
+              "EXPORT_FAILED",
+              "Video export failed: ${exportException.message ?: "Unknown error"}",
+              exportException
+            )
+          }
+        })
+        .build()
+
+      transformer.start(editedMediaItem, cleanOutputPath)
+    }
+  }
+}

package/build/ExpoVideoWatermarkModule.d.ts

@@ -0,0 +1,14 @@
+import { NativeModule } from 'expo';
+declare class ExpoVideoWatermarkModule extends NativeModule {
+    /**
+     * Adds a watermark image onto a video and writes the result to `outputPath`.
+     * @param videoPath Local filesystem path to the source MP4 video
+     * @param imagePath Local filesystem path to the PNG watermark image
+     * @param outputPath Local filesystem path where the output MP4 should be written
+     * @returns A promise that resolves with the output path on success.
+     */
+    watermarkVideo(videoPath: string, imagePath: string, outputPath: string): Promise<string>;
+}
+declare const _default: ExpoVideoWatermarkModule;
+export default _default;
+//# sourceMappingURL=ExpoVideoWatermarkModule.d.ts.map

package/build/ExpoVideoWatermarkModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoVideoWatermarkModule.d.ts","sourceRoot":"","sources":["../src/ExpoVideoWatermarkModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuB,MAAM,MAAM,CAAC;AAEzD,OAAO,OAAO,wBAAyB,SAAQ,YAAY;IACzD;;;;;;OAMG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAC1F;;AAGD,wBAAmF"}

package/build/ExpoVideoWatermarkModule.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo';
+// This call loads the native module object from the JSI.
+export default requireNativeModule('ExpoVideoWatermark');
+//# sourceMappingURL=ExpoVideoWatermarkModule.js.map

package/build/ExpoVideoWatermarkModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoVideoWatermarkModule.js","sourceRoot":"","sources":["../src/ExpoVideoWatermarkModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAazD,yDAAyD;AACzD,eAAe,mBAAmB,CAA2B,oBAAoB,CAAC,CAAC","sourcesContent":["import { NativeModule, requireNativeModule } from 'expo';\n\ndeclare class ExpoVideoWatermarkModule extends NativeModule {\n  /**\n   * Adds a watermark image onto a video and writes the result to `outputPath`.\n   * @param videoPath Local filesystem path to the source MP4 video\n   * @param imagePath Local filesystem path to the PNG watermark image\n   * @param outputPath Local filesystem path where the output MP4 should be written\n   * @returns A promise that resolves with the output path on success.\n   */\n  watermarkVideo(videoPath: string, imagePath: string, outputPath: string): Promise<string>;\n}\n\n// This call loads the native module object from the JSI.\nexport default requireNativeModule<ExpoVideoWatermarkModule>('ExpoVideoWatermark');\n"]}

package/build/ExpoVideoWatermarkModule.web.d.ts

@@ -0,0 +1,7 @@
+import { NativeModule } from 'expo';
+declare class ExpoVideoWatermarkModule extends NativeModule {
+    watermarkVideo(_videoPath: string, _imagePath: string, _outputPath: string): Promise<string>;
+}
+declare const _default: typeof ExpoVideoWatermarkModule;
+export default _default;
+//# sourceMappingURL=ExpoVideoWatermarkModule.web.d.ts.map

package/build/ExpoVideoWatermarkModule.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoVideoWatermarkModule.web.d.ts","sourceRoot":"","sources":["../src/ExpoVideoWatermarkModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,YAAY,EAAE,MAAM,MAAM,CAAC;AAEvD,cAAM,wBAAyB,SAAQ,YAAY;IAC3C,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAGnG;;AAED,wBAAuF"}

package/build/ExpoVideoWatermarkModule.web.js

@@ -0,0 +1,8 @@
+import { registerWebModule, NativeModule } from 'expo';
+class ExpoVideoWatermarkModule extends NativeModule {
+    async watermarkVideo(_videoPath, _imagePath, _outputPath) {
+        throw new Error('watermarkVideo is not supported on web');
+    }
+}
+export default registerWebModule(ExpoVideoWatermarkModule, 'ExpoVideoWatermarkModule');
+//# sourceMappingURL=ExpoVideoWatermarkModule.web.js.map

package/build/ExpoVideoWatermarkModule.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoVideoWatermarkModule.web.js","sourceRoot":"","sources":["../src/ExpoVideoWatermarkModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAEvD,MAAM,wBAAyB,SAAQ,YAAY;IACjD,KAAK,CAAC,cAAc,CAAC,UAAkB,EAAE,UAAkB,EAAE,WAAmB;QAC9E,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;IAC5D,CAAC;CACF;AAED,eAAe,iBAAiB,CAAC,wBAAwB,EAAE,0BAA0B,CAAC,CAAC","sourcesContent":["import { registerWebModule, NativeModule } from 'expo';\n\nclass ExpoVideoWatermarkModule extends NativeModule {\n  async watermarkVideo(_videoPath: string, _imagePath: string, _outputPath: string): Promise<string> {\n    throw new Error('watermarkVideo is not supported on web');\n  }\n}\n\nexport default registerWebModule(ExpoVideoWatermarkModule, 'ExpoVideoWatermarkModule');\n"]}

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './ExpoVideoWatermarkModule';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC"}

package/build/index.js

@@ -0,0 +1,4 @@
+// Reexport the native module. On web, it will be resolved to ExpoVideoWatermarkModule.web.ts
+// and on native platforms to ExpoVideoWatermarkModule.ts
+export { default } from './ExpoVideoWatermarkModule';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,yDAAyD;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC","sourcesContent":["// Reexport the native module. On web, it will be resolved to ExpoVideoWatermarkModule.web.ts\n// and on native platforms to ExpoVideoWatermarkModule.ts\nexport { default } from './ExpoVideoWatermarkModule';\n"]}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android", "web"],
+  "apple": {
+    "modules": ["ExpoVideoWatermarkModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.videowatermark.ExpoVideoWatermarkModule"]
+  }
+}

package/ios/ExpoVideoWatermark.podspec

@@ -0,0 +1,29 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoVideoWatermark'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = {
+    :ios => '15.1',
+    :tvos => '15.1'
+  }
+  s.swift_version  = '5.9'
+  s.source         = { git: 'https://github.com/ste00martin/expo-video-watermark' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end

package/ios/ExpoVideoWatermarkModule.swift

@@ -0,0 +1,205 @@
+import ExpoModulesCore
+import AVFoundation
+import UIKit
+
+public class ExpoVideoWatermarkModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("ExpoVideoWatermark")
+
+    AsyncFunction("watermarkVideo") { (videoPath: String, imagePath: String, outputPath: String, promise: Promise) in
+      DispatchQueue.global(qos: .userInitiated).async {
+        self.processWatermark(videoPath: videoPath, imagePath: imagePath, outputPath: outputPath, promise: promise)
+      }
+    }
+  }
+
+  private func processWatermark(videoPath: String, imagePath: String, outputPath: String, promise: Promise) {
+    // Strip file:// prefix if present
+    let cleanVideoPath = videoPath.hasPrefix("file://") ? String(videoPath.dropFirst(7)) : videoPath
+    let cleanImagePath = imagePath.hasPrefix("file://") ? String(imagePath.dropFirst(7)) : imagePath
+    let cleanOutputPath = outputPath.hasPrefix("file://") ? String(outputPath.dropFirst(7)) : outputPath
+
+    // Validate video file exists
+    let videoURL = URL(fileURLWithPath: cleanVideoPath)
+    guard FileManager.default.fileExists(atPath: cleanVideoPath) else {
+      promise.reject("VIDEO_NOT_FOUND", "Video file not found at path: \(cleanVideoPath)")
+      return
+    }
+
+    // Validate image file exists and load it
+    guard FileManager.default.fileExists(atPath: cleanImagePath),
+          let watermarkImage = UIImage(contentsOfFile: cleanImagePath) else {
+      promise.reject("IMAGE_NOT_FOUND", "Watermark image not found at path: \(cleanImagePath)")
+      return
+    }
+
+    // Load video asset
+    let asset = AVURLAsset(url: videoURL)
+
+    // Get video track
+    guard let videoTrack = asset.tracks(withMediaType: .video).first else {
+      promise.reject("INVALID_VIDEO", "No video track found in file: \(videoPath)")
+      return
+    }
+
+    // Create composition
+    let composition = AVMutableComposition()
+
+    guard let compositionVideoTrack = composition.addMutableTrack(
+      withMediaType: .video,
+      preferredTrackID: kCMPersistentTrackID_Invalid
+    ) else {
+      promise.reject("COMPOSITION_ERROR", "Failed to create video composition track")
+      return
+    }
+
+    let duration = asset.duration
+
+    do {
+      // Insert video track
+      try compositionVideoTrack.insertTimeRange(
+        CMTimeRange(start: .zero, duration: duration),
+        of: videoTrack,
+        at: .zero
+      )
+
+      // Handle audio track if present
+      if let audioTrack = asset.tracks(withMediaType: .audio).first,
+         let compositionAudioTrack = composition.addMutableTrack(
+           withMediaType: .audio,
+           preferredTrackID: kCMPersistentTrackID_Invalid
+         ) {
+        try compositionAudioTrack.insertTimeRange(
+          CMTimeRange(start: .zero, duration: duration),
+          of: audioTrack,
+          at: .zero
+        )
+      }
+    } catch {
+      promise.reject("COMPOSITION_ERROR", "Failed to insert tracks: \(error.localizedDescription)")
+      return
+    }
+
+    // Get video size accounting for transform
+    let videoSize = self.naturalSizeForTrack(videoTrack)
+
+    // Create layer hierarchy for watermark overlay
+    let parentLayer = CALayer()
+    let videoLayer = CALayer()
+
+    parentLayer.frame = CGRect(origin: .zero, size: videoSize)
+    videoLayer.frame = CGRect(origin: .zero, size: videoSize)
+    parentLayer.addSublayer(videoLayer)
+
+    // Create watermark layer spanning full width at bottom
+    let watermarkLayer = CALayer()
+    watermarkLayer.contents = watermarkImage.cgImage
+
+    // Scale watermark to match video width, maintaining aspect ratio
+    let watermarkWidth = videoSize.width
+    let aspectRatio = watermarkImage.size.height / watermarkImage.size.width
+    let watermarkHeight = watermarkWidth * aspectRatio
+
+    // Position at very bottom (Core Animation y=0 is bottom)
+    watermarkLayer.frame = CGRect(
+      x: 0,
+      y: 0,
+      width: watermarkWidth,
+      height: watermarkHeight
+    )
+    watermarkLayer.opacity = 1.0
+    parentLayer.addSublayer(watermarkLayer)
+
+    // Create video composition
+    let videoComposition = AVMutableVideoComposition()
+    videoComposition.renderSize = videoSize
+    videoComposition.frameDuration = CMTime(value: 1, timescale: 30)
+    videoComposition.animationTool = AVVideoCompositionCoreAnimationTool(
+      postProcessingAsVideoLayer: videoLayer,
+      in: parentLayer
+    )
+
+    // Create instruction
+    let instruction = AVMutableVideoCompositionInstruction()
+    instruction.timeRange = CMTimeRange(start: .zero, duration: duration)
+
+    let layerInstruction = AVMutableVideoCompositionLayerInstruction(assetTrack: compositionVideoTrack)
+
+    // Apply transform to handle rotated videos
+    let transform = self.transformForTrack(videoTrack)
+    layerInstruction.setTransform(transform, at: .zero)
+
+    instruction.layerInstructions = [layerInstruction]
+    videoComposition.instructions = [instruction]
+
+    // Setup export
+    let outputURL = URL(fileURLWithPath: cleanOutputPath)
+
+    // Remove existing file if present
+    try? FileManager.default.removeItem(at: outputURL)
+
+    // Create parent directory if needed
+    let parentDir = outputURL.deletingLastPathComponent()
+    try? FileManager.default.createDirectory(at: parentDir, withIntermediateDirectories: true)
+
+    guard let exportSession = AVAssetExportSession(
+      asset: composition,
+      presetName: AVAssetExportPresetHighestQuality
+    ) else {
+      promise.reject("EXPORT_ERROR", "Could not create export session")
+      return
+    }
+
+    exportSession.outputURL = outputURL
+    exportSession.outputFileType = .mp4
+    exportSession.videoComposition = videoComposition
+
+    exportSession.exportAsynchronously {
+      switch exportSession.status {
+      case .completed:
+        promise.resolve(outputPath)
+      case .failed:
+        let errorMessage = exportSession.error?.localizedDescription ?? "Unknown error"
+        promise.reject("EXPORT_FAILED", "Video export failed: \(errorMessage)")
+      case .cancelled:
+        promise.reject("EXPORT_CANCELLED", "Video export was cancelled")
+      default:
+        promise.reject("EXPORT_ERROR", "Export ended with status: \(exportSession.status.rawValue)")
+      }
+    }
+  }
+
+  // Calculate the natural size accounting for video transform/rotation
+  private func naturalSizeForTrack(_ track: AVAssetTrack) -> CGSize {
+    let size = track.naturalSize
+    let transform = track.preferredTransform
+
+    // Check if video is rotated 90 or 270 degrees
+    if abs(transform.a) == 0 && abs(transform.d) == 0 {
+      return CGSize(width: size.height, height: size.width)
+    }
+    return size
+  }
+
+  // Get the transform needed to render the video correctly
+  private func transformForTrack(_ track: AVAssetTrack) -> CGAffineTransform {
+    let size = track.naturalSize
+    let transform = track.preferredTransform
+
+    // Handle different rotation cases
+    if transform.a == 0 && transform.d == 0 {
+      if transform.b == 1.0 && transform.c == -1.0 {
+        // 90 degrees rotation
+        return CGAffineTransform(translationX: size.height, y: 0).rotated(by: .pi / 2)
+      } else if transform.b == -1.0 && transform.c == 1.0 {
+        // 270 degrees rotation
+        return CGAffineTransform(translationX: 0, y: size.width).rotated(by: -.pi / 2)
+      }
+    } else if transform.a == -1.0 && transform.d == -1.0 {
+      // 180 degrees rotation
+      return CGAffineTransform(translationX: size.width, y: size.height).rotated(by: .pi)
+    }
+
+    return .identity
+  }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@stefanmartin/expo-video-watermark",
+  "version": "0.2.0",
+  "description": "Creating video watermarks on locally stored videos",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module",
+    "open:ios": "xed example/ios",
+    "open:android": "open -a \"Android Studio\" example/android"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-video-watermark",
+    "ExpoVideoWatermark"
+  ],
+  "repository": "https://github.com/ste00martin/expo-video-watermark",
+  "bugs": {
+    "url": "https://github.com/ste00martin/expo-video-watermark/issues"
+  },
+  "author": "Stefan Martin <ste00martin@gmail.com> (https://github.com/ste00martin)",
+  "license": "MIT",
+  "homepage": "https://github.com/ste00martin/expo-video-watermark#readme",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "~19.1.0",
+    "expo": "^54.0.27",
+    "expo-module-scripts": "^5.0.8",
+    "react-native": "0.81.5"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  }
+}

package/src/ExpoVideoWatermarkModule.ts

@@ -0,0 +1,15 @@
+import { NativeModule, requireNativeModule } from 'expo';
+
+declare class ExpoVideoWatermarkModule extends NativeModule {
+  /**
+   * Adds a watermark image onto a video and writes the result to `outputPath`.
+   * @param videoPath Local filesystem path to the source MP4 video
+   * @param imagePath Local filesystem path to the PNG watermark image
+   * @param outputPath Local filesystem path where the output MP4 should be written
+   * @returns A promise that resolves with the output path on success.
+   */
+  watermarkVideo(videoPath: string, imagePath: string, outputPath: string): Promise<string>;
+}
+
+// This call loads the native module object from the JSI.
+export default requireNativeModule<ExpoVideoWatermarkModule>('ExpoVideoWatermark');

package/src/ExpoVideoWatermarkModule.web.ts

@@ -0,0 +1,9 @@
+import { registerWebModule, NativeModule } from 'expo';
+
+class ExpoVideoWatermarkModule extends NativeModule {
+  async watermarkVideo(_videoPath: string, _imagePath: string, _outputPath: string): Promise<string> {
+    throw new Error('watermarkVideo is not supported on web');
+  }
+}
+
+export default registerWebModule(ExpoVideoWatermarkModule, 'ExpoVideoWatermarkModule');

package/src/index.ts

@@ -0,0 +1,3 @@
+// Reexport the native module. On web, it will be resolved to ExpoVideoWatermarkModule.web.ts
+// and on native platforms to ExpoVideoWatermarkModule.ts
+export { default } from './ExpoVideoWatermarkModule';

package/tsconfig.json

@@ -0,0 +1,9 @@
+// @generated by expo-module-scripts
+{
+  "extends": "expo-module-scripts/tsconfig.base",
+  "compilerOptions": {
+    "outDir": "./build"
+  },
+  "include": ["./src"],
+  "exclude": ["**/__mocks__/*", "**/__tests__/*", "**/__rsc_tests__/*"]
+}