pixi-effects 0.47.5 → 0.48.0

package/dist/{chunk-LHUIEFMH.js → chunk-GX2WQV4A.js}

@@ -1,11 +1,11 @@
 import { CompositionSequence, maskSourceOf } from './chunk-UI7CEUTP.js';
+import { loadMediabunny } from './chunk-K3XOEC3C.js';
 import { EXPRESSION_NAMES, createTimeline, lengthen, ensureFilterLibrary, checkEase, parseEase, homeDistance, DEFAULT_FOV, random, noise, flattenSvgPath, trimPolylines, rand, DEG, timeRemapOf, contentLength, resolveAt, parseSpring, springDuration, spansMeta } from './chunk-4PYVHLIK.js';
 import { analyzeAudio, fft, resampleThrough, playSpan, measureLoudness } from './chunk-G4PXCV2B.js';
 import { usesAdvancedBlend, enableAdvancedBlend } from './chunk-JBDBICS2.js';
 import { describeLayer } from './chunk-BFRWSV3R.js';
 import { warnUnknownOptions, suggestName } from './chunk-WGRWFQOB.js';
 import { extensions, CullerPlugin, Application, Container, Rectangle, Culler, CanvasTextMetrics, TextStyle, Assets, ExtensionType, Filter, Texture, UniformGroup, GpuProgram, GlProgram, defaultFilterVert, Text, CanvasTextGenerator, CanvasPool } from 'pixi.js';
