react-native-compressor 1.8.0 → 1.8.2

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

@@ -0,0 +1,214 @@
+package com.reactnativecompressor.Video.VideoCompressor.video
+
+import android.graphics.SurfaceTexture
+import android.opengl.GLES11Ext
+import android.opengl.GLES20
+import android.opengl.Matrix
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.nio.FloatBuffer
+
+class TextureRenderer {
+
+    private val floatSizeBytes = 4
+    private val triangleVerticesDataStrideBytes = 5 * floatSizeBytes
+    private val triangleVerticesDataPosOffset = 0
+    private val triangleVerticesDataUvOffset = 3
+    private var mTriangleVertices: FloatBuffer
+
+    private val vertexShader = """uniform mat4 uMVPMatrix;
+uniform mat4 uSTMatrix;
+attribute vec4 aPosition;
+attribute vec4 aTextureCoord;
+varying vec2 vTextureCoord;
+void main() {
+  gl_Position = uMVPMatrix * aPosition;
+  vTextureCoord = (uSTMatrix * aTextureCoord).xy;
+}
+"""
+
+    private val fragmentShader = """#extension GL_OES_EGL_image_external : require
+precision mediump float;
+varying vec2 vTextureCoord;
+uniform samplerExternalOES sTexture;
+void main() {
+  gl_FragColor = texture2D(sTexture, vTextureCoord);
+}
+"""
+
+    private val mMVPMatrix = FloatArray(16)
+    private val mSTMatrix = FloatArray(16)
+
+    private var mProgram = 0
+    private var mTextureID = -12345
+    private var muMVPMatrixHandle = 0
+    private var muSTMatrixHandle = 0
+    private var maPositionHandle = 0
+    private var maTextureHandle = 0
+
+    init {
+        val mTriangleVerticesData = floatArrayOf( // X, Y, Z, U, V
+            -1.0f, -1.0f, 0f, 0f, 0f,
+            1.0f, -1.0f, 0f, 1f, 0f,
+            -1.0f, 1.0f, 0f, 0f, 1f,
+            1.0f, 1.0f, 0f, 1f, 1f
+        )
+        mTriangleVertices = ByteBuffer.allocateDirect(
+            mTriangleVerticesData.size * floatSizeBytes
+        )
+            .order(ByteOrder.nativeOrder()).asFloatBuffer()
+        mTriangleVertices.put(mTriangleVerticesData).position(0)
+
+        Matrix.setIdentityM(mSTMatrix, 0)
+    }
+
+    fun getTextureId(): Int = mTextureID
+
+    fun drawFrame(st: SurfaceTexture) {
+        checkGlError("onDrawFrame start")
+        st.getTransformMatrix(mSTMatrix)
+
+        GLES20.glClearColor(0.0f, 1.0f, 0.0f, 1.0f)
+        GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT or GLES20.GL_COLOR_BUFFER_BIT)
+
+        GLES20.glUseProgram(mProgram)
+        checkGlError("glUseProgram")
+
+        GLES20.glActiveTexture(GLES20.GL_TEXTURE0)
+        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, mTextureID)
+
+        mTriangleVertices.position(triangleVerticesDataPosOffset)
+        GLES20.glVertexAttribPointer(
+            maPositionHandle, 3, GLES20.GL_FLOAT, false,
+            triangleVerticesDataStrideBytes, mTriangleVertices
+        )
+        checkGlError("glVertexAttribPointer maPosition")
+        GLES20.glEnableVertexAttribArray(maPositionHandle)
+        checkGlError("glEnableVertexAttribArray maPositionHandle")
+
+        mTriangleVertices.position(triangleVerticesDataUvOffset)
+        GLES20.glVertexAttribPointer(
+            maTextureHandle, 2, GLES20.GL_FLOAT, false,
+            triangleVerticesDataStrideBytes, mTriangleVertices
+        )
+        checkGlError("glVertexAttribPointer maTextureHandle")
+        GLES20.glEnableVertexAttribArray(maTextureHandle)
+        checkGlError("glEnableVertexAttribArray maTextureHandle")
+
+        Matrix.setIdentityM(mMVPMatrix, 0)
+        GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0)
+        GLES20.glUniformMatrix4fv(muSTMatrixHandle, 1, false, mSTMatrix, 0)
+
+        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4)
+        checkGlError("glDrawArrays")
+        GLES20.glFinish()
+    }
+
+    /**
+     * Initializes GL state.  Call this after the EGL surface has been created and made current.
+     */
+    fun surfaceCreated() {
+        mProgram = createProgram()
+        if (mProgram == 0) {
+            throw RuntimeException("failed creating program")
+        }
+        maPositionHandle = GLES20.glGetAttribLocation(mProgram, "aPosition")
+        checkGlError("glGetAttribLocation aPosition")
+        if (maPositionHandle == -1) {
+            throw RuntimeException("Could not get attrib location for aPosition")
+        }
+        maTextureHandle = GLES20.glGetAttribLocation(mProgram, "aTextureCoord")
+        checkGlError("glGetAttribLocation aTextureCoord")
+        if (maTextureHandle == -1) {
+            throw RuntimeException("Could not get attrib location for aTextureCoord")
+        }
+
+        muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix")
+        checkGlError("glGetUniformLocation uMVPMatrix")
+        if (muMVPMatrixHandle == -1) {
+            throw RuntimeException("Could not get attrib location for uMVPMatrix")
+        }
+
+        muSTMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uSTMatrix")
+        checkGlError("glGetUniformLocation uSTMatrix")
+        if (muSTMatrixHandle == -1) {
+            throw RuntimeException("Could not get attrib location for uSTMatrix")
+        }
+
+        val textures = IntArray(1)
+        GLES20.glGenTextures(1, textures, 0)
+        mTextureID = textures[0]
+        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, mTextureID)
+        checkGlError("glBindTexture mTextureID")
+
+        GLES20.glTexParameterf(
+            GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MIN_FILTER,
+            GLES20.GL_NEAREST.toFloat()
+        )
+        GLES20.glTexParameterf(
+            GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MAG_FILTER,
+            GLES20.GL_LINEAR.toFloat()
+        )
+        GLES20.glTexParameteri(
+            GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_S,
+            GLES20.GL_CLAMP_TO_EDGE
+        )
+        GLES20.glTexParameteri(
+            GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_T,
+            GLES20.GL_CLAMP_TO_EDGE
+        )
+        checkGlError("glTexParameter")
+    }
+
+    private fun loadShader(shaderType: Int, source: String): Int {
+        var shader = GLES20.glCreateShader(shaderType)
+        checkGlError("glCreateShader type=$shaderType")
+        GLES20.glShaderSource(shader, source)
+        GLES20.glCompileShader(shader)
+        val compiled = IntArray(1)
+        GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0)
+        if (compiled[0] == 0) {
+            GLES20.glDeleteShader(shader)
+            shader = 0
+        }
+        return shader
+    }
+
+    private fun createProgram(): Int {
+        val vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShader)
+        if (vertexShader == 0) {
+            return 0
+        }
+
+        val pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShader)
+        if (pixelShader == 0) {
+            return 0
+        }
+
+        var program = GLES20.glCreateProgram()
+        checkGlError("glCreateProgram")
+        if (program == 0) {
+            return 0
+        }
+        GLES20.glAttachShader(program, vertexShader)
+        checkGlError("glAttachShader")
+        GLES20.glAttachShader(program, pixelShader)
+        checkGlError("glAttachShader")
+        GLES20.glLinkProgram(program)
+        val linkStatus = IntArray(1)
+        GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0)
+        if (linkStatus[0] != GLES20.GL_TRUE) {
+            GLES20.glDeleteProgram(program)
+            program = 0
+        }
+        return program
+    }
+
+    fun checkGlError(op: String) {
+        var error: Int
+        if (GLES20.glGetError().also { error = it } != GLES20.GL_NO_ERROR) {
+            throw RuntimeException("$op: glError $error")
+        }
+    }
+
+}

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

