@stefanmartin/expo-video-watermark 0.3.2 → 0.4.0

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

@@ -228,6 +228,9 @@ class ExpoVideoWatermarkModule : Module() {
     val frameRate = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_CAPTURE_FRAMERATE)?.toFloatOrNull() ?: 0f
     val colorStandard = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_COLOR_STANDARD) ?: "unknown"
     val colorTransfer = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_COLOR_TRANSFER) ?: "unknown"
+    val colorTransferInt = colorTransfer.toIntOrNull()
+    // Check for HDR color transfer characteristics. 6 = PQ (ST2084), 7 = HLG. See MediaFormat constants.
+    val isHdr = colorTransferInt == 6 || colorTransferInt == 7
     retriever.release()
 
     // Build comprehensive video info string for debugging
@@ -237,7 +240,7 @@ class ExpoVideoWatermarkModule : Module() {
       append("duration=${duration}ms, ")
       append("frameRate=$frameRate, ")
       append("colorStandard=$colorStandard, ")
-      append("colorTransfer=$colorTransfer")
+      append("colorTransfer=$colorTransfer (isHdr=$isHdr)")
     }
     Log.d(TAG, "[Step 6] Video metadata: $videoInfo")
 
@@ -254,34 +257,55 @@ class ExpoVideoWatermarkModule : Module() {
       rawVideoWidth to rawVideoHeight
     }
 
-    // Step 8: Calculate scale to make watermark span full video width, maintaining aspect ratio
-    val watermarkWidth = watermarkBitmap.width.toFloat()
-    val watermarkHeight = watermarkBitmap.height.toFloat()
-    val scale = videoWidth / watermarkWidth
+    // Step 8: Pre-scale watermark bitmap to match video width if needed
+    val originalWidth = watermarkBitmap.width
+    val originalHeight = watermarkBitmap.height
+    val targetWidth = videoWidth.toInt()
+    val scale = targetWidth.toFloat() / originalWidth.toFloat()
+    val targetHeight = (originalHeight * scale).toInt()
+
+    // Skip scaling if watermark already matches video width
+    val scaledWatermark: Bitmap = if (originalWidth == targetWidth) {
+      Log.d(TAG, "[Step 8] Watermark already matches video width (${originalWidth}x${originalHeight}), skipping scale")
+      watermarkBitmap
+    } else {
+      Log.d(TAG, "[Step 8] Pre-scaling watermark: ${originalWidth}x${originalHeight} -> ${targetWidth}x${targetHeight} (scale: $scale)")
+      try {
+        val scaled = Bitmap.createScaledBitmap(watermarkBitmap, targetWidth, targetHeight, true)
+        // Recycle original if we created a new scaled version
+        if (scaled !== watermarkBitmap) {
+          watermarkBitmap.recycle()
+        }
+        scaled
+      } catch (e: Exception) {
+        watermarkBitmap.recycle()
+        promise.reject("STEP8_SCALE_ERROR", "[Step 8] Failed to scale watermark bitmap: ${e.message}", e)
+        return
+      }
+    }
 
-    // Step 9: Create overlay settings for full-width bottom positioning
+    // Step 9: Create overlay settings for bottom positioning (no GPU scaling needed)
     // 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 = try {
       StaticOverlaySettings.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()
     } catch (e: Exception) {
-      watermarkBitmap.recycle()
+      scaledWatermark.recycle()
       promise.reject("STEP9_OVERLAY_SETTINGS_ERROR", "[Step 9] Failed to create overlay settings: ${e.message}", e)
       return
     }
 
-    // Step 10: Create the bitmap overlay with settings
+    // Step 10: Create the bitmap overlay with pre-scaled bitmap
     val bitmapOverlay = try {
       BitmapOverlay.createStaticBitmapOverlay(
-        watermarkBitmap,
+        scaledWatermark,
         overlaySettings
       )
     } catch (e: Exception) {
-      watermarkBitmap.recycle()
+      scaledWatermark.recycle()
       promise.reject("STEP10_BITMAP_OVERLAY_ERROR", "[Step 10] Failed to create bitmap overlay: ${e.message}", e)
       return
     }
