react-native-compressor 1.8.1 → 1.8.2

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

@@ -0,0 +1,196 @@
+package com.reactnativecompressor.Video.VideoCompressor.utils
+
+import android.media.MediaCodecInfo
+import android.media.MediaCodecList
+import android.media.MediaExtractor
+import android.media.MediaFormat
+import android.media.MediaMetadataRetriever
+import android.util.Log
+import com.reactnativecompressor.Video.VideoCompressor.video.Mp4Movie
+import java.io.File
+
+object CompressorUtils {
+
+  // Minimum height and width for videos
+  private const val MIN_HEIGHT = 640.0
+  private const val MIN_WIDTH = 368.0
+
+  // Interval between I-frames (keyframes) in seconds
+  private const val I_FRAME_INTERVAL = 1
+
+  /**
+   * Get the width of the video from metadata or use a default value if not available.
+   */
+  fun prepareVideoWidth(
+    mediaMetadataRetriever: MediaMetadataRetriever,
+  ): Double {
+    val widthData =
+      mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)
+    return if (widthData.isNullOrEmpty()) {
+      MIN_WIDTH
+    } else {
+      widthData.toDouble()
+    }
+  }
+
+  /**
+   * Get the height of the video from metadata or use a default value if not available.
+   */
+  fun prepareVideoHeight(
+    mediaMetadataRetriever: MediaMetadataRetriever,
+  ): Double {
+    val heightData =
+      mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)
+    return if (heightData.isNullOrEmpty()) {
+      MIN_HEIGHT
+    } else {
+      heightData.toDouble()
+    }
+  }
+
+  /**
+   * Set up an Mp4Movie with rotation and cache file.
+   */
+  fun setUpMP4Movie(
+    rotation: Int,
+    cacheFile: File,
+  ): Mp4Movie {
+    val movie = Mp4Movie()
+    movie.apply {
+      setCacheFile(cacheFile)
+      setRotation(rotation)
+    }
+    return movie
+  }
+
+  /**
+   * Set output parameters like bitrate and frame rate for video encoding.
+   */
+  fun setOutputFileParameters(
+    inputFormat: MediaFormat,
+    outputFormat: MediaFormat,
+    newBitrate: Int,
+  ) {
+    val newFrameRate = getFrameRate(inputFormat)
+    val iFrameInterval = getIFrameIntervalRate(inputFormat)
+    outputFormat.apply {
+      setInteger(
+        MediaFormat.KEY_COLOR_FORMAT,
+        MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface
+      )
+
+      setInteger(MediaFormat.KEY_FRAME_RATE, newFrameRate)
+      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
+      )
+
+      getColorStandard(inputFormat)?.let {
+        setInteger(MediaFormat.KEY_COLOR_STANDARD, it)
+      }
+
+      getColorTransfer(inputFormat)?.let {
+        setInteger(MediaFormat.KEY_COLOR_TRANSFER, it)
+      }
+
+      getColorRange(inputFormat)?.let {
+        setInteger(MediaFormat.KEY_COLOR_RANGE, it)
+      }
+
+      Log.i(
+        "Output file parameters",
+        "videoFormat: $this"
+      )
+    }
+  }
+
+  // Get the frame rate from the input format or use a default value
+  private fun getFrameRate(format: MediaFormat): Int {
+    return if (format.containsKey(MediaFormat.KEY_FRAME_RATE)) format.getInteger(MediaFormat.KEY_FRAME_RATE)
+    else 30
+  }
+
+  // Get the I-frame (keyframe) interval from the input format or use a default value
+  private fun getIFrameIntervalRate(format: MediaFormat): Int {
+    return if (format.containsKey(MediaFormat.KEY_I_FRAME_INTERVAL)) format.getInteger(
+      MediaFormat.KEY_I_FRAME_INTERVAL
+    )
+    else I_FRAME_INTERVAL
+  }
+
+  // Get the color standard from the input format or null if not available
+  private fun getColorStandard(format: MediaFormat): Int? {
+    return if (format.containsKey(MediaFormat.KEY_COLOR_STANDARD)) format.getInteger(
+      MediaFormat.KEY_COLOR_STANDARD
+    )
+    else null
+  }
+
+  // Get the color transfer from the input format or null if not available
+  private fun getColorTransfer(format: MediaFormat): Int? {
+    return if (format.containsKey(MediaFormat.KEY_COLOR_TRANSFER)) format.getInteger(
+      MediaFormat.KEY_COLOR_TRANSFER
+    )
+    else null
+  }
+
+  // Get the color range from the input format or null if not available
+  private fun getColorRange(format: MediaFormat): Int? {
+    return if (format.containsKey(MediaFormat.KEY_COLOR_RANGE)) format.getInteger(
+      MediaFormat.KEY_COLOR_RANGE
+    )
+    else null
+  }
+
+  /**
+   * Find the track index for video or audio in the media extractor.
+   *
+   * @param extractor MediaExtractor used to extract data from the media source.
+   * @param isVideo Determines whether we are looking for a video or audio track.
+   * @return Index of the requested track, or -5 if not found.
+   */
+  fun findTrack(
+    extractor: MediaExtractor,
+    isVideo: Boolean,
+  ): Int {
+    val numTracks = extractor.trackCount
+    for (i in 0 until numTracks) {
+      val format = extractor.getTrackFormat(i)
+      val mime = format.getString(MediaFormat.KEY_MIME)
+      if (isVideo) {
+        if (mime?.startsWith("video/")!!) return i
+      } else {
+        if (mime?.startsWith("audio/")!!) return i
+      }
+    }
+    return -5
+  }
+
+  /**
+   * Log an exception with a meaningful message.
+   */
+  fun printException(exception: Exception) {
+    var message = "An error has occurred!"
+    exception.localizedMessage?.let {
+      message = it
+    }
+    Log.e("Compressor", message, exception)
+  }
+
+  /**
+   * Check if the device has QTI (Qualcomm Technologies, Inc.) codecs.
+   */
+  fun hasQTI(): Boolean {
+    val list = MediaCodecList(MediaCodecList.REGULAR_CODECS).codecInfos
+    for (codec in list) {
+      Log.i("CODECS: ", codec.name)
+      if (codec.name.contains("qti.avc")) {
+        return true
+      }
+    }
+    return false
+  }
+}

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

