capacitor-video-transcoder 0.0.0-stage → 0.0.1

package/android/src/main/kotlin/io/github/maximbelov/videotranscoder/VideoTranscoder.kt

@@ -0,0 +1,265 @@
+package io.github.maximbelov.videotranscoder
+
+import android.content.Context
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MimeTypes
+import androidx.media3.effect.Presentation
+import androidx.media3.transformer.Composition
+import androidx.media3.transformer.DefaultEncoderFactory
+import androidx.media3.transformer.EditedMediaItem
+import androidx.media3.transformer.EditedMediaItemSequence
+import androidx.media3.transformer.Effects
+import androidx.media3.transformer.ExportException
+import androidx.media3.transformer.ExportResult
+import androidx.media3.transformer.InAppMp4Muxer
+import androidx.media3.transformer.ProgressHolder
+import androidx.media3.transformer.Transformer
+import androidx.media3.transformer.VideoEncoderSettings
+import java.io.File
+import java.util.UUID
+import java.util.concurrent.atomic.AtomicBoolean
+
+/** What a finished transcode wrote. [width] and [height] are the size a player shows, upright. */
+data class TranscodeOutcome(val file: File, val width: Int, val height: Int, val durationMs: Long, val size: Long)
+
+/**
+ * Transcodes a video into an MP4 a web browser plays, with Media3 Transformer: H.264 (High where the encoder has it, which
+ * Media3 picks on its own), 8-bit 4:2:0 BT.709 with HDR tone-mapped to SDR in OpenGL, AAC (an AAC source is copied, anything else
+ * encoded), the longer side at most `maxSize`, cut at `maxDurationMs`, `moov` before `mdat`, and the rotation kept as metadata.
+ * One transcode at a time; Transformer runs on the main looper.
+ */
+class VideoTranscoder(private val context: Context) {
+    private val main = Handler(Looper.getMainLooper())
+    private val running = AtomicBoolean(false)
+
+    @Volatile private var cancelRequested = false
+
+    /** Touched on the main thread only. */
+    private var job: Job? = null
+
+    private inner class Job(
+        val transformer: Transformer,
+        val output: File,
+        val onProgress: (Double) -> Unit,
+        val onDone: (Result<TranscodeOutcome>) -> Unit,
+    ) {
+        var finished = false
+        var reported = -1.0
+        val holder = ProgressHolder()
+        val poll =
+            object : Runnable {
+                override fun run() {
+                    if (finished) return
+                    if (transformer.getProgress(holder) == Transformer.PROGRESS_STATE_AVAILABLE) {
+                        val value = Geometry.progress(holder.progress)
+                        if (value >= reported + 0.01) {
+                            reported = value
+                            onProgress(value)
+                        }
+                    }
+                    main.postDelayed(this, PROGRESS_INTERVAL_MS)
+                }
+            }
+
+        fun finish(result: Result<TranscodeOutcome>) {
+            if (finished) return
+            finished = true
+            main.removeCallbacks(poll)
+            if (result.isFailure) output.delete()
+            job = null
+            running.set(false)
+            onDone(result)
+        }
+    }
+
+    /** Starts a transcode; [onDone] is called once, on the main thread or on the calling one. */
+    fun transcode(options: TranscodeOptions, onProgress: (Double) -> Unit, onDone: (Result<TranscodeOutcome>) -> Unit) {
+        if (!running.compareAndSet(false, true)) {
+            onDone(Result.failure(TranscodeException(ErrorCode.BUSY, "another transcode is still running")))
+            return
+        }
+        cancelRequested = false
+        val output: File
+        val uri: Uri
+        val target: Pair<Int, Int>
+        val hasAudio: Boolean
+        try {
+            uri = openable(options.source)
+            val source = probe(uri)
+            hasAudio = source.hasAudio
+            val shown = Geometry.displayedSize(source.width, source.height, source.rotation)
+            // Transformer turns the frames upright before the effects, so the size is fitted to the size as shown; it then
+            // encodes them in the orientation the encoder prefers and writes the rotation back as metadata.
+            target = Geometry.outputSize(shown.first, shown.second, options.maxSize)
+            output =
+                options.destination?.let { File(it) }
+                    ?: File(File(context.cacheDir, "video-transcoder"), "${UUID.randomUUID()}.mp4")
+            output.parentFile?.mkdirs()
+            if (output.exists() && !output.delete()) {
+                throw TranscodeException(ErrorCode.FAILED, "the file at ${output.path} cannot be replaced")
+            }
+        } catch (e: TranscodeException) {
+            running.set(false)
+            onDone(Result.failure(e))
+            return
+        }
+
+        val item =
+            MediaItem.Builder()
+                .setUri(uri)
+                .setClippingConfiguration(
+                    MediaItem.ClippingConfiguration.Builder().setEndPositionMs(options.maxDurationMs).build(),
+                )
+                .build()
+        val edited =
+            EditedMediaItem.Builder(item)
+                .setEffects(
+                    Effects(
+                        listOf(),
+                        listOf(Presentation.createForWidthAndHeight(target.first, target.second, Presentation.LAYOUT_SCALE_TO_FIT)),
+                    ),
+                )
+                .build()
+        // A sequence that has audio makes an audio track even when the source has none (silence, measured on a Pixel 10a), so a
+        // video without sound gets a video-only sequence.
+        val sequence =
+            if (hasAudio) EditedMediaItemSequence.withAudioAndVideoFrom(listOf(edited)) else EditedMediaItemSequence.withVideoFrom(listOf(edited))
+        val composition =
+            Composition.Builder(sequence)
+                .setHdrMode(Composition.HDR_MODE_TONE_MAP_HDR_TO_SDR_USING_OPEN_GL)
+                .build()
+
+        main.post {
+            if (cancelRequested) {
+                output.delete()
+                running.set(false)
+                onDone(Result.failure(cancelled()))
+                return@post
+            }
+            var current: Job? = null
+            val transformer =
+                Transformer.Builder(context)
+                    .setEncoderFactory(
+                        DefaultEncoderFactory.Builder(context)
+                            .setRequestedVideoEncoderSettings(VideoEncoderSettings.Builder().setBitrate(options.videoBitrate).build())
+                            .build(),
+                    )
+                    .setVideoMimeType(MimeTypes.VIDEO_H264)
+                    .setAudioMimeType(MimeTypes.AUDIO_AAC)
+                    .setMuxerFactory(InAppMp4Muxer.Factory().setAttemptStreamableOutputEnabled(true))
+                    .addListener(
+                        object : Transformer.Listener {
+                            override fun onCompleted(composition: Composition, exportResult: ExportResult) {
+                                val active = current ?: return
+                                val outcome = runCatching { describe(output) }
+                                if (outcome.isSuccess) active.onProgress(1.0)
+                                active.finish(outcome)
+                            }
+
+                            override fun onError(composition: Composition, exportResult: ExportResult, exception: ExportException) {
+                                current?.finish(
+                                    Result.failure(
+                                        TranscodeException(ErrorCode.FAILED, "${exception.errorCodeName}: ${exception.message}"),
+                                    ),
+                                )
+                            }
+                        },
+                    )
+                    .build()
+            current = Job(transformer, output, onProgress, onDone)
+            job = current
+            try {
+                transformer.start(composition, output.path)
+                main.post(current.poll)
+            } catch (e: RuntimeException) {
+                current.finish(Result.failure(TranscodeException(ErrorCode.FAILED, e.message ?: e.toString())))
+            }
+        }
+    }
+
+    /** Stops the running transcode, which then fails with `CANCELLED`. Does nothing when none is running. */
+    fun cancel() {
+        if (!running.get()) return
+        cancelRequested = true
+        main.post {
+            val current = job ?: return@post
+            current.transformer.cancel()
+            current.finish(Result.failure(cancelled()))
+        }
+    }
+
+    private fun cancelled() = TranscodeException(ErrorCode.CANCELLED, "the transcode was cancelled")
+
+    /** The source as a URI Media3 reads, once it is known to open. */
+    private fun openable(source: SourceLocation): Uri =
+        when (source) {
+            is SourceLocation.File -> {
+                val file = File(source.path)
+                if (!file.isFile || !file.canRead()) {
+                    throw TranscodeException(ErrorCode.NOT_FOUND, "there is no readable file at ${source.path}")
+                }
+                Uri.fromFile(file)
+            }
+            is SourceLocation.Content -> {
+                val uri = Uri.parse(source.uri)
+                try {
+                    context.contentResolver.openFileDescriptor(uri, "r")?.close()
+                        ?: throw TranscodeException(ErrorCode.NOT_FOUND, "${source.uri} cannot be opened")
+                } catch (e: TranscodeException) {
+                    throw e
+                } catch (e: Exception) {
+                    throw TranscodeException(ErrorCode.NOT_FOUND, "${source.uri} cannot be opened: ${e.message}")
+                }
+                uri
+            }
+        }
+
+    private data class Source(val width: Int, val height: Int, val rotation: Int, val hasAudio: Boolean)
+
+    /** The stored width, height and rotation of the video track, and whether there is sound. */
+    private fun probe(uri: Uri): Source {
+        val retriever = MediaMetadataRetriever()
+        try {
+            try {
+                retriever.setDataSource(context, uri)
+            } catch (e: Exception) {
+                throw TranscodeException(ErrorCode.NO_VIDEO, "$uri is not a video this device reads: ${e.message}")
+            }
+            if (retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_VIDEO) != "yes") {
+                throw TranscodeException(ErrorCode.NO_VIDEO, "$uri has no video track")
+            }
+            val width = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)?.toIntOrNull() ?: 0
+            val height = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)?.toIntOrNull() ?: 0
+            val rotation = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION)?.toIntOrNull() ?: 0
+            if (width <= 0 || height <= 0) throw TranscodeException(ErrorCode.NO_VIDEO, "$uri has a video track without a size")
+            val hasAudio = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_AUDIO) == "yes"
+            return Source(width, height, rotation, hasAudio)
+        } finally {
+            retriever.release()
+        }
+    }
+
+    /** What was written, read back from the file. */
+    private fun describe(file: File): TranscodeOutcome {
+        val retriever = MediaMetadataRetriever()
+        try {
+            retriever.setDataSource(file.path)
+            val width = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)?.toIntOrNull() ?: 0
+            val height = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)?.toIntOrNull() ?: 0
+            val rotation = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION)?.toIntOrNull() ?: 0
+            val duration = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)?.toLongOrNull() ?: 0
+            val shown = Geometry.displayedSize(width, height, rotation)
+            return TranscodeOutcome(file, shown.first, shown.second, duration, file.length())
+        } finally {
+            retriever.release()
+        }
+    }
+
+    private companion object {
+        const val PROGRESS_INTERVAL_MS = 200L
+    }
+}

