Key things to know before you start repairing an AVI
- AVI is a container, so a broken index can make a video look unreadable even when most of the data is still there.
- VLC is the fastest first test on Mac because it can often confirm whether the streams are still readable.
- FFmpeg is the most useful free tool when the file needs a clean remux or a timestamp rebuild.
- Avidemux can help with older AVI files that respond well to direct stream copy and a fresh save.
- Commercial repair apps are most useful when the file is truncated, the header is damaged, or you have a healthy reference clip.
- If the file is zero bytes or the data is genuinely gone, no repair tool can invent missing frames.

What usually breaks an AVI file on a Mac
AVI is only the wrapper. The real audio and video sit inside the container, and the file depends on index data to tell the player where frames are stored. When that index is damaged or missing, the clip may still contain playable material but behave like it is broken: no seeking, freezing playback, missing duration, or a complete refusal to open.
I usually see four causes. The first is an interrupted copy from an external drive or memory card. The second is a recording that ended badly because a camera, capture device, or battery failed mid-write. The third is filesystem trouble on the source disk. The fourth is a codec or header mismatch, which is common with older DivX and Xvid-era files that are perfectly valid in structure but awkward on modern macOS players.
That difference matters because container damage and data loss are not the same problem. If the container is the issue, a repair pass can be enough. If the payload is missing, the best outcome may be a partial recovery. The next step is to check which one you are dealing with.
Check whether the file is still worth repairing
Before I touch any repair setting, I want one quick answer: can the file still be parsed? A video with a normal file size, a visible duration, or a partial preview is usually worth trying to rescue. A zero-byte file, a suspiciously tiny export, or a clip that failed halfway through a copy is a much worse sign.
The fastest way to inspect that on a Mac is with ffprobe:
ffprobe -v error -show_format -show_streams input.avi
If it prints container and stream details, there is usually something to work with. If it returns almost nothing, the file may be too damaged for a simple repair. I also avoid trusting Finder preview as a diagnostic tool, because it can fail on an unsupported codec even when the AVI itself is still intact.
- If
ffprobesees streams, the file is probably salvageable in some form. - If the file opens in one player but not another, that may be a codec issue rather than corruption.
- If you have a healthy sample clip from the same camera or recorder, keep it ready for reference-based repair.
Once I know the file still has structure, I move to the quickest Mac-side fix, which is usually VLC.
Start with VLC when the problem looks like a broken index
For a lot of damaged AVI files, VLC is the fastest first pass on Mac. Open Preferences, go to Input / Codecs, and set the option for damaged or incomplete AVI files to Always fix. Then reopen the file and test playback. If VLC can play it, that is a strong sign the streams are still present and the index is the part that failed.
- Open VLC.
- Go to Preferences.
- Open Input / Codecs.
- Set damaged or incomplete AVI files to Always fix.
- Reopen the video and check whether it plays or at least seeks more cleanly.
I like this step because it is quick, local, and free. The limitation is just as important: VLC is a good test and sometimes a good playback rescue, but it is not always the cleanest way to produce a permanently repaired file. If the clip only works after VLC applies that setting, I treat it as a sign to move to a tool that can rewrite the container properly. That is where FFmpeg earns its keep.
Remux with FFmpeg when the streams are intact
FFmpeg is the most useful free tool when the AVI still contains valid audio and video but the wrapper is messy. The basic idea is simple: copy the streams into a new container without re-encoding them. That can rebuild timing information and produce a cleaner file with no quality loss.
A safe first attempt is to remux to a more forgiving container:
ffmpeg -i input.avi -c copy output.mkv
If that works, you can keep the MKV or decide whether you want another AVI output later. When timestamps are incomplete, I sometimes add generated presentation timestamps:
ffmpeg -fflags +genpts -i input.avi -c copy output.avi
That helps when the stream order is there but the timing metadata is not. It will not rebuild missing frames, and it will not rescue a file whose data has actually been lost. FFmpeg is powerful, but it is not magic.
For older MPEG-4-in-AVI material, one extra bitstream filter can help with packed B-frames:
ffmpeg -i input.avi -c copy -bsf:v mpeg4_unpack_bframes output.avi
That option is niche, but it matters for some legacy DivX and Xvid files that look broken in modern players even though the frames are still there. If stream copy keeps failing, I stop treating the task as a simple remux and start looking at dedicated repair apps.
Choose a repair app when the free tools hit a wall
When AVI repair moves beyond index rebuilding, commercial software starts to make sense. The reason is straightforward: these tools are designed for cases where the file header is damaged, the clip is truncated, or the app needs a healthy reference video to reconstruct missing structure. That is a very different job from a clean remux.
On Mac, the names I see most often are Stellar Repair for Video, Wondershare Repairit, and EaseUS Fixo. They are not free, and that matters. Typical pricing lands somewhere around £50 to £120 depending on the licence model, with some vendors offering monthly, yearly, or lifetime plans. Online repair tiers are usually cheaper or free, but they often cap file size at about 100 MB and are less practical for long clips.
| Method | Best for | Cost | My take |
|---|---|---|---|
| VLC | Broken index, quick playback test | Free | Best first check, but not always a final repair |
| FFmpeg | Clean remuxing, timestamp fixes, stream copy | Free | My preferred free tool when the streams still exist |
| Avidemux | Older AVI files that need a direct stream copy workflow | Free | A useful GUI fallback, especially for legacy clips |
| Dedicated repair app | Truncated files, missing headers, reference-based repair | Usually £50 to £120 | Worth paying for when free tools cannot parse the file |
If you go this route, use a desktop app for sensitive footage rather than a browser upload. For small, non-sensitive clips, online repair is convenient. For a full camera dump or client footage, I prefer to keep the media on my own Mac.
One detail that separates success from frustration: if the tool asks for a reference file, give it a clean clip from the same device, with the same resolution, frame rate, and codec family. A mismatched reference is a common reason people think the repair failed when the software was simply given the wrong sample. That leads directly into the workflow I would actually use.
What I do before I call a file unrecoverable
When I need to rescue a damaged AVI, I follow the same order every time. First, I duplicate the original and work only on the copy. Second, I run ffprobe to see whether the container still makes sense. Third, I try VLC, then FFmpeg. If both fail, I move to Avidemux or a dedicated repair app with a reference clip.
- Keep the original file untouched.
- Use the cleanest possible copy as your working version.
- Try a free tool before paying for software.
- If you get a partial repair, save it immediately and verify it in another player.
- If the file is truly truncated or unreadable, look for the original source card or backup before spending more time.
When I do recover a clip, I usually convert the repaired result into a more edit-friendly format for future work, such as H.264 MP4 for delivery or ProRes for heavier editing, while keeping the original AVI archived. That way the repaired file becomes usable, not just playable, and you are less likely to repeat the same problem on the next project.