react-native-compressor 1.18.2 → 1.19.0

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/utils/LocationExtractor.kt

@@ -0,0 +1,397 @@
+package com.reactnativecompressor.Video.VideoCompressor.utils
+
+import android.content.Context
+import android.net.Uri
+import android.os.ParcelFileDescriptor
+import android.util.Log
+import java.io.File
+import java.io.FileInputStream
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.nio.channels.FileChannel
+import java.nio.charset.StandardCharsets
+import java.util.Locale
+
+/**
+ * Raw MP4 walker that recovers an ISO 6709 GPS string when
+ * MediaMetadataRetriever.METADATA_KEY_LOCATION fails to return one.
+ *
+ * Why this exists: device vendors disagree on where GPS lives.
+ *   - Most phones write Apple "©xyz" under moov/udta or moov/trak/udta.
+ *   - Some ISO-compliant captures use the standard "loci" box.
+ *   - Newer iOS / Android captures use the iTunes-style
+ *     moov/meta/keys + moov/meta/ilst pair with the key
+ *     "com.apple.quicktime.location.ISO6709".
+ *
+ * Android's retriever only reads movie-level "©xyz" and silently returns
+ * null for everything else. The walker descends through every container
+ * atom and tries each known encoding in priority order.
+ */
+object LocationExtractor {
+
+  // Share the "Compressor" log tag so the atom dump is visible alongside
+  // the existing pipeline diagnostics without needing an extra logcat filter.
+  private const val TAG = "Compressor"
+
+  private val CONTAINER_TYPES = setOf("moov", "trak", "mdia", "minf", "udta", "meta", "ilst")
+
+  fun extract(context: Context, uri: Uri): String? {
+    Log.i(TAG, "LocationExtractor.extract uri=$uri")
+    return try {
+      openChannel(context, uri)?.use { channel ->
+        Log.i(TAG, "LocationExtractor: file size=${channel.size()}")
+        val state = WalkState()
+        walk(channel, 0L, channel.size(), state, depth = 0)
+        val viaBox = chooseBest(state)
+        // Log only presence, never the coordinate strings — these are the
+        // user's exact GPS values and must not land in production logcat.
+        Log.i(
+          TAG,
+          "LocationExtractor box scan: hasXyz=${!state.xyz.isNullOrEmpty()} hasItunesLocation=${!state.itunesLocation.isNullOrEmpty()} hasLoci=${!state.loci.isNullOrEmpty()} hasChosenLocation=${!viaBox.isNullOrEmpty()}"
+        )
+        // Samsung phones (Galaxy S10 / Android 12 verified) write GPS into
+        // an SEF (Samsung Extended Format) trailer that sits after mdat,
+        // outside the standard MP4 box hierarchy. The trailer contains
+        // an ISO 6709 string in plain ASCII. Scan the file tail and let
+        // the strict regex extract it.
+        viaBox ?: scanTrailerForIso6709(channel)
+      }
+    } catch (e: Exception) {
+      Log.w(TAG, "LocationExtractor extract failed", e)
+      null
+    }
+  }
+
+  /**
+   * Open a FileChannel for either a content:// URI (via ContentResolver) or
+   * a raw filesystem path. JS layer hands the compressor URIs in three
+   * shapes — content://, file://, and bare /storage/... paths — and the
+   * latter cannot be opened through ContentResolver.
+   */
+  private fun openChannel(context: Context, uri: Uri): FileChannel? {
+    val scheme = uri.scheme
+    if (scheme == null || scheme == "file") {
+      val path = uri.path ?: uri.toString()
+      val file = File(path)
+      if (!file.exists()) {
+        Log.w(TAG, "LocationExtractor: file does not exist $path")
+        return null
+      }
+      return FileInputStream(file).channel
+    }
+    val pfd = context.contentResolver.openFileDescriptor(uri, "r")
+    if (pfd == null) {
+      Log.w(TAG, "LocationExtractor: openFileDescriptor returned null for $uri")
+      return null
+    }
+    // AutoCloseInputStream closes the ParcelFileDescriptor when the stream
+    // is closed. A bare FileInputStream over pfd.fileDescriptor would leak
+    // the pfd until finalizer runs.
+    return ParcelFileDescriptor.AutoCloseInputStream(pfd).channel
+  }
+
+  // Strict ISO 6709 pattern: signed lat, signed lon, optional signed alt,
+  // mandatory trailing slash. Tight enough that random bytes inside mdat
+  // virtually never match, lenient enough to accept the small precision
+  // variations vendors use.
+  private val ISO6709_REGEX = Regex(
+    "[+-]\\d{1,3}\\.\\d{2,7}[+-]\\d{1,3}\\.\\d{2,7}([+-]\\d{1,5}(\\.\\d+)?)?/"
+  )
+
+  private fun scanTrailerForIso6709(channel: FileChannel): String? {
+    val size = channel.size()
+    // 1 MiB tail covers every SEF trailer observed so far. Capped so very
+    // small clips do not read past start of file.
+    val tailSize = minOf(size, 1L shl 20).toInt()
+    if (tailSize <= 0) return null
+    val start = size - tailSize
+    val buf = ByteBuffer.allocate(tailSize)
+    channel.position(start)
+    if (channel.read(buf) <= 0) return null
+    buf.flip()
+    val bytes = ByteArray(buf.remaining())
+    buf.get(bytes)
+    val text = String(bytes, StandardCharsets.ISO_8859_1)
+    val match = ISO6709_REGEX.find(text)
+    Log.i(TAG, "LocationExtractor SEF trailer scan matched=${match != null}")
+    return match?.value
+  }
+
+  private class WalkState {
+    var xyz: String? = null
+    var loci: String? = null
+    var itunesLocation: String? = null
+    // iTunes-style meta state.
+    val itunesKeys: ArrayList<String> = ArrayList()
+    var insideMeta: Boolean = false
+  }
+
+  private fun chooseBest(s: WalkState): String? {
+    return s.xyz?.takeIf { it.isNotEmpty() }
+      ?: s.itunesLocation?.takeIf { it.isNotEmpty() }
+      ?: s.loci?.takeIf { it.isNotEmpty() }
+  }
+
+  private fun walk(
+    channel: FileChannel,
+    start: Long,
+    end: Long,
+    state: WalkState,
+    depth: Int,
+  ) {
+    var pos = start
+    val header = ByteBuffer.allocate(16).order(ByteOrder.BIG_ENDIAN)
+    while (pos + 8 <= end) {
+      header.clear()
+      header.limit(8)
+      channel.position(pos)
+      if (channel.read(header) < 8) break
+      header.flip()
+      val rawSize = header.int.toLong() and 0xFFFFFFFFL
+      val typeBytes = ByteArray(4)
+      header.get(typeBytes)
+      val type = fourCC(typeBytes)
+
+      var headerSize = 8L
+      var boxSize = rawSize
+      if (rawSize == 1L) {
+        val ext = ByteBuffer.allocate(8).order(ByteOrder.BIG_ENDIAN)
+        channel.position(pos + 8)
+        if (channel.read(ext) < 8) break
+        ext.flip()
+        boxSize = ext.long
+        headerSize = 16L
+      } else if (rawSize == 0L) {
+        boxSize = end - pos
+      }
+
+      if (boxSize < headerSize || pos + boxSize > end) break
+      val childEnd = pos + boxSize
+      val childStart = pos + headerSize
+
+      if (depth < 5) {
+        // Use Log.i so the atom tree appears in default logcat output and
+        // can be pasted back when GPS extraction misses a vendor-specific
+        // box layout. Depth-bounded to avoid spamming on large mdat chunks.
+        Log.i(TAG, "LocationExtractor atom $type @ $pos size=$boxSize depth=$depth")
+      }
+
+      when {
+        // Apple Quicktime "©xyz" - 0xA9 'x' 'y' 'z'.
+        typeBytes[0] == 0xA9.toByte() &&
+          typeBytes[1] == 'x'.code.toByte() &&
+          typeBytes[2] == 'y'.code.toByte() &&
+          typeBytes[3] == 'z'.code.toByte() -> {
+          val parsed = readXyz(channel, childStart, childEnd)
+          if (!parsed.isNullOrEmpty() && state.xyz == null) {
+            state.xyz = parsed
+            Log.i(TAG, "found ©xyz")
+          }
+        }
+
+        // ISO 14496-12 "loci" location box.
+        type == "loci" -> {
+          val parsed = readLoci(channel, childStart, childEnd)
+          if (!parsed.isNullOrEmpty() && state.loci == null) {
+            state.loci = parsed
+            Log.i(TAG, "found loci")
+          }
+        }
+
+        // iTunes-style metadata under moov/meta.
+        type == "keys" && state.insideMeta -> {
+          parseItunesKeys(channel, childStart, childEnd, state)
+        }
+        type == "ilst" && state.insideMeta -> {
+          parseItunesIlst(channel, childStart, childEnd, state)
+        }
+      }
+
+      if (type in CONTAINER_TYPES) {
+        // "meta" has a 4-byte version+flags prefix before its children.
+        val innerStart = if (type == "meta") childStart + 4 else childStart
+        val priorMeta = state.insideMeta
+        if (type == "meta") state.insideMeta = true
+        walk(channel, innerStart, childEnd, state, depth + 1)
+        state.insideMeta = priorMeta
+      }
+
+      pos = childEnd
+    }
+  }
+
+  private fun fourCC(b: ByteArray): String {
+    val sb = StringBuilder(4)
+    for (byte in b) {
+      val c = byte.toInt() and 0xFF
+      sb.append(if (c in 0x20..0x7E) c.toChar() else '?')
+    }
+    return sb.toString()
+  }
+
+  private fun readBoxContent(channel: FileChannel, start: Long, end: Long): ByteBuffer? {
+    val len = (end - start).toInt()
+    if (len <= 0) return null
+    val buf = ByteBuffer.allocate(len).order(ByteOrder.BIG_ENDIAN)
+    channel.position(start)
+    if (channel.read(buf) < len) return null
+    buf.flip()
+    return buf
+  }
+
+  /**
+   * Apple "©xyz" content:
+   *   uint16 length
+   *   uint16 language code (packed)
+   *   bytes  ISO 6709 string
+   */
+  private fun readXyz(channel: FileChannel, start: Long, end: Long): String? {
+    val buf = readBoxContent(channel, start, end) ?: return null
+    if (buf.remaining() < 4) return null
+    val len = buf.short.toInt() and 0xFFFF
+    buf.short
+    val take = minOf(len, buf.remaining())
+    if (take <= 0) return null
+    val bytes = ByteArray(take)
+    buf.get(bytes)
+    return String(bytes, StandardCharsets.UTF_8).trim().ifEmpty { null }
+  }
+
+  /**
+   * ISO 14496-12 "loci" content:
+   *   uint8  version
+   *   uint24 flags
+   *   uint16 language
+   *   utf8z  name
+   *   uint8  role
+   *   uint32 longitude (16.16 fixed)
+   *   uint32 latitude  (16.16 fixed)
+   *   uint32 altitude  (16.16 fixed)
+   *   ...
+   */
+  private fun readLoci(channel: FileChannel, start: Long, end: Long): String? {
+    val buf = readBoxContent(channel, start, end) ?: return null
+    if (buf.remaining() < 6) return null
+    buf.int // version + flags
+    buf.short // language
+    // Skip null-terminated name.
+    while (buf.hasRemaining() && buf.get() != 0.toByte()) { /* skip */ }
+    if (buf.remaining() < 1 + 12) return null
+    buf.get() // role
+    val longitude = fixedPoint1616(buf.int)
+    val latitude = fixedPoint1616(buf.int)
+    val altitude = fixedPoint1616(buf.int)
+    return formatIso6709(latitude, longitude, altitude)
+  }
+
+  private fun fixedPoint1616(raw: Int): Double {
+    return raw.toDouble() / 65536.0
+  }
+
+  private fun formatIso6709(lat: Double, lon: Double, alt: Double): String {
+    val sb = StringBuilder()
+    sb.append(if (lat >= 0) "+" else "")
+    sb.append(String.format(Locale.US, "%.4f", lat))
+    sb.append(if (lon >= 0) "+" else "")
+    sb.append(String.format(Locale.US, "%.4f", lon))
+    if (alt != 0.0) {
+      sb.append(if (alt >= 0) "+" else "")
+      sb.append(String.format(Locale.US, "%.3f", alt))
+    }
+    sb.append('/')
+    return sb.toString()
+  }
+
+  /**
+   * Apple iTunes-style "keys" box content:
+   *   uint32 version+flags
+   *   uint32 entry_count
+   *   for each:
+   *     uint32 key_size (includes header)
+   *     uint32 key_namespace ('mdta')
+   *     bytes  key_value (utf-8)
+   */
+  private fun parseItunesKeys(channel: FileChannel, start: Long, end: Long, state: WalkState) {
+    val buf = readBoxContent(channel, start, end) ?: return
+    state.itunesKeys.clear()
+    if (buf.remaining() < 8) return
+    buf.int // version + flags
+    val count = buf.int
+    for (i in 0 until count) {
+      if (buf.remaining() < 8) break
+      val entrySize = buf.int
+      buf.int // namespace
+      val keyLen = entrySize - 8
+      if (keyLen <= 0 || keyLen > buf.remaining()) break
+      val keyBytes = ByteArray(keyLen)
+      buf.get(keyBytes)
+      state.itunesKeys.add(String(keyBytes, StandardCharsets.UTF_8))
+    }
+    Log.i(TAG, "LocationExtractor itunes keys: ${state.itunesKeys}")
+  }
+
+  /**
+   * Apple iTunes-style "ilst" box. Each child is an indexed item whose
+   * type is a uint32 index pointing back into the "keys" table. Inside
+   * each item is a "data" sub-box with the actual payload.
+   */
+  private fun parseItunesIlst(channel: FileChannel, start: Long, end: Long, state: WalkState) {
+    var pos = start
+    val header = ByteBuffer.allocate(8).order(ByteOrder.BIG_ENDIAN)
+    while (pos + 8 <= end) {
+      header.clear()
+      channel.position(pos)
+      if (channel.read(header) < 8) break
+      header.flip()
+      val itemSize = header.int.toLong() and 0xFFFFFFFFL
+      val indexBytes = ByteArray(4)
+      header.get(indexBytes)
+      val index = ByteBuffer.wrap(indexBytes).order(ByteOrder.BIG_ENDIAN).int
+      if (itemSize < 8 || pos + itemSize > end) break
+      val itemEnd = pos + itemSize
+      val key = state.itunesKeys.getOrNull(index - 1)
+      if (key == "com.apple.quicktime.location.ISO6709") {
+        val payload = findItunesData(channel, pos + 8, itemEnd)
+        if (!payload.isNullOrEmpty() && state.itunesLocation == null) {
+          state.itunesLocation = payload
+          Log.i(TAG, "found itunes location")
+        }
+      }
+      pos = itemEnd
+    }
+  }
+
+  private fun findItunesData(channel: FileChannel, start: Long, end: Long): String? {
+    var pos = start
+    val header = ByteBuffer.allocate(8).order(ByteOrder.BIG_ENDIAN)
+    while (pos + 8 <= end) {
+      header.clear()
+      channel.position(pos)
+      if (channel.read(header) < 8) break
+      header.flip()
+      val size = header.int.toLong() and 0xFFFFFFFFL
+      val typeBytes = ByteArray(4)
+      header.get(typeBytes)
+      val type = fourCC(typeBytes)
+      if (size < 8 || pos + size > end) break
+      if (type == "data") {
+        // data box: uint32 type indicator, uint32 locale, then payload.
+        val payloadStart = pos + 8 + 8
+        val payloadEnd = pos + size
+        if (payloadEnd > payloadStart) {
+          val len = (payloadEnd - payloadStart).toInt()
+          val buf = ByteBuffer.allocate(len)
+          channel.position(payloadStart)
+          if (channel.read(buf) >= len) {
+            buf.flip()
+            val bytes = ByteArray(len)
+            buf.get(bytes)
+            return String(bytes, StandardCharsets.UTF_8).trim().ifEmpty { null }
+          }
+        }
+      }
+      pos += size
+    }
+    return null
+  }
+}

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/videoHelpers/LocationBox.kt