@@ -0,0 +1,286 @@
+package com.reactnativecompressor.Video.VideoCompressor.video
+
+import android.media.MediaCodec
+import android.media.MediaCodecInfo
+import android.media.MediaFormat
+import com.coremedia.iso.boxes.SampleDescriptionBox
+import com.coremedia.iso.boxes.sampleentry.AudioSampleEntry
+import com.coremedia.iso.boxes.sampleentry.VisualSampleEntry
+import com.googlecode.mp4parser.boxes.mp4.ESDescriptorBox
+import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.AudioSpecificConfig
+import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.DecoderConfigDescriptor
+import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.ESDescriptor
+import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.SLConfigDescriptor
+import com.mp4parser.iso14496.part15.AvcConfigurationBox
+import java.util.*
+
+class Track(id: Int, format: MediaFormat, audio: Boolean) {
+
+    private var trackId: Long = 0
+    private val samples = ArrayList<Sample>()
+    private var duration: Long = 0
+    private var handler: String
+    private var sampleDescriptionBox: SampleDescriptionBox
+    private var syncSamples: LinkedList<Int>? = null
+    private var timeScale = 0
+    private val creationTime = Date()
+    private var height = 0
+    private var width = 0
+    private var volume = 0f
+    private val sampleDurations = ArrayList<Long>()
+    private val isAudio = audio
+    private var samplingFrequencyIndexMap: Map<Int, Int> = HashMap()
+    private var lastPresentationTimeUs: Long = 0
+    private var first = true
+
+    init {
+        samplingFrequencyIndexMap = mapOf(
+            96000 to 0x0,
+            88200 to 0x1,
+            64000 to 0x2,
+            48000 to 0x3,
+            44100 to 0x4,
+            32000 to 0x5,
+            24000 to 0x6,
+            22050 to 0x7,
+            16000 to 0x8,
+            12000 to 0x9,
+            11025 to 0xa,
+            8000 to 0xb,
+        )
+
+        trackId = id.toLong()
+        if (!isAudio) {
+            sampleDurations.add(3015.toLong())
+            duration = 3015
+            width = format.getInteger(MediaFormat.KEY_WIDTH)
+            height = format.getInteger(MediaFormat.KEY_HEIGHT)
+            timeScale = 90000
+            syncSamples = LinkedList()
+            handler = "vide"
+
+            sampleDescriptionBox = SampleDescriptionBox()
+            val mime = format.getString(MediaFormat.KEY_MIME)
+            if (mime == "video/avc") {
+                val visualSampleEntry =
+                    VisualSampleEntry(VisualSampleEntry.TYPE3).setup(width, height)
+
+                val avcConfigurationBox = AvcConfigurationBox()
+                if (format.getByteBuffer("csd-0") != null) {
+                    val spsArray = ArrayList<ByteArray>()
+                    val spsBuff = format.getByteBuffer("csd-0")
+                    spsBuff!!.position(4)
+
+                    val spsBytes = ByteArray(spsBuff.remaining())
+                    spsBuff[spsBytes]
+                    spsArray.add(spsBytes)
+
+                    val ppsArray = ArrayList<ByteArray>()
+                    val ppsBuff = format.getByteBuffer("csd-1")
+                    ppsBuff?.let {
+                        it.position(4)
+
+                        val ppsBytes = ByteArray(it.remaining())
+                        it[ppsBytes]
+
+                        ppsArray.add(ppsBytes)
+                        avcConfigurationBox.sequenceParameterSets = spsArray
+                        avcConfigurationBox.pictureParameterSets = ppsArray
+                    }
+                }
+
+                if (format.containsKey("level")) {
+                    when (format.getInteger("level")) {
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel1 -> {
+                            avcConfigurationBox.avcLevelIndication = 1
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel2 -> {
+                            avcConfigurationBox.avcLevelIndication = 2
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel11 -> {
+                            avcConfigurationBox.avcLevelIndication = 11
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel12 -> {
+                            avcConfigurationBox.avcLevelIndication = 12
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel13 -> {
+                            avcConfigurationBox.avcLevelIndication = 13
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel21 -> {
+                            avcConfigurationBox.avcLevelIndication = 21
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel22 -> {
+                            avcConfigurationBox.avcLevelIndication = 22
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel3 -> {
+                            avcConfigurationBox.avcLevelIndication = 3
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel31 -> {
+                            avcConfigurationBox.avcLevelIndication = 31
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel32 -> {
+                            avcConfigurationBox.avcLevelIndication = 32
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel4 -> {
+                            avcConfigurationBox.avcLevelIndication = 4
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel41 -> {
+                            avcConfigurationBox.avcLevelIndication = 41
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel42 -> {
+                            avcConfigurationBox.avcLevelIndication = 42
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel5 -> {
+                            avcConfigurationBox.avcLevelIndication = 5
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel51 -> {
+                            avcConfigurationBox.avcLevelIndication = 51
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel52 -> {
+                            avcConfigurationBox.avcLevelIndication = 52
+                        }
+                        MediaCodecInfo.CodecProfileLevel.AVCLevel1b -> {
+                            avcConfigurationBox.avcLevelIndication = 0x1b
+                        }
+                        else -> avcConfigurationBox.avcLevelIndication = 13
+                    }
+                } else {
+                    avcConfigurationBox.avcLevelIndication = 13
+                }
+
+                avcConfigurationBox.avcProfileIndication = 100
+                avcConfigurationBox.bitDepthLumaMinus8 = -1
+                avcConfigurationBox.bitDepthChromaMinus8 = -1
+                avcConfigurationBox.chromaFormat = -1
+                avcConfigurationBox.configurationVersion = 1
+                avcConfigurationBox.lengthSizeMinusOne = 3
+                avcConfigurationBox.profileCompatibility = 0
+
+                visualSampleEntry.addBox(avcConfigurationBox)
+                sampleDescriptionBox.addBox(visualSampleEntry)
+
+            } else if (mime == "video/mp4v") {
+                val visualSampleEntry =
+                    VisualSampleEntry(VisualSampleEntry.TYPE1).setup(width, height)
+                sampleDescriptionBox.addBox(visualSampleEntry)
+            }
+        } else {
+            sampleDurations.add(1024.toLong())
+            duration = 1024
+            volume = 1f
+            timeScale = format.getInteger(MediaFormat.KEY_SAMPLE_RATE)
+            handler = "soun"
+            sampleDescriptionBox = SampleDescriptionBox()
+
+            val audioSampleEntry = AudioSampleEntry(AudioSampleEntry.TYPE3).setup(format)
+
+            val esds = ESDescriptorBox()
+
+            val descriptor = ESDescriptor()
+            descriptor.esId = 0
+
+            val slConfigDescriptor = SLConfigDescriptor()
+            slConfigDescriptor.predefined = 2
+            descriptor.slConfigDescriptor = slConfigDescriptor
+
+            val decoderConfigDescriptor = DecoderConfigDescriptor().setup()
+
+            val audioSpecificConfig = AudioSpecificConfig()
+            audioSpecificConfig.setAudioObjectType(2)
+            audioSpecificConfig.setSamplingFrequencyIndex(
+                samplingFrequencyIndexMap[audioSampleEntry.sampleRate.toInt()]!!
+            )
+            audioSpecificConfig.setChannelConfiguration(audioSampleEntry.channelCount)
+            decoderConfigDescriptor.audioSpecificInfo = audioSpecificConfig
+            descriptor.decoderConfigDescriptor = decoderConfigDescriptor
+
+            val data = descriptor.serialize()
+            esds.esDescriptor = descriptor
+            esds.data = data
+            audioSampleEntry.addBox(esds)
+            sampleDescriptionBox.addBox(audioSampleEntry)
+        }
+    }
+
+    fun getTrackId(): Long = trackId
+
+    fun addSample(offset: Long, bufferInfo: MediaCodec.BufferInfo) {
+        val isSyncFrame = !isAudio && bufferInfo.flags and MediaCodec.BUFFER_FLAG_KEY_FRAME != 0
+
+        samples.add(Sample(offset, bufferInfo.size.toLong()))
+
+        if (syncSamples != null && isSyncFrame) {
+            syncSamples?.add(samples.size)
+        }
+        var delta = bufferInfo.presentationTimeUs - lastPresentationTimeUs
+        lastPresentationTimeUs = bufferInfo.presentationTimeUs
+        delta = (delta * timeScale + 500000L) / 1000000L
+        if (!first) {
+            sampleDurations.add(sampleDurations.size - 1, delta)
+            duration += delta
+        }
+        first = false
+    }
+
+    fun getSamples(): ArrayList<Sample> = samples
+
+    fun getDuration(): Long = duration
+
+    fun getHandler(): String = handler
+
+    fun getSampleDescriptionBox(): SampleDescriptionBox = sampleDescriptionBox
+
+    fun getSyncSamples(): LongArray? {
+        if (syncSamples == null || syncSamples!!.isEmpty()) {
+            return null
+        }
+        val returns = LongArray(syncSamples!!.size)
+        for (i in syncSamples!!.indices) {
+            returns[i] = syncSamples!![i].toLong()
+        }
+        return returns
+    }
+
+    fun getTimeScale(): Int = timeScale
+
+    fun getCreationTime(): Date = creationTime
+
+    fun getWidth(): Int = width
+
+    fun getHeight(): Int = height
+
+    fun getVolume(): Float = volume
+
+    fun getSampleDurations(): ArrayList<Long> = sampleDurations
+
+    fun isAudio(): Boolean = isAudio
+
+    private fun DecoderConfigDescriptor.setup(): DecoderConfigDescriptor = apply {
+        objectTypeIndication = 0x40
+        streamType = 5
+        bufferSizeDB = 1536
+        maxBitRate = 96000
+        avgBitRate = 96000
+    }
+
+    private fun VisualSampleEntry.setup(w: Int, h: Int): VisualSampleEntry = apply {
+        dataReferenceIndex = 1
+        depth = 24
+        frameCount = 1
+        horizresolution = 72.0
+        vertresolution = 72.0
+        width = w
+        height = h
+        compressorname = "AVC Coding"
+    }
+
+    private fun AudioSampleEntry.setup(format: MediaFormat): AudioSampleEntry = apply {
+        channelCount =
+            if (format.getInteger(MediaFormat.KEY_CHANNEL_COUNT) == 1) 2 else format.getInteger(
+                MediaFormat.KEY_CHANNEL_COUNT
+            )
+        sampleRate = format.getInteger(MediaFormat.KEY_SAMPLE_RATE).toLong()
+        dataReferenceIndex = 1
+        sampleSize = 16
+    }
+}

package/android/src/oldarch/CompressorSpec.kt

@@ -27,6 +27,8 @@ abstract class CompressorSpec(context: ReactApplicationContext?) : ReactContextB
     abstract fun download(fileUrl: String, options: ReadableMap, promise: Promise)
     abstract fun activateBackgroundTask(options: ReadableMap, promise: Promise)
     abstract fun deactivateBackgroundTask(options: ReadableMap, promise: Promise)
+    abstract fun createVideoThumbnail(fileUrl: String?, options: ReadableMap?, promise: Promise)
+    abstract fun clearCache(cacheDir: String?, promise: com.facebook.react.bridge.Promise?)
     abstract fun addListener(eventName: String)
     abstract fun removeListeners(count: Double)
 }

package/ios/Compressor.mm

@@ -52,6 +52,15 @@ RCT_EXTERN_METHOD(deactivateBackgroundTask: (NSDictionary *)options
                  withResolver:(RCTPromiseResolveBlock)resolve
                  withRejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(createVideoThumbnail:(NSString *)fileUrl
+                 withOptions:(NSDictionary *)options
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(clearCache:(NSString *)cacheDir
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(cancelCompression:(NSString *)uuid)
 
 // Don't compile this code when we build for the old architecture.

package/ios/CompressorManager.swift

@@ -92,5 +92,16 @@ class Compressor: RCTEventEmitter {
             resolve(downloadedPath)
         }
     }
+    
+    @objc(createVideoThumbnail:withOptions:withResolver:withRejecter:)
+    func createVideoThumbnail(fileUrl: String, options: NSDictionary, resolve:@escaping RCTPromiseResolveBlock, reject:@escaping RCTPromiseRejectBlock) -> Void {
+        let videoThumbnail=CreateVideoThumbnail()
+        videoThumbnail.create(fileUrl,options: options, resolve: resolve, rejecter: reject)
+    }
+    
+    @objc(clearCache:withResolver:withRejecter:)
+    func clearCache(cacheDir: String, resolve:@escaping RCTPromiseResolveBlock, reject:@escaping RCTPromiseRejectBlock) -> Void {
+        CreateVideoThumbnail.cleanCacheDir(cacheDir: cacheDir,resolve: resolve,rejecter: reject)
+    }
       
 }

package/ios/Utils/CreateVideoThumbnail.swift

@@ -0,0 +1,111 @@
+//
+//  CreateVideoThumbnail.swift
+//  react-native-compressor
+//
+//  Created by Numan on 13/09/2023.
+//
+
+import Foundation
+import AVFoundation
+import UIKit
+
+class CreateVideoThumbnail: NSObject {
+
+    func create(_ fileUrl:String, options: NSDictionary, resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+    let headers = options["headers"] as? [String: Any] ?? [:]
+    let format = "jpeg"
+   
+    do {
+      // Prepare cache folder
+      var tempDirectory = NSSearchPathForDirectoriesInDomains(.cachesDirectory, .userDomainMask, true).last ?? ""
+      tempDirectory = (tempDirectory as NSString).appendingPathComponent("thumbnails/")
+      // Create thumbnail directory if not exists
+      try FileManager.default.createDirectory(atPath: tempDirectory, withIntermediateDirectories: true, attributes: nil)
+      let fileName = "thumb-\(ProcessInfo.processInfo.globallyUniqueString).\(format)"
+      let fullPath = (tempDirectory as NSString).appendingPathComponent(fileName)
+
+      if FileManager.default.fileExists(atPath: fullPath) {
+        if let imageData = try? Data(contentsOf: URL(fileURLWithPath: fullPath)) {
+          if let thumbnail = UIImage(data: imageData) {
+            resolve([
+              "path": fullPath,
+              "size": Float(imageData.count),
+              "mime": "image/\(format)",
+              "width": Float(thumbnail.size.width),
+              "height": Float(thumbnail.size.height)
+            ])
+            return
+          }
+        }
+      }
+
+      var vidURL: URL?
+      let fileUrlLowerCase = fileUrl.lowercased()
+
+      if fileUrlLowerCase.hasPrefix("http://") || fileUrlLowerCase.hasPrefix("https://") || fileUrlLowerCase.hasPrefix("file://") {
+        vidURL = URL(string: fileUrl)
+      } else {
+        // Consider it's file url path
+        vidURL = URL(fileURLWithPath: fileUrl)
+      }
+
+      let asset = AVURLAsset(url: vidURL!, options: ["AVURLAssetHTTPHeaderFieldsKey": headers])
+      generateThumbImage(asset: asset, atTime: 0, completion: { thumbnail in
+        // Generate thumbnail
+        var data: Data? = thumbnail.jpegData(compressionQuality: 1.0)
+
+        if let data = data {
+          try? data.write(to: URL(fileURLWithPath: fullPath))
+          resolve([
+            "path": fullPath,
+            "size": Float(data.count),
+            "mime": "image/\(format)",
+            "width": Float(thumbnail.size.width),
+            "height": Float(thumbnail.size.height)
+          ] as [String : Any])
+        }
+      }, failure: { error in
+          reject(error._domain, error.localizedDescription, nil)
+      })
+
+    } catch {
+      reject("Error", error.localizedDescription, nil)
+    }
+  }
+
+    static func cleanCacheDir(cacheDir: String, resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let cachePathDir: String = cacheDir.isEmpty ? "thumbnails/" : cacheDir
+        var cacheDirectoryPath = NSSearchPathForDirectoriesInDomains(.cachesDirectory, .userDomainMask, true).last ?? ""
+        cacheDirectoryPath = (cacheDirectoryPath as NSString).appendingPathComponent(cachePathDir)
+        
+        let fm = FileManager.default
+        do {
+            let files = try fm.contentsOfDirectory(atPath: cacheDirectoryPath)
+            for file in files {
+                let filePath = (cacheDirectoryPath as NSString).appendingPathComponent(file)
+                try fm.removeItem(atPath: filePath)
+            }
+            resolve("done")
+        } catch {
+            // Handle error if necessary
+            reject("Error", error.localizedDescription, nil)
+        }
+    }
+
+  func generateThumbImage(asset: AVURLAsset, atTime timeStamp: Int, completion: @escaping (UIImage) -> Void, failure: @escaping (Error) -> Void) {
+    let generator = AVAssetImageGenerator(asset: asset)
+    generator.appliesPreferredTrackTransform = true
+    generator.maximumSize = CGSize(width: 512, height: 512)
+    generator.requestedTimeToleranceBefore = CMTimeMake(value: 0, timescale: 1000)
+    generator.requestedTimeToleranceAfter = CMTimeMake(value: 0, timescale: 1000)
+    let time = CMTimeMake(value: Int64(timeStamp), timescale: 1000)
+    generator.generateCGImagesAsynchronously(forTimes: [NSValue(time: time)]) { _, image, _, result, error in
+      if result == .succeeded, let cgImage = image {
+        let thumbnail = UIImage(cgImage: cgImage)
+        completion(thumbnail)
+      } else if let error = error {
+        failure(error)
+      }
+    }
+  }
+}

package/lib/commonjs/Spec/NativeCompressor.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNative","require","_default","TurboModuleRegistry","getEnforcing","exports","default"],"sourceRoot":"../../../src","sources":["Spec/NativeCompressor.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAmD,IAAAC,QAAA,GAyBpCC,gCAAmB,CAACC,YAAY,CAAO,YAAY,CAAC;AAAAC,OAAA,CAAAC,OAAA,GAAAJ,QAAA"}
+{"version":3,"names":["_reactNative","require","_default","TurboModuleRegistry","getEnforcing","exports","default"],"sourceRoot":"../../../src","sources":["Spec/NativeCompressor.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAmD,IAAAC,QAAA,GAoCpCC,gCAAmB,CAACC,YAAY,CAAO,YAAY,CAAC;AAAAC,OAAA,CAAAC,OAAA,GAAAJ,QAAA"}

package/lib/commonjs/index.js

@@ -27,6 +27,18 @@ Object.defineProperty(exports, "backgroundUpload", {
     return _utils.backgroundUpload;
   }
 });
+Object.defineProperty(exports, "clearCache", {
+  enumerable: true,
+  get: function () {
+    return _utils.clearCache;
+  }
+});
+Object.defineProperty(exports, "createVideoThumbnail", {
+  enumerable: true,
+  get: function () {
+    return _utils.createVideoThumbnail;
+  }
+});
 exports.default = void 0;
 Object.defineProperty(exports, "download", {
   enumerable: true,
@@ -86,6 +98,8 @@ var _default = {
   getVideoMetaData: _utils.getVideoMetaData,
   getFileSize: _utils.getFileSize,
   backgroundUpload: _utils.backgroundUpload,
+  createVideoThumbnail: _utils.createVideoThumbnail,
+  clearCache: _utils.clearCache,
   download: _utils.download
 };
 exports.default = _default;