@@ -0,0 +1,47 @@
+package com.reactnativecompressor.Video.VideoCompressor.utils
+
+/**
+ * Converts a 32-bit unsigned integer to a long.
+ * @param int32 The 32-bit unsigned integer to convert.
+ * @return The equivalent long value.
+ */
+fun uInt32ToLong(int32: Int): Long {
+  return int32.toLong()
+}
+
+/**
+ * Converts a long to a 32-bit unsigned integer, throwing an exception if the value is too large.
+ * @param uInt32 The long value to convert.
+ * @return The equivalent 32-bit unsigned integer.
+ * @throws Exception if the provided long value is greater than Int.MAX_VALUE or negative.
+ */
+fun uInt32ToInt(uInt32: Long): Int {
+  if (uInt32 > Int.MAX_VALUE || uInt32 < 0) {
+    throw Exception("uInt32 value is too large or negative")
+  }
+  return uInt32.toInt()
+}
+
+/**
+ * Converts a 64-bit unsigned integer to a long, throwing an exception if the value is negative.
+ * @param uInt64 The 64-bit unsigned integer to convert.
+ * @return The equivalent long value.
+ * @throws Exception if the provided long value is negative.
+ */
+fun uInt64ToLong(uInt64: Long): Long {
+  if (uInt64 < 0) throw Exception("uInt64 value is negative")
+  return uInt64
+}
+
+/**
+ * Converts a 32-bit unsigned integer to an integer, throwing an exception if the value is negative.
+ * @param uInt32 The 32-bit unsigned integer to convert.
+ * @return The equivalent integer value.
+ * @throws Exception if the provided integer value is negative.
+ */
+fun uInt32ToInt(uInt32: Int): Int {
+  if (uInt32 < 0) {
+    throw Exception("uInt32 value is negative")
+  }
+  return uInt32
+}

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

