Convert RMVB to SWF — Free Online Tool
Convert RMVB (RealMedia Variable Bitrate) video files to SWF (Shockwave Flash) format directly in your browser, re-encoding the video stream to the FLV1 (Sorenson Spark) codec and audio to MP3 using LAME — the classic codec pairing used by early web video players. This conversion is ideal for embedding legacy RealMedia content into Flash-based web environments or archiving variable-bitrate RealMedia streams in a Flash-compatible container.
to
FFmpeg Command
Copy this command to run the same conversion locally with FFmpeg on your desktop. Download FFmpeg
Drop your RMVB 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
RMVB files use RealNetworks' proprietary RealVideo and RealAudio codecs inside a variable-bitrate RealMedia container — a format that most modern players and web environments cannot natively handle. During this conversion, FFmpeg fully decodes the RealVideo stream and re-encodes it as FLV1 (also known as Sorenson Spark or H.263-based Flash Video), which is the native video codec for the SWF/Flash container. Similarly, the audio — typically encoded in RealAudio — is decoded and re-encoded to MP3 using the LAME encoder, since SWF's primary supported audio format is MP3. Because both the video and audio codecs are completely different between RMVB and SWF, this is a full transcode (not a remux), meaning every frame is decoded and re-encoded, which takes more processing time and introduces generational quality loss. The resulting SWF file wraps the FLV1 video and MP3 audio in Adobe's Flash container, suitable for playback in legacy Flash players or embedding in older web pages.
What Each Flag Does
| Flag | What it does |
|---|---|
ffmpeg
|
Invokes the FFmpeg binary — the open-source multimedia processing engine that handles decoding the proprietary RealMedia Variable Bitrate container and re-encoding its contents to SWF. In the browser version, this runs via FFmpeg.wasm compiled to WebAssembly. |
-i input.rmvb
|
Specifies the input file in RMVB format. FFmpeg uses its libavformat demuxer to parse the RealMedia container and its software-based RealVideo/RealAudio decoders to decode the streams, since RealMedia codecs have no hardware decode path. |
-c:v flv1
|
Instructs FFmpeg to re-encode the video stream using the FLV1 codec (Sorenson Spark, an H.263 derivative), which is the native video codec for the SWF container and is expected by legacy Flash Player runtimes that will play this file. |
-c:a libmp3lame
|
Re-encodes the audio stream to MP3 using the LAME encoder. The SWF container's audio support is built around MP3, and libmp3lame is FFmpeg's high-quality MPEG Layer 3 encoder — this replaces whatever audio codec (typically RealAudio) was used in the RMVB source. |
-q:v 5
|
Sets the FLV1 video quality on a scale of 1 (best quality, largest file) to 10 (worst quality, smallest file). A value of 5 represents a balanced midpoint; unlike libx264's CRF scale used in the RMVB input side, this maps directly to a quantization parameter inside the Sorenson Spark encoder. |
-b:a 128k
|
Sets the MP3 audio bitrate to 128 kilobits per second, which is a standard perceptually transparent bitrate for stereo MP3 audio and keeps the SWF file size reasonable while preserving the dialogue and music content from the original RMVB source. |
output.swf
|
Specifies the output filename and triggers FFmpeg's SWF muxer, which wraps the FLV1 video and MP3 audio streams into the Small Web Format container — a binary format historically used for Adobe Flash Player content delivery on the web. |
Common Use Cases
- Republishing archived RealMedia TV recordings or old downloaded shows on legacy Flash-based video portals that only accept SWF or FLV1 content
- Migrating a library of RMVB-encoded anime or foreign films downloaded in the early 2000s into a Flash-compatible format for playback in vintage Flash projectors or CD-ROM kiosks
- Embedding RMVB-sourced video clips into legacy educational courseware or interactive Flash presentations (e.g., .swf-based e-learning modules) that cannot ingest RealMedia directly
- Archiving old streaming RealMedia content captured from legacy sites into an SWF container for preservation in Flash-era digital archives
- Preparing RMVB video for use in legacy Flash-based video players on older intranet sites where Flash is still the only supported playback technology
- Debugging or testing a Flash-based media pipeline by converting known RMVB source material to SWF to verify FLV1 encode settings and MP3 audio sync behavior
Frequently Asked Questions
Yes — this conversion involves a full transcode of both the video and audio streams, so some quality loss is unavoidable. The RealVideo codec used in RMVB and the FLV1 (Sorenson Spark) codec used in SWF are entirely different compression technologies, meaning every frame must be decoded from RealVideo and re-encoded to FLV1. Additionally, if the RMVB source already has compression artifacts, those will be baked into the FLV1 output. Using a lower -q:v value (closer to 1) will reduce additional quality loss from the FLV1 encode, at the cost of a larger file.
SWF is the Shockwave Flash container format, which was standardized by Adobe before H.264 became dominant. While later versions of Flash Player (Flash Player 9+) could technically support H.264 video in an F4V container, the native SWF container is built around the FLV1 (Sorenson Spark) video codec and MP3 audio — the codecs baked into the Flash runtime from the beginning. FFmpeg's SWF muxer defaults to FLV1 and MP3/LAME for maximum compatibility with the widest range of Flash Player versions.
RMVB's defining feature is its variable bitrate video stream, which dynamically allocates more bits to complex scenes and fewer to simple ones. When re-encoding to FLV1 in SWF using FFmpeg's default -q:v 5 setting, the FLV1 output also uses a quality-based variable bitrate mode — so the variable-rate philosophy is preserved, but it is driven by FLV1's own quality algorithm rather than RealNetworks' original VBR decisions. The original RMVB bitrate envelope is not carried over; the output bitrate is determined entirely by the FLV1 encoder's quality target.
Yes. The -q:v flag controls FLV1 video quality on a scale of 1 (best quality, largest file) to 10 (lowest quality, smallest file); the default of 5 is a balanced midpoint. To reduce file size, increase -q:v to 7 or 8. To improve quality at the cost of a larger file, lower it to 2 or 3. For audio, you can change -b:a from the default 128k to 96k or 64k to shrink the file, or up to 192k or 256k for better audio fidelity — though 128k MP3 is generally transparent for most spoken or music content at this bitrate.
On Linux or macOS, you can use a shell loop: `for f in *.rmvb; do ffmpeg -i "$f" -c:v flv1 -c:a libmp3lame -q:v 5 -b:a 128k "${f%.rmvb}.swf"; done`. On Windows Command Prompt, use: `for %f in (*.rmvb) do ffmpeg -i "%f" -c:v flv1 -c:a libmp3lame -q:v 5 -b:a 128k "%~nf.swf"`. The in-browser tool processes one file at a time, so the FFmpeg command is the recommended approach for batch jobs or files over 1GB.
No. Neither RMVB nor SWF support subtitles or chapter markers in a way that FFmpeg can carry through this conversion pipeline — and even if the RMVB source contained embedded subtitle streams, the SWF container format does not support subtitle tracks at all. If your RMVB file contains hardcoded (burned-in) subtitles as part of the video image, those will remain visible in the output since they are part of the pixel data, but any soft subtitle tracks will be dropped during the transcode.
Technical Notes
RMVB (RealMedia Variable Bitrate) is a proprietary container format from RealNetworks that relies on the RealVideo and RealAudio codec family — codecs that are not natively supported by most modern hardware decoders or browsers, which is why FFmpeg's software decoder is essential for this conversion. The SWF container, while widely associated with interactive Flash content, can also encapsulate video and audio streams using the FLV1 (Sorenson Spark, a variant of H.263) video codec and MP3 audio. FLV1 is a significantly older and less efficient codec than the RealVideo 4 codec commonly found in RMVB files — meaning at the same visual quality, FLV1-encoded video will typically be larger. The -q:v parameter for FLV1 in FFmpeg is a global quality scale (not a CRF like libx264) ranging from 1 to 10, where lower numbers mean higher quality; this maps to JPEG-style quantization internally. One known limitation of the SWF muxer in FFmpeg is that it does not support audio tracks encoded with AAC — only MP3 (libmp3lame) is reliably supported in SWF output, which is why LAME is used here regardless of the RMVB source's original audio codec. Frame rate and resolution from the RMVB source are passed through to the SWF output unchanged unless explicitly overridden. No metadata, chapter markers, or multiple audio tracks from the RMVB source are preserved in the SWF output.