package/android/src/main/kotlin/io/github/maximbelov/videotranscoder/VideoTranscoderPlugin.kt

@@ -0,0 +1,51 @@
+package io.github.maximbelov.videotranscoder
+
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import org.json.JSONObject
+
+@CapacitorPlugin(name = "VideoTranscoder")
+class VideoTranscoderPlugin : Plugin() {
+    private val transcoder by lazy { VideoTranscoder(context) }
+
+    @PluginMethod
+    fun transcode(call: PluginCall) {
+        val options =
+            try {
+                TranscodeOptions.parse { key -> call.data.opt(key).takeUnless { it == JSONObject.NULL } }
+            } catch (e: TranscodeException) {
+                call.reject(e.message, e.code.name)
+                return
+            }
+        transcoder.transcode(
+            options,
+            onProgress = { progress -> notifyListeners("progress", JSObject().put("progress", progress)) },
+        ) { result ->
+            result.fold(
+                onSuccess = { outcome -> call.resolve(result(outcome)) },
+                onFailure = { error ->
+                    val code = (error as? TranscodeException)?.code ?: ErrorCode.FAILED
+                    call.reject(error.message ?: code.name, code.name)
+                },
+            )
+        }
+    }
+
+    @PluginMethod
+    fun cancel(call: PluginCall) {
+        transcoder.cancel()
+        call.resolve()
+    }
+
+    private fun result(outcome: TranscodeOutcome) =
+        JSObject()
+            .put("path", outcome.file.absolutePath)
+            .put("uri", TranscodeOptions.fileUrl(outcome.file))
+            .put("width", outcome.width)
+            .put("height", outcome.height)
+            .put("durationMs", outcome.durationMs)
+            .put("size", outcome.size)
+}

