rn-av-binder 1.0.0 → 1.0.1

package/android/src/main/java/expo/modules/imageaudiovideo/ImageAudioVideoModule.kt

@@ -2,16 +2,17 @@ package expo.modules.imageaudiovideo
 
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
+import android.media.Image
 import android.media.MediaCodec
 import android.media.MediaCodecInfo
 import android.media.MediaExtractor
 import android.media.MediaFormat
 import android.media.MediaMetadataRetriever
 import android.media.MediaMuxer
+import android.net.Uri
+import android.os.ParcelFileDescriptor
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
 import java.io.File
 import java.nio.ByteBuffer
 
@@ -21,14 +22,16 @@ class ImageAudioVideoModule : Module() {
     Events("onProgress")
 
     AsyncFunction("createVideoAsync") { options: Map<String, String?> ->
-      withContext(Dispatchers.IO) {
-        createVideo(options)
-      }
+      createVideo(options)
     }
   }
 
   private data class EncodedChunk(val data: ByteArray, val info: MediaCodec.BufferInfo)
 
+  // MP4 (MUXER_OUTPUT_MPEG_4) can only passthrough these audio codecs. MP3 (audio/mpeg)
+  // is NOT muxable into MP4 — we reject it up front with a clear error.
+  private val muxableAudioMimes = setOf("audio/mp4a-latm", "audio/3gpp", "audio/amr-wb")
+
   private fun createVideo(options: Map<String, String?>): Map<String, Any> {
     // ── Step 1 — Resolve paths ────────────────────────────────────────────────
     val imagePath = options["imageUri"]?.takeIf { it.isNotEmpty() }
@@ -42,176 +45,287 @@ class ImageAudioVideoModule : Module() {
     File(outputPath).takeIf { it.exists() }?.delete()
     sendEvent("onProgress", mapOf("progress" to 0.0))
 
-    // ── Step 2 — Load and prepare image ───────────────────────────────────────
-    var bitmap = BitmapFactory.decodeFile(imagePath)
-      ?: throw Exception("ERR_INVALID_IMAGE: could not decode image at $imagePath")
-    if (bitmap.width > 4096 || bitmap.height > 4096) {
-      val scale = 4096.0 / maxOf(bitmap.width, bitmap.height)
-      bitmap = Bitmap.createScaledBitmap(
-        bitmap, (bitmap.width * scale).toInt(), (bitmap.height * scale).toInt(), true
-      )
-    }
-    if (bitmap.config != Bitmap.Config.ARGB_8888) {
-      bitmap = bitmap.copy(Bitmap.Config.ARGB_8888, false)
-    }
-    // Round both dimensions down to the nearest even integer (H.264 requires even dims)
-    val width = (bitmap.width / 2) * 2
-    val height = (bitmap.height / 2) * 2
-    if (width <= 0 || height <= 0) throw Exception("ERR_INVALID_IMAGE: image dimensions are too small")
-
-    // ── Step 3 — Get audio duration and validate ──────────────────────────────
-    val retriever = MediaMetadataRetriever()
-    retriever.setDataSource(audioPath)
-    val durationMs = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)
-      ?.toLongOrNull() ?: throw Exception("ERR_INVALID_AUDIO: cannot read audio duration")
-    retriever.release()
-    if (durationMs <= 0) throw Exception("ERR_INVALID_AUDIO: audio has zero or invalid duration")
-    val durationUs = durationMs * 1000L
-
-    val validator = MediaExtractor()
-    validator.setDataSource(audioPath)
-    val hasAudio = (0 until validator.trackCount).any {
-      validator.getTrackFormat(it).getString(MediaFormat.KEY_MIME)?.startsWith("audio/") == true
-    }
-    validator.release()
-    if (!hasAudio) throw Exception("ERR_NO_AUDIO_TRACK: audio file has no audio track")
-
-    // ── Step 4 — Configure H.264 encoder ──────────────────────────────────────
-    val videoFormat = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, width, height).apply {
-      setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible)
-      setInteger(MediaFormat.KEY_BIT_RATE, width * height * 2)
-      setInteger(MediaFormat.KEY_FRAME_RATE, 1)
-      setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1)
+    // All native resources are tracked here and released exactly once in `finally`, so a
+    // failure mid-pipeline never leaks the hardware encoder/muxer (which would otherwise
+    // brick every subsequent call) and never leaves a half-written MP4 on disk.
+    val openFds = mutableListOf<ParcelFileDescriptor>()
+    var retriever: MediaMetadataRetriever? = null
+    var validator: MediaExtractor? = null
+    var encoder: MediaCodec? = null
+    var muxer: MediaMuxer? = null
+    var muxerStarted = false
+    var extractor: MediaExtractor? = null
+    var bitmap: Bitmap? = null
+    var success = false
+
+    // Open a content:// (or other non-filesystem) URI through the ContentResolver and
+    // return a FileDescriptor; returns null for a plain filesystem path. expo-document-picker
+    // commonly hands back content:// URIs, which MediaExtractor/Retriever's String overloads
+    // cannot read.
+    fun openFd(path: String): java.io.FileDescriptor? {
+      if (path.startsWith("/")) return null
+      val resolver = appContext.reactContext?.contentResolver
+        ?: throw Exception("ERR_OPEN: no context to resolve $path")
+      val pfd = resolver.openFileDescriptor(Uri.parse(path), "r")
+        ?: throw Exception("ERR_OPEN: cannot open $path")
+      openFds.add(pfd)
+      return pfd.fileDescriptor
     }
