Convert Y4M to MOV — Free Online Tool
Convert Y4M (YUV4MPEG2) uncompressed video files to MOV format using H.264 video encoding and AAC audio in Apple's QuickTime container. This tool compresses raw, uncompressed Y4M frames — which can be enormous in size — into an efficient, broadly compatible MOV file ready for editing, sharing, or playback on Apple devices.
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 is a headerless, uncompressed raw video format that stores every frame as full YUV pixel data with no compression whatsoever — a single second of 1080p Y4M footage can easily exceed 300MB. During this conversion, FFmpeg reads each raw YUV frame from the Y4M file and encodes it using the libx264 H.264 encoder, applying lossy compression via the CRF quality scale (default CRF 23) to dramatically reduce file size while preserving perceptual quality. Because Y4M contains no audio stream by default, the AAC audio codec flag is included in the command but will only activate if an audio track is somehow present. The output is wrapped in Apple's MOV (QuickTime) container with the +faststart flag, which relocates the MP4/MOV metadata atom to the beginning of the file, enabling progressive playback and streaming before the entire file is downloaded.
What Each Flag Does
| Flag | What it does |
|---|---|
ffmpeg
|
Invokes the FFmpeg program, the open-source multimedia processing engine that handles reading the Y4M container, decoding its raw YUV frames, encoding them with H.264, and writing the MOV output file. |
-i input.y4m
|
Specifies the input file — a Y4M (YUV4MPEG2) file containing uncompressed raw video frames in YUV colorspace. FFmpeg reads the Y4M header to extract the frame dimensions, frame rate, and pixel format before processing begins. |
-c:v libx264
|
Encodes the uncompressed YUV video frames from the Y4M source using the libx264 H.264 encoder, applying temporal and spatial compression for the first time to dramatically reduce file size while maintaining perceptual quality in the MOV output. |
-c:a aac
|
Sets the audio codec to AAC (Advanced Audio Coding) for any audio stream present in the source. Since Y4M files do not normally carry audio, this flag is effectively inactive in most Y4M-to-MOV conversions but is included to ensure a valid MOV output if audio is somehow present. |
-crf 23
|
Sets the Constant Rate Factor for the H.264 encoder to 23, which is libx264's default quality setting. This controls the quality-to-filesize tradeoff for compressing the formerly uncompressed Y4M frames — lower values (e.g., 18) produce higher quality at larger file sizes, while higher values (e.g., 28) reduce file size at the cost of visible compression artifacts. |
-b:a 128k
|
Sets the AAC audio bitrate to 128 kilobits per second, a standard quality level for stereo audio in a MOV file. This only applies if the Y4M source contains an audio track, which is rare given Y4M's nature as a video-only format. |
-movflags +faststart
|
Moves the MOV container's metadata block (moov atom) to the beginning of the output file after encoding completes. This allows QuickTime Player, web browsers, and streaming platforms to begin playing the MOV file before it is fully downloaded, without affecting video or audio quality. |
output.mov
|
The destination filename with the .mov extension, telling FFmpeg to wrap the H.264 video and AAC audio into Apple's QuickTime MOV container format, which is natively supported by macOS, Final Cut Pro, QuickTime Player, and professional video editing software. |
Common Use Cases
- Delivering a finished video file from a Linux-based video processing pipeline (such as FFmpeg, MLT, or VapourSynth) that outputs Y4M as its final lossless intermediate, converting it to MOV for hand-off to a macOS editor or client.
- Compressing a Y4M capture from a software video synthesizer or generative art tool (like Hydra or Processing) into a portable MOV file small enough to share or upload to a portfolio site.
- Converting Y4M output from a video test signal generator or broadcast QC tool into MOV for archiving or review in QuickTime Player or Final Cut Pro.
- Taking a Y4M frame sequence exported by a scientific imaging or motion analysis application and packaging it into a MOV file that can be embedded in a presentation or shared with colleagues on macOS.
- Reducing the massive file size of a Y4M intermediate produced during lossless inter-application piping (e.g., between ffmpeg and x264 CLI tools) into a delivery-ready MOV for upload to Vimeo or YouTube.
- Converting Y4M test clips used in codec benchmarking (like the standard Sintel or Big Buck Bunny raw Y4M sources) into MOV files for comparative playback testing on Apple hardware.
Frequently Asked Questions
Yes — this conversion applies lossy compression for the first time, since Y4M stores completely uncompressed YUV pixel data and MOV here uses H.264 at CRF 23. CRF 23 is H.264's default and produces visually high-quality output, but it is not lossless. If you need a lossless result inside a MOV container, you can change the video codec to PNG (-c:v png) or use H.264 lossless mode (-crf 0), though both will produce much larger files than a typical CRF 23 encode.
Y4M is entirely uncompressed — every pixel of every frame is stored as raw YUV values with no encoding of any kind. H.264 inside MOV uses temporal and spatial compression algorithms that can reduce file size by 50x to 200x compared to raw video at comparable perceived quality. A 10GB Y4M file at CRF 23 might compress down to 50–300MB as a MOV, depending on the content's complexity and motion.
Standard Y4M files do not carry an audio stream — the format is purely a raw video container designed for piping video data between applications. The -c:a aac flag in the command is harmless when no audio is present; FFmpeg will simply produce a video-only MOV file. If you are piping a combined stream that somehow includes audio alongside the Y4M video, it will be encoded to AAC at 128k bitrate in the output.
The +faststart flag moves the MOV/MP4 metadata 'moov atom' from the end of the file to the beginning during a post-processing step. This has zero effect on video or audio quality — it purely reorganizes internal file structure. Its benefit is that video players and web browsers can begin buffering and playing the file before it is fully downloaded, which is important if you plan to host or stream the MOV online.
Change the CRF value in the -crf flag to control the quality-to-size tradeoff. Lower values mean higher quality and larger files (CRF 18 is considered near-visually lossless for H.264), while higher values sacrifice quality for smaller files (CRF 28–35 is acceptable for web previews). For example: ffmpeg -i input.y4m -c:v libx264 -c:a aac -crf 18 -b:a 128k -movflags +faststart output.mov produces a significantly higher-quality encode at the cost of a larger file.
Yes. On Linux or macOS, wrap the command in a shell loop: for f in *.y4m; do ffmpeg -i "$f" -c:v libx264 -c:a aac -crf 23 -b:a 128k -movflags +faststart "${f%.y4m}.mov"; done — this processes every Y4M file in the current directory and outputs a corresponding MOV file. On Windows Command Prompt, use: for %f in (*.y4m) do ffmpeg -i "%f" -c:v libx264 -c:a aac -crf 23 -b:a 128k -movflags +faststart "%~nf.mov".
Technical Notes
Y4M encodes video in YUV colorspace (typically 4:2:0 chroma subsampling, though 4:2:2 and 4:4:4 variants exist) without any compression, making it ideal as a lossless intermediate but impractical for storage or distribution. When libx264 encodes these frames into H.264, it inherits the input's YUV 4:2:0 colorspace by default, which is the standard for H.264 in a MOV container and is fully compatible with QuickTime Player, Final Cut Pro, Adobe Premiere, and virtually all Apple hardware. One important limitation is that Y4M does not support transparency (alpha channel), so no alpha data is lost during this conversion — both formats are opaque in this pipeline. Y4M also carries no metadata beyond basic frame dimensions, frame rate, and pixel format in its header, so there is no complex metadata or chapter information to preserve or lose. If your Y4M source was captured at an unusual frame rate (such as 23.976 or 59.94 fps), FFmpeg will correctly read the rate from the Y4M header and encode it into the MOV output. For very high-resolution or high-frame-rate Y4M sources (4K 60fps and above), be aware that H.264 encoding is CPU-intensive and the in-browser WebAssembly conversion may be slow; for files over 1GB, using the displayed FFmpeg command locally with hardware acceleration (e.g., -c:v h264_videotoolbox on macOS) is strongly recommended.