@@ -0,0 +1,47 @@
+package com.reactnativecompressor.Video.VideoCompressor.video
+
+import org.mp4parser.support.AbstractBox
+import java.nio.ByteBuffer
+import java.nio.charset.StandardCharsets
+
+/**
+ * Apple Quicktime "©xyz" box that stores an ISO 6709 location string
+ * (e.g. "+37.4220-122.0840/" or "+37.4220-122.0840+009.000/").
+ *
+ * Android's MediaMetadataRetriever.METADATA_KEY_LOCATION reads this exact
+ * box; writing it preserves GPS metadata across the compression rewrite.
+ *
+ * Layout of the box content:
+ *   uint16 BE  text byte length
+ *   uint16 BE  language packed code (0x15c7 = "und")
+ *   bytes      ISO 6709 string (no NUL terminator)
+ */
+class LocationBox : AbstractBox(TYPE) {
+
+  var location: String = ""
+
+  override fun getContentSize(): Long {
+    val bytes = location.toByteArray(StandardCharsets.UTF_8)
+    return (2 + 2 + bytes.size).toLong()
+  }
+
+  override fun _parseDetails(content: ByteBuffer) {
+    val len = content.short.toInt() and 0xFFFF
+    content.short
+    val bytes = ByteArray(len)
+    content.get(bytes)
+    location = String(bytes, StandardCharsets.UTF_8)
+  }
+
+  override fun getContent(byteBuffer: ByteBuffer) {
+    val bytes = location.toByteArray(StandardCharsets.UTF_8)
+    byteBuffer.putShort(bytes.size.toShort())
+    byteBuffer.putShort(LANG_UND)
+    byteBuffer.put(bytes)
+  }
+
+  companion object {
+    const val TYPE = "©xyz"
+    private const val LANG_UND: Short = 0x15c7
+  }
+}

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/videoHelpers/MP4Builder.kt