@@ -0,0 +1,209 @@
+package com.reactnativecompressor.Video.VideoCompressor.utils
+
+import android.util.Log
+import com.reactnativecompressor.Video.VideoCompressor.data.*
+import java.io.*
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.nio.channels.FileChannel
+
+object StreamableVideo {
+
+    private const val tag = "StreamableVideo"
+    private const val ATOM_PREAMBLE_SIZE = 8
+
+    /**
+     * Starts the process of making a video file "fast start" and saves it to the output file.
+     *
+     * @param inputVideoFile The input video file.
+     * @param outputVideoFile The output video file.
+     * @return `true` if the operation is successful, `false` if the input file is already fast start.
+     * @throws IOException if an I/O error occurs.
+     */
+    @Throws(IOException::class)
+    fun start(`in`: File?, out: File): Boolean {
+        var ret = false
+        var inStream: FileInputStream? = null
+        var outStream: FileOutputStream? = null
+        return try {
+            inStream = FileInputStream(`in`)
+            val infile = inStream.channel
+            outStream = FileOutputStream(out)
+            val outfile = outStream.channel
+            convert(infile, outfile).also { ret = it }
+        } finally {
+            safeClose(inStream)
+            safeClose(outStream)
+            if (!ret) {
+                out.delete()
+            }
+        }
+    }
+
+  @Throws(IOException::class)
+  private fun convert(inputFileChannel: FileChannel, outputFileChannel: FileChannel): Boolean {
+    val atomBytes = ByteBuffer.allocate(ATOM_PREAMBLE_SIZE).order(ByteOrder.BIG_ENDIAN)
+    var atomType = 0
+    var atomSize: Long = 0
+    val lastOffset: Long
+    val moovAtom: ByteBuffer
+    var ftypAtom: ByteBuffer? = null
+    var startOffset: Long = 0
+
+    // Traverse through the atoms in the file to ensure that 'moov' is at the end.
+    while (readAndFill(inputFileChannel, atomBytes)) {
+      atomSize = uInt32ToLong(atomBytes.int)
+      atomType = atomBytes.int
+
+      // Keep the 'ftyp' atom.
+      if (atomType == FTYP_ATOM) {
+        val ftypAtomSize = uInt32ToInt(atomSize)
+        ftypAtom = ByteBuffer.allocate(ftypAtomSize).order(ByteOrder.BIG_ENDIAN)
+        atomBytes.rewind()
+        ftypAtom.put(atomBytes)
+        if (inputFileChannel.read(ftypAtom) < ftypAtomSize - ATOM_PREAMBLE_SIZE) break
+        ftypAtom.flip()
+        startOffset = inputFileChannel.position() // After 'ftyp' atom.
+      } else {
+        if (atomSize == 1L) {
+          /* 64-bit special case */
+          atomBytes.clear()
+          if (!readAndFill(inputFileChannel, atomBytes)) break
+          atomSize = uInt64ToLong(atomBytes.long)
+          inputFileChannel.position(inputFileChannel.position() + atomSize - ATOM_PREAMBLE_SIZE * 2) // Seek.
+        } else {
+          inputFileChannel.position(inputFileChannel.position() + atomSize - ATOM_PREAMBLE_SIZE) // Seek.
+        }
+      }
+      if (atomType != FREE_ATOM
+        && atomType != JUNK_ATOM
+        && atomType != MDAT_ATOM
+        && atomType != MOOV_ATOM
+        && atomType != PNOT_ATOM
+        && atomType != SKIP_ATOM
+        && atomType != WIDE_ATOM
+        && atomType != PICT_ATOM
+        && atomType != UUID_ATOM
+        && atomType != FTYP_ATOM
+      ) {
+        Log.wtf(tag, "Encountered a non-QT top-level atom (Is this a QuickTime file?)")
+        break
+      }
+
+      /* The atom header is 8 (or 16 bytes). If the atom size (which
+   * includes these 8 or 16 bytes) is less than that, we won't be
+   * able to continue scanning sensibly after this atom, so break. */
+      if (atomSize < 8) break
+    }
+    if (atomType != MOOV_ATOM) {
+      Log.wtf(tag, "The last atom in the file was not a 'moov' atom")
+      return false
+    }
+
+    // 'atomSize' is 'uint64', but for 'moov', 'uint32' should be stored.
+    val moovAtomSize: Int = uInt32ToInt(atomSize)
+    lastOffset =
+      inputFileChannel.size() - moovAtomSize
+    moovAtom = ByteBuffer.allocate(moovAtomSize).order(ByteOrder.BIG_ENDIAN)
+    if (!readAndFill(inputFileChannel, moovAtom, lastOffset)) {
+      throw Exception("Failed to read 'moov' atom")
+    }
+
+    if (moovAtom.getInt(12) == CMOV_ATOM) {
+      throw Exception("This utility does not support compressed 'moov' atoms yet")
+    }
+
+    // Crawl through the 'moov' chunk in search of 'stco' or 'co64' atoms.
+    while (moovAtom.remaining() >= 8) {
+      val atomHead = moovAtom.position()
+      atomType = moovAtom.getInt(atomHead + 4)
+      if (!(atomType == STCO_ATOM || atomType == CO64_ATOM)) {
+        moovAtom.position(moovAtom.position() + 1)
+        continue
+      }
+      atomSize = uInt32ToLong(moovAtom.getInt(atomHead)) // 'uint32'
+      if (atomSize > moovAtom.remaining()) {
+        throw Exception("Bad atom size")
+      }
+      // Skip size (4 bytes), type (4 bytes), version (1 byte), and flags (3 bytes).
+      moovAtom.position(atomHead + 12)
+      if (moovAtom.remaining() < 4) {
+        throw Exception("Malformed atom")
+      }
+      // 'uint32_t', but assuming 'moovAtomSize' is in 'int32' range, so this will be in 'int32' range.
+      val offsetCount = uInt32ToInt(moovAtom.int)
+      if (atomType == STCO_ATOM) {
+        Log.i(tag, "Patching 'stco' atom...")
+        if (moovAtom.remaining() < offsetCount * 4) {
+          throw Exception("Bad atom size/element count")
+        }
+        for (i in 0 until offsetCount) {
+          val currentOffset = moovAtom.getInt(moovAtom.position())
+          val newOffset =
+            currentOffset + moovAtomSize // Calculate 'uint32' in 'int', bitwise addition.
+
+          if (currentOffset < 0 && newOffset >= 0) {
+            throw Exception(
+              "This is a bug in the original 'qt-faststart.c': " +
+                "'stco' atom should be extended to 'co64' atom as the new offset value overflows 'uint32', " +
+                "but it is not implemented."
+            )
+          }
+          moovAtom.putInt(newOffset)
+        }
+      } else if (atomType == CO64_ATOM) {
+        Log.wtf(tag, "Patching 'co64' atom...")
+        if (moovAtom.remaining() < offsetCount * 8) {
+          throw Exception("Bad atom size/element count")
+        }
+        for (i in 0 until offsetCount) {
+          val currentOffset = moovAtom.getLong(moovAtom.position())
+          moovAtom.putLong(currentOffset + moovAtomSize) // Calculate 'uint64' in 'long', bitwise addition.
+        }
+      }
+    }
+    inputFileChannel.position(startOffset) // Seek after 'ftyp' atom.
+    if (ftypAtom != null) {
+      // Dump the same 'ftyp' atom.
+      Log.i(tag, "Writing 'ftyp' atom...")
+      ftypAtom.rewind()
+      outputFileChannel.write(ftypAtom)
+    }
+
+    // Dump the new 'moov' atom.
+    Log.i(tag, "Writing 'moov' atom...")
+    moovAtom.rewind()
+    outputFileChannel.write(moovAtom)
+
+    // Copy the remainder of the input file, from offset 0 -> (lastOffset - startOffset) - 1.
+    Log.i(tag, "Copying the rest of the file...")
+    inputFileChannel.transferTo(startOffset, lastOffset - startOffset, outputFileChannel)
+    return true
+  }
+
+  private fun safeClose(closeable: Closeable?) {
+    if (closeable != null) {
+      try {
+        closeable.close()
+      } catch (e: IOException) {
+        Log.wtf(tag, "Failed to close file: ")
+      }
+    }
+  }
+
+  @Throws(IOException::class)
+  private fun readAndFill(inputFileChannel: FileChannel, buffer: ByteBuffer): Boolean {
+    buffer.clear()
+    val size = inputFileChannel.read(buffer)
+    buffer.flip()
+    return size == buffer.capacity()
+  }
+
+  @Throws(IOException::class)
+  private fun readAndFill(inputFileChannel: FileChannel, buffer: ByteBuffer, position: Long): Boolean {
+    buffer.clear()
+    val size = inputFileChannel.read(buffer, position)
+    buffer.flip()
+    return size == buffer.capacity()
+  }
+}

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