package/dist/docs.json

@@ -0,0 +1,221 @@
+{
+  "api": {
+    "name": "VideoTranscoderPlugin",
+    "slug": "videotranscoderplugin",
+    "docs": "",
+    "tags": [],
+    "methods": [
+      {
+        "name": "transcode",
+        "signature": "(options: TranscodeOptions) => Promise<TranscodeResult>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "TranscodeOptions"
+          }
+        ],
+        "returns": "Promise<TranscodeResult>",
+        "tags": [],
+        "docs": "Transcode a video into an MP4 that web browsers play:\n\n- H.264 video (High profile where the encoder offers it), 8-bit 4:2:0, tagged\n  BT.709; an HDR source (HLG or PQ) is tone-mapped to SDR\n- AAC audio: an AAC source track is copied as it is, anything else is\n  encoded; a video without sound gets no audio track\n- the longer side at most `maxSize`, cut at `maxDurationMs`\n- the index (`moov`) before the media data, so playback can start before\n  the whole file has downloaded\n- a portrait video keeps its rotation as track metadata, the way a phone\n  records it, so players show it upright\n\nOne runs at a time: a second call while one is running rejects with `BUSY`.\nOn the web it rejects with the `UNIMPLEMENTED` code.",
+        "complexTypes": [
+          "TranscodeResult",
+          "TranscodeOptions"
+        ],
+        "slug": "transcode"
+      },
+      {
+        "name": "cancel",
+        "signature": "() => Promise<void>",
+        "parameters": [],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "Stop the running `transcode`, which then rejects with `CANCELLED` and leaves\nno file behind. Resolves straight away, and does nothing when none is\nrunning. On the web it rejects with the `UNIMPLEMENTED` code.",
+        "complexTypes": [],
+        "slug": "cancel"
+      },
+      {
+        "name": "addListener",
+        "signature": "(eventName: 'progress', listenerFunc: (event: TranscodeProgress) => void) => Promise<PluginListenerHandle>",
+        "parameters": [
+          {
+            "name": "eventName",
+            "docs": "",
+            "type": "'progress'"
+          },
+          {
+            "name": "listenerFunc",
+            "docs": "",
+            "type": "(event: TranscodeProgress) => void"
+          }
+        ],
+        "returns": "Promise<PluginListenerHandle>",
+        "tags": [],
+        "docs": "Listen to the progress of the running `transcode`.",
+        "complexTypes": [
+          "PluginListenerHandle",
+          "TranscodeProgress"
+        ],
+        "slug": "addlistenerprogress-"
+      },
+      {
+        "name": "removeAllListeners",
+        "signature": "() => Promise<void>",
+        "parameters": [],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "Remove every listener of this plugin.",
+        "complexTypes": [],
+        "slug": "removealllisteners"
+      }
+    ],
+    "properties": []
+  },
+  "interfaces": [
+    {
+      "name": "TranscodeResult",
+      "slug": "transcoderesult",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "path",
+          "tags": [],
+          "docs": "The absolute path of the MP4 that was written.",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "uri",
+          "tags": [],
+          "docs": "The same file as a `file://` URL.",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "width",
+          "tags": [],
+          "docs": "The width of the video as a player shows it, upright: the rotation the\noutput carries as metadata is already applied.",
+          "complexTypes": [],
+          "type": "number"
+        },
+        {
+          "name": "height",
+          "tags": [],
+          "docs": "The height of the video as a player shows it, upright.",
+          "complexTypes": [],
+          "type": "number"
+        },
+        {
+          "name": "durationMs",
+          "tags": [],
+          "docs": "The length of the output, in milliseconds.",
+          "complexTypes": [],
+          "type": "number"
+        },
+        {
+          "name": "size",
+          "tags": [],
+          "docs": "The size of the output file, in bytes.",
+          "complexTypes": [],
+          "type": "number"
+        }
+      ]
+    },
+    {
+      "name": "TranscodeOptions",
+      "slug": "transcodeoptions",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "source",
+          "tags": [],
+          "docs": "The video to transcode: an absolute path or a `file://` URL. On Android it\ncan also be a `content://` URI, such as the one a system picker returns; it\nis read in place, without a copy.",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "destination",
+          "tags": [],
+          "docs": "Where to write the MP4: an absolute path or a `file://` URL. A file that is\nalready there is replaced, and missing directories are created.\n\nWhen it is left out, a new file is created in the app's cache directory\n(Android) or temporary directory (iOS). The app owns that file and deletes it\nwhen it is done with it.",
+          "complexTypes": [],
+          "type": "string | undefined"
+        },
+        {
+          "name": "maxSize",
+          "tags": [
+            {
+              "text": "1280",
+              "name": "default"
+            }
+          ],
+          "docs": "The longest side of the output, in pixels. A larger video is scaled down to\nfit, keeping its aspect ratio; a smaller one keeps its size. Both sides are\nrounded down to an even number, as H.264 4:2:0 needs. A whole number, at\nleast 16.",
+          "complexTypes": [],
+          "type": "number | undefined"
+        },
+        {
+          "name": "maxDurationMs",
+          "tags": [
+            {
+              "text": "30000",
+              "name": "default"
+            }
+          ],
+          "docs": "The longest the output may be, in milliseconds. A longer video is cut at\nthis point; a shorter one is kept whole. A whole number, at least 1.",
+          "complexTypes": [],
+          "type": "number | undefined"
+        },
+        {
+          "name": "videoBitrate",
+          "tags": [
+            {
+              "text": "1800000",
+              "name": "default"
+            }
+          ],
+          "docs": "The average video bitrate the encoder is asked for, in bits per second.\nA whole number, at least 1.",
+          "complexTypes": [],
+          "type": "number | undefined"
+        }
+      ]
+    },
+    {
+      "name": "PluginListenerHandle",
+      "slug": "pluginlistenerhandle",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "remove",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "() => Promise<void>"
+        }
+      ]
+    },
+    {
+      "name": "TranscodeProgress",
+      "slug": "transcodeprogress",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "progress",
+          "tags": [],
+          "docs": "How far the running `transcode` is, from 0 to 1. It only grows, and the\nlast event before the promise resolves is 1.",
+          "complexTypes": [],
+          "type": "number"
+        }
+      ]
+    }
+  ],
+  "enums": [],
+  "typeAliases": [],
+  "pluginConfigs": []
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,120 @@
+import type { PluginListenerHandle } from '@capacitor/core';
+export interface TranscodeOptions {
+    /**
+     * The video to transcode: an absolute path or a `file://` URL. On Android it
+     * can also be a `content://` URI, such as the one a system picker returns; it
+     * is read in place, without a copy.
+     */
+    source: string;
+    /**
+     * Where to write the MP4: an absolute path or a `file://` URL. A file that is
+     * already there is replaced, and missing directories are created.
+     *
+     * When it is left out, a new file is created in the app's cache directory
+     * (Android) or temporary directory (iOS). The app owns that file and deletes it
+     * when it is done with it.
+     */
+    destination?: string;
+    /**
+     * The longest side of the output, in pixels. A larger video is scaled down to
+     * fit, keeping its aspect ratio; a smaller one keeps its size. Both sides are
+     * rounded down to an even number, as H.264 4:2:0 needs. A whole number, at
+     * least 16.
+     *
+     * @default 1280
+     */
+    maxSize?: number;
+    /**
+     * The longest the output may be, in milliseconds. A longer video is cut at
+     * this point; a shorter one is kept whole. A whole number, at least 1.
+     *
+     * @default 30000
+     */
+    maxDurationMs?: number;
+    /**
+     * The average video bitrate the encoder is asked for, in bits per second.
+     * A whole number, at least 1.
+     *
+     * @default 1800000
+     */
+    videoBitrate?: number;
+}
+export interface TranscodeResult {
+    /**
+     * The absolute path of the MP4 that was written.
+     */
+    path: string;
+    /**
+     * The same file as a `file://` URL.
+     */
+    uri: string;
+    /**
+     * The width of the video as a player shows it, upright: the rotation the
+     * output carries as metadata is already applied.
+     */
+    width: number;
+    /**
+     * The height of the video as a player shows it, upright.
+     */
+    height: number;
+    /**
+     * The length of the output, in milliseconds.
+     */
+    durationMs: number;
+    /**
+     * The size of the output file, in bytes.
+     */
+    size: number;
+}
+export interface TranscodeProgress {
+    /**
+     * How far the running `transcode` is, from 0 to 1. It only grows, and the
+     * last event before the promise resolves is 1.
+     */
+    progress: number;
+}
+/**
+ * Why a call failed, as the `code` of the rejected error.
+ *
+ * - `INVALID_ARGUMENT`: `source` is missing or not a path or URL this platform reads, `destination` is not a path or
+ *   `file://` URL, or a number is out of range or not a whole number
+ * - `NOT_FOUND`: there is no file at `source`, or it cannot be opened
+ * - `NO_VIDEO`: `source` is not a video this device reads, or has no video track
+ * - `BUSY`: another `transcode` is still running; one runs at a time
+ * - `CANCELLED`: `cancel()` stopped it; nothing is left at the destination
+ * - `FAILED`: the decoder, the encoder or the writer failed; nothing is left at the destination
+ */
+export type TranscodeErrorCode = 'INVALID_ARGUMENT' | 'NOT_FOUND' | 'NO_VIDEO' | 'BUSY' | 'CANCELLED' | 'FAILED';
+export interface VideoTranscoderPlugin {
+    /**
+     * Transcode a video into an MP4 that web browsers play:
+     *
+     * - H.264 video (High profile where the encoder offers it), 8-bit 4:2:0, tagged
+     *   BT.709; an HDR source (HLG or PQ) is tone-mapped to SDR
+     * - AAC audio: an AAC source track is copied as it is, anything else is
+     *   encoded; a video without sound gets no audio track
+     * - the longer side at most `maxSize`, cut at `maxDurationMs`
+     * - the index (`moov`) before the media data, so playback can start before
+     *   the whole file has downloaded
+     * - a portrait video keeps its rotation as track metadata, the way a phone
+     *   records it, so players show it upright
+     *
+     * One runs at a time: a second call while one is running rejects with `BUSY`.
+     * On the web it rejects with the `UNIMPLEMENTED` code.
+     */
+    transcode(options: TranscodeOptions): Promise<TranscodeResult>;
+    /**
+     * Stop the running `transcode`, which then rejects with `CANCELLED` and leaves
+     * no file behind. Resolves straight away, and does nothing when none is
+     * running. On the web it rejects with the `UNIMPLEMENTED` code.
+     */
+    cancel(): Promise<void>;
+    /**
+     * Listen to the progress of the running `transcode`.
+     */
+    addListener(eventName: 'progress', listenerFunc: (event: TranscodeProgress) => void): Promise<PluginListenerHandle>;
+    /**
+     * Remove every listener of this plugin.
+     */
+    removeAllListeners(): Promise<void>;
+}

