Combining Two Corrupted Movie Files into a Working File

Combining two corrupted movie files into a single working file requires careful handling of damaged headers and streams. Using ffmpeg, you can attempt to repair broken metadata before concatenating the segments. This process involves diagnosing corruption, repairing headers if possible, and then merging the valid portions into a new container.

Understanding File Corruption in Video Containers

When video files become corrupted, the issue often lies in the container format (like MP4 or MKV) rather than the actual video data itself. The container holds the index, timestamps, and codec information that players use to read the stream. If this header is damaged, the player cannot locate the frames, resulting in errors or black screens. However, the raw video data might still be intact within the file. It is crucial to distinguish between a corrupted container and a corrupted stream. A corrupted container may have a broken index but valid pixel data. In contrast, a corrupted stream means the actual encoded video bits are missing or garbled. Repairing a broken container is often feasible using tools like ffmpeg or specialized utilities. Re-encoding a corrupted stream is difficult because the decoder cannot interpret the invalid data. Therefore, the first step is always to assess whether the underlying video packets are recoverable.

Detecting the Extent of Damage

Before attempting any combination, you must identify what is wrong with each file. Run a diagnostic scan using ffprobe, which is part of the FFmpeg suite. This tool analyzes the file structure without modifying it. Use the following command to check for errors:

ffprobe -v error -show_format -show_streams input_corrupted.mp4

Look for output lines indicating "corrupt" or "error." If ffprobe reports severe parsing errors at the beginning of the file, the header is likely damaged. If it reads through most of the file but fails at specific timestamps, only those segments are problematic. This information dictates your recovery strategy. If the header is completely unreadable, you may need to force the parser to ignore errors, though this carries risks as discussed later.

Repairing Corrupted Headers Before Concatenation

Once you have identified the corruption, the next step is to attempt repair. FFmpeg offers several flags to handle damaged files during processing. One common approach is to use the -err_detect flag to tell the decoder how to handle errors. However, simply ignoring errors does not guarantee success if the stream structure is fundamentally broken. A more robust method for simple container repairs is to remux the file into a new container. This process forces FFmpeg to rebuild the index and headers while copying the existing video and audio streams. Use the copy codec option to avoid re-encoding, which preserves quality and speed.

ffmpeg -i input_corrupted.mp4 -c copy repaired_output.mp4

If this command fails, try adding the -ignore_unknown flag or using -f mp4 to explicitly specify the output format. Sometimes, the input file's extension is misleading; specifying the correct muxer can help FFmpeg parse the data correctly. If the file is severely corrupted, you might need to extract the raw stream and wrap it in a new container manually, but this is advanced and risky.

Concatenating Repaired Files

After repairing both files individually, you can combine them. The standard way to concatenate videos in FFmpeg is using the concat demuxer. This method requires a text file listing the inputs. Create a file named list.txt with the following content:

file 'repaired_part1.mp4'
file 'repaired_part2.mp4'

Then, run the concatenation command:

ffmpeg -f concat -safe 0 -i list.txt -c copy final_combined.mp4

The -c copy flag ensures no re-encoding occurs, maintaining the original quality. The -safe 0 flag allows absolute paths if necessary, though relative paths are safer. If the files have different codecs or resolutions, direct copying will fail. In such cases, you must re-encode one or both files to match the other's parameters, which increases processing time and may reduce quality.

Handling Different Codecs or Resolutions

If the two parts were recorded with different settings, you cannot simply copy the streams. You must normalize them. For example, if Part 1 is H.264 and Part 2 is HEVC, you must transcode one to match the other. Identify the parameters of the target file using ffprobe. Then, apply filters to resize or convert the mismatched file before concatenation.

ffmpeg -i mismatched_part.mp4 -vf scale=1920:1080 -c:v libx264 normalized_part.mp4

This step ensures compatibility. Note that re-encoding introduces generation loss. Always keep backups of the original corrupted files. If the repair steps fail, you may lose data permanently. Consider seeking professional data recovery services if the content is critical.

Risks and Limitations of Automated Repair

Automated tools like FFmpeg are powerful but not infallible. Using flags like -err_detect ignore_err can lead to silent failures where artifacts appear in the output. This happens because the decoder skips invalid data, creating gaps or glitches in playback. It is better to let FFmpeg report errors and address them manually than to produce a file that looks playable but has hidden defects. Furthermore, combining files does not fix internal stream corruption. If a segment of video data is missing, the output will show visual artifacts or crashes at that point. No software can reconstruct missing pixels from nothing. The goal is to salvage as much usable content as possible. For heavily damaged files, specialized forensic tools might offer better results than general-purpose media converters.

Frequently Asked Questions

Can I combine files if one is completely unrecoverable?

No, you cannot include a file that FFmpeg cannot parse at all. If ffprobe fails to read the file structure, the stream is too damaged for standard tools. You may need specialized forensic software to extract raw data fragments.

Why does my combined file play back with glitches?

Glitches usually indicate that the decoder skipped corrupted packets due to error detection flags. Check the logs for "dropped" frames. Re-encoding the affected segments might smooth out these artifacts, though it reduces quality slightly.

Is it safe to use -err_detect ignore_err?

This flag should be used cautiously. It forces the decoder to continue despite errors, which can cause synchronization issues or visual corruption. Only use it if you have exhausted other repair options and understand the risk of silent data loss.

What if the two files have different frame rates?

Direct concatenation will result in stuttering playback. You must re-encode one file to match the frame rate of the other using the -r flag or frame rate filters. This ensures smooth timing across the combined timeline.

How do I know if the header is fixed after remuxing?

Play the repaired file in multiple media players. If it plays smoothly from start to finish without errors, the header is likely fixed. Use ffprobe again on the repaired file to confirm no error messages are generated during analysis.