react-native-compressor 1.18.2 → 2.0.0

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

@@ -49,16 +49,19 @@ object CompressorUtils {
   }
 
   /**
-   * Set up an Mp4Movie with rotation and cache file.
+   * Set up an Mp4Movie with rotation, cache file and optional ISO 6709
+   * location string forwarded from the source video.
    */
   fun setUpMP4Movie(
     rotation: Int,
     cacheFile: File,
+    location: String? = null,
   ): Mp4Movie {
     val movie = Mp4Movie()
     movie.apply {
       setCacheFile(cacheFile)
       setRotation(rotation)
+      setLocation(location)
     }
     return movie
   }
@@ -71,6 +74,7 @@ object CompressorUtils {
     outputFormat: MediaFormat,
     newBitrate: Int,
     targetFrameRate: Int,
+    applyThroughputTuning: Boolean = true,
   ) {
     val newFrameRate = targetFrameRate.coerceAtLeast(1)
     val iFrameInterval = getIFrameIntervalRate(inputFormat)
@@ -84,10 +88,25 @@ object CompressorUtils {
       setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, iFrameInterval)
       // Bitrate in bits per second
       setInteger(MediaFormat.KEY_BIT_RATE, newBitrate)
-      setInteger(
-        MediaFormat.KEY_BITRATE_MODE,
-        MediaCodecInfo.EncoderCapabilities.BITRATE_MODE_CBR
-      )
+
+      // Throughput tuning. Some encoders reject these keys at configure() time,
+      // so the caller drops them (applyThroughputTuning = false) and reconfigures
+      // with default rate control on a fallback pass — see Compressor.prepareEncoder.
+      if (applyThroughputTuning) {
+        // VBR transcodes ~10-20% faster than CBR by skipping rate-control overhead
+        // on low-motion frames; quality stays equivalent for short-form video.
+        setInteger(
+          MediaFormat.KEY_BITRATE_MODE,
+          MediaCodecInfo.EncoderCapabilities.BITRATE_MODE_VBR
+        )
+        // Hint the hardware codec to run as fast as it can (not throttled to
+        // realtime playback) and at the highest scheduling priority. These keys
+        // unlock full throughput on Qualcomm / Exynos / MTK SoCs that accept them.
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
+          setInteger(MediaFormat.KEY_PRIORITY, 0)
+          setInteger(MediaFormat.KEY_OPERATING_RATE, Short.MAX_VALUE.toInt())
+        }
+      }
 
       getColorStandard(inputFormat)?.let {
         setInteger(MediaFormat.KEY_COLOR_STANDARD, it)
@@ -188,4 +207,76 @@ object CompressorUtils {
     }
     return false
   }
+
+  // MIME type reported by MediaExtractor for Dolby Vision tracks (e.g. iPhone .MOV files)
+  private const val MIMETYPE_VIDEO_DOLBY_VISION = "video/dolby-vision"
+
+  /**
+   * Check whether the device exposes a decoder for the given MIME type.
+   */
+  private fun hasDecoderForMime(mime: String): Boolean {
+    val codecList = MediaCodecList(MediaCodecList.REGULAR_CODECS)
+    for (codec in codecList.codecInfos) {
+      if (codec.isEncoder) continue
+      for (type in codec.supportedTypes) {
+        if (type.equals(mime, ignoreCase = true)) return true
+      }
+    }
+    return false
+  }
+
+  /**
+   * Resolve the backward-compatible base-layer MIME type for a Dolby Vision track.
+   *
+   * Dolby Vision profiles 8.x (DvheSt) and 4 (DvheDtr) carry an HEVC base layer, and
+   * profile 9 (DvavSe) carries an AVC base layer; these can be decoded by the standard
+   * HEVC/AVC decoders. Profiles 5 (DvheStn) and 7 (DvheDtb) have no usable single base
+   * layer, so they return null. When the profile is unknown we assume HEVC, which covers
+   * the common consumer case (e.g. iPhone records Dolby Vision profile 8).
+   */
+  private fun dolbyVisionBaseLayerMime(inputFormat: MediaFormat): String? {
+    if (!inputFormat.containsKey(MediaFormat.KEY_PROFILE)) {
+      return MediaFormat.MIMETYPE_VIDEO_HEVC
+    }
+    return when (inputFormat.getInteger(MediaFormat.KEY_PROFILE)) {
+      MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvavSe -> MediaFormat.MIMETYPE_VIDEO_AVC
+      MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheSt,
+      MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheDtr -> MediaFormat.MIMETYPE_VIDEO_HEVC
+      else -> null
+    }
+  }
+
+  /**
+   * Ensure the input video format can be decoded on this device.
+   *
+   * Some containers (notably iPhone `.MOV` files) expose the video track as
+   * `video/dolby-vision`. Many Android devices have no Dolby Vision decoder, so
+   * `MediaCodec.createDecoderByType("video/dolby-vision")` fails with NAME_NOT_FOUND.
+   * When the dedicated decoder is missing but the stream carries a backward-compatible
+   * base layer, this rewrites the format MIME to the base-layer codec so the standard
+   * HEVC/AVC decoder can decode it. If no compatible decoder exists, it throws a clear
+   * error instead of letting the cryptic native failure surface (see issue #398).
+   */
+  fun ensureDecodableVideoFormat(inputFormat: MediaFormat) {
+    val mime = inputFormat.getString(MediaFormat.KEY_MIME) ?: return
+    if (hasDecoderForMime(mime)) return
+
+    if (mime.equals(MIMETYPE_VIDEO_DOLBY_VISION, ignoreCase = true)) {
+      val fallbackMime = dolbyVisionBaseLayerMime(inputFormat)
+      if (fallbackMime != null && hasDecoderForMime(fallbackMime)) {
+        Log.w(
+          "Compressor",
+          "No Dolby Vision decoder on this device; decoding the $fallbackMime base layer instead."
+        )
+        inputFormat.setString(MediaFormat.KEY_MIME, fallbackMime)
+        return
+      }
+      throw IllegalStateException(
+        "This video uses Dolby Vision, which is not supported by this device's decoders " +
+          "and has no backward-compatible base layer to fall back to."
+      )
+    }
+
+    throw IllegalStateException("No decoder available for video format: $mime")
+  }
 }

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 -> {