@mediabunny/server 1.48.1 → 1.50.0

package/README.md

@@ -12,7 +12,7 @@
 By default, Mediabunny requires a browser environment for full access to decoders, encoders, and video processing features. `@mediabunny/server` uses [NodeAV](https://github.com/seydx/node-av) to polyfill this functionality for server-side environments such as Node, Bun, or Deno, enabling the usage of all Mediabunny features on the server. The result is a server-side media processing API that integrates naturally with TypeScript as opposed to the awkwardness and inefficiencies of calling out to the FFmpeg CLI.
 
 Features added by this package include:
-- Video decoders and encoders for AVC (H.264), HEVC (H.265), VP8, VP9, and AV1. Supports both length-prefixed and Annex B AVC/HEVC as well as transparent video via VP9.
+- Video decoders and encoders for AVC (H.264), HEVC (H.265), VP8, VP9, AV1, and ProRes. Supports both length-prefixed and Annex B AVC/HEVC as well as transparent video via VP9 and ProRes.
 - Audio decoders and encoders for AAC, MP3, Vorbis, Opus, FLAC, AC-3 and E-AC-3. Supports AAC in both AAC and ADTS formats.
 - Video frame transformation support (resize, rotate, crop)
 - Automatic hardware acceleration on all platforms (macOS, Linux, Windows)
@@ -279,6 +279,40 @@ return new VideoSample(pixels, {
 });
 ```
 
+## Controlling logging
+
+Especially in command-line applications you usually don't want Mediabunny interfering with your stdout and stderr output. Mediabunny provides ways to control its console output:
+```ts
+import { Logging, LogLevel } from 'mediabunny';
+
+// The default: Mediabunny can log errors, warnings, and information messages.
+Logging.level = LogLevel.Info;
+
+// Only log warnings and errors.
+Logging.level = LogLevel.Warnings;
+
+// Only log errors.
+Logging.level = LogLevel.Errors;
+
+// Don't log anything at all.
+Logging.level = LogLevel.None;
+```
+
+You can also hook into log events:
+```ts
+Logging.on('error', (args: unknown[]) => {
+	// Handle error message
+});
+
+Logging.on('warn', (args: unknown[]) => {
+	// Handle warning message
+});
+
+Logging.on('info', (args: unknown[]) => {
+	// Handle info message
+});
+```
+
 ## Implementation details
 
 `@mediabunny/server` uses [NodeAV](https://github.com/seydx/node-av) under the hood which provides N-API C bindings to FFmpeg's C API. Using NodeAV, this package implements [custom decoders and encoders](https://mediabunny.dev/guide/supported-formats-and-codecs#custom-coders) by directly using the APIs provided by `libavcodec`.
@@ -287,6 +321,8 @@ For encoding, video frames and audio samples are transferred to FFmpeg by conver
 
 Whenever possible, `AVFrame`s are never copied over to JavaScript unless explicitly needed. This enables zero-copy decode -> transformation -> encode paths.
 
+ProRes decoding support is provided by [TurboRes](https://github.com/Vanilagy/turbores), as it is often faster than FFmpeg.
+
 ## License
 
 `@mediabunny/server` uses the same MPL-2.0 license as Mediabunny.

package/dist/bundles/mediabunny-server.cjs

@@ -65,6 +65,7 @@ var MediabunnyServer = (() => {
     vp8: NodeAv.AV_CODEC_ID_VP8,
     vp9: NodeAv.AV_CODEC_ID_VP9,
     av1: NodeAv.AV_CODEC_ID_AV1,
+    prores: NodeAv.AV_CODEC_ID_PRORES,
     aac: NodeAv.AV_CODEC_ID_AAC,
     opus: NodeAv.AV_CODEC_ID_OPUS,
     mp3: NodeAv.AV_CODEC_ID_MP3,
@@ -380,6 +381,56 @@ var MediabunnyServer = (() => {
     }
   };
 
+  // src/logging.ts
+  var _Logging = class _Logging {
+    constructor() {
+    }
+    /** The current log level. Defaults to {@link LogLevel.Info}. */
+    static get level() {
+      return _Logging._level;
+    }
+    static set level(value) {
+      if (value !== 0 /* Silent */ && value !== 1 /* Errors */ && value !== 2 /* Warnings */ && value !== 3 /* Info */) {
+        throw new TypeError("Invalid log level. Use one of the values of the LogLevel enum.");
+      }
+      _Logging._level = value;
+    }
+    /** @internal */
+    static get _emitter() {
+      return _Logging._emitterInstance ??= new EventEmitter();
+    }
+    /** Registers a listener for a log event. Returns a function that, when called, removes the listener again. */
+    static on(event, listener, options) {
+      return _Logging._emitter.on(event, listener, options);
+    }
+    /** @internal */
+    static _error(...args) {
+      _Logging._emitter._emit("error", args);
+      if (_Logging._level >= 1 /* Errors */) {
+        console.error(...args);
+      }
+    }
+    /** @internal */
+    static _warn(...args) {
+      _Logging._emitter._emit("warn", args);
+      if (_Logging._level >= 2 /* Warnings */) {
+        console.warn(...args);
+      }
+    }
+    /** @internal */
+    static _info(...args) {
+      _Logging._emitter._emit("info", args);
+      if (_Logging._level >= 3 /* Info */) {
+        console.info(...args);
+      }
+    }
+  };
+  /** @internal */
+  _Logging._level = 3 /* Info */;
+  /** @internal */
+  _Logging._emitterInstance = null;
+  var Logging = _Logging;
+
   // src/misc.ts
   function assert(x) {
     if (!x) {
@@ -487,6 +538,9 @@ var MediabunnyServer = (() => {
     }
     return ans;
   };
+  var assertNever = (x) => {
+    throw new Error(`Unexpected value: ${x}`);
+  };
   var SECOND_TO_MICROSECOND_FACTOR = 1e6 * (1 + Number.EPSILON);
   var simplifyRational = (rational) => {
     assert(Number.isInteger(rational.num));
@@ -505,6 +559,41 @@ var MediabunnyServer = (() => {
       den: rational.den / gcd
     };
   };
+  var EventEmitter = class {
+    constructor() {
+      /** @internal */
+      this._listeners = /* @__PURE__ */ new Map();
+    }
+    /** Registers a listener for the given event. Returns a function that, when called, removes the listener again. */
+    on(event, listener, options) {
+      if (!this._listeners.has(event)) {
+        this._listeners.set(event, /* @__PURE__ */ new Set());
+      }
+      const entry = { fn: listener, once: options?.once ?? false };
+      this._listeners.get(event).add(entry);
+      return () => {
+        this._listeners.get(event)?.delete(entry);
+      };
+    }
+    /** @internal */
+    _emit(...args) {
+      const [event, data] = args;
+      const listeners = this._listeners.get(event);
+      if (!listeners) {
+        return;
+      }
+      for (const entry of listeners) {
+        try {
+          entry.fn(data);
+        } catch (error) {
+          console.error(error);
+        }
+        if (entry.once) {
+          listeners.delete(entry);
+        }
+      }
+    }
+  };
 
   // packages/server/src/video-sample.ts
   var import_mediabunny = __require("mediabunny");
@@ -1101,8 +1190,31 @@ var MediabunnyServer = (() => {
   ];
   var VP9_DEFAULT_SUFFIX = ".01.01.01.01.00";
   var AV1_DEFAULT_SUFFIX = ".0.110.01.01.01.0";
+  var PRORES_FOURCCS = [
+    "ap4x",
+    // ProRes 4444 XQ
+    "ap4h",
+    // ProRes 4444
+    "apch",
+    // ProRes 422 High Quality
+    "apcn",
+    // ProRes 422 Standard Definition
+    "apcs",
+    // ProRes 422 LT
+    "apco"
+    // ProRes 422 Proxy
+  ];
   var extractVideoCodecString = (trackInfo) => {
-    const { codec, codecDescription, colorSpace, avcCodecInfo, hevcCodecInfo, vp9CodecInfo, av1CodecInfo } = trackInfo;
+    const {
+      codec,
+      codecDescription,
+      colorSpace,
+      avcCodecInfo,
+      hevcCodecInfo,
+      vp9CodecInfo,
+      av1CodecInfo,
+      proresFormat
+    } = trackInfo;
     if (codec === "avc") {
       assert(trackInfo.avcType !== null);
       if (avcCodecInfo) {
@@ -1222,9 +1334,14 @@ var MediabunnyServer = (() => {
         string = string.slice(0, -AV1_DEFAULT_SUFFIX.length);
       }
       return string;
+    } else if (codec === "prores") {
+      return proresFormat ?? "apch";
+    } else if (codec !== null) {
+      assertNever(codec);
     }
     throw new TypeError(`Unhandled codec '${codec}'.`);
   };
+  var VALID_VIDEO_CODEC_STRING_PREFIXES = ["avc1", "avc3", "hev1", "hvc1", "vp8", "vp09", "av01", ...PRORES_FOURCCS];
 
   // src/codec-data.ts
   var iterateNalUnitsInAnnexB = function* (packetData) {
@@ -1320,7 +1437,7 @@ var MediabunnyServer = (() => {
         sequenceParameterSetExt: hasExtendedData ? spsExtUnits : null
       };
     } catch (error) {
-      console.error("Error building AVC Decoder Configuration Record:", error);
+      Logging._error("Error building AVC Decoder Configuration Record:", error);
       return null;
     }
   };
@@ -1594,7 +1711,7 @@ var MediabunnyServer = (() => {
         maxDecFrameBuffering
       };
     } catch (error) {
-      console.error("Error parsing AVC SPS:", error);
+      Logging._error("Error parsing AVC SPS:", error);
       return null;
     }
   };
@@ -1738,7 +1855,7 @@ var MediabunnyServer = (() => {
         minSpatialSegmentationIdc
       };
     } catch (error) {
-      console.error("Error parsing HEVC SPS:", error);
+      Logging._error("Error parsing HEVC SPS:", error);
       return null;
     }
   };
@@ -1849,7 +1966,7 @@ var MediabunnyServer = (() => {
       };
       return record;
     } catch (error) {
-      console.error("Error building HEVC Decoder Configuration Record:", error);
+      Logging._error("Error building HEVC Decoder Configuration Record:", error);
       return null;
     }
   };
@@ -2523,6 +2640,14 @@ var MediabunnyServer = (() => {
   var EAC3_REGISTRATION_DESCRIPTOR = new Uint8Array([5, 4, 69, 65, 67, 51]);
 
   // packages/server/src/video-encoder.ts
+  var PRORES_FOURCC_TO_PROFILE = {
+    apco: NodeAv4.AV_PROFILE_PRORES_PROXY,
+    apcs: NodeAv4.AV_PROFILE_PRORES_LT,
+    apcn: NodeAv4.AV_PROFILE_PRORES_STANDARD,
+    apch: NodeAv4.AV_PROFILE_PRORES_HQ,
+    ap4h: NodeAv4.AV_PROFILE_PRORES_4444,
+    ap4x: NodeAv4.AV_PROFILE_PRORES_XQ
+  };
   var NodeAvVideoEncoder = class extends import_mediabunny3.CustomVideoEncoder {
     constructor() {
       super(...arguments);
@@ -2536,7 +2661,7 @@ var MediabunnyServer = (() => {
       this.preciseTimings = [];
     }
     static supports(codec, config) {
-      return (codec === "avc" || codec === "hevc" || codec === "vp8" || codec === "vp9" || codec === "av1") && config.bitrateMode !== "quantizer";
+      return (codec === "avc" || codec === "hevc" || codec === "vp8" || codec === "vp9" || codec === "av1" || codec === "prores") && config.bitrateMode !== "quantizer";
     }
     async init() {
       this.frame = new NodeAv4.Frame();
@@ -2546,13 +2671,22 @@ var MediabunnyServer = (() => {
       this.packet.alloc();
       const codecId = CODEC_TO_CODEC_ID[this.codec];
       assert(codecId !== void 0);
+      const getSoftwareCodec = () => {
+        if (this.codec === "prores") {
+          const proresKs = NodeAv4.Codec.findEncoderByName(NodeAv4.FF_ENCODER_PRORES_KS);
+          if (proresKs) {
+            return proresKs;
+          }
+        }
+        return NodeAv4.Codec.findEncoder(codecId);
+      };
       let codec = null;
       if (this.codec === "vp9" && this.config.alpha === "keep") {
         codec = NodeAv4.Codec.findEncoderByName(NodeAv4.FF_ENCODER_LIBVPX_VP9) ?? NodeAv4.Codec.findEncoder(codecId);
       } else if (this.config.hardwareAcceleration === "prefer-software") {
-        codec = NodeAv4.Codec.findEncoder(codecId);
+        codec = getSoftwareCodec();
       } else {
-        codec = await getHardwareEncoderCodec(codecId) ?? NodeAv4.Codec.findEncoder(codecId);
+        codec = await getHardwareEncoderCodec(codecId) ?? getSoftwareCodec();
       }
       if (!codec) {
         throw new Error(`Unable to obtain libav codec for '${this.codec}'.`);
@@ -2569,8 +2703,15 @@ var MediabunnyServer = (() => {
         if (!this.avCodec.pixelFormats.includes(NodeAv4.AV_PIX_FMT_YUV420P)) {
           pixelFormat = this.avCodec.pixelFormats[0];
         }
-        if (this.config.alpha === "keep" && this.avCodec.pixelFormats.includes(NodeAv4.AV_PIX_FMT_YUVA420P)) {
-          pixelFormat = NodeAv4.AV_PIX_FMT_YUVA420P;
+        if (this.config.alpha === "keep") {
+          if (this.avCodec.pixelFormats.includes(NodeAv4.AV_PIX_FMT_YUVA420P)) {
+            pixelFormat = NodeAv4.AV_PIX_FMT_YUVA420P;
+          } else {
+            pixelFormat = NodeAv4.avcodecFindBestPixFmtOfList(
+              this.avCodec.pixelFormats,
+              NodeAv4.AV_PIX_FMT_YUVA444P12LE
+            );
+          }
         }
       }
       const pixelAspectRatio = simplifyRational({
@@ -2623,6 +2764,11 @@ var MediabunnyServer = (() => {
           codecContext.setOption("preset", "12");
         }
       }
+      if (this.codec === "prores") {
+        const profile = PRORES_FOURCC_TO_PROFILE[this.config.codec];
+        assert(profile !== void 0);
+        codecContext.setOption("profile", String(profile));
+      }
       const ret = await codecContext.open2();
       NodeAv4.FFmpegError.throwIfError(ret, "Open codec context");
       this.codecContext = codecContext;
@@ -2773,7 +2919,8 @@ var MediabunnyServer = (() => {
             avcCodecInfo: null,
             hevcCodecInfo: null,
             vp9CodecInfo: null,
-            av1CodecInfo: null
+            av1CodecInfo: null,
+            proresFormat: null
           });
           if (!expectsAnnexB) {
             decoderConfigDescription = serializedRecord;
@@ -2826,7 +2973,8 @@ var MediabunnyServer = (() => {
             avcCodecInfo: null,
             hevcCodecInfo: null,
             vp9CodecInfo: null,
-            av1CodecInfo: null
+            av1CodecInfo: null,
+            proresFormat: null
           });
         }
       } else if (this.codec === "vp9") {
@@ -2842,7 +2990,8 @@ var MediabunnyServer = (() => {
             avcCodecInfo: null,
             hevcCodecInfo: null,
             vp9CodecInfo,
-            av1CodecInfo: null
+            av1CodecInfo: null,
+            proresFormat: null
           });
         }
       } else if (this.codec === "av1") {
@@ -2858,7 +3007,24 @@ var MediabunnyServer = (() => {
             avcCodecInfo: null,
             hevcCodecInfo: null,
             vp9CodecInfo: null,
-            av1CodecInfo
+            av1CodecInfo,
+            proresFormat: null
+          });
+        }
+      } else if (this.codec === "prores") {
+        if (!this.packetEmitted) {
+          decoderConfigCodecString = extractVideoCodecString({
+            width: this.config.width,
+            height: this.config.height,
+            codec: "prores",
+            codecDescription: null,
+            colorSpace: null,
+            avcType: null,
+            avcCodecInfo: null,
+            hevcCodecInfo: null,
+            vp9CodecInfo: null,
+            av1CodecInfo: null,
+            proresFormat: this.config.codec
           });
         }
       } else {
@@ -3348,9 +3514,10 @@ var MediabunnyServer = (() => {
   };
 
   // packages/server/src/index.ts
+  var import_prores = __require("@mediabunny/prores");
   var SERVER_LOADED_SYMBOL = Symbol.for("@mediabunny/server loaded");
   if (globalThis[SERVER_LOADED_SYMBOL]) {
-    console.error(
+    import_mediabunny7.Logging._error(
       "[WARNING]\n@mediabunny/server was loaded twice. This will likely cause the package not to work correctly. Check if multiple dependencies are importing different versions of @mediabunny/server, or if something is being bundled incorrectly."
     );
   }
@@ -3373,6 +3540,7 @@ var MediabunnyServer = (() => {
     _serverOptions = options;
     NodeAv8.Log.setLevel(NodeAv8.AV_LOG_ERROR);
     (0, import_mediabunny7.registerDecoder)(NodeAvVideoDecoder);
+    (0, import_prores.registerProresDecoder)();
     (0, import_mediabunny7.registerEncoder)(NodeAvVideoEncoder);
     (0, import_mediabunny7.registerDecoder)(NodeAvAudioDecoder);
     (0, import_mediabunny7.registerEncoder)(NodeAvAudioEncoder);