munim-ffmpeg 0.1.0

package/android/src/main/java/com/margelo/nitro/munimffmpeg/HybridMunimFfmpeg.kt

@@ -0,0 +1,141 @@
+package com.margelo.nitro.munimffmpeg
+
+import androidx.annotation.Keep
+import com.arthenica.ffmpegkit.FFmpegKit
+import com.arthenica.ffmpegkit.FFmpegKitConfig
+import com.arthenica.ffmpegkit.FFprobeKit
+import com.arthenica.ffmpegkit.ReturnCode
+import com.arthenica.ffmpegkit.Session
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
+
+@Keep
+@DoNotStrip
+class HybridMunimFfmpeg : HybridMunimFfmpegSpec() {
+  override val ffmpegVersion: String
+    get() = FFmpegKitConfig.getFFmpegVersion()
+
+  override fun execute(
+    arguments_: Array<String>,
+    onLog: ((message: String) -> Unit)?,
+    onStatistics: ((
+      timeMs: Double,
+      sizeBytes: Double,
+      bitrateKbits: Double,
+      speed: Double,
+      videoFrameNumber: Double,
+      fps: Double,
+      quality: Double,
+    ) -> Unit)?,
+    onSessionCreated: ((sessionId: Double) -> Unit)?,
+  ): Promise<FFmpegSessionResult> {
+    val promise = Promise<FFmpegSessionResult>()
+
+    try {
+      val session = FFmpegKit.executeWithArgumentsAsync(
+        arguments_,
+        { session -> promise.resolve(session.toResult()) },
+        { log -> onLog?.invoke(log.message) },
+        { statistics ->
+          onStatistics?.invoke(
+            statistics.time,
+            statistics.size.toDouble(),
+            statistics.bitrate,
+            statistics.speed,
+            statistics.videoFrameNumber.toDouble(),
+            statistics.videoFps,
+            statistics.videoQuality,
+          )
+        },
+      )
+      onSessionCreated?.invoke(session.sessionId.toDouble())
+    } catch (error: Throwable) {
+      promise.reject(error)
+    }
+
+    return promise
+  }
+
+  override fun probe(
+    arguments_: Array<String>,
+    onLog: ((message: String) -> Unit)?,
+    onSessionCreated: ((sessionId: Double) -> Unit)?,
+  ): Promise<FFmpegSessionResult> {
+    val promise = Promise<FFmpegSessionResult>()
+
+    try {
+      val session = FFprobeKit.executeWithArgumentsAsync(
+        arguments_,
+        { session -> promise.resolve(session.toResult()) },
+        { log -> onLog?.invoke(log.message) },
+      )
+      onSessionCreated?.invoke(session.sessionId.toDouble())
+    } catch (error: Throwable) {
+      promise.reject(error)
+    }
+
+    return promise
+  }
+
+  override fun getMediaInformation(path: String): Promise<String> {
+    return Promise.async {
+      val session = FFprobeKit.executeWithArguments(
+        arrayOf(
+          "-v",
+          "error",
+          "-print_format",
+          "json",
+          "-show_format",
+          "-show_streams",
+          "-show_chapters",
+          path,
+        ),
+      )
+      val returnCode = session.returnCode
+
+      if (!ReturnCode.isSuccess(returnCode)) {
+        throw IllegalStateException(
+          session.failStackTrace ?: session.output.ifEmpty {
+            "FFprobe failed with return code ${returnCode?.value ?: -1}"
+          },
+        )
+      }
+
+      session.output
+    }
+  }
+
+  override fun cancel(sessionId: Double?) {
+    if (sessionId == null) {
+      FFmpegKit.cancel()
+    } else {
+      require(
+        sessionId.isFinite() &&
+          sessionId > 0 &&
+          sessionId % 1.0 == 0.0 &&
+          sessionId <= 9_007_199_254_740_991.0,
+      ) {
+        "Invalid FFmpeg session ID: $sessionId. Expected a positive safe integer."
+      }
+      FFmpegKit.cancel(sessionId.toLong())
+    }
+  }
+
+  override fun cancelAll() {
+    FFmpegKit.cancel()
+  }
+
+  private fun Session.toResult(): FFmpegSessionResult {
+    val code = returnCode
+    return FFmpegSessionResult(
+      sessionId = sessionId.toDouble(),
+      returnCode = (code?.value ?: -1).toDouble(),
+      success = ReturnCode.isSuccess(code),
+      cancelled = ReturnCode.isCancel(code),
+      state = state.name.lowercase(),
+      durationMs = duration.toDouble(),
+      output = output,
+      failStackTrace = failStackTrace,
+    )
+  }
+}

