Convert SWF to 3GP — Free Online Tool
Convert SWF Flash animations and multimedia files to 3GP format for playback on 3G mobile devices. This tool re-encodes the SWF's FLV1 or MJPEG video stream into H.264 (libx264) and transcodes the audio to AAC — the standard codec pair for the 3GP container — making legacy Flash content accessible on mobile handsets without requiring a Flash player.
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 graphics, video streams (typically encoded in FLV1 or MJPEG), and audio (MP3 or AAC) into Adobe's Flash container. Because 3GP is a mobile-optimized container built around the MPEG-4 standard, none of SWF's native codecs can be directly carried over — a full re-encode is required. FFmpeg demuxes the SWF, decodes the embedded video frames, and re-encodes them into H.264 using the libx264 encoder with a CRF of 23. The audio is transcoded from MP3 (libmp3lame) to AAC at 64k bitrate, which is appropriate for the low-bandwidth assumptions of 3GP. A scale filter ensures the output dimensions are divisible by 2, which is a hard requirement for H.264 encoding and prevents errors when SWF content has odd pixel dimensions.
What Each Flag Does
| Flag | What it does |
|---|---|
ffmpeg
|
Invokes the FFmpeg binary — the open-source multimedia processing engine that handles demuxing the SWF container, decoding FLV1/MJPEG video and MP3 audio, and re-encoding everything into the 3GP output. |
-i input.swf
|
Specifies the input SWF file. FFmpeg uses its SWF demuxer to parse the Flash container and extract any embedded video and audio elementary streams for processing. |
-c:v libx264
|
Selects the libx264 encoder to re-encode the video stream into H.264, replacing the SWF's native FLV1 or MJPEG codec with the codec required by the 3GP container for maximum mobile device compatibility. |
-c:a aac
|
Transcodes the audio stream to AAC (Advanced Audio Coding), converting from the SWF's typical MP3 (libmp3lame) audio into the AAC-LC format that is the standard audio codec for 3GP and expected by 3G mobile handsets. |
-crf 23
|
Sets the Constant Rate Factor for libx264 to 23, a balanced quality level that produces moderate-size 3GP files suitable for mobile delivery without significant visible degradation from the decoded SWF video frames. |
-b:a 64k
|
Targets a 64 kilobit-per-second bitrate for the AAC audio stream, aligned with 3GP's low-bandwidth design goals and sufficient for voice narration or background music typically found in Flash content. |
-vf scale=trunc(iw/2)*2:trunc(ih/2)*2
|
Applies a video filter that rounds the output width and height down to the nearest even number, which is required because libx264 cannot encode frames with odd pixel dimensions — a common issue with SWF files that use non-standard canvas sizes. |
output.3gp
|
Defines the output file name and tells FFmpeg to use the 3GP muxer, which packages the H.264 video and AAC audio into the 3GPP container format optimized for mobile playback and streaming. |
Common Use Cases
- Repurposing archived Flash-based educational animations or e-learning modules for playback on older 3G feature phones that support 3GP but not Flash.
- Converting Flash advertisement creatives or banner animations into a mobile-compatible format for distribution via MMS or early mobile ad networks.
- Preserving SWF-based cartoon clips or short animations from the Flash era into 3GP so they can be stored and played on legacy mobile devices or embedded systems.
- Migrating Flash video content from old web archives into 3GP for low-bandwidth streaming environments where H.264 inside 3GP is the accepted delivery format.
- Extracting and re-encoding video from SWF game cutscenes or intro sequences into a compact, mobile-friendly 3GP file for documentation or archival purposes.
- Preparing Flash-based video tutorials or screencasts for distribution to users in regions where 3G mobile video via 3GP remains a common consumption format.
Frequently Asked Questions
No. 3GP is a passive video container and has no concept of interactivity, scripting, or vector animation logic. FFmpeg treats the SWF as a video/audio source and captures only the rendered video frames and the audio stream. All ActionScript, button interactions, timeline branching, and vector graphics instructions are discarded — the output is a flat, non-interactive video of whatever was rendered from the SWF.
SWF files store content as vector graphics and programmatic instructions, which are resolution-independent and often very compact in their raw form, but the comparison shifts once rendered. 3GP targets low-bandwidth mobile delivery, so the output is constrained by the 64k audio bitrate and a CRF of 23, which produces a moderate-quality H.264 stream. For SWFs that contain embedded raster video, the output may actually be similar in size; for SWFs that are primarily vector animations, the 3GP will be larger since it stores fully rasterized frames rather than drawing instructions.
64k AAC is the default because 3GP was designed for 3G mobile networks with limited bandwidth, and 64k AAC delivers acceptable speech and music quality within that constraint. For voice-over or narration in educational SWFs, 64k is generally sufficient. If the source SWF contains high-quality music or rich audio, you may notice some loss of fidelity compared to the original MP3 stream. You can raise the bitrate in the FFmpeg command by replacing '-b:a 64k' with '-b:a 96k' or '-b:a 128k' if audio quality is a priority.
The '-vf scale=trunc(iw/2)*2:trunc(ih/2)*2' filter ensures the output video dimensions are even numbers (divisible by 2). H.264 encoding with libx264 requires even dimensions, and SWF files frequently use non-standard canvas sizes that may have odd pixel widths or heights. Removing this filter risks an encoding error such as 'width not divisible by 2'. It is safe to keep it — it only changes dimensions by at most 1 pixel when the original is already even.
Video quality is controlled by the '-crf' value, where lower numbers mean higher quality and larger file size. The default CRF of 23 is a balanced midpoint for H.264. For better quality suitable for larger screens, try '-crf 18' or '-crf 20'. For a smaller file at the cost of quality — appropriate for very low-bandwidth 3G delivery — try '-crf 28' or '-crf 30'. The full range supported by libx264 is 0 (lossless) to 51 (lowest quality), but values below 18 or above 35 are rarely practical.
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 64k -vf scale=trunc(iw/2)*2:trunc(ih/2)*2 "${f%.swf}.3gp"; done'. On Windows Command Prompt, use 'for %f in (*.swf) do ffmpeg -i "%f" -c:v libx264 -c:a aac -crf 23 -b:a 64k -vf scale=trunc(iw/2)*2:trunc(ih/2)*2 "%~nf.3gp"'. This processes each SWF in the current directory and outputs a matching 3GP file.
Technical Notes
SWF is a fundamentally unusual input for FFmpeg because it was designed as an interactive runtime format rather than a media container. FFmpeg's SWF demuxer extracts the embedded video (FLV1 or MJPEG) and audio (MP3 or AAC) streams but cannot interpret vector graphics or ActionScript — the output is limited to whatever pre-rendered raster video and audio tracks exist in the file. SWFs that are purely vector-based animations without an embedded video stream may produce no output or a very short, low-frame-rate result. The 3GP container conforms to the 3GPP TS 26.244 specification and mandates H.264 baseline profile video and AAC-LC audio for widest device compatibility, which is exactly what this command produces. The libx264 encoder defaults to the main profile at CRF 23, which is compatible with most 3GP-capable devices. Note that 3GP does not support transparency, chapters, subtitles, or multiple audio tracks, and any such metadata from the SWF source is silently dropped. The output file will be playable on devices supporting 3GPP Release 4 and later, as well as modern smartphones and media players that recognize the 3GP container.