Convert SWF to MTS — Free Online Tool
Convert SWF Flash animations and video content to MTS (AVCHD) format, re-encoding the FLV1 or MJPEG video stream to H.264 and the MP3 audio to AAC — producing a broadcast-compatible MPEG-2 Transport Stream file suitable for camcorder workflows and professional video editing pipelines.
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 typically contain video encoded with the FLV1 (Sorenson Spark) or MJPEG codec alongside MP3 audio, wrapped in Adobe's proprietary Flash container. Since MTS (AVCHD) requires H.264 video and AAC audio inside an MPEG-2 Transport Stream, this conversion cannot simply remux the existing streams — both the video and audio must be fully re-encoded. FFmpeg decodes the SWF's video and audio streams, then re-encodes the video using the libx264 H.264 encoder at CRF 23 (a balanced quality-to-file-size tradeoff) and the audio using the AAC encoder at 128k bitrate. The resulting .mts file conforms to the AVCHD standard structure, making it importable into professional NLEs like Premiere Pro and Final Cut Pro that recognize the AVCHD transport stream format.
What Each Flag Does
| Flag | What it does |
|---|---|
ffmpeg
|
Invokes the FFmpeg program, the open-source multimedia processing engine that handles decoding the SWF container and re-encoding its streams into the MTS/AVCHD output format. |
-i input.swf
|
Specifies the input SWF file. FFmpeg's SWF demuxer reads the Flash container and extracts the embedded video stream (typically FLV1/Sorenson Spark or MJPEG) and audio stream (typically MP3) for re-encoding. |
-c:v libx264
|
Selects the libx264 encoder to re-encode the SWF's video stream (FLV1 or MJPEG) into H.264, the video codec required by the AVCHD/MTS standard and expected by professional NLEs when importing MTS files. |
-c:a aac
|
Selects FFmpeg's built-in AAC encoder to transcode the SWF's embedded MP3 audio into AAC, which is the standard audio codec for AVCHD MTS files and offers better compression efficiency than the source MP3. |
-crf 23
|
Sets the Constant Rate Factor for the H.264 encoder to 23, a balanced default that delivers visually good quality for typical SWF animation and video content without producing unnecessarily large MTS files. Lower values (e.g., 18) increase quality and file size; higher values (e.g., 28) reduce both. |
-b:a 128k
|
Sets the AAC audio bitrate to 128 kilobits per second, a standard quality level that matches the typical fidelity ceiling of MP3 audio embedded in SWF files — increasing this beyond 192k would not recover quality lost in the original SWF's audio encoding. |
output.mts
|
Specifies the output filename with the .mts extension, which causes FFmpeg to write an MPEG-2 Transport Stream container formatted to the AVCHD standard, containing the newly encoded H.264 video and AAC audio streams. |
Common Use Cases
- Archiving legacy Flash-based corporate training videos or e-learning animations into a broadcast-compatible format before SWF support disappears entirely from modern systems
- Importing Flash animation content into Sony or Panasonic AVCHD-based camcorder editing workflows that expect native MTS footage
- Bringing old SWF product demo or promotional videos into a professional video editing pipeline (Premiere Pro, DaVinci Resolve) that handles MTS/AVCHD natively
- Converting Flash-based animated content to MTS so it can be ingested into broadcast playout systems that accept MPEG-2 Transport Stream input
- Preserving animated SWF web content as a high-quality H.264 MTS file for long-term archival, since Flash is no longer supported by modern browsers or operating systems
- Standardizing a mixed library of legacy web video assets — including SWF files — into a single MTS format for unified storage and editing in a camcorder footage archive
Frequently Asked Questions
Yes, some quality loss is inevitable because this conversion requires full re-encoding of both streams. The SWF's FLV1 or MJPEG video is decoded and re-encoded to H.264, and the MP3 audio is decoded and re-encoded to AAC — this is a lossy-to-lossy transcode. However, the default CRF 23 setting for H.264 produces visually very good results for most content. Animated vector-style SWF content may show slight softening in fine line detail after re-encoding, but for most archival or editing purposes the output quality is more than adequate.
SWF files often contain vector graphics and animation instructions rather than raw pixel video, which makes them very compact. When FFmpeg rasterizes and re-encodes this content to H.264 inside an MTS container, the output size depends heavily on the video's resolution, motion complexity, and the CRF value used. Highly animated or complex SWF content can produce a significantly larger MTS file because H.264 is encoding full raster frames rather than compact vector instructions. Conversely, SWFs that contain pre-encoded FLV1 video may produce similar or smaller MTS files due to H.264's superior compression efficiency.
In most cases, yes. The MTS output uses H.264 video and AAC audio inside an MPEG-2 Transport Stream, which matches the AVCHD standard that Sony Vegas, Adobe Premiere Pro, and Final Cut Pro are designed to handle. However, metadata fields that native camcorder MTS files carry — such as shooting date, GPS coordinates, or camera model — will be absent from an SWF-converted MTS file, since that information simply doesn't exist in the source Flash file. The video and audio content will import and play correctly.
No. SWF files can contain ActionScript-driven interactivity, clickable elements, and vector animation timelines — none of this is preserved in the MTS output. FFmpeg renders only the visible video and audible audio output of the SWF's playback, and encodes that rasterized result into the MTS container. The MTS format is a linear video format with no capacity for interactivity or scripting.
The video quality is controlled by the -crf flag, which accepts values from 0 (lossless, very large file) to 51 (heavily compressed, low quality). The default is 23. To improve quality for SWF content with fine animation detail, lower the CRF value — for example, use -crf 18 for near-transparent quality. To reduce file size at the cost of some sharpness, raise it to -crf 28 or -crf 30. For audio, increase the -b:a value from 128k to 192k or 256k if the source SWF has high-quality music or voice content.
Yes. On Linux or macOS you can use a shell loop: `for f in *.swf; do ffmpeg -i "$f" -c:v libx264 -c:a aac -crf 23 -b:a 128k "${f%.swf}.mts"; done`. On Windows Command Prompt, use: `for %f in (*.swf) do ffmpeg -i "%f" -c:v libx264 -c:a aac -crf 23 -b:a 128k "%~nf.mts"`. Each SWF file will be individually re-encoded and saved as a corresponding .mts file in the same directory. Note that SWF re-encoding is CPU-intensive, so batch jobs on large collections may take significant time.
Technical Notes
SWF files present a unique challenge for FFmpeg because the format was designed for browser-rendered interactive playback, not linear video extraction. FFmpeg's SWF demuxer handles files that contain embedded FLV1 (Sorenson Spark H.263-based) video or MJPEG video streams, but purely vector-animated SWFs with no embedded video stream may produce an empty or very short output. The re-encoding to H.264 via libx264 at CRF 23 is generally appropriate for the resolutions typical of SWF content (often 640x480 or smaller), but if the source SWF was authored at an unusual aspect ratio or non-standard frame rate, FFmpeg will preserve those values in the MTS output. MTS does not support transparency, chapters, or embedded subtitles from the SWF side — none of which SWF exports in a meaningful linear-video sense anyway. The AAC audio output at 128k is a step up in codec modernity from the SWF's typical MP3 audio, though the source quality ceiling of the original MP3 stream limits the final audio fidelity. One important limitation: SWF files with DRM or encryption (common in commercial Flash games and protected content) cannot be decoded by FFmpeg and will produce an error or empty output.