-    val encoder = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC)
-    encoder.configure(videoFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
-    encoder.start()
-
-    // ── Step 6 — Encode exactly 2 frames and collect output ───────────────────
-    val videoChunks = mutableListOf<EncodedChunk>()
-    var outputFormat: MediaFormat? = null
-
-    fun encodeFrame(yuvData: ByteArray, presentationTimeUs: Long, isLast: Boolean) {
-      val inputIndex = encoder.dequeueInputBuffer(10_000L)
-      if (inputIndex >= 0) {
-        val inputBuffer = encoder.getInputBuffer(inputIndex)!!
-        inputBuffer.clear()
-        inputBuffer.put(yuvData)
-        val flags = if (isLast) MediaCodec.BUFFER_FLAG_END_OF_STREAM else 0
-        encoder.queueInputBuffer(inputIndex, 0, yuvData.size, presentationTimeUs, flags)
+
+    try {
+      // ── Step 2 — Load and prepare image ─────────────────────────────────────
+      val imageFd = openFd(imagePath)
+      var bmp = (if (imageFd != null) BitmapFactory.decodeFileDescriptor(imageFd)
+                 else BitmapFactory.decodeFile(imagePath))
+        ?: throw Exception("ERR_INVALID_IMAGE: could not decode image at $imagePath")
+      bitmap = bmp
+      if (bmp.width > 4096 || bmp.height > 4096) {
+        val scale = 4096.0 / maxOf(bmp.width, bmp.height)
+        val scaled = Bitmap.createScaledBitmap(
+          bmp, (bmp.width * scale).toInt(), (bmp.height * scale).toInt(), true
+        )
+        if (scaled !== bmp) bmp.recycle()
+        bmp = scaled
+        bitmap = bmp
+      }
+      if (bmp.config != Bitmap.Config.ARGB_8888) {
+        val argb = bmp.copy(Bitmap.Config.ARGB_8888, false)
+        if (argb !== bmp) bmp.recycle()
+        bmp = argb
+        bitmap = bmp
       }
-      // Drain output
+      // Round both dimensions down to the nearest even integer (H.264 requires even dims)
+      val width = (bmp.width / 2) * 2
+      val height = (bmp.height / 2) * 2
+      if (width <= 0 || height <= 0) throw Exception("ERR_INVALID_IMAGE: image dimensions are too small")
+
+      // ── Step 3 — Get audio duration and validate ────────────────────────────
+      retriever = MediaMetadataRetriever()
+      val retrieverFd = openFd(audioPath)
+      if (retrieverFd != null) retriever.setDataSource(retrieverFd) else retriever.setDataSource(audioPath)
+      val durationMs = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)
+        ?.toLongOrNull() ?: throw Exception("ERR_INVALID_AUDIO: cannot read audio duration")
+      if (durationMs <= 0) throw Exception("ERR_INVALID_AUDIO: audio has zero or invalid duration")
+      val durationUs = durationMs * 1000L
+
+      // Validate the audio track exists AND is muxable into MP4 — fail fast before the
+      // expensive encode so we never write a partial file.
+      val audioValidator = MediaExtractor()
+      validator = audioValidator
+      val validatorFd = openFd(audioPath)
+      if (validatorFd != null) audioValidator.setDataSource(validatorFd) else audioValidator.setDataSource(audioPath)
+      val audioMime = (0 until audioValidator.trackCount)
+        .map { audioValidator.getTrackFormat(it).getString(MediaFormat.KEY_MIME) }
+        .firstOrNull { it?.startsWith("audio/") == true }
+        ?: throw Exception("ERR_NO_AUDIO_TRACK: audio file has no audio track")
+      if (audioMime !in muxableAudioMimes) {
+        throw Exception(
+          "ERR_UNSUPPORTED_AUDIO: MP4 output supports AAC (.m4a) audio for passthrough; " +
+            "got '$audioMime'. Provide an AAC/.m4a file."
+        )
+      }
+      audioValidator.release()
+      validator = null
+
+      // ── Step 4 — Configure H.264 encoder ────────────────────────────────────
+      val videoFormat = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, width, height).apply {
+        setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible)
+        setInteger(MediaFormat.KEY_BIT_RATE, width * height * 2)
+        setInteger(MediaFormat.KEY_FRAME_RATE, 1)
+        setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1)
+      }
+      encoder = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC)
+      encoder.configure(videoFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
+      encoder.start()
+
+      // ── Step 6 — Encode exactly 2 frames and collect output ─────────────────
+      val videoChunks = mutableListOf<EncodedChunk>()
+      var outputFormat: MediaFormat? = null
+
+      val pixels = IntArray(width * height)
+      bmp.getPixels(pixels, 0, width, 0, 0, width, height)
+      // Second frame PTS must be strictly greater than the first (0); clamp for very
+      // short (~1ms) audio so MediaMuxer doesn't reject non-monotonic timestamps.
+      val frameTimesUs = longArrayOf(0L, maxOf(durationUs - 1000L, 1000L))
+      val frameSize = width * height * 3 / 2
       val bufferInfo = MediaCodec.BufferInfo()
-      var draining = true
-      while (draining) {
+      var nextFrame = 0
+      var inputDone = false
+      var outputDone = false
+      var spins = 0
+
+      // Single feed-and-drain loop: queue both frames (the last carries EOS), then keep
+      // polling until the encoder reports END_OF_STREAM. INFO_TRY_AGAIN_LATER means "not
+      // ready yet" — we must keep looping, NOT stop draining.
+      while (!outputDone) {
+        if (!inputDone) {
+          val inputIndex = encoder.dequeueInputBuffer(10_000L)
+          if (inputIndex >= 0) {
+            // Fill via the Image plane API honoring rowStride/pixelStride. Writing raw I420
+            // bytes into a COLOR_FormatYUV420Flexible buffer produces garbled/green video on
+            // real (NV12) hardware encoders; getInputImage adapts to each device's layout.
+            val image = encoder.getInputImage(inputIndex)
+              ?: throw Exception("ERR_ENCODE: encoder did not provide an input image")
+            fillInputImage(image, pixels, width, height)
+            val isLast = nextFrame == frameTimesUs.size - 1
+            val flags = if (isLast) MediaCodec.BUFFER_FLAG_END_OF_STREAM else 0
+            encoder.queueInputBuffer(inputIndex, 0, frameSize, frameTimesUs[nextFrame], flags)
+            nextFrame++
+            if (isLast) inputDone = true
+          }
+        }
+
         val outputIndex = encoder.dequeueOutputBuffer(bufferInfo, 10_000L)
         when {
-          outputIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> outputFormat = encoder.outputFormat
+          outputIndex == MediaCodec.INFO_TRY_AGAIN_LATER -> {
+            if (inputDone && ++spins > 2000) {
+              throw Exception("ERR_ENCODE: timed out waiting for encoder output")
+            }
+          }
+          outputIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
+            outputFormat = encoder.outputFormat
+          }
           outputIndex >= 0 -> {
+            spins = 0
             val outputBuffer = encoder.getOutputBuffer(outputIndex)!!
-            val chunk = ByteArray(bufferInfo.size)
-            outputBuffer.get(chunk)
-            videoChunks.add(EncodedChunk(chunk, MediaCodec.BufferInfo().also {
-              it.offset = 0
-              it.size = bufferInfo.size
-              it.presentationTimeUs = bufferInfo.presentationTimeUs
-              it.flags = bufferInfo.flags
-            }))
+            val isConfig = bufferInfo.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG != 0
+            // Skip codec-config (SPS/PPS) buffers — that csd is already carried in
+            // outputFormat, which we hand to the muxer via addTrack().
+            if (!isConfig && bufferInfo.size > 0) {
+              outputBuffer.position(bufferInfo.offset)
+              outputBuffer.limit(bufferInfo.offset + bufferInfo.size)
+              val data = ByteArray(bufferInfo.size)
+              outputBuffer.get(data)
+              val sampleFlags = bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM.inv()
+              videoChunks.add(EncodedChunk(data, MediaCodec.BufferInfo().also {
+                it.set(0, data.size, bufferInfo.presentationTimeUs, sampleFlags)
+              }))
+            }
             encoder.releaseOutputBuffer(outputIndex, false)
-            if (bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM != 0) draining = false
+            if (bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM != 0) outputDone = true
           }
-          else -> draining = false
         }
       }
-    }
 
