Convert Y4M to RMVB — Free Online Tool
Convert Y4M (YUV4MPEG2) lossless uncompressed video files to RMVB format using H.264 video encoding and AAC audio — compressing raw pixel data into a compact, streamable variable-bitrate file. This tool is ideal for reducing the enormous file sizes of Y4M intermediates into a distributable format while retaining solid visual quality via libx264's CRF-based encoding.
to
FFmpeg Command
Copy this command to run the same conversion locally with FFmpeg on your desktop. Download FFmpeg
Drop your Y4M 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
Y4M files store raw, uncompressed YUV pixel data frame-by-frame with no compression whatsoever, making them extremely large but losslessly faithful to the source. During this conversion, FFmpeg reads the raw YUV frames and encodes them using libx264 — a highly efficient H.264 encoder — applying lossy compression via a Constant Rate Factor (CRF) of 23 by default. Because Y4M files typically carry no audio track (it is a video-only format), the AAC audio codec flag is included for compatibility but will only produce an audio stream if the source happens to contain one. The resulting RMVB file uses variable bitrate encoding, meaning libx264 dynamically allocates more bits to complex scenes and fewer to static ones, producing a much smaller file than the raw Y4M source while maintaining good perceptual quality.
What Each Flag Does
| Flag | What it does |
|---|---|
ffmpeg
|
Invokes the FFmpeg command-line tool, which is the underlying engine used by this browser-based converter via its WebAssembly (FFmpeg.wasm) build. |
-i input.y4m
|
Specifies the input file — a Y4M (YUV4MPEG2) uncompressed raw video file. FFmpeg reads the plaintext Y4M frame headers and raw YUV pixel planes directly, requiring no video decoding step since the data is already uncompressed. |
-c:v libx264
|
Sets the video codec to libx264, the leading open-source H.264 encoder. This encodes the raw YUV frames from the Y4M source into compressed H.264 video for storage in the RMVB container, dramatically reducing file size. |
-c:a aac
|
Sets the audio codec to AAC (Advanced Audio Coding). Since Y4M is a video-only format and typically carries no audio, this flag primarily ensures compatibility if an audio stream is present; otherwise it has no effect on the output. |
-crf 23
|
Sets the Constant Rate Factor for libx264 to 23, the default quality level. This tells the H.264 encoder to target consistent perceptual quality across all frames of the Y4M source rather than a fixed bitrate, with lower values producing higher quality and larger RMVB output files. |
-b:a 128k
|
Sets the AAC audio bitrate to 128 kilobits per second. This is a standard quality level for AAC that balances file size and audio fidelity; it applies only if the Y4M source contains an audio stream. |
output.rmvb
|
Specifies the output filename with the .rmvb extension, which tells FFmpeg to wrap the encoded H.264 video and AAC audio into the RealMedia Variable Bitrate container format developed by RealNetworks. |
Common Use Cases
- Archiving the output of a video processing pipeline — such as one using tools like ffmpeg, mjpegtools, or avisynth — that outputs Y4M intermediates, into a compact RMVB file for long-term storage or sharing.
- Distributing lossless-quality render outputs from compositing or motion graphics software that exports Y4M, to audiences or clients who need a small, playable file rather than a raw stream.
- Converting Y4M test sequences used in video codec research or quality benchmarking into RMVB for easier review and comparison without requiring specialized raw video players.
- Compressing uncompressed Y4M footage captured or piped from tools like VirtualDub or raw camera interfaces into a manageable RMVB file suitable for upload or streaming on older or bandwidth-limited platforms.
- Producing RMVB files for playback on legacy media players or set-top boxes that were popular in the early 2000s and 2010s and are commonly found in certain regional markets where RMVB remains a recognized format.
- Reducing the file size of Y4M animation frames assembled into a video stream so they can be reviewed on devices that cannot handle raw uncompressed playback.
Frequently Asked Questions
Y4M files are completely uncompressed, storing raw YUV pixel data for every frame, so they are extraordinarily large — a single minute of 1080p Y4M footage can exceed 10–15 GB. After encoding with libx264 at the default CRF 23, the resulting RMVB file is typically 50 to 200 times smaller, depending on the video content's complexity. Static or low-motion content compresses far more aggressively than fast-moving or highly detailed scenes.
Yes — this conversion is lossy because libx264 applies H.264 compression to the raw YUV frames. At the default CRF 23, the output is perceptually good for most content but is not a lossless copy of the original. If you need higher fidelity, lower the CRF value (e.g., CRF 18 produces near-lossless results at the cost of a larger file). CRF 0 would produce lossless H.264, but the RMVB container is not designed for lossless use and file sizes would be very large.
Y4M is a video-only format and almost never contains an audio stream. The '-c:a aac' and '-b:a 128k' flags are included in the command for safety and container compatibility — if your Y4M source somehow contains an audio stream (rare but possible in some piping workflows), it will be encoded to AAC at 128 kbps. If there is no audio in the source, FFmpeg will simply produce an RMVB file with no audio track and these flags have no effect on the output.
Change the '-crf 23' value in the command. CRF (Constant Rate Factor) controls the quality-to-filesize tradeoff for libx264: lower values mean higher quality and larger files (CRF 18 is near-visually lossless), while higher values mean smaller files with more compression artifacts (CRF 28–35 is acceptable for web or preview use). The range is 0 (lossless) to 51 (worst quality), and the default of 23 is a good general-purpose starting point for distributable RMVB content.
Yes. On Linux or macOS, you can use a shell loop: 'for f in *.y4m; do ffmpeg -i "$f" -c:v libx264 -c:a aac -crf 23 -b:a 128k "${f%.y4m}.rmvb"; done'. On Windows Command Prompt, use: 'for %f in (*.y4m) do ffmpeg -i "%f" -c:v libx264 -c:a aac -crf 23 -b:a 128k "%~nf.rmvb"'. The browser-based tool processes one file at a time, so the FFmpeg command is especially valuable for batch workflows involving many large Y4M files.
RMVB was widely used in the early-to-mid 2000s, particularly in East Asian markets, and while native support has declined significantly, the video stream inside the RMVB container in this conversion is standard H.264 — the same codec used in MP4 and MKV files. Modern players like VLC can play RMVB files without issue. However, web browsers, mobile devices, and streaming platforms generally do not support RMVB natively, so if broad compatibility is your goal, consider converting to MP4 with H.264 instead.
Technical Notes
Y4M (YUV4MPEG2) encodes each frame as raw planar YUV data with a simple text header per frame, making it trivially parseable but massively space-inefficient. FFmpeg reads the YUV colorspace data directly without any decode step, which makes the input stage very fast. The libx264 encoder then applies H.264 inter-frame compression, leveraging motion estimation and discrete cosine transforms to eliminate the spatial and temporal redundancy that Y4M preserves verbatim. One key detail is that Y4M files commonly use 4:2:0 chroma subsampling, which libx264 handles natively, but if your Y4M source uses 4:2:2 or 4:4:4 chroma (less common), libx264 will downsample to 4:2:0 by default — you can override this with '-pix_fmt yuv444p' if needed, though RMVB players may not support it. RMVB does not support subtitles, chapters, or multiple audio tracks, so none of that metadata can be preserved even if it existed in a modified source. The variable bitrate nature of RMVB output means file sizes will vary significantly based on scene complexity, making CRF encoding a natural fit for this container.