@@ -0,0 +1,128 @@
+package com.reactnativecompressor.Video.VideoCompressor.video
+
+import android.opengl.EGL14
+import android.opengl.EGLConfig
+import android.opengl.EGLContext
+import android.opengl.EGLDisplay
+import android.opengl.EGLExt
+import android.opengl.EGLSurface
+import android.view.Surface
+
+class InputSurface(surface: Surface?) {
+
+    private val eglRecordableAndroid = 0x3142
+    private val eglOpenGlES2Bit = 4
+    private var mEGLDisplay: EGLDisplay? = null
+    private var mEGLContext: EGLContext? = null
+    private var mEGLSurface: EGLSurface? = null
+    private var mSurface: Surface? = null
+
+    init {
+        if (surface == null) {
+            throw NullPointerException()
+        }
+        mSurface = surface
+        eglSetup()
+    }
+
+    private fun eglSetup() {
+        mEGLDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY)
+        if (mEGLDisplay === EGL14.EGL_NO_DISPLAY) {
+            throw RuntimeException("unable to get EGL14 display")
+        }
+        val version = IntArray(2)
+        if (!EGL14.eglInitialize(mEGLDisplay, version, 0, version, 1)) {
+            mEGLDisplay = null
+            throw RuntimeException("unable to initialize EGL14")
+        }
+        val attribList = intArrayOf(
+            EGL14.EGL_RED_SIZE,
+            8,
+            EGL14.EGL_GREEN_SIZE,
+            8,
+            EGL14.EGL_BLUE_SIZE,
+            8,
+            EGL14.EGL_RENDERABLE_TYPE,
+            eglOpenGlES2Bit,
+            eglRecordableAndroid,
+            1,
+            EGL14.EGL_NONE,
+        )
+        val configs = arrayOfNulls<EGLConfig>(1)
+        val numConfigs = IntArray(1)
+        if (!EGL14.eglChooseConfig(
+                mEGLDisplay, attribList, 0, configs, 0, configs.size,
+                numConfigs, 0
+            )
+        ) {
+            throw RuntimeException("unable to find RGB888+recordable ES2 EGL config")
+        }
+        val attrs = intArrayOf(
+            EGL14.EGL_CONTEXT_CLIENT_VERSION, 2,
+            EGL14.EGL_NONE
+        )
+        mEGLContext =
+            EGL14.eglCreateContext(mEGLDisplay, configs[0], EGL14.EGL_NO_CONTEXT, attrs, 0)
+        checkEglError()
+        if (mEGLContext == null) {
+            throw RuntimeException("null context")
+        }
+        val surfaceAttrs = intArrayOf(
+            EGL14.EGL_NONE
+        )
+        mEGLSurface = EGL14.eglCreateWindowSurface(
+            mEGLDisplay, configs[0], mSurface,
+            surfaceAttrs, 0
+        )
+        checkEglError()
+        if (mEGLSurface == null) {
+            throw RuntimeException("surface was null")
+        }
+    }
+
+    fun release() {
+        if (EGL14.eglGetCurrentContext() == mEGLContext) {
+            EGL14.eglMakeCurrent(
+                mEGLDisplay,
+                EGL14.EGL_NO_SURFACE,
+                EGL14.EGL_NO_SURFACE,
+                EGL14.EGL_NO_CONTEXT
+            )
+        }
+        EGL14.eglDestroySurface(mEGLDisplay, mEGLSurface)
+        EGL14.eglDestroyContext(mEGLDisplay, mEGLContext)
+
+        mSurface?.release()
+
+        mEGLDisplay = null
+        mEGLContext = null
+        mEGLSurface = null
+
+        mSurface = null
+    }
+
+    fun makeCurrent() {
+        if (!EGL14.eglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext)) {
+            throw RuntimeException("eglMakeCurrent failed")
+        }
+    }
+
+    fun swapBuffers(): Boolean =
+        EGL14.eglSwapBuffers(mEGLDisplay, mEGLSurface)
+
+
+    fun setPresentationTime(nsecs: Long) {
+        EGLExt.eglPresentationTimeANDROID(mEGLDisplay, mEGLSurface, nsecs)
+    }
+
+    private fun checkEglError() {
+        var failed = false
+        while (EGL14.eglGetError() != EGL14.EGL_SUCCESS) {
+            failed = true
+        }
+        if (failed) {
+            throw RuntimeException("EGL error encountered (see log)")
+        }
+    }
+
+}