-    val yuvData = bitmapToYuv420(bitmap, width, height)
-    encodeFrame(yuvData, 0L, false)
-    encodeFrame(yuvData, durationUs - 1000L, true)
-
-    encoder.stop()
-    encoder.release()
-    sendEvent("onProgress", mapOf("progress" to 0.5))
-
-    // ── Step 7 — Mux video + audio ────────────────────────────────────────────
-    val muxer = MediaMuxer(outputPath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
-    val videoTrack = muxer.addTrack(
-      outputFormat ?: throw Exception("ERR_ENCODE: encoder produced no output format")
-    )
-
-    // Add audio track from extractor
-    val extractor = MediaExtractor()
-    extractor.setDataSource(audioPath)
-    val audioTrackIndex = (0 until extractor.trackCount).first {
-      extractor.getTrackFormat(it).getString(MediaFormat.KEY_MIME)?.startsWith("audio/") == true
-    }
-    extractor.selectTrack(audioTrackIndex)
-    val audioTrack = muxer.addTrack(extractor.getTrackFormat(audioTrackIndex))
-    muxer.start()
-
-    // Write video
-    val videoBuffer = ByteBuffer.allocate(1024 * 512)
-    for (chunk in videoChunks) {
-      videoBuffer.clear()
-      videoBuffer.put(chunk.data)
-      videoBuffer.flip()
-      muxer.writeSampleData(videoTrack, videoBuffer, chunk.info)
-    }
+      encoder.stop()
+      encoder.release()
+      encoder = null
+      if (outputFormat == null) throw Exception("ERR_ENCODE: encoder produced no output format")
+      sendEvent("onProgress", mapOf("progress" to 0.5))
 
-    // Write audio (passthrough)
-    val audioBuffer = ByteBuffer.allocate(1024 * 512)
-    val audioInfo = MediaCodec.BufferInfo()
-    while (true) {
-      val sampleSize = extractor.readSampleData(audioBuffer, 0)
-      if (sampleSize < 0) break
-      audioInfo.offset = 0
-      audioInfo.size = sampleSize
-      audioInfo.presentationTimeUs = extractor.sampleTime
-      audioInfo.flags = extractor.sampleFlags
-      muxer.writeSampleData(audioTrack, audioBuffer, audioInfo)
-      extractor.advance()
-    }
+      // ── Step 7 — Mux video + audio ──────────────────────────────────────────
+      muxer = MediaMuxer(outputPath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
+      val videoTrack = muxer.addTrack(outputFormat)
+
+      val audioExtractor = MediaExtractor()
+      extractor = audioExtractor
+      val extractorFd = openFd(audioPath)
+      if (extractorFd != null) audioExtractor.setDataSource(extractorFd) else audioExtractor.setDataSource(audioPath)
+      val audioTrackIndex = (0 until audioExtractor.trackCount).first {
+        audioExtractor.getTrackFormat(it).getString(MediaFormat.KEY_MIME)?.startsWith("audio/") == true
+      }
+      val audioFormat = audioExtractor.getTrackFormat(audioTrackIndex)
+      audioExtractor.selectTrack(audioTrackIndex)
+      val audioTrack = muxer.addTrack(audioFormat)
+      muxer.start()
+      muxerStarted = true
+
+      // Write the first video frame at t=0 (wrap its exact-sized array to avoid a fixed-buffer
+      // overflow on a large keyframe).
+      val firstChunk = videoChunks.firstOrNull()
+        ?: throw Exception("ERR_ENCODE: no encoded video frames")
+      firstChunk.info.presentationTimeUs = 0L
+      muxer.writeSampleData(videoTrack, ByteBuffer.wrap(firstChunk.data), firstChunk.info)
 
-    extractor.release()
-    muxer.stop()
-    muxer.release()
+      // Write audio (passthrough), sizing the read buffer from the track's max input size and
+      // tracking the REAL end timestamp from the samples themselves.
+      val audioBufferSize = (if (audioFormat.containsKey(MediaFormat.KEY_MAX_INPUT_SIZE))
+        audioFormat.getInteger(MediaFormat.KEY_MAX_INPUT_SIZE) else 0).coerceAtLeast(256 * 1024)
+      val audioBuffer = ByteBuffer.allocate(audioBufferSize)
+      val audioInfo = MediaCodec.BufferInfo()
+      var lastAudioPts = 0L
+      while (true) {
+        val sampleSize = audioExtractor.readSampleData(audioBuffer, 0)
+        if (sampleSize < 0) break
+        val pts = audioExtractor.sampleTime
+        audioInfo.set(0, sampleSize, pts, audioExtractor.sampleFlags)
+        muxer.writeSampleData(audioTrack, audioBuffer, audioInfo)
+        if (pts > lastAudioPts) lastAudioPts = pts
+        audioExtractor.advance()
+      }
+
+      // Stretch the still image across the ENTIRE audio: place the remaining video frame(s) at
+      // the real audio end (from the samples, not the sometimes-wrong duration metadata), so the
+      // output video length equals the audio length.
+      val videoEndUs = maxOf(lastAudioPts, 1000L)
+      for (i in 1 until videoChunks.size) {
+        val chunk = videoChunks[i]
+        chunk.info.presentationTimeUs = videoEndUs + (i - 1)
+        muxer.writeSampleData(videoTrack, ByteBuffer.wrap(chunk.data), chunk.info)
+      }
 
-    sendEvent("onProgress", mapOf("progress" to 1.0))
-    return mapOf("uri" to outputPath, "durationMs" to durationMs)
+      success = true
+      sendEvent("onProgress", mapOf("progress" to 1.0))
+      val outDurationMs = maxOf(durationMs, videoEndUs / 1000L)
+      return mapOf("uri" to outputPath, "durationMs" to outDurationMs)
+    } finally {
+      try { encoder?.stop() } catch (_: Exception) {}
+      encoder?.release()
+      try { if (muxerStarted) muxer?.stop() } catch (_: Exception) {}
+      muxer?.release()
+      extractor?.release()
+      validator?.release()
+      retriever?.release()
+      bitmap?.let { if (!it.isRecycled) it.recycle() }
+      for (fd in openFds) { try { fd.close() } catch (_: Exception) {} }
+      if (!success) File(outputPath).takeIf { it.exists() }?.delete()
+    }
   }
 
