@@ -1,3 +1,4 @@
+// Downloads the @ffmpeg packages from npm into public/assets.
 const tar = require("tar");
 const fs = require("fs");
 
@@ -7,17 +8,14 @@ const ROOT = "public/assets";
 const FFMPEG_VERSION = "0.12.15";
 const UTIL_VERSION = "0.12.2";
 const CORE_VERSION = "0.12.10";
-const CORE_MT_VERSION = "0.12.10";
 
 const FFMPEG_TGZ = `ffmpeg-${FFMPEG_VERSION}.tgz`;
 const UTIL_TGZ = `util-${UTIL_VERSION}.tgz`;
 const CORE_TGZ = `core-${CORE_VERSION}.tgz`;
-const CORE_MT_TGZ = `core-mt-${CORE_MT_VERSION}.tgz`;
 
 const FFMPEG_TGZ_URL = `${NPM_URL}/@ffmpeg/ffmpeg/-/${FFMPEG_TGZ}`;
 const UTIL_TGZ_URL = `${NPM_URL}/@ffmpeg/util/-/${UTIL_TGZ}`;
 const CORE_TGZ_URL = `${NPM_URL}/@ffmpeg/core/-/${CORE_TGZ}`;
-const CORE_MT_TGZ_URL = `${NPM_URL}/@ffmpeg/core-mt/-/${CORE_MT_TGZ}`;
 
 const mkdir = (dir) => {
   !fs.existsSync(dir) && fs.mkdirSync(dir);
@@ -42,4 +40,3 @@ mkdir(ROOT);
 downloadAndUntar(FFMPEG_TGZ_URL, FFMPEG_TGZ, "ffmpeg");
 downloadAndUntar(UTIL_TGZ_URL, UTIL_TGZ, "util");
 downloadAndUntar(CORE_TGZ_URL, CORE_TGZ, "core");
-downloadAndUntar(CORE_MT_TGZ_URL, CORE_MT_TGZ, "core-mt");
@@ -4,7 +4,7 @@
   "description": "browser example",
   "private": true,
   "scripts": {
-    "download": "node ../../scripts/download-assets.cjs",
+    "download": "node download-assets.cjs",
     "prestart": "pnpm download",
     "start": "node server.js"
   },
 
@@ -20,21 +20,27 @@ A native `ffmpeg` binary is still faster if you can ship one.
 
 ### Why ffmpeg.wasm is so slow comparing to ffmpeg?
 
-As of now, WebAssembly is still a lot slower than native, it is possible to further speed up using
-WebAssembly intrinsic, which is basically writing assembly code. It is something we are investigating
-and hope to introduce in the future.
+WebAssembly runs FFmpeg's C code without its hand-written assembly, and
+SIMD is limited to 128 bits, so encoding is several times slower than native.
+Decoding and remuxing are closer. `pnpm bench` in the repository
+measures common jobs against native FFmpeg on your machine.
 
-Since 0.13, @ffmpeg/core runs FFmpeg's multi-threaded pipeline, which is
-faster than the single-thread core of 0.12.
+To speed things up:
+- Use a faster preset: `-preset ultrafast` for x264, `-deadline realtime` for VP9.
+- Remux with `-c copy` when you don't need to re-encode.
+- Mount large inputs with `WORKERFS` instead of copying them with `writeFile()`.
+- On machines with many cores, `load({ threads: 8 })` lets codecs use more threads.
 
 ### Is RTSP supported by ffmpeg.wasm?
 
-We are trying to support, but so far WebAssembly itself lack of features like sockets which makes
-it hard to implement RTSP protocol. Possible workarounds are still under investigation.
+No. Browsers don't give WebAssembly raw TCP/UDP sockets, so ffmpeg.wasm is
+built without network protocols (RTSP, RTMP, HTTP). Fetch inputs in
+JavaScript and write them to the file system, or use WebRTC/MediaRecorder for
+live streams.
 
 ### What is the license of ffmpeg.wasm?
 
-There are two components inside ffmpeg.wasm:
+The JavaScript packages are MIT; `@ffmpeg/core` is GPL-2.0-or-later. There are two components inside ffmpeg.wasm:
 
 - @ffmpeg/ffmpeg (https://github.com/ffmpegwasm/ffmpeg.wasm/packages/ffmpeg)
 - @ffmpeg/core (https://github.com/ffmpegwasm/ffmpeg.wasm/packages/core)
@@ -45,7 +51,30 @@ There are two components inside ffmpeg.wasm:
 
 ### What is the maximum size of input file?
 
-2 GB, which is a hard limit in WebAssembly. Might become 4 GB in the future.
+Files written with `writeFile()` live in JavaScript memory, outside the
+WebAssembly heap, so they can be larger than 2 GB if the browser allows it.
+For big inputs, `mount("WORKERFS", { files: [file] }, "/input")` avoids
+copying them at all. FFmpeg's own memory can grow to 4 GB, the limit of 32-bit
+WebAssembly.
+
+`WORKERFS` mounts are read-only: write outputs outside the mount point.
+
+### Why are all log messages of type `stderr`?
+
+FFmpeg writes its log (banner, progress, warnings) to stderr, like the
+native `ffmpeg`. Only a few outputs, such as `ffprobe` results without `-o`,
+go to stdout.
+
+### Why do raw frames differ slightly from native FFmpeg?
+
+The WebAssembly build uses swscale's C code paths, while native FFmpeg uses
+assembly with slightly different rounding. For output closer to native, add
+`-sws_flags accurate_rnd+bitexact`.
+
+### How do I decode a WebM video with transparency?
+
+FFmpeg's built-in VP8/VP9 decoders drop the alpha channel. Ask for the
+libvpx decoder before the input: `["-c:v", "libvpx-vp9", "-i", "input.webm", ...]`.
 
 ### How can I build my own ffmpeg.wasm?
 
 
@@ -14,11 +14,19 @@ import "ace-builds/src-noconflict/mode-text";
 import "ace-builds/src-noconflict/theme-dracula";
 import "ace-builds/src-noconflict/theme-github";
 
-const genFFmpegText = (args: string) => {
-  let data: any = [];
+// The arguments as a list of strings, or [] while the JSON is incomplete or not
+// such a list (#791, #872).
+export const parseArgs = (args: string): string[] => {
   try {
-    data = JSON.parse(args);
-  } catch (e) {}
+    const data: unknown = JSON.parse(args);
+    return Array.isArray(data) && data.every((a) => typeof a === "string") ? data : [];
+  } catch {
+    return [];
+  }
+};
+
+const genFFmpegText = (args: string) => {
+  const data = parseArgs(args);
   return `// equivalent ffmpeg.wasm API call
 ffmpeg.exec(${JSON.stringify(data)});
 
 
@@ -12,7 +12,7 @@ import { downloadFile } from "@site/src/util";
 import { Node } from "./types";
 import FileSystemManager from "./FileSystemManager";
 import { SAMPLE_FILES } from "../const";
-import Editor from "./Editor";
+import Editor, { parseArgs } from "./Editor";
 
 const defaultArgs = JSON.stringify(["-i", "video.webm", "video.mp4"], null, 2);
 
@@ -136,7 +136,7 @@ export default function Workspace({ ffmpeg: _ffmpeg }: WorkspaceProps) {
     ffmpeg.on("log", logListener);
     ffmpeg.on("progress", progListener);
     const start = performance.now();
-    await ffmpeg.exec(JSON.parse(args));
+    await ffmpeg.exec(parseArgs(args));
     setTime(performance.now() - start);
     ffmpeg.off("log", logListener);
     ffmpeg.off("progress", progListener);
 
@@ -107,6 +107,17 @@ await test("playground: loads the core and runs the default command", async (pag
   await workspace.getByText("video.mp4", { exact: true }).waitFor();
 });
 
+await test("playground: survives arguments that aren't a list of strings (#791, #872)", async (page) => {
+  await page.goto(`${url}/playground`);
+  const editor = page.getByTestId("playground").locator("#input-args textarea");
+  for (const args of ["", "{", '["-i", {"toString": "1"}]', "42"]) {
+    await editor.focus();
+    await page.keyboard.press("ControlOrMeta+A");
+    await page.keyboard.insertText(args);
+    await page.getByTestId("playground").getByText("ffmpeg.exec([]);").waitFor();
+  }
+});
+
 await browser.close();
 server.close();
 process.exit(failures ? 1 : 0);