react-native-video-trim 6.2.2 → 7.0.0

package/android/src/main/java/com/videotrim/utils/VideoTrimmerUtil.kt

@@ -2,12 +2,14 @@ package com.videotrim.utils
 
 import android.annotation.SuppressLint
 import android.graphics.Bitmap
+import android.graphics.RectF
 import android.media.MediaMetadataRetriever
 import android.util.Log
 import com.arthenica.ffmpegkit.FFmpegKit
 import com.arthenica.ffmpegkit.FFmpegSession
 import com.arthenica.ffmpegkit.ReturnCode
 import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.UiThreadUtil
 import com.videotrim.enums.ErrorCode
 import com.videotrim.interfaces.VideoTrimListener
 import iknow.android.utils.DeviceUtil
@@ -17,6 +19,7 @@ import iknow.android.utils.thread.BackgroundExecutor
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.TimeZone
+import kotlin.math.roundToInt
 
 object VideoTrimmerUtil {
 
@@ -41,8 +44,13 @@ object VideoTrimmerUtil {
     videoDuration: Int,
     startMs: Long,
     endMs: Long,
-    enableRotation: Boolean,
-    rotationAngle: Double,
+    userRotationCount: Int,
+    userIsFlipped: Boolean,
+    cropNormalized: RectF?,
+    videoWidth: Int,
+    videoHeight: Int,
+    videoBitrate: Long,
+    enablePreciseTrimming: Boolean,
     callback: VideoTrimListener
   ): FFmpegSession {
     val currentDate = Date()
@@ -57,18 +65,75 @@ object VideoTrimmerUtil {
     cmds.add("-to")
     cmds.add("${endMs}ms")
 
-    if (enableRotation) {
-      cmds.add("-display_rotation")
-      cmds.add(rotationAngle.toString())
-    }
+    val hasUserTransform = userRotationCount != 0 || userIsFlipped
+    // Re-encode is required when: (1) user applied flip/rotate, (2) user cropped, or
+    // (3) enablePreciseTrimming is on. In all three cases, -c copy won't work because
+    // either we need video filters or we need frame-accurate cut points.
+    val needsReEncode = hasUserTransform || cropNormalized != null || enablePreciseTrimming
+
+    if (needsReEncode) {
+      val videoFilters = mutableListOf<String>()
+
+      when (userRotationCount) {
+        1 -> videoFilters.add("transpose=2")
+        2 -> { videoFilters.add("transpose=2"); videoFilters.add("transpose=2") }
+        3 -> videoFilters.add("transpose=1")
+      }
+      if (userIsFlipped) {
+        videoFilters.add("hflip")
+      }
+
+      // Convert normalized crop rect [0..1] to pixel coordinates in the post-rotation frame.
+      if (cropNormalized != null && videoWidth > 0 && videoHeight > 0) {
+        val postW: Int
+        val postH: Int
+        // After 90°/270° rotation the width and height are swapped.
+        if (userRotationCount % 2 != 0) {
+          postW = videoHeight; postH = videoWidth
+        } else {
+          postW = videoWidth; postH = videoHeight
+        }
+        val cx = (cropNormalized.left * postW).roundToInt()
+        val cy = (cropNormalized.top * postH).roundToInt()
+        var cw = (cropNormalized.width() * postW).roundToInt()
+        var ch = (cropNormalized.height() * postH).roundToInt()
+        // H.264 requires even dimensions; round down to nearest even number.
+        cw = cw and 1.inv()
+        ch = ch and 1.inv()
+        if (cw > 0 && ch > 0) {
+          videoFilters.add("crop=$cw:$ch:$cx:$cy")
+        }
+      }
+
+      val filterString = videoFilters.joinToString(",")
+      // Preserve source quality by matching the original bitrate. Falls back to 10 Mbps.
+      val bitrateStr = if (videoBitrate > 0) "$videoBitrate" else "10M"
 
-    cmds.add("-i")
-    cmds.add(inputFile)
-    cmds.add("-c")
-    cmds.add("copy")
-    cmds.add("-metadata")
-    cmds.add("creation_time=$formattedDateTime")
-    cmds.add(outputFile)
+      cmds.addAll(listOf("-i", inputFile))
+      // When enablePreciseTrimming is the only reason for re-encode (no transforms),
+      // videoFilters is empty — skip -vf entirely to avoid FFmpeg error on empty filter.
+      if (filterString.isNotEmpty()) {
+        cmds.addAll(listOf("-vf", filterString))
+      }
+      // h264_mediacodec: Android's hardware H.264 encoder — fast and energy-efficient.
+      // Note: Android FFmpegKit auto-rotates by default, so no -noautorotate is needed.
+      // The transpose filters above only handle user-initiated rotation, not source metadata.
+      cmds.addAll(listOf(
+        "-c:v", "h264_mediacodec",
+        "-b:v", bitrateStr,
+        "-c:a", "copy",
+        "-metadata", "creation_time=$formattedDateTime",
+        outputFile
+      ))
+    } else {
+      // Stream copy: no re-encoding, extremely fast but only cuts at keyframes.
+      cmds.addAll(listOf(
+        "-i", inputFile,
+        "-c", "copy",
+        "-metadata", "creation_time=$formattedDateTime",
+        outputFile
+      ))
+    }
 
     val command = cmds.toTypedArray()
     val cmdStr = "Command: ${command.joinToString(" ")}"
@@ -82,16 +147,18 @@ object VideoTrimmerUtil {
     return FFmpegKit.executeWithArgumentsAsync(command, { session ->
       val state = session.state
       val returnCode = session.returnCode
-      when {
-        ReturnCode.isSuccess(session.returnCode) -> {
-          callback.onFinishTrim(outputFile, startMs, endMs, videoDuration)
-        }
-        ReturnCode.isCancel(session.returnCode) -> {
-          callback.onCancelTrim()
-        }
-        else -> {
-          val errorMessage = "Command failed with state $state and rc $returnCode.${session.failStackTrace}"
-          callback.onError(errorMessage, ErrorCode.TRIMMING_FAILED)
+      UiThreadUtil.runOnUiThread {
+        when {
+          ReturnCode.isSuccess(returnCode) -> {
+            callback.onFinishTrim(outputFile, startMs, endMs, videoDuration)
+          }
+          ReturnCode.isCancel(returnCode) -> {
+            callback.onCancelTrim()
+          }
+          else -> {
+            val errorMessage = "Command failed with state $state and rc $returnCode.${session.failStackTrace}"
+            callback.onError(errorMessage, ErrorCode.TRIMMING_FAILED)
+          }
         }
       }
     }, { log ->
@@ -102,12 +169,16 @@ object VideoTrimmerUtil {
       map.putString("message", log.message)
       map.putDouble("sessionId", log.sessionId.toDouble())
       map.putString("logStr", log.toString())
-      callback.onLog(map)
+      UiThreadUtil.runOnUiThread {
+        callback.onLog(map)
+      }
     }, { statistics ->
       val timeInMilliseconds = statistics.time.toInt()
       if (timeInMilliseconds > 0) {
         val completePercentage = (timeInMilliseconds * 100) / videoDuration
-        callback.onTrimmingProgress(completePercentage.coerceIn(0, 100))
+        UiThreadUtil.runOnUiThread {
+          callback.onTrimmingProgress(completePercentage.coerceIn(0, 100))
+        }
       }
 
       val map = Arguments.createMap()
@@ -120,7 +191,9 @@ object VideoTrimmerUtil {
       map.putDouble("bitrate", statistics.bitrate.toDouble())
       map.putDouble("speed", statistics.speed.toDouble())
       map.putString("statisticsStr", statistics.toString())
-      callback.onStatistics(map)
+      UiThreadUtil.runOnUiThread {
+        callback.onStatistics(map)
+      }
     })
   }
 

package/android/src/main/java/com/videotrim/widgets/CropOverlayView.kt

@@ -0,0 +1,293 @@
+package com.videotrim.widgets
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.graphics.Region
+import android.os.Build
+import android.util.AttributeSet
+import android.util.TypedValue
+import android.view.MotionEvent
+import android.view.ScaleGestureDetector
+import android.view.View
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
+
+class CropOverlayView @JvmOverloads constructor(
+  context: Context,
+  attrs: AttributeSet? = null,
+  defStyleAttr: Int = 0
+) : View(context, attrs, defStyleAttr) {
+
+  var cropRect = RectF()
+    set(value) {
+      field.set(value)
+      invalidate()
+    }
+
+  var allowedRect = RectF()
+    set(value) {
+      field.set(value)
+      if (cropRect.isEmpty) {
+        cropRect = RectF(value)
+      } else {
+        val clamped = RectF()
+        if (!clamped.setIntersect(cropRect, value) || clamped.width() < minCropSize || clamped.height() < minCropSize) {
+          cropRect = RectF(value)
+        }
+      }
+    }
+
+  var onCropChanged: (() -> Unit)? = null
+  var onCropBegan: (() -> Unit)? = null
+  var onCropEnded: (() -> Unit)? = null
+
+  private val minCropSize = dpToPx(60f)
+  private val borderWidth = dpToPx(1f)
+  private val cornerLength = dpToPx(20f)
+  private val cornerWidth = dpToPx(4f)
+  private val gridLineWidth = 1f / resources.displayMetrics.density
+  private val edgeHitZone = dpToPx(30f)
+
+  private val borderPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+    style = Paint.Style.STROKE
+    color = Color.argb(153, 255, 255, 255)
+    strokeWidth = borderWidth
+  }
+  private val gridPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+    style = Paint.Style.STROKE
+    color = Color.WHITE
+    strokeWidth = gridLineWidth
+  }
+  private val cornerPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+    style = Paint.Style.STROKE
+    color = Color.WHITE
+    strokeWidth = cornerWidth
+    strokeCap = Paint.Cap.ROUND
+  }
+  private val dimmingPaint = Paint().apply {
+    color = Color.argb(140, 0, 0, 0)
+    style = Paint.Style.FILL
+  }
+
+  private enum class DragEdge {
+    TOP, BOTTOM, LEFT, RIGHT,
+    TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT,
+    MOVE
+  }
+
+  private var activeEdge: DragEdge? = null
+  private var dragStartX = 0f
+  private var dragStartY = 0f
+  private var dragStartRect = RectF()
+  private var gestureStarted = false
+
+  private val scaleDetector = ScaleGestureDetector(context, object : ScaleGestureDetector.SimpleOnScaleGestureListener() {
+    private var pinchStartRect = RectF()
+
+    override fun onScaleBegin(detector: ScaleGestureDetector): Boolean {
+      pinchStartRect.set(cropRect)
+      if (!gestureStarted) {
+        gestureStarted = true
+        onCropBegan?.invoke()
+      }
+      return true
+    }
+
+    override fun onScale(detector: ScaleGestureDetector): Boolean {
+      val scale = detector.scaleFactor
+      val cx = pinchStartRect.centerX()
+      val cy = pinchStartRect.centerY()
+      var newW = max(pinchStartRect.width() * scale, minCropSize)
+      var newH = max(pinchStartRect.height() * scale, minCropSize)
+      newW = min(newW, allowedRect.width())
+      newH = min(newH, allowedRect.height())
+      val r = RectF(cx - newW / 2, cy - newH / 2, cx + newW / 2, cy + newH / 2)
+      clamp(r, isMove = true)
+      cropRect = r
+      onCropChanged?.invoke()
+      return true
+    }
+
+    override fun onScaleEnd(detector: ScaleGestureDetector) {
+      if (gestureStarted) {
+        gestureStarted = false
+        onCropEnded?.invoke()
+      }
+    }
+  })
+
+  override fun onDraw(canvas: Canvas) {
+    super.onDraw(canvas)
+    if (cropRect.isEmpty) return
+    val cr = cropRect
+
+    drawDimming(canvas, cr)
+
+    canvas.drawRect(cr, borderPaint)
+
+    for (i in 1..2) {
+      val x = cr.left + cr.width() * i / 3f
+      canvas.drawLine(x, cr.top, x, cr.bottom, gridPaint)
+    }
+    for (i in 1..2) {
+      val y = cr.top + cr.height() * i / 3f
+      canvas.drawLine(cr.left, y, cr.right, y, gridPaint)
+    }
+
+    val cl = cornerLength
+    val path = Path()
+    fun addCorner(sx: Float, sy: Float, cx: Float, cy: Float, ex: Float, ey: Float) {
+      path.moveTo(sx, sy); path.lineTo(cx, cy); path.lineTo(ex, ey)
+    }
+    addCorner(cr.left, cr.top + cl, cr.left, cr.top, cr.left + cl, cr.top)
+    addCorner(cr.right - cl, cr.top, cr.right, cr.top, cr.right, cr.top + cl)
+    addCorner(cr.left, cr.bottom - cl, cr.left, cr.bottom, cr.left + cl, cr.bottom)
+    addCorner(cr.right - cl, cr.bottom, cr.right, cr.bottom, cr.right, cr.bottom - cl)
+    canvas.drawPath(path, cornerPaint)
+  }
+
+  private fun drawDimming(canvas: Canvas, cr: RectF) {
+    canvas.save()
+    val fullPath = Path()
+    fullPath.addRect(0f, 0f, width.toFloat(), height.toFloat(), Path.Direction.CW)
+    val cropPath = Path()
+    cropPath.addRect(cr, Path.Direction.CW)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      fullPath.op(cropPath, Path.Op.DIFFERENCE)
+      canvas.drawPath(fullPath, dimmingPaint)
+    } else {
+      @Suppress("DEPRECATION")
+      canvas.clipPath(cropPath, Region.Op.DIFFERENCE)
+      canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), dimmingPaint)
+    }
+    canvas.restore()
+  }
+
+  override fun onTouchEvent(event: MotionEvent): Boolean {
+    if (event.pointerCount > 1) {
+      scaleDetector.onTouchEvent(event)
+      return true
+    }
+
+    val x = event.x
+    val y = event.y
+
+    when (event.actionMasked) {
+      MotionEvent.ACTION_DOWN -> {
+        activeEdge = detectEdge(x, y) ?: return false
+        dragStartX = x
+        dragStartY = y
+        dragStartRect.set(cropRect)
+        gestureStarted = true
+        onCropBegan?.invoke()
+        return true
+      }
+      MotionEvent.ACTION_MOVE -> {
+        val edge = activeEdge ?: return false
+        val dx = x - dragStartX
+        val dy = y - dragStartY
+        cropRect = computeNewRect(edge, dx, dy)
+        onCropChanged?.invoke()
+        return true
+      }
+      MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+        activeEdge = null
+        if (gestureStarted) {
+          gestureStarted = false
+          onCropEnded?.invoke()
+        }
+        return true
+      }
+    }
+    return false
+  }
+
+  private fun detectEdge(px: Float, py: Float): DragEdge? {
+    val r = cropRect
+    val z = edgeHitZone
+
+    val nearT = abs(py - r.top) < z
+    val nearB = abs(py - r.bottom) < z
+    val nearL = abs(px - r.left) < z
+    val nearR = abs(px - r.right) < z
+    val inH = px > r.left - z && px < r.right + z
+    val inV = py > r.top - z && py < r.bottom + z
+
+    if (nearT && nearL) return DragEdge.TOP_LEFT
+    if (nearT && nearR) return DragEdge.TOP_RIGHT
+    if (nearB && nearL) return DragEdge.BOTTOM_LEFT
+    if (nearB && nearR) return DragEdge.BOTTOM_RIGHT
+    if (nearT && inH) return DragEdge.TOP
+    if (nearB && inH) return DragEdge.BOTTOM
+    if (nearL && inV) return DragEdge.LEFT
+    if (nearR && inV) return DragEdge.RIGHT
+    if (r.contains(px, py)) return DragEdge.MOVE
+    return null
+  }
+
+  private fun computeNewRect(edge: DragEdge, dx: Float, dy: Float): RectF {
+    val r = RectF(dragStartRect)
+
+    when (edge) {
+      DragEdge.TOP_LEFT -> { r.left += dx; r.top += dy }
+      DragEdge.TOP_RIGHT -> { r.right += dx; r.top += dy }
+      DragEdge.BOTTOM_LEFT -> { r.left += dx; r.bottom += dy }
+      DragEdge.BOTTOM_RIGHT -> { r.right += dx; r.bottom += dy }
+      DragEdge.TOP -> r.top += dy
+      DragEdge.BOTTOM -> r.bottom += dy
+      DragEdge.LEFT -> r.left += dx
+      DragEdge.RIGHT -> r.right += dx
+      DragEdge.MOVE -> {
+        r.offset(dx, dy)
+        clamp(r, isMove = true)
+        return r
+      }
+    }
+
+    if (r.width() < minCropSize) {
+      val anchorsRight = edge == DragEdge.LEFT || edge == DragEdge.TOP_LEFT || edge == DragEdge.BOTTOM_LEFT
+      if (anchorsRight) r.left = r.right - minCropSize else r.right = r.left + minCropSize
+    }
+    if (r.height() < minCropSize) {
+      val anchorsBottom = edge == DragEdge.TOP || edge == DragEdge.TOP_LEFT || edge == DragEdge.TOP_RIGHT
+      if (anchorsBottom) r.top = r.bottom - minCropSize else r.bottom = r.top + minCropSize
+    }
+
+    clamp(r, isMove = false)
+    return r
+  }
+
+  private fun clamp(r: RectF, isMove: Boolean) {
+    val a = allowedRect
+    if (a.isEmpty) return
+
+    if (isMove) {
+      val w = min(r.width(), a.width())
+      val h = min(r.height(), a.height())
+      r.right = r.left + w
+      r.bottom = r.top + h
+      if (r.left < a.left) r.offset(a.left - r.left, 0f)
+      if (r.top < a.top) r.offset(0f, a.top - r.top)
+      if (r.right > a.right) r.offset(a.right - r.right, 0f)
+      if (r.bottom > a.bottom) r.offset(0f, a.bottom - r.bottom)
+    } else {
+      r.left = max(r.left, a.left)
+      r.top = max(r.top, a.top)
+      if (r.right > a.right) r.right = a.right
+      if (r.bottom > a.bottom) r.bottom = a.bottom
+    }
+  }
+
+  fun resetCrop() {
+    cropRect = RectF(allowedRect)
+  }
+
+  private fun dpToPx(dp: Float): Float {
+    return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, resources.displayMetrics)
+  }
+}