-  // ── Step 5 — RGB → YUV420 (I420 planar: Y, then U, then V) ──────────────────
-  private fun bitmapToYuv420(bitmap: Bitmap, width: Int, height: Int): ByteArray {
-    val ySize = width * height
-    val cSize = (width / 2) * (height / 2)
-    val out = ByteArray(ySize + 2 * cSize)
-    val pixels = IntArray(width * height)
-    bitmap.getPixels(pixels, 0, width, 0, 0, width, height)
+  // ── Step 5 — Fill a YUV_420_888 encoder input image from ARGB pixels ────────
+  // Honors each plane's rowStride/pixelStride, so it works on both planar (pixelStride==1)
+  // and semi-planar/NV12 (pixelStride==2) hardware encoders.
+  private fun fillInputImage(image: Image, pixels: IntArray, width: Int, height: Int) {
+    val yPlane = image.planes[0]
+    val uPlane = image.planes[1]
+    val vPlane = image.planes[2]
+    val yBuf = yPlane.buffer
+    val uBuf = uPlane.buffer
+    val vBuf = vPlane.buffer
+    val yRow = yPlane.rowStride
+    val yPix = yPlane.pixelStride
+    val uRow = uPlane.rowStride
+    val uPix = uPlane.pixelStride
+    val vRow = vPlane.rowStride
+    val vPix = vPlane.pixelStride
 
     // Y plane (full resolution)
-    var yIndex = 0
     for (j in 0 until height) {
+      val rowBase = j * yRow
+      val pixBase = j * width
       for (i in 0 until width) {
-        val p = pixels[j * width + i]
+        val p = pixels[pixBase + i]
         val r = (p shr 16) and 0xFF
         val g = (p shr 8) and 0xFF
         val b = p and 0xFF
         val y = ((66 * r + 129 * g + 25 * b + 128) shr 8) + 16
-        out[yIndex++] = clamp(y).toByte()
+        yBuf.put(rowBase + i * yPix, clamp(y).toByte())
       }
     }
 
     // U and V planes (subsampled — average each 2×2 block)
-    var uIndex = ySize
-    var vIndex = ySize + cSize
-    for (j in 0 until height step 2) {
-      for (i in 0 until width step 2) {
+    val chromaW = width / 2
+    val chromaH = height / 2
+    for (j in 0 until chromaH) {
+      val uRowBase = j * uRow
+      val vRowBase = j * vRow
+      for (i in 0 until chromaW) {
         var sumR = 0
         var sumG = 0
         var sumB = 0
         for (dj in 0 until 2) {
           for (di in 0 until 2) {
-            val p = pixels[(j + dj) * width + (i + di)]
+            val p = pixels[(j * 2 + dj) * width + (i * 2 + di)]
             sumR += (p shr 16) and 0xFF
             sumG += (p shr 8) and 0xFF
             sumB += p and 0xFF
@@ -222,11 +336,10 @@ class ImageAudioVideoModule : Module() {
         val b = sumB / 4
         val u = ((-38 * r - 74 * g + 112 * b + 128) shr 8) + 128
         val v = ((112 * r - 94 * g - 18 * b + 128) shr 8) + 128
-        out[uIndex++] = clamp(u).toByte()
-        out[vIndex++] = clamp(v).toByte()
+        uBuf.put(uRowBase + i * uPix, clamp(u).toByte())
+        vBuf.put(vRowBase + i * vPix, clamp(v).toByte())
       }
     }
-    return out
   }
 
   private fun clamp(value: Int): Int = when {

package/build/index.d.ts

@@ -1,7 +1,7 @@
 export interface CreateVideoOptions {
     /** file:// URI to a JPEG or PNG image */
     imageUri: string;
-    /** file:// URI to an AAC, MP3, or M4A audio file */
+    /** file:// URI to an AAC / .m4a audio file (passed through into the MP4; MP3 is not supported by the MP4 muxer) */
     audioUri: string;
     /**
      * Optional file:// URI for the output MP4.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rn-av-binder",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "On-device image + audio → MP4 composition for React Native. AVFoundation (iOS) and MediaCodec/MediaMuxer (Android). New Architecture compatible.",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/android/src/main/java/expo/modules/imageaudiovideo/ImageAudioVideoPackage.kt

@@ -1,7 +0,0 @@
-package expo.modules.imageaudiovideo
-
-import expo.modules.kotlin.Package
-
-class ImageAudioVideoPackage : Package {
-  override fun createModules() = listOf(ImageAudioVideoModule())
-}