-import { Output, BufferTarget, CanvasSource, AudioBufferSource, Input, ALL_FORMATS, BlobSource, WavOutputFormat, Conversion, VideoSampleSink, OggOutputFormat, QUALITY_VERY_HIGH, QUALITY_HIGH, QUALITY_MEDIUM, QUALITY_LOW, QUALITY_VERY_LOW, MkvOutputFormat, WebMOutputFormat, MovOutputFormat, Mp4OutputFormat, canEncodeVideo, getFirstEncodableAudioCodec } from 'mediabunny';
 
 // src/core/gpuShare.ts
 function sharedGpuOf(renderer) {
@@ -41,7 +41,8 @@ function ensureLoadersRegistered(audioContext) {
     extension: { type: ExtensionType.LoadParser, name: "pixi-effects-video", priority: 1 },
     test: (url) => /\.(mp4|webm|mov|mkv)$/i.test(url),
     async load(url) {
-      const blob = await fetch(url).then((r) => r.blob());
+      const [M, blob] = await Promise.all([loadMediabunny(), fetch(url).then((r) => r.blob())]);
+      const { Input, BlobSource, ALL_FORMATS, Output, WavOutputFormat, BufferTarget, Conversion, VideoSampleSink } = M;
       const input = new Input({ source: new BlobSource(blob), formats: ALL_FORMATS });
       const videoTrack = await input.getPrimaryVideoTrack();
       if (!videoTrack || !await videoTrack.canDecode()) {
@@ -598,10 +599,10 @@ var AUDIO_PREFERENCE = {
   mkv: ["opus", "vorbis", "aac", "flac", "mp3"],
   ogg: ["opus", "vorbis", "flac"]
 };
-async function chooseAudioCodec(fmt, requested, container, audio, bitrate) {
+async function chooseAudioCodec(M, fmt, requested, container, audio, bitrate) {
   const supported = container.getSupportedAudioCodecs?.();
   const preferred = AUDIO_PREFERENCE[fmt].filter((c) => !supported || supported.includes(c));
-  const canEncode = (list) => getFirstEncodableAudioCodec(list, { numberOfChannels: audio.numberOfChannels ?? 2, sampleRate: audio.sampleRate, bitrate });
+  const canEncode = (list) => M.getFirstEncodableAudioCodec(list, { numberOfChannels: audio.numberOfChannels ?? 2, sampleRate: audio.sampleRate, bitrate });
   if (requested) {
     if (await canEncode([requested])) return requested;
     const alt = await canEncode(preferred.filter((c) => c !== requested));
@@ -614,27 +615,34 @@ async function chooseAudioCodec(fmt, requested, container, audio, bitrate) {
   }
   return chosen;
 }
-var qualityMap = {
-  "very-low": QUALITY_VERY_LOW,
-  "low": QUALITY_LOW,
-  "medium": QUALITY_MEDIUM,
-  "high": QUALITY_HIGH,
-  "very-high": QUALITY_VERY_HIGH
-};
-function bitrateOf(v, fallback) {
+function qualityOf(M, name) {
+  switch (name) {
+    case "very-low":
+      return M.QUALITY_VERY_LOW;
+    case "low":
+      return M.QUALITY_LOW;
+    case "medium":
+      return M.QUALITY_MEDIUM;
+    case "very-high":
+      return M.QUALITY_VERY_HIGH;
+    default:
+      return M.QUALITY_HIGH;
+  }
+}
+function bitrateOf(M, v) {
   const b = parseBitrate(v);
-  return b.bps ?? (b.quality ? qualityMap[b.quality] : fallback);
+  return b.bps ?? qualityOf(M, b.quality ?? "high");
 }
-function makeOutputFormat(name) {
+function makeOutputFormat(M, name) {
   switch (name) {
     case "mp4":
-      return new Mp4OutputFormat({ fastStart: "in-memory" });
+      return new M.Mp4OutputFormat({ fastStart: "in-memory" });
     case "mov":
-      return new MovOutputFormat({ fastStart: "in-memory" });
+      return new M.MovOutputFormat({ fastStart: "in-memory" });
     case "webm":
-      return new WebMOutputFormat();
+      return new M.WebMOutputFormat();
     case "mkv":
-      return new MkvOutputFormat();
+      return new M.MkvOutputFormat();
   }
 }
 function sliceAudio(buffer, fromSec, toSec, fadeIn, fadeOut) {
@@ -649,18 +657,19 @@ async function exportAudioOnly(movie, options, fmt, range2) {
     throw new Error(`pixi-effects: render({ format: '${fmt}' }): this movie has no sound to export (add an audio layer, an sfx or a music score); for the picture use mp4, webm, mov or mkv`);
   }
   if (options.video) console.warn(`pixi-effects: render({ format: '${fmt}' }): video options are ignored, only the sound is written`);
+  const M = await loadMediabunny();
   const audio = range2.partial ? sliceAudio(movie.audioBuffer, range2.fromSec, range2.toSec, range2.fromFrame > 0, range2.toFrame < movie.totalFrames) : movie.audioBuffer;
-  const container = fmt === "wav" ? new WavOutputFormat() : new OggOutputFormat();
+  const container = fmt === "wav" ? new M.WavOutputFormat() : new M.OggOutputFormat();
   let codec;
   if (fmt === "wav") {
     codec = options.audio?.codec ?? "pcm-s16";
     const held = container.getSupportedAudioCodecs();
     if (!held.includes(codec)) throw new Error(`pixi-effects: render({ format: 'wav', audio: { codec: "${codec}" } }): wav holds ${held.join(", ")} (the usual is pcm-s16)`);
   } else {
-    codec = await chooseAudioCodec("ogg", options.audio?.codec, container, audio, bitrateOf(options.audio?.bitrate, QUALITY_HIGH));
+    codec = await chooseAudioCodec(M, "ogg", options.audio?.codec, container, audio, bitrateOf(M, options.audio?.bitrate));
   }
-  const output = new Output({ format: container, target: new BufferTarget() });
-  const source = new AudioBufferSource({ codec, ...fmt === "wav" ? {} : { bitrate: bitrateOf(options.audio?.bitrate, QUALITY_HIGH) } });
+  const output = new M.Output({ format: container, target: new M.BufferTarget() });
+  const source = new M.AudioBufferSource({ codec, ...fmt === "wav" ? {} : { bitrate: bitrateOf(M, options.audio?.bitrate) } });
   output.addAudioTrack(source);
   movie.emit("progress", { progress: 0, frame: range2.fromFrame, totalFrames: movie.totalFrames });
   await output.start();
@@ -678,21 +687,22 @@ async function exportFrames(movie, options = {}) {
   if (!["mp4", "mov", "webm", "mkv"].includes(fmt)) throw new Error(`pixi-effects: render({ format: "${String(fmt)}" }): use mp4, mov, webm, mkv (a picture) or wav, ogg (only the sound)`);
   warnUnknownOptions("movie.render({ video })", options.video, ["codec", "bitrate", "hardware", "keyFrameInterval"]);
   warnUnknownOptions("movie.render({ audio })", options.audio, ["codec", "bitrate"]);
-  const videoBitrate = bitrateOf(eff.bitrate ?? "high", QUALITY_HIGH);
+  const M = await loadMediabunny();
+  const videoBitrate = bitrateOf(M, eff.bitrate ?? "high");
   const opts = {
     format: fmt,
     video: { codec: "", bitrate: videoBitrate },
     audio: {
       codec: options.audio?.codec ?? (fmt === "mp4" || fmt === "mov" ? "aac" : "opus"),
-      bitrate: bitrateOf(options.audio?.bitrate, QUALITY_HIGH)
+      bitrate: bitrateOf(M, options.audio?.bitrate)
     }
   };
-  const container = makeOutputFormat(opts.format);
+  const container = makeOutputFormat(M, opts.format);
   const audio = movie.audioBuffer && range2.partial ? sliceAudio(movie.audioBuffer, range2.fromSec, range2.toSec, range2.fromFrame > 0, range2.toFrame < movie.totalFrames) : movie.audioBuffer;
-  if (audio) opts.audio.codec = await chooseAudioCodec(fmt, options.audio?.codec, container, audio, opts.audio.bitrate);
-  const output = new Output({
+  if (audio) opts.audio.codec = await chooseAudioCodec(M, fmt, options.audio?.codec, container, audio, opts.audio.bitrate);
+  const output = new M.Output({
     format: container,
-    target: new BufferTarget()
+    target: new M.BufferTarget()
   });
   const mb = eff.motionBlur !== void 0 ? resolveMotionBlur(eff.motionBlur, "movie.render()") : movie.motionBlur ?? null;
   const stage = movie.app.canvas;
@@ -704,7 +714,7 @@ async function exportFrames(movie, options = {}) {
     fmt,
     requested: options.video?.codec,
     supported: container.getSupportedVideoCodecs(),
-    canEncode: (c) => canEncodeVideo(c, { width: picture.width, height: picture.height, bitrate: opts.video.bitrate })
+    canEncode: (c) => M.canEncodeVideo(c, { width: picture.width, height: picture.height, bitrate: opts.video.bitrate })
   });
   if (chosen.fellBackFrom) console.warn(`pixi-effects: this browser cannot encode ${chosen.fellBackFrom.toUpperCase()} video, so the ${fmt} carries ${chosen.codec.toUpperCase()} instead (name a codec with render({ video: { codec } }) to choose yourself).`);
   opts.video.codec = chosen.codec;
@@ -712,14 +722,14 @@ async function exportFrames(movie, options = {}) {
   if (hardware !== void 0 && !["no-preference", "prefer-hardware", "prefer-software"].includes(hardware)) {
     throw new Error(`pixi-effects: render({ video: { hardware: "${String(hardware)}" } }): use 'prefer-hardware', 'prefer-software' or 'no-preference'`);
   }
-  const canvasSource = new CanvasSource(picture, {
+  const canvasSource = new M.CanvasSource(picture, {
     codec: opts.video.codec,
     bitrate: opts.video.bitrate,
     ...hardware ? { hardwareAcceleration: hardware } : {}
   });
   output.addVideoTrack(canvasSource, { frameRate: movie.frameRate });
   if (audio) {
-    const audioSource = new AudioBufferSource({
+    const audioSource = new M.AudioBufferSource({
       codec: opts.audio.codec,
       bitrate: opts.audio.bitrate
     }, { startTimestamp: opts.audio.codec === "aac" ? -2112 / audio.sampleRate : 0 });
@@ -5013,5 +5023,5 @@ function withFade(spec, opts) {
 }
 
 export { Movie, animateText, audioEnvelope, bpmEnvelope, cameraPath, computeEnvelope, dismissLoader, failLoader, followPath, kenBurns, measureText, musicBuffer, musicEnvelope, musicEvents, orbit, parseEase2 as parseEase, particles, react, resolveLoader, samplePath, splitText, stagger, wiggle, withFade };
-//# sourceMappingURL=chunk-LHUIEFMH.js.map
-//# sourceMappingURL=chunk-LHUIEFMH.js.map
+//# sourceMappingURL=chunk-GX2WQV4A.js.map
+//# sourceMappingURL=chunk-GX2WQV4A.js.map