Convert SWF to MOD — Free Online Tool
Convert SWF (Shockwave Flash) files to MOD format by decoding Flash video content — typically encoded with FLV1 or MJPEG — and re-encoding it into H.264 video with AAC audio inside an MPEG-PS-based container compatible with JVC and Panasonic camcorder workflows. This is especially useful for archiving or editing legacy Flash animations and video content in a format recognized by older video editing suites.
to
FFmpeg Command
Copy this command to run the same conversion locally with FFmpeg on your desktop. Download FFmpeg
Drop your SWF file here
or click to browse
Free — no uploads, no signups. Your files never leave your browser.
Settings
Note: Browser-based encoding uses approximate quality targets. For precise CRF compression, copy the FFmpeg command above and run it on your desktop.
Estimated output:
Conversion Complete!
DownloadHow It Works
SWF files package vector animations, interactive elements, and video streams (most commonly encoded with the FLV1/Sorenson Spark codec or MJPEG) along with MP3 or AAC audio. During this conversion, FFmpeg demuxes the SWF container to extract the raw video and audio streams, then fully re-encodes the video using the libx264 H.264 encoder — since FLV1 is not compatible with the MOD container — and transcodes the audio to AAC. The result is written into a MOD file, which is structurally an MPEG-PS container. Because both the video and audio must be re-encoded (not remuxed), this is a full transcode operation, and the CRF quality setting directly controls the output video fidelity.
What Each Flag Does
| Flag | What it does |
|---|---|
ffmpeg
|
Invokes the FFmpeg binary — the open-source multimedia processing engine running here as FFmpeg.wasm compiled to WebAssembly, executing entirely inside your browser without uploading your SWF file to any server. |
-i input.swf
|
Specifies the input file — in this case a .swf file. FFmpeg's SWF demuxer will parse the Flash container and extract any embedded video (typically FLV1 or MJPEG) and audio (MP3 or AAC) streams for re-encoding. |
-c:v libx264
|
Sets the video encoder to libx264, which produces H.264-encoded video. This is necessary because the FLV1 codec native to SWF is incompatible with the MOD/MPEG-PS container, requiring a full video transcode rather than a stream copy. |
-c:a aac
|
Sets the audio encoder to AAC, transcoding whatever audio was in the SWF (commonly MP3 via libmp3lame) into AAC, which is the default audio codec for this MOD output and provides good quality at the 128k bitrate used. |
-crf 23
|
Sets the Constant Rate Factor for libx264 to 23, the default value that balances file size and visual quality. Lower values (e.g., 18) produce higher-quality output for detail-rich Flash animations; higher values (e.g., 28) reduce file size when quality is less critical. |
-b:a 128k
|
Sets the AAC audio output bitrate to 128 kilobits per second, which is sufficient for voice-over and music tracks typical in Flash content. Increase to 192k or 256k if the source SWF contained high-fidelity stereo audio. |
output.mod
|
Defines the output filename with the .mod extension, signalling to FFmpeg to write an MPEG-PS-based container as used by JVC and Panasonic camcorders, wrapping the newly encoded H.264 video and AAC audio streams. |
Common Use Cases
- Archiving legacy Flash animations or educational content from the pre-HTML5 era into a format that can be ingested by video editing software that supports MPEG-PS-based MOD files
- Importing converted Flash video content into older JVC or Panasonic camcorder editing suites that expect MOD-format footage alongside native camcorder clips
- Recovering and repurposing video content embedded in SWF files — such as product demos or training videos — for use in broadcast or post-production pipelines that still handle MOD
- Batch-converting a library of archived SWF-based web videos to MOD so they can be catalogued and played back on hardware media players that support MPEG-2-era formats
- Extracting and re-encoding Flash-based animated content into a frame-accurate format for frame-by-frame review in editing tools that import MOD natively
Frequently Asked Questions
No — MOD is a purely passive video format and cannot carry any of the interactivity, scripting, or vector animation logic embedded in the SWF. FFmpeg renders only the video and audio streams it can decode from the SWF container; ActionScript, button behaviours, and vector graphics that are not rasterized into a video stream will not appear in the output. Only SWF content that has an actual encoded video track (FLV1 or MJPEG) will produce meaningful MOD output.
SWF files often use vector graphics that scale without quality loss, but FFmpeg must rasterize the content at a fixed resolution before encoding to H.264. If the source SWF has no embedded raster video track and FFmpeg is interpreting the vector content, the output resolution may be low. Additionally, the default CRF value of 23 introduces some compression; lowering CRF (e.g., to 18) will improve sharpness at the cost of a larger file.
Change the -crf value in the command. The CRF (Constant Rate Factor) scale for libx264 runs from 0 (lossless) to 51 (worst quality), with 23 as the default. For higher quality output, use a lower number such as -crf 18. For a smaller file where quality is less critical, increase it to -crf 28. You can also change the audio bitrate by replacing -b:a 128k with values like -b:a 192k or -b:a 256k for better audio fidelity.
Yes, using a shell loop. On Linux or macOS, run: for f in *.swf; do ffmpeg -i "$f" -c:v libx264 -c:a aac -crf 23 -b:a 128k "${f%.swf}.mod"; done. On Windows Command Prompt: for %f in (*.swf) do ffmpeg -i "%f" -c:v libx264 -c:a aac -crf 23 -b:a 128k "%~nf.mod". This processes each SWF in the current directory sequentially and names the MOD output to match.
SWF files store animations as compact vector instructions rather than rasterized video frames, which makes them extremely small relative to the visual content they represent. Converting to MOD requires rasterizing every frame and encoding it as H.264 video in a full MPEG-PS container, which is inherently much larger. This size increase is expected and is not a sign of an error. Raising the CRF value (e.g., -crf 28 or -crf 35) can reduce the output file size at the cost of some visual quality.
Virtually none. SWF metadata (such as author tags or frame rate annotations) is not standardised in a way that FFmpeg maps to MPEG-PS container metadata. The MOD output will have standard MPEG-PS stream properties like video frame rate and audio sample rate derived from the decoded SWF streams, but descriptive metadata tags embedded in the SWF are discarded during the transcode.
Technical Notes
SWF-to-MOD conversion involves two distinct challenges: demuxing a Flash container that may contain vector-rendered content rather than a conventional raster video stream, and writing output into an MPEG-PS-based container (MOD) that JVC and Panasonic camcorders originally produced. FFmpeg's SWF demuxer works best when the SWF contains an actual embedded video track encoded with FLV1 (Sorenson Spark) or MJPEG; pure ActionScript-driven or vector-only SWF files may produce no output or very limited results. The libx264 encoder is used because it produces H.264 video that is far more widely compatible with editing software than the MPEG-2 video that native MOD files contain — the MOD container extension is used here as a wrapper rather than a strict adherence to the camcorder MPEG-2 specification. Because SWF does not support transparency in its video stream layer, and MOD equally has no alpha channel support, there is no transparency loss to worry about. Neither format supports subtitle tracks or chapter markers, so no ancillary data is at risk of being dropped. The CRF-based encoding of libx264 ensures consistent visual quality across scenes, which is preferable to a fixed bitrate when the source material includes both high-motion video segments and static animation frames typical of Flash content.