package/android/src/main/java/com/margelo/nitro/munimffmpeg/NitroMunimFfmpegPackage.kt

@@ -0,0 +1,18 @@
+package com.margelo.nitro.munimffmpeg
+
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.BaseReactPackage
+
+class NitroMunimFfmpegPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
+
+    companion object {
+        init {
+            NitroMunimFfmpegOnLoad.initializeNative()
+        }
+    }
+}

package/app.plugin.js

@@ -0,0 +1,5 @@
+module.exports = function withMunimFfmpeg(config) {
+  return config
+}
+
+module.exports.default = module.exports

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  NitroMunimFfmpeg
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once

package/ios/HybridMunimFfmpeg.swift

@@ -0,0 +1,161 @@
+import NitroModules
+import ffmpegkit
+
+final class HybridMunimFfmpeg: HybridMunimFfmpegSpec {
+  var ffmpegVersion: String {
+    FFmpegKitConfig.getFFmpegVersion()
+  }
+
+  func execute(
+    arguments_: [String],
+    onLog: ((_ message: String) -> Void)?,
+    onStatistics: ((_ timeMs: Double, _ sizeBytes: Double, _ bitrateKbits: Double, _ speed: Double, _ videoFrameNumber: Double, _ fps: Double, _ quality: Double) -> Void)?,
+    onSessionCreated: ((_ sessionId: Double) -> Void)?
+  ) throws -> Promise<FFmpegSessionResult> {
+    let promise = Promise<FFmpegSessionResult>()
+
+    let session = FFmpegKit.execute(
+      withArgumentsAsync: arguments_,
+      withCompleteCallback: { session in
+        guard let session else {
+          promise.reject(withError: MunimFfmpegError.missingSession)
+          return
+        }
+        promise.resolve(withResult: Self.result(from: session))
+      },
+      withLogCallback: { log in
+        guard let message = log?.getMessage() else { return }
+        onLog?(message)
+      },
+      withStatisticsCallback: { statistics in
+        guard let statistics else { return }
+        onStatistics?(
+          statistics.getTime(),
+          Double(statistics.getSize()),
+          statistics.getBitrate(),
+          statistics.getSpeed(),
+          Double(statistics.getVideoFrameNumber()),
+          Double(statistics.getVideoFps()),
+          Double(statistics.getVideoQuality())
+        )
+      }
+    )
+    if let session {
+      onSessionCreated?(Double(session.getId()))
+    }
+
+    return promise
+  }
+
+  func probe(
+    arguments_: [String],
+    onLog: ((_ message: String) -> Void)?,
+    onSessionCreated: ((_ sessionId: Double) -> Void)?
+  ) throws -> Promise<FFmpegSessionResult> {
+    let promise = Promise<FFmpegSessionResult>()
+
+    let session = FFprobeKit.execute(
+      withArgumentsAsync: arguments_,
+      withCompleteCallback: { session in
+        guard let session else {
+          promise.reject(withError: MunimFfmpegError.missingSession)
+          return
+        }
+        promise.resolve(withResult: Self.result(from: session))
+      },
+      withLogCallback: { log in
+        guard let message = log?.getMessage() else { return }
+        onLog?(message)
+      }
+    )
+    if let session {
+      onSessionCreated?(Double(session.getId()))
+    }
+
+    return promise
+  }
+
+  func getMediaInformation(path: String) throws -> Promise<String> {
+    let promise = Promise<String>()
+    let arguments = [
+      "-v",
+      "error",
+      "-print_format",
+      "json",
+      "-show_format",
+      "-show_streams",
+      "-show_chapters",
+      path,
+    ]
+
+    FFprobeKit.execute(
+      withArgumentsAsync: arguments,
+      withCompleteCallback: { session in
+        guard let session else {
+          promise.reject(withError: MunimFfmpegError.missingSession)
+          return
+        }
+        let returnCode = session.getReturnCode()
+        guard ReturnCode.isSuccess(returnCode) else {
+          let message = session.getFailStackTrace() ?? session.getOutput() ?? "FFprobe failed"
+          promise.reject(withError: MunimFfmpegError.executionFailed(message))
+          return
+        }
+        promise.resolve(withResult: session.getOutput() ?? "{}")
+      }
+    )
+
+    return promise
+  }
+
+  func cancel(sessionId: Double?) throws {
+    if let sessionId {
+      guard
+        sessionId.isFinite,
+        sessionId > 0,
+        sessionId.rounded(.towardZero) == sessionId,
+        sessionId <= 9_007_199_254_740_991
+      else {
+        throw MunimFfmpegError.invalidSessionId(sessionId)
+      }
+      FFmpegKit.cancel(Int(sessionId))
+    } else {
+      FFmpegKit.cancel()
+    }
+  }
+
+  func cancelAll() throws {
+    FFmpegKit.cancel()
+  }
+
+  private static func result(from session: Session) -> FFmpegSessionResult {
+    let returnCode = session.getReturnCode()
+    return FFmpegSessionResult(
+      sessionId: Double(session.getId()),
+      returnCode: Double(returnCode?.getValue() ?? -1),
+      success: ReturnCode.isSuccess(returnCode),
+      cancelled: ReturnCode.isCancel(returnCode),
+      state: String(describing: session.getState()).lowercased(),
+      durationMs: Double(session.getDuration()),
+      output: session.getOutput() ?? "",
+      failStackTrace: session.getFailStackTrace()
+    )
+  }
+}
+
+private enum MunimFfmpegError: LocalizedError {
+  case missingSession
+  case executionFailed(String)
+  case invalidSessionId(Double)
+
+  var errorDescription: String? {
+    switch self {
+    case .missingSession:
+      return "FFmpegKit did not return a session."
+    case .executionFailed(let message):
+      return message
+    case .invalidSessionId(let sessionId):
+      return "Invalid FFmpeg session ID: \(sessionId). Expected a positive safe integer."
+    }
+  }
+}

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+import type { FFmpegLogCallback, FFmpegSessionResult, FFmpegSessionCreatedCallback, FFmpegStatisticsCallback, MunimFfmpeg as MunimFfmpegSpec } from './specs/MunimFfmpeg.nitro';
+declare const MunimFfmpeg: MunimFfmpegSpec;
+export type { FFmpegLogCallback, FFmpegSessionResult, FFmpegSessionCreatedCallback, FFmpegStatisticsCallback, MunimFfmpegSpec, };
+export declare function execute(arguments_: string[], onLog?: FFmpegLogCallback, onStatistics?: FFmpegStatisticsCallback, onSessionCreated?: FFmpegSessionCreatedCallback): Promise<FFmpegSessionResult>;
+export declare function probe(arguments_: string[], onLog?: FFmpegLogCallback, onSessionCreated?: FFmpegSessionCreatedCallback): Promise<FFmpegSessionResult>;
+export declare function getMediaInformation(path: string): Promise<unknown>;
+export declare function cancel(sessionId?: number): void;
+export declare function cancelAll(): void;
+export declare function getFFmpegVersion(): string;
+export default MunimFfmpeg;

