react-native-compressor 1.19.2 → 1.19.4

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/compressor/Compressor.kt

@@ -151,6 +151,7 @@ object Compressor {
         newWidth = tempHeight
         0
       }
+
       180 -> 0
       else -> rotation
     }
@@ -311,189 +312,196 @@ object Compressor {
 
           while (!outputDone) {
             if (!inputDone) {
-                            // Feed the decoder until it has no free input slots or the
-                            // extractor is empty. HW codecs typically have 4-8 input
-                            // slots; queuing only one sample per outer iteration starves
-                            // the pipeline and forces serial decode-render-encode.
-                            feedLoop@ while (!inputDone) {
-                                val index = extractor.sampleTrackIndex
-
-                                if (index == videoIndex) {
-                                    val inputBufferIndex =
-                                        decoder.dequeueInputBuffer(0L)
-                                    if (inputBufferIndex < 0) break@feedLoop
-                                    val inputBuffer = decoder.getInputBuffer(inputBufferIndex)
-                                    val chunkSize = extractor.readSampleData(inputBuffer!!, 0)
-                                    when {
-                                        chunkSize < 0 -> {
-                                            decoder.queueInputBuffer(
-                                                inputBufferIndex,
-                                                0,
-                                                0,
-                                                0L,
-                                                MediaCodec.BUFFER_FLAG_END_OF_STREAM
-                                            )
-                                            inputDone = true
-                                        }
-                                        else -> {
-                                            decoder.queueInputBuffer(
-                                                inputBufferIndex,
-                                                0,
-                                                chunkSize,
-                                                extractor.sampleTime,
-                                                0
-                                            )
-                                            extractor.advance()
-                                        }
-                                    }
-                                } else if (index == -1) { //end of file
-                                    val inputBufferIndex =
-                                        decoder.dequeueInputBuffer(0L)
-                                    if (inputBufferIndex < 0) break@feedLoop
-                                    decoder.queueInputBuffer(
-                                        inputBufferIndex,
-                                        0,
-                                        0,
-                                        0L,
-                                        MediaCodec.BUFFER_FLAG_END_OF_STREAM
-                                    )
-                                    inputDone = true
-                                } else {
-                                    // Different track type at head of extractor (audio etc.).
-                                    break@feedLoop
-                                }
-                            }
-                        }
-
-                        var decoderOutputAvailable = true
-                        var encoderOutputAvailable = true
-
-                        loop@ while (decoderOutputAvailable || encoderOutputAvailable) {
-
-                            if (!isRunning) {
-                                dispose(
-                                    videoIndex,
-                                    decoder,
-                                    encoder,
-                                    inputSurface,
-                                    outputSurface,
-                                    extractor
-                                )
-
-                                compressionProgressListener.onProgressCancelled(id)
-                                return Result(
-                                    id,
-                                    success = false,
-                                    failureMessage = "The compression has stopped!"
-                                )
-                            }
-
-                            //Encoder
-                            val encoderStatus =
-                                encoder.dequeueOutputBuffer(bufferInfo, MEDIACODEC_TIMEOUT_DEFAULT)
-
-                            when {
-                                encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER -> encoderOutputAvailable =
-                                    false
-                                encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
-                                    val newFormat = encoder.outputFormat
-                                    if (videoTrackIndex == -5)
-                                        videoTrackIndex = mediaMuxer.addTrack(newFormat, false)
-                                }
-                                encoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED -> {
-                                    // ignore this status
-                                }
-                                encoderStatus < 0 -> throw RuntimeException("unexpected result from encoder.dequeueOutputBuffer: $encoderStatus")
-                                else -> {
-                                    val encodedData = encoder.getOutputBuffer(encoderStatus)
-                                        ?: throw RuntimeException("encoderOutputBuffer $encoderStatus was null")
-
-                                    if (bufferInfo.size > 1) {
-                                        if ((bufferInfo.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG) == 0) {
-                                            mediaMuxer.writeSampleData(
-                                                videoTrackIndex,
-                                                encodedData, bufferInfo, false
-                                            )
-                                        }
-
-                                    }
-
-                                    outputDone =
-                                        bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM != 0
-                                    encoder.releaseOutputBuffer(encoderStatus, false)
-                                }
-                            }
-                            if (encoderStatus != MediaCodec.INFO_TRY_AGAIN_LATER) continue@loop
-
-                            //Decoder
-                            val decoderStatus =
-                                decoder.dequeueOutputBuffer(bufferInfo, MEDIACODEC_TIMEOUT_DEFAULT)
-                            when {
-                                decoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER -> decoderOutputAvailable =
-                                    false
-                                decoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED -> {
-                                    // ignore this status
-                                }
-                                decoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
-                                    // ignore this status
-                                }
-                                decoderStatus < 0 -> throw RuntimeException("unexpected result from decoder.dequeueOutputBuffer: $decoderStatus")
-                                else -> {
-                                    val isEos = (bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0
-                                    var doRender = bufferInfo.size != 0 && !isEos
-
-                                    // Drop frames whose PTS falls before the next target slot.
-                                    // Anchor the next slot to the ideal grid (previous slot +
-                                    // interval) instead of to the actual PTS — anchoring to PTS
-                                    // lets source-side jitter compound into extra drops, which
-                                    // collapses the output frame rate well below the target.
-                                    if (doRender && targetFrameIntervalUs > 0L) {
-                                        if (bufferInfo.presentationTimeUs < nextTargetPtsUs) {
-                                            doRender = false
-                                        } else {
-                                            nextTargetPtsUs += targetFrameIntervalUs
-                                            // Snap forward when the source skips past a slot
-                                            // (gap, seek, very low source fps) so the gate doesn't
-                                            // burst-emit every following frame.
-                                            if (bufferInfo.presentationTimeUs >= nextTargetPtsUs) {
-                                                nextTargetPtsUs = bufferInfo.presentationTimeUs + targetFrameIntervalUs
-                                            }
-                                        }
-                                    }
-
-                                    decoder.releaseOutputBuffer(decoderStatus, doRender)
-                                    if (doRender) {
-                                        var errorWait = false
-                                        try {
-                                            outputSurface.awaitNewImage()
-                                        } catch (e: Exception) {
-                                            errorWait = true
-                                            Log.e(
-                                                "Compressor",
-                                                e.message ?: "Compression failed at swapping buffer"
-                                            )
-                                        }
-
-                                        if (!errorWait) {
-                                            outputSurface.drawImage()
-
-                                            inputSurface.setPresentationTime(bufferInfo.presentationTimeUs * 1000)
-
-                                            compressionProgressListener.onProgressChanged(
-                                                id,
-                                                bufferInfo.presentationTimeUs.toFloat() / duration.toFloat() * 100
-                                            )
-
-                                            inputSurface.swapBuffers()
-                                        }
-                                    }
-                                    if ((bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
-                                        decoderOutputAvailable = false
-                                        encoder.signalEndOfInputStream()
-                                    }
-                                }
-                            }
-                        }
+              // Feed the decoder until it has no free input slots or the
+              // extractor is empty. HW codecs typically have 4-8 input
+              // slots; queuing only one sample per outer iteration starves
+              // the pipeline and forces serial decode-render-encode.
+              feedLoop@ while (!inputDone) {
+                val index = extractor.sampleTrackIndex
+
+                if (index == videoIndex) {
+                  val inputBufferIndex =
+                    decoder.dequeueInputBuffer(0L)
+                  if (inputBufferIndex < 0) break@feedLoop
+                  val inputBuffer = decoder.getInputBuffer(inputBufferIndex)
+                  val chunkSize = extractor.readSampleData(inputBuffer!!, 0)
+                  when {
+                    chunkSize < 0 -> {
+                      decoder.queueInputBuffer(
+                        inputBufferIndex,
+                        0,
+                        0,
+                        0L,
+                        MediaCodec.BUFFER_FLAG_END_OF_STREAM
+                      )
+                      inputDone = true
+                    }
+
+                    else -> {
+                      decoder.queueInputBuffer(
+                        inputBufferIndex,
+                        0,
+                        chunkSize,
+                        extractor.sampleTime,
+                        0
+                      )
+                      extractor.advance()
+                    }
+                  }
+                } else if (index == -1) { //end of file
+                  val inputBufferIndex =
+                    decoder.dequeueInputBuffer(0L)
+                  if (inputBufferIndex < 0) break@feedLoop
+                  decoder.queueInputBuffer(
+                    inputBufferIndex,
+                    0,
+                    0,
+                    0L,
+                    MediaCodec.BUFFER_FLAG_END_OF_STREAM
+                  )
+                  inputDone = true
+                } else {
+                  // Different track type at head of extractor (audio etc.).
+                  break@feedLoop
+                }
+              }
+            }
+
+            var decoderOutputAvailable = true
+            var encoderOutputAvailable = true
+
+            loop@ while (decoderOutputAvailable || encoderOutputAvailable) {
+
+              if (!isRunning) {
+                dispose(
+                  videoIndex,
+                  decoder,
+                  encoder,
+                  inputSurface,
+                  outputSurface,
+                  extractor
+                )
+
+                compressionProgressListener.onProgressCancelled(id)
+                return Result(
+                  id,
+                  success = false,
+                  failureMessage = "The compression has stopped!"
+                )
+              }
+
+              //Encoder
+              val encoderStatus =
+                encoder.dequeueOutputBuffer(bufferInfo, MEDIACODEC_TIMEOUT_DEFAULT)
+
+              when {
+                encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER -> encoderOutputAvailable =
+                  false
+
+                encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
+                  val newFormat = encoder.outputFormat
+                  if (videoTrackIndex == -5)
+                    videoTrackIndex = mediaMuxer.addTrack(newFormat, false)
+                }
+
+                encoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED -> {
+                  // ignore this status
+                }
+
+                encoderStatus < 0 -> throw RuntimeException("unexpected result from encoder.dequeueOutputBuffer: $encoderStatus")
+                else -> {
+                  val encodedData = encoder.getOutputBuffer(encoderStatus)
+                    ?: throw RuntimeException("encoderOutputBuffer $encoderStatus was null")
+
+                  if (bufferInfo.size > 1) {
+                    if ((bufferInfo.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG) == 0) {
+                      mediaMuxer.writeSampleData(
+                        videoTrackIndex,
+                        encodedData, bufferInfo, false
+                      )
+                    }
+
+                  }
+
+                  outputDone =
+                    bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM != 0
+                  encoder.releaseOutputBuffer(encoderStatus, false)
+                }
+              }
+              if (encoderStatus != MediaCodec.INFO_TRY_AGAIN_LATER) continue@loop
+
+              //Decoder
+              val decoderStatus =
+                decoder.dequeueOutputBuffer(bufferInfo, MEDIACODEC_TIMEOUT_DEFAULT)
+              when {
+                decoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER -> decoderOutputAvailable =
+                  false
+
+                decoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED -> {
+                  // ignore this status
+                }
+
+                decoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
+                  // ignore this status
+                }
+
+                decoderStatus < 0 -> throw RuntimeException("unexpected result from decoder.dequeueOutputBuffer: $decoderStatus")
+                else -> {
+                  val isEos = (bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0
+                  var doRender = bufferInfo.size != 0 && !isEos
+
+                  // Drop frames whose PTS falls before the next target slot.
+                  // Anchor the next slot to the ideal grid (previous slot +
+                  // interval) instead of to the actual PTS — anchoring to PTS
+                  // lets source-side jitter compound into extra drops, which
+                  // collapses the output frame rate well below the target.
+                  if (doRender && targetFrameIntervalUs > 0L) {
+                    if (bufferInfo.presentationTimeUs < nextTargetPtsUs) {
+                      doRender = false
+                    } else {
+                      nextTargetPtsUs += targetFrameIntervalUs
+                      // Snap forward when the source skips past a slot
+                      // (gap, seek, very low source fps) so the gate doesn't
+                      // burst-emit every following frame.
+                      if (bufferInfo.presentationTimeUs >= nextTargetPtsUs) {
+                        nextTargetPtsUs = bufferInfo.presentationTimeUs + targetFrameIntervalUs
+                      }
+                    }
+                  }
+
+                  decoder.releaseOutputBuffer(decoderStatus, doRender)
+                  if (doRender) {
+                    var errorWait = false
+                    try {
+                      outputSurface.awaitNewImage()
+                    } catch (e: Exception) {
+                      errorWait = true
+                      Log.e(
+                        "Compressor",
+                        e.message ?: "Compression failed at swapping buffer"
+                      )
+                    }
+
+                    if (!errorWait) {
+                      outputSurface.drawImage()
+
+                      inputSurface.setPresentationTime(bufferInfo.presentationTimeUs * 1000)
+
+                      compressionProgressListener.onProgressChanged(
+                        id,
+                        bufferInfo.presentationTimeUs.toFloat() / duration.toFloat() * 100
+                      )
+
+                      inputSurface.swapBuffers()
+                    }
+                  }
+                  if ((bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
+                    decoderOutputAvailable = false
+                    encoder.signalEndOfInputStream()
+                  }
+                }
+              }
+            }
           }
 
         } catch (exception: Throwable) {
@@ -605,207 +613,221 @@ object Compressor {
   }
 
   // Function to process audio
-    private fun processAudio(
-        mediaMuxer: MP4Builder,
-        bufferInfo: MediaCodec.BufferInfo,
-        disableAudio: Boolean,
-        extractor: MediaExtractor
-    ) {
-        val audioIndex = findTrack(extractor, isVideo = false)
-        if (audioIndex >= 0 && !disableAudio) {
-            extractor.selectTrack(audioIndex)
-            val audioFormat = extractor.getTrackFormat(audioIndex)
-            if (!isSupportedAudioFormat(audioFormat)) {
-                extractor.unselectTrack(audioIndex)
-                return
-            }
-            val muxerTrackIndex = mediaMuxer.addTrack(audioFormat, true)
-            var maxBufferSize = if (audioFormat.containsKey(MediaFormat.KEY_MAX_INPUT_SIZE)) {
-                audioFormat.getInteger(MediaFormat.KEY_MAX_INPUT_SIZE)
-            } else {
-                64 * 1024
-            }
+  private fun processAudio(
+    mediaMuxer: MP4Builder,
+    bufferInfo: MediaCodec.BufferInfo,
+    disableAudio: Boolean,
+    extractor: MediaExtractor
+  ) {
+    val audioIndex = findTrack(extractor, isVideo = false)
+    if (audioIndex >= 0 && !disableAudio) {
+      extractor.selectTrack(audioIndex)
+      val audioFormat = extractor.getTrackFormat(audioIndex)
+      if (!isSupportedAudioFormat(audioFormat)) {
+        extractor.unselectTrack(audioIndex)
+        return
+      }
+      val muxerTrackIndex = mediaMuxer.addTrack(audioFormat, true)
+      var maxBufferSize = if (audioFormat.containsKey(MediaFormat.KEY_MAX_INPUT_SIZE)) {
+        audioFormat.getInteger(MediaFormat.KEY_MAX_INPUT_SIZE)
+      } else {
+        64 * 1024
+      }
 
-            if (maxBufferSize <= 0) {
-                maxBufferSize = 64 * 1024
-            }
+      if (maxBufferSize <= 0) {
+        maxBufferSize = 64 * 1024
+      }
 
-            var buffer: ByteBuffer = ByteBuffer.allocateDirect(maxBufferSize)
-            if (Build.VERSION.SDK_INT >= 28) {
-                val size = extractor.sampleSize
-                if (size > maxBufferSize) {
-                    maxBufferSize = (size + 1024).toInt()
-                    buffer = ByteBuffer.allocateDirect(maxBufferSize)
-                }
+      var buffer: ByteBuffer = ByteBuffer.allocateDirect(maxBufferSize)
+      if (Build.VERSION.SDK_INT >= 28) {
+        val size = extractor.sampleSize
+        if (size > maxBufferSize) {
+          maxBufferSize = (size + 1024).toInt()
+          buffer = ByteBuffer.allocateDirect(maxBufferSize)
+        }
+      }
+      var inputDone = false
+      extractor.seekTo(0, MediaExtractor.SEEK_TO_PREVIOUS_SYNC)
+
+      while (!inputDone) {
+        val index = extractor.sampleTrackIndex
+        if (index == audioIndex) {
+          bufferInfo.size = extractor.readSampleData(buffer, 0)
+
+          if (bufferInfo.size >= 0) {
+            bufferInfo.apply {
+              presentationTimeUs = extractor.sampleTime
+              offset = 0
+              flags = MediaCodec.BUFFER_FLAG_KEY_FRAME
             }
-            var inputDone = false
-            extractor.seekTo(0, MediaExtractor.SEEK_TO_PREVIOUS_SYNC)
-
-            while (!inputDone) {
-                val index = extractor.sampleTrackIndex
-                if (index == audioIndex) {
-                    bufferInfo.size = extractor.readSampleData(buffer, 0)
-
-                    if (bufferInfo.size >= 0) {
-                        bufferInfo.apply {
-                            presentationTimeUs = extractor.sampleTime
-                            offset = 0
-                            flags = MediaCodec.BUFFER_FLAG_KEY_FRAME
-                        }
-                        mediaMuxer.writeSampleData(muxerTrackIndex, buffer, bufferInfo, true)
-                        extractor.advance()
+            mediaMuxer.writeSampleData(muxerTrackIndex, buffer, bufferInfo, true)
+            extractor.advance()
 
-                    } else {
-                        bufferInfo.size = 0
-                        inputDone = true
-                    }
-                } else if (index == -1) {
-                    inputDone = true
-                }
-            }
-            extractor.unselectTrack(audioIndex)
+          } else {
+            bufferInfo.size = 0
+            inputDone = true
+          }
+        } else if (index == -1) {
+          inputDone = true
         }
+      }
+      extractor.unselectTrack(audioIndex)
     }
+  }
 
-    private fun isSupportedAudioFormat(audioFormat: MediaFormat): Boolean {
-        if (!audioFormat.containsKey(MediaFormat.KEY_SAMPLE_RATE) ||
-            !audioFormat.containsKey(MediaFormat.KEY_CHANNEL_COUNT)) {
-            return false
-        }
-        val sampleRate = audioFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE)
-        val channelCount = audioFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
-        return channelCount > 0 && sampleRate in SUPPORTED_AUDIO_SAMPLE_RATES
+  private fun isSupportedAudioFormat(audioFormat: MediaFormat): Boolean {
+    if (!audioFormat.containsKey(MediaFormat.KEY_SAMPLE_RATE) ||
+      !audioFormat.containsKey(MediaFormat.KEY_CHANNEL_COUNT)
+    ) {
+      return false
     }
+    val sampleRate = audioFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE)
+    val channelCount = audioFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
+    return channelCount > 0 && sampleRate in SUPPORTED_AUDIO_SAMPLE_RATES
+  }
 
   // Function to prepare the video encoder
-    private fun prepareEncoder(
-        outputFormat: MediaFormat,
-        hasQTI: Boolean,
-        baselineFormatProvider: () -> MediaFormat,
-    ): MediaCodec {
-        // Prefer hardware AVC encoder while skipping known-broken QTI codec that
-        // produces files unplayable on Mac/iOS (c2.qti.avc.encoder).
-        val encoder = pickAvcEncoder(outputFormat, hasQTI)
-        try {
-            encoder.configure(
-                outputFormat, null, null,
-                MediaCodec.CONFIGURE_FLAG_ENCODE
-            )
-            Log.i("Compressor", "encoder selected: ${encoder.name}")
-            return encoder
-        } catch (e: Exception) {
-            // Some encoders reject the throughput-tuning keys (VBR bitrate mode,
-            // priority, operating rate) at configure() time. A codec that throws
-            // from configure() is unusable, so release it and retry on a fresh
-            // codec with a baseline format (default rate control) rather than
-            // failing the whole compression.
-            Log.w(
-                "Compressor",
-                "encoder.configure rejected tuned format; retrying with default settings",
-                e
-            )
-            runCatching { encoder.release() }
-        }
+  private fun prepareEncoder(
+    outputFormat: MediaFormat,
+    hasQTI: Boolean,
+    baselineFormatProvider: () -> MediaFormat,
+  ): MediaCodec {
+    // Prefer hardware AVC encoder while skipping known-broken QTI codec that
+    // produces files unplayable on Mac/iOS (c2.qti.avc.encoder).
+    val encoder = pickAvcEncoder(outputFormat, hasQTI)
+    try {
+      encoder.configure(
+        outputFormat, null, null,
+        MediaCodec.CONFIGURE_FLAG_ENCODE
+      )
+      Log.i("Compressor", "encoder selected: ${encoder.name}")
+      return encoder
+    } catch (e: Exception) {
+      // Some encoders reject the throughput-tuning keys (VBR bitrate mode,
+      // priority, operating rate) at configure() time. A codec that throws
+      // from configure() is unusable, so release it and retry on a fresh
+      // codec with a baseline format (default rate control) rather than
+      // failing the whole compression.
+      Log.w(
+        "Compressor",
+        "encoder.configure rejected tuned format; retrying with default settings",
+        e
+      )
+      runCatching { encoder.release() }
+    }
 
-        val baseline = baselineFormatProvider()
-        val fallback = pickAvcEncoder(baseline, hasQTI)
-        try {
-            fallback.configure(
-                baseline, null, null,
-                MediaCodec.CONFIGURE_FLAG_ENCODE
-            )
-        } catch (e: Exception) {
-            // Even the baseline format was rejected; release the codec so it
-            // doesn't leak, then let start()'s outer catch report the failure.
-            runCatching { fallback.release() }
-            throw e
-        }
-        Log.i("Compressor", "encoder selected (fallback, default rate control): ${fallback.name}")
-        return fallback
+    val baseline = baselineFormatProvider()
+    val fallback = pickAvcEncoder(baseline, hasQTI)
+    try {
+      fallback.configure(
+        baseline, null, null,
+        MediaCodec.CONFIGURE_FLAG_ENCODE
+      )
+    } catch (e: Exception) {
+      // Even the baseline format was rejected; release the codec so it
+      // doesn't leak, then let start()'s outer catch report the failure.
+      runCatching { fallback.release() }
+      throw e
     }
+    Log.i("Compressor", "encoder selected (fallback, default rate control): ${fallback.name}")
+    return fallback
+  }
 
-    private fun pickAvcEncoder(outputFormat: MediaFormat, hasQTI: Boolean): MediaCodec {
-        // ALL_CODECS surfaces vendor codecs that REGULAR_CODECS hides (e.g. some
-        // Exynos / MTK HW encoders). We still filter blacklisted / SW codecs below.
-        val codecList = MediaCodecList(MediaCodecList.ALL_CODECS)
-        val candidates = codecList.codecInfos.filter { info ->
-            info.isEncoder && info.supportedTypes.any { it.equals(MIME_TYPE, ignoreCase = true) }
-        }
+  private fun pickAvcEncoder(outputFormat: MediaFormat, hasQTI: Boolean): MediaCodec {
+    // ALL_CODECS surfaces vendor codecs that REGULAR_CODECS hides (e.g. some
+    // Exynos / MTK HW encoders). We still filter blacklisted / SW codecs below.
+    val codecList = MediaCodecList(MediaCodecList.ALL_CODECS)
+    val candidates = codecList.codecInfos.filter { info ->
+      info.isEncoder && info.supportedTypes.any { it.equals(MIME_TYPE, ignoreCase = true) }
+    }
 
-        fun isBlacklisted(name: String): Boolean {
-            val lower = name.lowercase()
-            return lower.contains("c2.qti.avc.encoder") || lower.contains("omx.qcom.video.encoder.avc.secure")
-        }
+    fun isBlacklisted(name: String): Boolean {
+      val lower = name.lowercase()
+      return lower.contains("c2.qti.avc.encoder") || lower.contains("omx.qcom.video.encoder.avc.secure")
+    }
 
-        fun isSoftware(info: MediaCodecInfo): Boolean {
-            val name = info.name.lowercase()
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                if (info.isSoftwareOnly) return true
-            }
-            return name.startsWith("omx.google.") ||
-                name.startsWith("c2.android.") ||
-                name.contains(".sw.")
-        }
+    fun isSoftware(info: MediaCodecInfo): Boolean {
+      val name = info.name.lowercase()
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+        if (info.isSoftwareOnly) return true
+      }
+      return name.startsWith("omx.google.") ||
+        name.startsWith("c2.android.") ||
+        name.contains(".sw.")
+    }
 
-        val supportsFormat = candidates.filter { info ->
-            runCatching {
-                info.getCapabilitiesForType(MIME_TYPE).isFormatSupported(outputFormat)
-            }.getOrDefault(false) && !isBlacklisted(info.name)
-        }
+    val supportsFormat = candidates.filter { info ->
+      runCatching {
+        info.getCapabilitiesForType(MIME_TYPE).isFormatSupported(outputFormat)
+      }.getOrDefault(false) && !isBlacklisted(info.name)
+    }
 
-        val hardwareFirst = supportsFormat.firstOrNull { !isSoftware(it) }
-        val chosen = hardwareFirst ?: supportsFormat.firstOrNull()
+    val hardwareFirst = supportsFormat.firstOrNull { !isSoftware(it) }
+    val chosen = hardwareFirst ?: supportsFormat.firstOrNull()
 
-        if (chosen != null) {
-            return MediaCodec.createByCodecName(chosen.name)
-        }
+    if (chosen != null) {
+      return MediaCodec.createByCodecName(chosen.name)
+    }
 
-        // Fallback: keep historical QTI-safe path when format probing fails.
-        return if (hasQTI) {
-            MediaCodec.createByCodecName("c2.android.avc.encoder")
-        } else {
-            MediaCodec.createEncoderByType(MIME_TYPE)
-        }
+    // Fallback: keep historical QTI-safe path when format probing fails.
+    return if (hasQTI) {
+      MediaCodec.createByCodecName("c2.android.avc.encoder")
+    } else {
+      MediaCodec.createEncoderByType(MIME_TYPE)
     }
+  }
 
   // Dolby Vision profile 5 (0x20) carries no HEVC base layer, so no standard
   // Android decoder can render it. Detect it up front so start() can reject the
   // input before allocating the muxer/encoder/EGL surfaces. Profiles 8.x do carry
   // an HEVC base layer and are remapped to HEVC in prepareDecoder.
-    private fun isUnsupportedDolbyVision(inputFormat: MediaFormat): Boolean {
-        val mime = inputFormat.getString(MediaFormat.KEY_MIME) ?: return false
-        if (!mime.equals("video/dolby-vision", ignoreCase = true)) return false
-        val profile = if (inputFormat.containsKey(MediaFormat.KEY_PROFILE)) {
-            inputFormat.getInteger(MediaFormat.KEY_PROFILE)
-        } else {
-            -1
-        }
-        return profile == 0x20
+  private fun isUnsupportedDolbyVision(inputFormat: MediaFormat): Boolean {
+    val mime = inputFormat.getString(MediaFormat.KEY_MIME) ?: return false
+    if (!mime.equals("video/dolby-vision", ignoreCase = true)) return false
+    val profile = if (inputFormat.containsKey(MediaFormat.KEY_PROFILE)) {
+      inputFormat.getInteger(MediaFormat.KEY_PROFILE)
+    } else {
+      -1
+    }
+    return profile == 0x20
+  }
+
+  // Some inputs (e.g. iPhone .MOV files) report a "video/dolby-vision" MIME
+  // type that many devices cannot decode. Profiles 8.x carry an HEVC base
+  // layer that the standard HEVC decoder can render, so we remap them to
+  // HEVC here. Profile 5 has no compatible base layer and is rejected by
+  // isUnsupportedDolbyVision() in start() before any codec/surface is
+  // created, so it never reaches this helper (#398).
+  private fun ensureDecodableVideoFormat(inputFormat: MediaFormat) {
+    val mime = inputFormat.getString(MediaFormat.KEY_MIME) ?: return
+    if (mime.equals("video/dolby-vision", ignoreCase = true)) {
+      inputFormat.setString(MediaFormat.KEY_MIME, MediaFormat.MIMETYPE_VIDEO_HEVC)
     }
+  }
 
   // Function to prepare the video decoder
-    private fun prepareDecoder(
-        inputFormat: MediaFormat,
-        outputSurface: OutputSurface,
-    ): MediaCodec {
-        // Some inputs (e.g. iPhone .MOV files) report a "video/dolby-vision" MIME
-        // type that many devices cannot decode. Remap to a decodable base-layer
-        // codec, or fail with a clear error, before creating the decoder (#398).
-        ensureDecodableVideoFormat(inputFormat)
-
-        // Clear Dolby Vision specific profile and level to prevent configuration failures
-        // when the MIME type has been remapped to AVC/HEVC.
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            inputFormat.removeKey(MediaFormat.KEY_PROFILE)
-            inputFormat.removeKey(MediaFormat.KEY_LEVEL)
-        }
+  private fun prepareDecoder(
+    inputFormat: MediaFormat,
+    outputSurface: OutputSurface,
+  ): MediaCodec {
+    // Some inputs (e.g. iPhone .MOV files) report a "video/dolby-vision" MIME
+    // type that many devices cannot decode. Remap to a decodable base-layer
+    // codec, or fail with a clear error, before creating the decoder (#398).
+    ensureDecodableVideoFormat(inputFormat)
+
+    // Clear Dolby Vision specific profile and level to prevent configuration failures
+    // when the MIME type has been remapped to AVC/HEVC.
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      inputFormat.removeKey(MediaFormat.KEY_PROFILE)
+      inputFormat.removeKey(MediaFormat.KEY_LEVEL)
+    }
 
-        val decoder = MediaCodec.createDecoderByType(inputFormat.getString(MediaFormat.KEY_MIME)!!)
+    val decoder = MediaCodec.createDecoderByType(inputFormat.getString(MediaFormat.KEY_MIME)!!)
 
-        decoder.configure(inputFormat, outputSurface.getSurface(), null, 0)
+    decoder.configure(inputFormat, outputSurface.getSurface(), null, 0)
 
-        return decoder
-    }
+    return decoder
+  }
 
   // Function to release resources.
   // Every call is wrapped in runCatching so a failure in one teardown step
@@ -818,30 +840,30 @@ object Compressor {
   // decoder / inputSurface / outputSurface are nullable so this also serves the
   // partial-init cleanup path, where a setup failure leaves some handles
   // uncreated. The encoder is always created before teardown is reachable.
-    private fun dispose(
-        videoIndex: Int,
-        decoder: MediaCodec?,
-        encoder: MediaCodec,
-        inputSurface: InputSurface?,
-        outputSurface: OutputSurface?,
-        extractor: MediaExtractor
-    ) {
-        runCatching { extractor.unselectTrack(videoIndex) }
-            .onFailure { Log.w("Compressor", "extractor.unselectTrack failed", it) }
-
-        runCatching { decoder?.stop() }
-            .onFailure { Log.w("Compressor", "decoder.stop failed", it) }
-        runCatching { decoder?.release() }
-            .onFailure { Log.w("Compressor", "decoder.release failed", it) }
-
-        runCatching { encoder.stop() }
-            .onFailure { Log.w("Compressor", "encoder.stop failed", it) }
-        runCatching { encoder.release() }
-            .onFailure { Log.w("Compressor", "encoder.release failed", it) }
-
-        runCatching { inputSurface?.release() }
-            .onFailure { Log.w("Compressor", "inputSurface.release failed", it) }
-        runCatching { outputSurface?.release() }
-            .onFailure { Log.w("Compressor", "outputSurface.release failed", it) }
-    }
+  private fun dispose(
+    videoIndex: Int,
+    decoder: MediaCodec?,
+    encoder: MediaCodec,
+    inputSurface: InputSurface?,
+    outputSurface: OutputSurface?,
+    extractor: MediaExtractor
+  ) {
+    runCatching { extractor.unselectTrack(videoIndex) }
+      .onFailure { Log.w("Compressor", "extractor.unselectTrack failed", it) }
+
+    runCatching { decoder?.stop() }
+      .onFailure { Log.w("Compressor", "decoder.stop failed", it) }
+    runCatching { decoder?.release() }
+      .onFailure { Log.w("Compressor", "decoder.release failed", it) }
+
+    runCatching { encoder.stop() }
+      .onFailure { Log.w("Compressor", "encoder.stop failed", it) }
+    runCatching { encoder.release() }
+      .onFailure { Log.w("Compressor", "encoder.release failed", it) }
+
+    runCatching { inputSurface?.release() }
+      .onFailure { Log.w("Compressor", "inputSurface.release failed", it) }
+    runCatching { outputSurface?.release() }
+      .onFailure { Log.w("Compressor", "outputSurface.release failed", it) }
+  }
 }