@@ -289,8 +313,9 @@ class ExpoVideoWatermarkModule : Module() {
     // Step 11: Create overlay effect with proper typing
     val overlayEffect = try {
       OverlayEffect(ImmutableList.of<TextureOverlay>(bitmapOverlay))
-    } catch (e: Exception) {
-      watermarkBitmap.recycle()
+    }
+    catch (e: Exception) {
+      scaledWatermark.recycle()
       promise.reject("STEP11_OVERLAY_EFFECT_ERROR", "[Step 11] Failed to create overlay effect: ${e.message}", e)
       return
     }
@@ -304,17 +329,34 @@ class ExpoVideoWatermarkModule : Module() {
     // Step 13: Create media item from video
     val mediaItem = MediaItem.fromUri("file://$cleanVideoPath")
 
-    // Step 14: Create edited media item with effects
+    // Step 14: Create edited media item, requesting HDR to SDR tone-mapping if needed.
+    // This is the modern API for handling HDR in Media3, replacing the deprecated setHdrMode.
     val editedMediaItem = try {
-      EditedMediaItem.Builder(mediaItem)
-        .setEffects(effects)
-        .build()
+      val builder = EditedMediaItem.Builder(mediaItem).setEffects(effects)
+      if (isHdr) {
+        Log.d(TAG, "[Step 14] HDR video detected. Requesting tone-mapping.")
+        builder.setForceHdrToSdrToneMap(true)
+      } else {
+        Log.d(TAG, "[Step 14] SDR video detected. No tone-mapping needed.")
+      }
+      builder.build()
     } catch (e: Exception) {
-      watermarkBitmap.recycle()
+      scaledWatermark.recycle()
       promise.reject("STEP14_EDITED_MEDIA_ERROR", "[Step 14] Failed to create edited media item: ${e.message}", e)
       return
     }
 
+    // Step 14b: Create composition
+    val composition = try {
+      Composition.Builder(listOf(editedMediaItem))
+        .build()
+    } catch (e: Exception) {
+      scaledWatermark.recycle()
+      promise.reject("STEP14B_COMPOSITION_ERROR", "[Step 14b] Failed to create composition: ${e.message}", e)
+      return
+    }
+    Log.d(TAG, "[Step 14b] Composition created successfully.")
+
     // Handler for main thread callbacks
     val mainHandler = Handler(Looper.getMainLooper())
 
@@ -338,7 +380,7 @@ class ExpoVideoWatermarkModule : Module() {
                 "averageAudioBitrate: ${exportResult.averageAudioBitrate}, " +
                 "averageVideoBitrate: ${exportResult.averageVideoBitrate}, " +
                 "videoFrameCount: ${exportResult.videoFrameCount}")
-              watermarkBitmap.recycle()
+              scaledWatermark.recycle()
 
               // Step 16: Re-encode to H.265 if device supports HEVC encoder
               val supportsHevc = hasHevcEncoder()
@@ -452,7 +494,8 @@ class ExpoVideoWatermarkModule : Module() {
                 appendLine("Input path: $cleanVideoPath")
                 appendLine()
                 appendLine("--- Watermark Info ---")
-                appendLine("Dimensions: ${watermarkWidth.toInt()}x${watermarkHeight.toInt()}")
+                appendLine("Original dimensions: ${originalWidth}x${originalHeight}")
+                appendLine("Scaled dimensions: ${targetWidth}x${targetHeight}")
                 appendLine("Bitmap info: $bitmapInfo")
                 appendLine("Scale factor: $scale")
                 appendLine()
@@ -478,14 +521,14 @@ class ExpoVideoWatermarkModule : Module() {
                 causeLevel++
               }
 
-              watermarkBitmap.recycle()
+              scaledWatermark.recycle()
 
               // Reject with comprehensive error message
               val errorMessage = "[Step 15] Transform failed - " +
                 "ErrorCode: $errorCodeName (${exportException.errorCode}), " +
                 "Device: ${Build.MANUFACTURER} ${Build.MODEL} (API ${Build.VERSION.SDK_INT}), " +
                 "Video: ${videoWidth.toInt()}x${videoHeight.toInt()} $mimeType, " +
-                "Watermark: ${watermarkWidth.toInt()}x${watermarkHeight.toInt()}, " +
+                "Watermark: ${originalWidth}x${originalHeight} -> ${targetWidth}x${targetHeight}, " +
                 "Scale: $scale, " +
                 "Message: ${exportException.message ?: "Unknown error"}"
 
@@ -499,13 +542,13 @@ class ExpoVideoWatermarkModule : Module() {
           .build()
 
         Log.d(TAG, "[Step 15] Transformer built, starting export...")
-        transformer.start(editedMediaItem, cleanOutputPath)
+        transformer.start(composition, cleanOutputPath)
         Log.d(TAG, "[Step 15] Transformer.start() called, waiting for completion...")
       } catch (e: Exception) {
         Log.e(TAG, "[Step 15] Exception building/starting transformer", e)
         Log.e(TAG, "[Step 15] Device info: $deviceInfo")
         Log.e(TAG, "[Step 15] GL info: $glInfo")
-        watermarkBitmap.recycle()
+        scaledWatermark.recycle()
         promise.reject(
           "STEP15_TRANSFORMER_BUILD_ERROR",
           "[Step 15] Failed to build/start transformer on ${Build.MANUFACTURER} ${Build.MODEL}: ${e.message}",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stefanmartin/expo-video-watermark",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Creating video watermarks on locally stored videos",
   "main": "build/index.js",
   "types": "build/index.d.ts",