package/lib/index.js

@@ -0,0 +1,21 @@
+import { NitroModules } from 'react-native-nitro-modules';
+const MunimFfmpeg = NitroModules.createHybridObject('MunimFfmpeg');
+export function execute(arguments_, onLog, onStatistics, onSessionCreated) {
+    return MunimFfmpeg.execute(arguments_, onLog, onStatistics, onSessionCreated);
+}
+export function probe(arguments_, onLog, onSessionCreated) {
+    return MunimFfmpeg.probe(arguments_, onLog, onSessionCreated);
+}
+export function getMediaInformation(path) {
+    return MunimFfmpeg.getMediaInformation(path).then((value) => JSON.parse(value));
+}
+export function cancel(sessionId) {
+    MunimFfmpeg.cancel(sessionId);
+}
+export function cancelAll() {
+    MunimFfmpeg.cancelAll();
+}
+export function getFFmpegVersion() {
+    return MunimFfmpeg.ffmpegVersion;
+}
+export default MunimFfmpeg;

package/lib/specs/MunimFfmpeg.nitro.d.ts

@@ -0,0 +1,25 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export type FFmpegSessionResult = {
+    sessionId: number;
+    returnCode: number;
+    success: boolean;
+    cancelled: boolean;
+    state: string;
+    durationMs: number;
+    output: string;
+    failStackTrace?: string;
+};
+export type FFmpegLogCallback = (message: string) => void;
+export type FFmpegSessionCreatedCallback = (sessionId: number) => void;
+export type FFmpegStatisticsCallback = (timeMs: number, sizeBytes: number, bitrateKbits: number, speed: number, videoFrameNumber: number, fps: number, quality: number) => void;
+export interface MunimFfmpeg extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    readonly ffmpegVersion: string;
+    execute(arguments_: string[], onLog?: FFmpegLogCallback, onStatistics?: FFmpegStatisticsCallback, onSessionCreated?: FFmpegSessionCreatedCallback): Promise<FFmpegSessionResult>;
+    probe(arguments_: string[], onLog?: FFmpegLogCallback, onSessionCreated?: FFmpegSessionCreatedCallback): Promise<FFmpegSessionResult>;
+    getMediaInformation(path: string): Promise<string>;
+    cancel(sessionId?: number): void;
+    cancelAll(): void;
+}

