react-native-ensys-camera-x 1.0.7

package/android/src/main/java/com/customcamera/VideoEditUtils.kt

@@ -0,0 +1,210 @@
+package com.customcamera
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.media.MediaCodec
+import android.media.MediaExtractor
+import android.media.MediaFormat
+import android.media.MediaMetadataRetriever
+import android.media.MediaMuxer
+import android.net.Uri
+import android.util.Log
+import java.io.File
+import java.io.FileOutputStream
+import java.nio.ByteBuffer
+
+/**
+ * Lossless, no-re-encode video edits used by the pre-send editor ([MediaPreviewEditor]):
+ * trim, mute (drop audio), and cover-frame extraction.
+ *
+ * Trim and mute are pure container remuxes — compressed samples are copied verbatim from a
+ * [MediaExtractor] into a [MediaMuxer], so there is no quality loss and the operation is fast.
+ * This is the container-copy counterpart to the frame-level [VideoRotationTranscoder] (which
+ * DOES re-encode); nothing here touches pixels.
+ *
+ * IMPORTANT — orientation: recorded clips carry their orientation as rotation METADATA, not as
+ * baked pixels, so every remux copies the source's rotation onto the output via
+ * [MediaMuxer.setOrientationHint]. Skipping this makes portrait clips play back sideways.
+ *
+ * IMPORTANT — retriever: [MediaMetadataRetriever] is only AutoCloseable on API 29+, so it is
+ * always released in a try/finally, never via Kotlin `.use { }` (which crashes on API 24–28).
+ */
+object VideoEditUtils {
+  private const val TAG = "VideoEditUtils"
+
+  // Fallback sample buffer when a track advertises no max input size (~2 MB covers 1080p frames).
+  private const val FALLBACK_BUFFER_SIZE = 2 * 1024 * 1024
+
+  /** Trim [input] to [startMs, endMs] (lossless), optionally dropping audio, into [output]. */
+  fun trim(
+    context: Context,
+    input: File,
+    output: File,
+    startMs: Long,
+    endMs: Long,
+    dropAudio: Boolean
+  ): Boolean = remux(context, input, output, startMs, endMs, dropAudio)
+
+  /** Copy [input] to [output] with the audio track removed (full duration). */
+  fun mute(context: Context, input: File, output: File): Boolean =
+    remux(context, input, output, 0L, Long.MAX_VALUE, dropAudio = true)
+
+  /** True if [input] contains at least one audio track. */
+  fun hasAudioTrack(input: File): Boolean {
+    var extractor: MediaExtractor? = null
+    return try {
+      extractor = MediaExtractor()
+      extractor.setDataSource(input.absolutePath)
+      (0 until extractor.trackCount).any { i ->
+        extractor.getTrackFormat(i).getString(MediaFormat.KEY_MIME)?.startsWith("audio/") == true
+      }
+    } catch (e: Exception) {
+      Log.w(TAG, "hasAudioTrack failed", e)
+      false
+    } finally {
+      runCatching { extractor?.release() }
+    }
+  }
+
+  /** Decode the frame nearest [positionMs] and write it to [output] as a JPEG. */
+  fun extractCover(
+    context: Context,
+    uri: Uri,
+    positionMs: Long,
+    output: File,
+    quality: Int = 90
+  ): Boolean {
+    var retriever: MediaMetadataRetriever? = null
+    return try {
+      retriever = MediaMetadataRetriever()
+      retriever.setDataSource(context, uri)
+      val timeUs = positionMs * 1000L
+      val frame = retriever.getFrameAtTime(timeUs, MediaMetadataRetriever.OPTION_CLOSEST)
+        ?: retriever.getFrameAtTime(timeUs, MediaMetadataRetriever.OPTION_CLOSEST_SYNC)
+        ?: return false
+      FileOutputStream(output).use { out ->
+        frame.compress(Bitmap.CompressFormat.JPEG, quality.coerceIn(1, 100), out)
+      }
+      frame.recycle()
+      true
+    } catch (e: Exception) {
+      Log.w(TAG, "extractCover failed", e)
+      runCatching { output.delete() }
+      false
+    } finally {
+      // MediaMetadataRetriever is only AutoCloseable on API 29+, so never use `.use {}` here.
+      runCatching { retriever?.release() }
+    }
+  }
+
+  private fun remux(
+    context: Context,
+    input: File,
+    output: File,
+    startMs: Long,
+    endMs: Long,
+    dropAudio: Boolean
+  ): Boolean {
+    var extractor: MediaExtractor? = null
+    var muxer: MediaMuxer? = null
+    var started = false
+    var wroteAny = false
+    try {
+      extractor = MediaExtractor()
+      extractor.setDataSource(input.absolutePath)
+      muxer = MediaMuxer(output.absolutePath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
+
+      // Select the tracks we keep and map each source index to its muxer index.
+      val indexMap = HashMap<Int, Int>()
+      var hasVideo = false
+      var maxInputSize = 0
+      for (i in 0 until extractor.trackCount) {
+        val format = extractor.getTrackFormat(i)
+        val mime = format.getString(MediaFormat.KEY_MIME) ?: continue
+        when {
+          mime.startsWith("video/") -> hasVideo = true
+          mime.startsWith("audio/") -> if (dropAudio) continue
+          else -> continue // ignore text/metadata tracks
+        }
+        extractor.selectTrack(i)
+        if (format.containsKey(MediaFormat.KEY_MAX_INPUT_SIZE)) {
+          maxInputSize = maxOf(maxInputSize, format.getInteger(MediaFormat.KEY_MAX_INPUT_SIZE))
+        }
+        indexMap[i] = muxer.addTrack(format)
+      }
+      if (!hasVideo || indexMap.isEmpty()) return false
+
+      // Preserve the source orientation (stored as metadata, not pixels).
+      val rotation = readRotation(input)
+      if (rotation != 0) muxer.setOrientationHint(rotation)
+
+      val bufferSize = if (maxInputSize > 0) maxInputSize else FALLBACK_BUFFER_SIZE
+      val buffer = ByteBuffer.allocate(bufferSize)
+      val bufferInfo = MediaCodec.BufferInfo()
+
+      val startUs = startMs * 1000L
+      val endUs = if (endMs == Long.MAX_VALUE) Long.MAX_VALUE else endMs * 1000L
+
+      // Start at the keyframe at/just before the requested start so the clip stays decodable,
+      // then rebase every timestamp so the output begins at ~0.
+      extractor.seekTo(startUs, MediaExtractor.SEEK_TO_PREVIOUS_SYNC)
+      val baseUs = extractor.sampleTime.let { if (it >= 0) it else 0L }
+
+      muxer.start()
+      started = true
+
+      // Per-track termination: keep copying until EVERY kept track has passed endUs (or EOF),
+      // so trimming never truncates one track early when audio/video are interleaved.
+      val finishedTracks = HashSet<Int>()
+      while (finishedTracks.size < indexMap.size) {
+        val sampleSize = extractor.readSampleData(buffer, 0)
+        if (sampleSize < 0) break
+        val srcIndex = extractor.sampleTrackIndex
+        val dstIndex = indexMap[srcIndex]
+        val sampleTime = extractor.sampleTime
+        if (dstIndex != null && srcIndex !in finishedTracks) {
+          if (endUs != Long.MAX_VALUE && sampleTime > endUs) {
+            finishedTracks.add(srcIndex)
+          } else {
+            bufferInfo.offset = 0
+            bufferInfo.size = sampleSize
+            bufferInfo.presentationTimeUs = (sampleTime - baseUs).coerceAtLeast(0L)
+            bufferInfo.flags =
+              if (extractor.sampleFlags and MediaExtractor.SAMPLE_FLAG_SYNC != 0) {
+                MediaCodec.BUFFER_FLAG_KEY_FRAME
+              } else {
+                0
+              }
+            muxer.writeSampleData(dstIndex, buffer, bufferInfo)
+            wroteAny = true
+          }
+        }
+        extractor.advance()
+      }
+
+      if (!wroteAny) runCatching { output.delete() }
+      return wroteAny
+    } catch (e: Exception) {
+      Log.w(TAG, "remux failed", e)
+      runCatching { output.delete() }
+      return false
+    } finally {
+      if (started) runCatching { muxer?.stop() }
+      runCatching { muxer?.release() }
+      runCatching { extractor?.release() }
+    }
+  }
+
+  private fun readRotation(input: File): Int {
+    var retriever: MediaMetadataRetriever? = null
+    return try {
+      retriever = MediaMetadataRetriever()
+      retriever.setDataSource(input.absolutePath)
+      retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION)?.toIntOrNull() ?: 0
+    } catch (e: Exception) {
+      0
+    } finally {
+      runCatching { retriever?.release() }
+    }
+  }
+}