Convert SWF to TS — Free Online Tool
Convert SWF Flash animations and multimedia content to MPEG-2 Transport Stream (TS) format, re-encoding the FLV1 or MJPEG video to H.264 and the MP3 audio to AAC — producing a broadcast-compatible container ideal for streaming pipelines, HLS delivery, and legacy Flash content preservation.
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 contain vector graphics, interactivity, and multimedia streams encoded typically with FLV1 (Sorenson Spark) video and MP3 audio. During this conversion, FFmpeg demuxes the SWF container and extracts those raw streams, then fully re-encodes the video using the libx264 H.264 encoder and the audio using the AAC encoder. This is a full transcode — not a remux — because neither FLV1 video nor MP3 audio is natively carried in a TS container without conversion. The output TS file uses the MPEG-2 Transport Stream container, which segments data into fixed-size packets optimized for broadcast and streaming environments, including HLS-compatible workflows. Interactive and vector elements embedded in the SWF (ActionScript, vector paths, button events) are not transferable and will be rendered or dropped depending on what FFmpeg can decode from the SWF's embedded media streams.
What Each Flag Does
| Flag | What it does |
|---|---|
ffmpeg
|
Invokes the FFmpeg binary — the open-source multimedia processing engine running here via WebAssembly (ffmpeg.wasm) entirely in your browser, with no server upload required. |
-i input.swf
|
Specifies the input SWF file. FFmpeg demuxes the SWF container to extract its embedded media streams — typically FLV1 or MJPEG video and MP3 or AAC audio — for re-encoding. |
-c:v libx264
|
Re-encodes the video stream using the libx264 H.264 encoder, transcoding from the SWF's native FLV1 (Sorenson Spark) codec to the far more efficient and broadly supported H.264, as required by the TS output container. |
-c:a aac
|
Re-encodes the audio stream to AAC using FFmpeg's native AAC encoder, converting from the SWF's typical MP3 audio to the AAC format that is standard in broadcast TS workflows and HLS streaming. |
-crf 23
|
Sets the H.264 Constant Rate Factor to 23, the default quality level for libx264. Lower values (e.g., 15–18) produce higher quality and larger files, which is advisable when archiving Flash content to minimize the generational loss from re-encoding already-compressed FLV1 video. |
-b:a 128k
|
Sets the AAC audio output bitrate to 128 kilobits per second, a standard quality level for speech and general-purpose content. For music-heavy SWF animations or high-fidelity audio, this can be raised to 192k or 256k. |
output.ts
|
Defines the output file as an MPEG-2 Transport Stream, signaled by the .ts extension. FFmpeg muxes the H.264 video and AAC audio into fixed 188-byte TS packets, producing a file compatible with broadcast playout systems, HLS pipelines, and streaming encoders. |
Common Use Cases
- Preserving legacy Flash animations from the pre-HTML5 era into a broadcast-safe TS file before browsers fully deprecated SWF support
- Ingesting archived SWF-based e-learning or training videos into a video-on-demand or HLS streaming pipeline that requires TS segments
- Preparing Flash-based explainer videos or advertisements for playout on digital signage systems that accept MPEG-2 TS input
- Converting SWF promotional animations exported from Adobe Animate into a TS file for broadcast television delivery
- Archiving SWF game cutscenes or intro sequences as H.264/AAC TS files for long-term storage with broad hardware decoder support
- Extracting and re-encoding the video content from a SWF-wrapped FLV stream into a TS container for integration with broadcast encoder workflows
Frequently Asked Questions
No — MPEG-2 Transport Stream is a linear audio/video container and has no concept of interactivity, scripting, or vector graphics. FFmpeg can only access the raw media streams embedded within the SWF (typically FLV1 video and MP3 audio). All ActionScript logic, button events, animations driven by timeline scripting, and vector path data are discarded entirely. Only the rasterized video frames and audio FFmpeg can decode from the SWF will appear in the TS output.
SWF files render dynamically — vector shapes, text, and animations are drawn at runtime by the Flash player, often at any resolution. FFmpeg decodes the SWF by processing its embedded bitmap video stream (FLV1 or MJPEG), which may not capture the full fidelity of a vector-rendered playback. If the SWF relied heavily on vector animation rather than embedded video frames, the decoded output may appear at a lower resolution or with some elements missing, since FFmpeg is not a full Flash runtime.
There are two stages of lossy compression at play. The SWF's original FLV1 video stream was already lossy, and re-encoding it to H.264 with CRF 23 (the default) introduces a second generation of compression artifacts. CRF 23 is a widely accepted balance between quality and file size for H.264, but for high-quality archival you should lower the CRF value (e.g., -crf 15 or -crf 18) to minimize generational loss. The audio similarly goes from MP3 to AAC at 128k, which is generally transparent for most content but can be raised to 192k or 256k for critical audio.
To improve video quality, lower the CRF value — for example, replace '-crf 23' with '-crf 15' for noticeably higher fidelity at the cost of a larger file. To increase audio quality, raise the bitrate by replacing '-b:a 128k' with '-b:a 192k' or '-b:a 256k'. Conversely, raising the CRF (e.g., '-crf 30') or lowering the audio bitrate (e.g., '-b:a 96k') will reduce file size at the expense of quality. These adjustments are especially worth making when archiving historically significant Flash content where quality preservation matters.
Yes. On Linux or macOS, you can loop over all SWF files in a directory with: 'for f in *.swf; do ffmpeg -i "$f" -c:v libx264 -c:a aac -crf 23 -b:a 128k "${f%.swf}.ts"; 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.ts"'. This is particularly useful when archiving a collection of legacy Flash files, and since the browser tool handles files up to 1GB, the command-line approach is the better choice for large batch jobs.
TS (MPEG-2 Transport Stream) is specifically designed for streaming and broadcast environments — it is the container used in HLS streaming, DVB broadcast, and many professional playout systems. If your goal is simple local playback or web embedding, MP4 with the same H.264/AAC codecs would be more universally compatible with media players and browsers. TS is the right choice when you need to feed the output into a streaming encoder, an HLS segmenter, or a broadcast system that expects transport stream input.
Technical Notes
SWF support in FFmpeg is limited to demuxing the container and decoding its embedded media streams — specifically FLV1 (Sorenson Spark H.263-based codec) and MJPEG video, paired with MP3 or AAC audio. FFmpeg is not a Flash runtime, so SWFs that rely purely on vector timeline animation without embedded video frames may produce blank or incomplete output. The TS output container uses fixed 188-byte transport packets, making it inherently robust for streaming but slightly larger than equivalent MP4 files due to packetization overhead. The H.264 stream produced by libx264 is compatible with most broadcast hardware decoders, set-top boxes, and HLS players. Metadata from the SWF (such as title or author tags) is generally not preserved in the TS output, as SWF metadata structures do not map to TS container metadata. Multiple audio tracks are supported by the TS container but the SWF format only carries a single audio track, so the output will always be mono-track. Subtitles and chapters are not present in SWF and are not generated during this conversion.