package/lib/specs/MunimFfmpeg.nitro.js

@@ -0,0 +1 @@
+export {};

package/nitro.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": [
+    "munimffmpeg"
+  ],
+  "ios": {
+    "iosModuleName": "NitroMunimFfmpeg"
+  },
+  "android": {
+    "androidNamespace": [
+      "munimffmpeg"
+    ],
+    "androidCxxLibName": "NitroMunimFfmpeg"
+  },
+  "autolinking": {
+    "MunimFfmpeg": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridMunimFfmpeg"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridMunimFfmpeg"
+      }
+    }
+  },
+  "ignorePaths": [
+    "**/node_modules"
+  ]
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

package/nitrogen/generated/android/NitroMunimFfmpeg+autolinking.cmake

@@ -0,0 +1,81 @@
+#
+# NitroMunimFfmpeg+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroMunimFfmpeg+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_NITROMUNIMFFMPEG_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  NitroMunimFfmpeg PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/NitroMunimFfmpegOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridMunimFfmpegSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridMunimFfmpegSpec.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  NitroMunimFfmpeg PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        NitroMunimFfmpeg
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        NitroMunimFfmpeg
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        NitroMunimFfmpeg
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/NitroMunimFfmpeg+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// NitroMunimFfmpeg+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/NitroMunimFfmpeg+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 NitroMunimFfmpeg is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/NitroMunimFfmpegOnLoad.cpp

@@ -0,0 +1,60 @@
+///
+/// NitroMunimFfmpegOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_NITROMUNIMFFMPEG_WITH_GENERATED_CMAKE_PROJECT
+#error NitroMunimFfmpegOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "NitroMunimFfmpegOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridMunimFfmpegSpec.hpp"
+#include "JFunc_void_std__string.hpp"
+#include "JFunc_void_double_double_double_double_double_double_double.hpp"
+#include "JFunc_void_double.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::munimffmpeg {
+
+int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::munimffmpeg::registerAllNatives();
+  });
+}
+
+struct JHybridMunimFfmpegSpecImpl: public jni::JavaClass<JHybridMunimFfmpegSpecImpl, JHybridMunimFfmpegSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/munimffmpeg/HybridMunimFfmpeg;";
+  static std::shared_ptr<JHybridMunimFfmpegSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridMunimFfmpegSpecImpl::javaobject()>();
+    jni::local_ref<JHybridMunimFfmpegSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridMunimFfmpegSpec();
+  }
+};
+
+void registerAllNatives() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::munimffmpeg;
+
+  // Register native JNI methods
+  margelo::nitro::munimffmpeg::JHybridMunimFfmpegSpec::CxxPart::registerNatives();
+  margelo::nitro::munimffmpeg::JFunc_void_std__string_cxx::registerNatives();
+  margelo::nitro::munimffmpeg::JFunc_void_double_double_double_double_double_double_double_cxx::registerNatives();
+  margelo::nitro::munimffmpeg::JFunc_void_double_cxx::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MunimFfmpeg",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridMunimFfmpegSpecImpl::create();
+    }
+  );
+}
+
+} // namespace margelo::nitro::munimffmpeg

package/nitrogen/generated/android/NitroMunimFfmpegOnLoad.hpp

@@ -0,0 +1,34 @@
+///
+/// NitroMunimFfmpegOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <functional>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::munimffmpeg {
+
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
+  /**
+   * Register the native (C++) part of NitroMunimFfmpeg, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all NitroMunimFfmpeg HybridObjects
+   *     margelo::nitro::munimffmpeg::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
+   * }
+   * ```
+   */
+  void registerAllNatives();
+
+} // namespace margelo::nitro::munimffmpeg