package/dist/esm/definitions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["import type { PluginListenerHandle } from '@capacitor/core';\n\nexport interface TranscodeOptions {\n  /**\n   * The video to transcode: an absolute path or a `file://` URL. On Android it\n   * can also be a `content://` URI, such as the one a system picker returns; it\n   * is read in place, without a copy.\n   */\n  source: string;\n  /**\n   * Where to write the MP4: an absolute path or a `file://` URL. A file that is\n   * already there is replaced, and missing directories are created.\n   *\n   * When it is left out, a new file is created in the app's cache directory\n   * (Android) or temporary directory (iOS). The app owns that file and deletes it\n   * when it is done with it.\n   */\n  destination?: string;\n  /**\n   * The longest side of the output, in pixels. A larger video is scaled down to\n   * fit, keeping its aspect ratio; a smaller one keeps its size. Both sides are\n   * rounded down to an even number, as H.264 4:2:0 needs. A whole number, at\n   * least 16.\n   *\n   * @default 1280\n   */\n  maxSize?: number;\n  /**\n   * The longest the output may be, in milliseconds. A longer video is cut at\n   * this point; a shorter one is kept whole. A whole number, at least 1.\n   *\n   * @default 30000\n   */\n  maxDurationMs?: number;\n  /**\n   * The average video bitrate the encoder is asked for, in bits per second.\n   * A whole number, at least 1.\n   *\n   * @default 1800000\n   */\n  videoBitrate?: number;\n}\n\nexport interface TranscodeResult {\n  /**\n   * The absolute path of the MP4 that was written.\n   */\n  path: string;\n  /**\n   * The same file as a `file://` URL.\n   */\n  uri: string;\n  /**\n   * The width of the video as a player shows it, upright: the rotation the\n   * output carries as metadata is already applied.\n   */\n  width: number;\n  /**\n   * The height of the video as a player shows it, upright.\n   */\n  height: number;\n  /**\n   * The length of the output, in milliseconds.\n   */\n  durationMs: number;\n  /**\n   * The size of the output file, in bytes.\n   */\n  size: number;\n}\n\nexport interface TranscodeProgress {\n  /**\n   * How far the running `transcode` is, from 0 to 1. It only grows, and the\n   * last event before the promise resolves is 1.\n   */\n  progress: number;\n}\n\n/**\n * Why a call failed, as the `code` of the rejected error.\n *\n * - `INVALID_ARGUMENT`: `source` is missing or not a path or URL this platform reads, `destination` is not a path or\n *   `file://` URL, or a number is out of range or not a whole number\n * - `NOT_FOUND`: there is no file at `source`, or it cannot be opened\n * - `NO_VIDEO`: `source` is not a video this device reads, or has no video track\n * - `BUSY`: another `transcode` is still running; one runs at a time\n * - `CANCELLED`: `cancel()` stopped it; nothing is left at the destination\n * - `FAILED`: the decoder, the encoder or the writer failed; nothing is left at the destination\n */\nexport type TranscodeErrorCode = 'INVALID_ARGUMENT' | 'NOT_FOUND' | 'NO_VIDEO' | 'BUSY' | 'CANCELLED' | 'FAILED';\n\nexport interface VideoTranscoderPlugin {\n  /**\n   * Transcode a video into an MP4 that web browsers play:\n   *\n   * - H.264 video (High profile where the encoder offers it), 8-bit 4:2:0, tagged\n   *   BT.709; an HDR source (HLG or PQ) is tone-mapped to SDR\n   * - AAC audio: an AAC source track is copied as it is, anything else is\n   *   encoded; a video without sound gets no audio track\n   * - the longer side at most `maxSize`, cut at `maxDurationMs`\n   * - the index (`moov`) before the media data, so playback can start before\n   *   the whole file has downloaded\n   * - a portrait video keeps its rotation as track metadata, the way a phone\n   *   records it, so players show it upright\n   *\n   * One runs at a time: a second call while one is running rejects with `BUSY`.\n   * On the web it rejects with the `UNIMPLEMENTED` code.\n   */\n  transcode(options: TranscodeOptions): Promise<TranscodeResult>;\n\n  /**\n   * Stop the running `transcode`, which then rejects with `CANCELLED` and leaves\n   * no file behind. Resolves straight away, and does nothing when none is\n   * running. On the web it rejects with the `UNIMPLEMENTED` code.\n   */\n  cancel(): Promise<void>;\n\n  /**\n   * Listen to the progress of the running `transcode`.\n   */\n  addListener(eventName: 'progress', listenerFunc: (event: TranscodeProgress) => void): Promise<PluginListenerHandle>;\n\n  /**\n   * Remove every listener of this plugin.\n   */\n  removeAllListeners(): Promise<void>;\n}\n"]}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import type { VideoTranscoderPlugin } from './definitions';
+declare const VideoTranscoder: VideoTranscoderPlugin;
+export * from './definitions';
+export { VideoTranscoder };