@@ -30,13 +30,20 @@ class MP4Builder {
         fos = FileOutputStream(mp4Movie.getCacheFile())
         fc = fos.channel
 
-        val fileTypeBox: FileTypeBox = createFileTypeBox()
-        fileTypeBox.getBox(fc)
-        dataOffset += fileTypeBox.size
-        wroteSinceLastMdat = dataOffset
-
-        mdat = Mdat()
-        sizeBuffer = ByteBuffer.allocateDirect(4)
+        // Streams are open now; if header writing throws, the caller never gets
+        // a reference to close, so release them here before rethrowing.
+        try {
+            val fileTypeBox: FileTypeBox = createFileTypeBox()
+            fileTypeBox.getBox(fc)
+            dataOffset += fileTypeBox.size
+            wroteSinceLastMdat = dataOffset
+
+            mdat = Mdat()
+            sizeBuffer = ByteBuffer.allocateDirect(4)
+        } catch (e: Exception) {
+            close()
+            throw e
+        }
 
         return this
     }
@@ -131,6 +138,19 @@ class MP4Builder {
         fos.close()
     }
 
+    // Close the underlying file streams without finalizing the movie. Used on
+    // failure paths where finishMovie() never runs, so the FileOutputStream and
+    // its FileChannel opened in createMovie() don't leak. Safe to call when
+    // createMovie() failed early (streams not yet initialized) and idempotent.
+    fun close() {
+        if (::fc.isInitialized) {
+            runCatching { fc.close() }
+        }
+        if (::fos.isInitialized) {
+            runCatching { fos.close() }
+        }
+    }
+
     private fun createFileTypeBox(): FileTypeBox {
         // completed list can be found at https://www.ftyps.com/
         val minorBrands = listOf(
@@ -190,6 +210,18 @@ class MP4Builder {
             movieBox.addBox(createTrackBox(track, movie))
         }
 
+        // Preserve source GPS metadata. MediaMetadataRetriever and most
+        // gallery apps read the Apple "©xyz" box inside moov/udta, so any
+        // ISO 6709 string passed in is written there verbatim.
+        val location = movie.getLocation()
+        if (!location.isNullOrEmpty()) {
+            val udta = UserDataBox()
+            val xyz = LocationBox()
+            xyz.location = location
+            udta.addBox(xyz)
+            movieBox.addBox(udta)
+        }
+
         return movieBox
     }
 

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/videoHelpers/Mp4Movie.kt

@@ -11,6 +11,7 @@ class Mp4Movie {
     private var matrix = Matrix.ROTATE_0
     private val tracks = ArrayList<Track>()
     private var cacheFile: File? = null
+    private var location: String? = null
 
     fun getMatrix(): Matrix? = matrix
 
@@ -18,6 +19,12 @@ class Mp4Movie {
         cacheFile = file
     }
 
+    fun setLocation(value: String?) {
+        location = value
+    }
+
+    fun getLocation(): String? = location
+
     fun setRotation(angle: Int) {
         when (angle) {
             0 -> {

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/videoHelpers/OutputSurface.kt

@@ -2,6 +2,8 @@ package com.reactnativecompressor.Video.VideoCompressor.video
 
 import android.graphics.SurfaceTexture
 import android.graphics.SurfaceTexture.OnFrameAvailableListener
+import android.os.Handler
+import android.os.HandlerThread
 import android.view.Surface
 
 class OutputSurface : OnFrameAvailableListener {
@@ -12,6 +14,15 @@ class OutputSurface : OnFrameAvailableListener {
     private var mFrameAvailable = false
     private var mTextureRender: TextureRenderer? = null
 
+    // Dedicated thread for SurfaceTexture's onFrameAvailable callback.
+    // Without this, Android delivers the callback on the main UI thread
+    // (because the compression coroutine has no Looper), so awaitNewImage()
+    // stalls whenever the main thread is busy with UI / JS bridge work.
+    // Routing the callback to its own thread removes that contention and
+    // is the single biggest throughput win for the decoder→encoder pipeline.
+    private val mCallbackThread = HandlerThread("CompressorSurfaceTexCb").apply { start() }
+    private val mCallbackHandler = Handler(mCallbackThread.looper)
+
     /**
      * Creates an OutputSurface using the current EGL context. This Surface will be
      * passed to MediaCodec.configure().
@@ -35,7 +46,7 @@ class OutputSurface : OnFrameAvailableListener {
             // causes the native finalizer to run.
             mSurfaceTexture = SurfaceTexture(it.getTextureId())
             mSurfaceTexture?.let { surfaceTexture ->
-                surfaceTexture.setOnFrameAvailableListener(this)
+                surfaceTexture.setOnFrameAvailableListener(this, mCallbackHandler)
                 mSurface = Surface(mSurfaceTexture)
             }
         }
@@ -43,6 +54,13 @@ class OutputSurface : OnFrameAvailableListener {
 
     /**
      * Discards all resources held by this class, notably the EGL context.
+     *
+     * quitSafely() returns immediately; the HandlerThread's native pthread
+     * may still be terminating when callers proceed to tear down MediaCodec.
+     * If the ART sampling profiler walks threads during that window it can
+     * dereference a stale pthread_t and SIGABRT. join(500) blocks until the
+     * thread is fully exited (pthread_join) so the pthread_t is no longer
+     * tracked. Bounded at 500ms to avoid hanging on a pathological looper.
      */
     fun release() {
         mSurface?.release()
@@ -50,6 +68,13 @@ class OutputSurface : OnFrameAvailableListener {
         mTextureRender = null
         mSurface = null
         mSurfaceTexture = null
+
+        mCallbackThread.quitSafely()
+        try {
+            mCallbackThread.join(500)
+        } catch (ignored: InterruptedException) {
+            Thread.currentThread().interrupt()
+        }
     }
 
     /**
@@ -63,12 +88,13 @@ class OutputSurface : OnFrameAvailableListener {
      * data is available.
      */
     fun awaitNewImage() {
-        val timeOutMS = 100
+        // 10s timeout to avoid spurious failures under heavy main-thread load.
+        // The callback now arrives on a dedicated thread, so realistic frames
+        // land in <50ms; this bound only catches a stuck pipeline.
+        val timeOutMS = 10_000
         synchronized(mFrameSyncObject) {
             while (!mFrameAvailable) {
                 try {
-                    // Wait for onFrameAvailable() to signal us.  Use a timeout to avoid
-                    // stalling the test if it doesn't arrive.
                     mFrameSyncObject.wait(timeOutMS.toLong())
                     if (!mFrameAvailable) {
                         throw RuntimeException("Surface frame wait timed out")

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressorHelper.kt

@@ -100,6 +100,29 @@ class VideoCompressorHelper {
                 ?: 0
         }
 
+        /**
+         * Derive the source video frame rate. METADATA_KEY_CAPTURE_FRAMERATE
+         * is only populated for slow-motion captures, so most regular videos
+         * return 0 and downstream code falls back to a hard-coded 30 fps —
+         * which silently halves the frame count of any 60 fps source and
+         * produces visibly choppy output.
+         *
+         * Strategy: trust CAPTURE_FRAMERATE when present, otherwise compute
+         * fps from frame count / duration (API 28+ exposes the frame count
+         * via METADATA_KEY_VIDEO_FRAME_COUNT). Returns 0 if neither path
+         * yields a usable value.
+         */
+        fun getSourceFrameRate(metaRetriever: MediaMetadataRetriever): Int {
+            val capture = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_CAPTURE_FRAMERATE)
+            if (capture > 0) return capture
+
+            val frameCount = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_VIDEO_FRAME_COUNT)
+            val durationMs = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_DURATION)
+            if (frameCount <= 0 || durationMs <= 0) return 0
+            val fps = (frameCount.toLong() * 1000L / durationMs.toLong()).toInt()
+            return fps.coerceIn(0, 240)
+        }
+
         fun VideoCompressManual(fileUrl: String?, options: VideoCompressorHelper, promise: Promise, reactContext: ReactApplicationContext?) {
             try {
                 val uri = Uri.parse(fileUrl)
@@ -110,7 +133,7 @@ class VideoCompressorHelper {
                 val height = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)
                 val width = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)
                 val bitrate = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_BITRATE)
-                val frameRate = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_CAPTURE_FRAMERATE)
+                val frameRate = getSourceFrameRate(metaRetriever)
                 if (height <= 0 || width <= 0) {
                     promise.reject(Throwable("Failed to read the input video dimensions"))
                     return