Recording Crashed Midway or Power Cut — File Won't Open? Missing Index, Truncated Data & Container Diagnosis Guide

2026-11-18 | GPU Repair | 48 minutes | HK GPU Fix Editorial Team

Recording Crashed Midway or Power Cut — File Won't Open? Missing Index, Truncated Data & Container Diagnosis Guide

Key Summary

A recording cut short by a crash, a power cut, or a forced shutdown can hold picture and sound data that no player can open, because the index mapping that data was never written. This guide separates a missing index from truncated data and from a file holding nothing, using file size, a ffprobe reading, and the container format.

The Shape of the Problem: A File With Size That No Player Opens

This guide is about one narrow shape, and the shape is the whole diagnosis. A recording is running — in OBS or another capture program — and the machine crashes, the power cuts out, the program is forced closed, or the disk fills up. Afterwards, the recording file will not open. Every player reports an error, or shows a duration of 0:00, or refuses to load the file at all. The file has a real size, often hundreds of megabytes or more, but no player can play a single second of it.

Three facts pin the shape down, and all three have to hold. First, the recording was interrupted in the middle: a crash, a power cut, a forced shutdown, or a disk that ran out of space while writing. Second, the file has a size that is not zero — a file of 0 bytes, or a file whose contents are all zeros, is a different shape, and this guide treats it as a stop line rather than a repair job. Third, the file cannot be opened at all — not a file that opens and plays with a fault, not a file that plays the picture and loses the sound halfway through, and not a finished export that came out wrong. The file itself will not open.

That distinction matters because the most common mistake with this shape is to treat it as a playback problem and to keep trying different players, different converters, and different settings. A file that will not open after a mid-recording crash is almost never a player problem. The players are all reading the same file, and they are all failing at the same first step: finding the index that tells them where the picture and sound data lives inside the file. Trying a fifth player after four have failed does not change the file. The work of this guide is to find out which layer failed — the index, the data, or the storage underneath — and to do it with tests that give a different answer for each layer.

The shape also has a clear time boundary. This guide starts after the interruption has already happened. It does not explain why the machine crashed, why the power cut out, or why the program closed. A crash during a heavy render or a creative workload is a different question, and it belongs with a different guide. What this guide answers is narrower and more practical: given a recording file that will not open after an interruption, what is still inside it, what can still be recovered, and what has to be left alone.

How a Recording File Is Built: Data First, Index Last

To understand why a crashed recording will not open, it helps to understand what a traditional MP4 file is made of. A traditional MP4 file has two main parts. The first part is the media data, stored in a section called the mdat atom: the actual video frames and audio packets, written in the order they were captured. The second part is the index, stored in a section called the moov atom: a map that records every track in the file, the codec each track uses, the total duration, and the position and size of every frame. A player opening a file reads the index first. Without the index, the player does not know how many tracks the file holds, which codec each track uses, or where the first frame sits. It cannot find the first frame, so it cannot play anything at all.

The order in which those two parts are written is the whole story. While a recording is running, the capture program writes media data into the file continuously, frame by frame, packet by packet. The index cannot be written until the recording stops, because the index has to cover every frame that was written, and the total duration and the position of every frame are only known once the last frame is in. So the index is the final step of a recording session. A crash, a power cut, or a forced shutdown strikes before that final step. The file is left with its media data in place and its index unwritten — the footage is there, but the map is not. This is not a file that has been damaged in the usual sense. It is a file that was never finished.

One repair-tool guide describes the situation in a short phrase: the footage was never lost, only the map. The phrase is useful because it separates two very different situations that look identical on screen. A player that reports an error and shows nothing could be looking at a file with a full set of media data and no index, or it could be looking at a file with nothing inside it at all. The file size is the first clue that tells them apart, and the ffprobe reading is the second. Both tests are covered in the seven diagnostic steps below.

Three containers, three crash outcomes. The container format decides what a crash leaves behind, and the three common choices behave very differently. A traditional MP4 or MOV file writes its index only at the end, so an interruption means the index was never written and the file will not open. OBS documentation warns against recording directly to traditional MP4 for exactly this reason: an interrupted file may not be recoverable. An MKV file uses the Matroska container, which is designed to tolerate interruption: its structure is written as the recording goes, so there is no final step that a crash can skip. After a crash, an MKV recording usually still plays, missing only the last few seconds. OBS documentation states that an unfinished MKV recording remains playable and recoverable. A Hybrid MP4 file, available in OBS from version 30.2 onwards, sits between the two: it writes in a segmented structure during the recording and then performs a soft remux into a traditional MP4 when the recording stops cleanly. After a crash, the segmented structure is still there, so the file has a chance of recovery — but the chapter markers are written only during the final step, so an interrupted file will have no chapter markers, and not every player or editing program recognises the segmented structure.

ContainerHow the structure is writtenWhat a mid-recording crash leaves behind
Traditional MP4 / MOVIndex written only when recording stopsMedia data present, index missing, file will not open
MKVStructure written continuously as recording runsFile usually still plays, missing only the last few seconds
Hybrid MP4 / Fragmented MP4Segmented structure during recording, soft remux to traditional MP4 at stopSegmented structure survives, recovery is possible, chapter markers are absent

That table is the reason the container format is the third deciding fork in this guide, after file size and the ffprobe reading. Two recordings interrupted by the same crash can have completely different outcomes, and the difference is the format they were recorded in. It is also the reason the prevention advice at the end of this guide starts with the recording format rather than with any repair tool: the format is chosen before the recording starts, and it decides the fate of the file before anything goes wrong.

The same table also explains why the advice to record in MKV and then remux to MP4 after the recording finishes is prevention rather than repair. Remuxing repackages the existing streams into a new container without re-encoding, and it works because the MKV structure is still there to be read. It cannot save a traditional MP4 whose index was never written, because there is nothing to repackage from. The two actions look similar — both end with an MP4 file — but one starts from a complete structure and the other starts from a missing index, and only the first one works.

How repair tools rebuild an index. A repair tool for this shape does not repair media data. It rebuilds a map. The best-known open-source tool of this kind, untrunc, works by taking a healthy reference file — a short clip recorded on the same machine, with the same settings, that plays normally — and reading the index from that reference file. The reference file holds a correctly written index: the codec parameters, the track layout, and the frame size table. The tool applies that structure to the media data inside the damaged file and writes a new index for it. The media data itself is never re-encoded, so the picture and sound in the repaired file are the picture and sound that were originally recorded.

That mechanism sets a hard boundary on what repair tools can do. The reference file has to match the damaged file in codec, resolution, frame rate, and container. If the reference file does not match, the rebuilt index points at the wrong positions, and the repaired file will not play either. One guide lists five matching requirements for the reference file: the same codec, the same resolution, the same frame rate, the same container version, and a reference file that is itself undamaged. Another guide puts it more simply — the same device, the same settings — but the direction is the same: the closer the reference file matches, the better the chance of a successful rebuild. A guide that only says to find a healthy clip, without listing what has to match, is leaving out the check that decides whether the attempt is worth making at all.

There is also an old limitation that has to be dated honestly. An OBS forum reply from the era of OBS 0.472b, around 2013, said that tools of this kind had limited success on OBS files because OBS does not use a fixed frame rate or a fixed bitrate. That reply is more than a decade old, and it describes the tools and the OBS version of its time. It cannot be presented as a conclusion about current versions. The current picture is different: Hybrid MP4 exists, repair tools have moved on, and an interrupted MP4 is no longer automatically a lost file. At the same time, the new tools are not a guarantee. The honest statement is that a missing index can sometimes be rebuilt when the media data is still there and a matching reference file exists — and that a file with no media data in it cannot be rebuilt by any tool.

The Deciding Forks: Three Comparisons That Narrow the Field

The diagnosis in this guide runs on three forks, and each fork is a comparison with two possible answers. The forks have to be taken in order, because each one narrows the field for the next.

The first fork is file size. A file of 0 bytes, or a file whose contents are all zeros when viewed in a hex viewer, holds no media data at all. Nothing was written, so there is nothing for a repair tool to rebuild an index from, and the diagnosis stops at the third suspicion layer, the zero-data layer. A file with a real size — hundreds of megabytes or more for a recording of any length — holds media data that may still be intact, and the diagnosis moves to the second fork. File size is also evidence in a second way: a file whose size does not match its expected length points at the truncation layer. A recording that ran for an hour but produced a file of only a few dozen megabytes has lost part of its data, not just its index.

The second fork is the ffprobe or MediaInfo reading. Running ffprobe on the file and seeing the message `moov atom not found`, or opening the file in MediaInfo and finding that it reads no tracks at all, points at the index layer: the moov atom was never written. Running ffprobe and seeing tracks, codecs, and a duration points at the truncation layer or the playback layer: the file has structure, but its data is incomplete. A file that ffprobe cannot read at all points at the file and disk layer: the storage underneath the file is itself at fault.

The third fork is the container format. A traditional MP4 or MOV file that will not open after a crash points at the index layer as the most likely explanation, because that format writes its index last. An MKV or Hybrid MP4 file that will not open after the same crash points elsewhere — at the truncation layer or the file and disk layer — because those formats should still have played. And a file that turns out to be FLV with a single audio track is not this shape at all: it belongs on a different diagnostic road, the one that deals with track mapping and codec recognition.

Those three forks also draw the boundaries of this guide. A recording file that opens and plays but has no sound at all belongs with the guide for a recording file with no audio track written. A recording file that opens with sound at the start and goes silent halfway through belongs with the guide for a mid-recording audio break. A finished export that has sound but no picture belongs with the guide for an output file with a missing video track. An export that errors and stops halfway belongs with the guide for a failed output. And a crash during a render or a creative workload — the question of why the machine crashed — belongs with the guide for crashes under load. This guide covers one shape only: a recording file interrupted mid-way that will not open.

The Five Suspicion Layers

Every file that will not open after a mid-recording interruption sits in one of five layers. The layers run from the index side towards the disk side, but the order does not say which layer is most likely: the sources reach no settled view on which layer is most likely, and each layer has to be confirmed or excluded by a test before it can be named.

LayerWhat it meansEvidence that points at it
First layer: index layer, moov never writtenTraditional MP4 or MOV recording interrupted before the final step, so the index was never written while the media data is presentFile has size but will not play; ffprobe reports `moov atom not found`; MediaInfo reads no tracks; container is traditional MP4 or MOV
Second layer: truncation layer, data written only partwayDisk filled up or writing fell behind during recording, so the media data itself stops partway through and the tail of the file is missingFile size does not match the expected length; ffprobe reads tracks but the duration is shorter than expected; a repaired file plays up to one point and then stops
Third layer: zero-data layer, nothing was writtenFile is 0 bytes or all zeros, so the recording wrote no media data at allFile size is 0 bytes; a hex viewer shows the contents are all zeros; every repair tool reports that there is nothing to rebuild from
Fourth layer: container layer, format decides the fateThe same crash leaves an MKV or Hybrid MP4 file still playable and a traditional MP4 file unopenable, so the format itself is diagnostic evidenceContainer format as shown by MediaInfo; a comparison of files in different formats from the same crash event; the recording format set in the capture program
Fifth layer: file and disk layer, storage itself failedDisk fault, filesystem damage, or the file being overwritten during writing, so the media data itself is gone or has been changedFile size is suddenly smaller than expected; the disk shows error messages; the file cannot be read on a different computer; a repair tool reports that the media data itself is damaged

The first layer is the one this guide spends the most time on, because it is the one where the media data is still there and recovery is possible. A traditional MP4 or MOV recording interrupted by a crash, a power cut, or a forced shutdown leaves the media data in the file and the index unwritten. The evidence is consistent: the file has a size, ffprobe reports `moov atom not found`, MediaInfo reads no tracks, and the container is a traditional MP4 or MOV. When all four pieces of evidence line up, the index layer is the working answer, and the repair attempt in step six is worth making.

The second layer is the one that catches people who assume that a repaired file is a complete file. Truncation means the media data itself stops partway through: the disk filled up, or the writing could not keep up with the recording, so the tail of the recording was never written. The file size is the first sign — a recording that ran for an hour should not produce a file of only a few dozen megabytes — and the ffprobe duration is the second: the tracks are readable, but the duration is shorter than the recording was expected to run. A repaired file from this layer plays up to the point where the data stops and then ends. That is not a failed repair. It is a repair that recovered everything that was actually written, and the rest was never there to recover.

The third layer is the stop line, and it has to be recognised early so that no time is wasted on repair attempts that cannot work. A file of 0 bytes holds nothing. A file whose contents are all zeros holds nothing either. No repair tool can rebuild an index for data that does not exist, and no converter can extract picture and sound from an empty file. The only useful action in this layer is to confirm the reading — check the size, check the contents in a hex viewer — and then stop, keep the file as a record of what happened, and turn to prevention for the next recording.

The fourth layer is the container layer, and it is the only layer where the format itself is the evidence. The same crash, the same machine, the same recording session: an MKV file from that session plays, and a traditional MP4 file from that session does not. That contrast tells the reader that the crash did not destroy the recording — it destroyed the final step of one format and not the other. The container setting in the capture program is part of the evidence too. If the recording format was set to MKV or Hybrid MP4 and the file still will not open, the index layer is unlikely, and the diagnosis should move to the truncation layer or the file and disk layer.

The fifth layer is the one where the storage underneath the file has failed. The signs are different from the other layers: the file size is suddenly smaller than it should be, the disk shows error messages, the file cannot be read on a different computer, or a repair tool reports that the media data itself is damaged. In this layer the media data is gone or has been changed, and rebuilding an index will not bring it back. The diagnosis stops here as well, and the file becomes evidence for a storage check rather than a repair attempt.

The Seven Diagnostic Steps

The seven steps below are written to be followed in order. Each step produces a result that decides which step comes next. Skipping ahead to the repair tool before the first five steps are done is the most common way to waste an attempt: without a matching reference file and without knowing which layer the file sits in, a repair run tells the reader nothing, even when it fails.

StepActionWhat the result means
Step 1Copy the damaged file to another folder and work only on the copyThe original stays untouched, so a failed repair attempt cannot destroy the only chance of a second try
Step 2Compare the file size with the expected recording length0 bytes or a few kilobytes points at the zero-data layer; a real size moves the diagnosis to step 3; a size far below the expected length points at truncation
Step 3Read the file with ffprobe or MediaInfo`moov atom not found` or no tracks points at the index layer; readable tracks with a duration points at truncation or playback; unreadable file points at the file and disk layer
Step 4Check the container formatTraditional MP4 or MOV supports the index layer; MKV or Hybrid MP4 that will not open points at truncation or the file and disk layer
Step 5Compare a healthy reference file recorded on the same machine with the same settingsCodec, resolution, frame rate, and container all have to match before a repair attempt is worth making
Step 6Run a repair tool on the copy only, then open the repaired file and check its full length and audio-video syncA playable repaired file confirms the index layer; a failure means changing the reference file and trying once more, not trying tool after tool on the same copy
Step 7Stop when the layer cannot be identified, the file holds no data, or a tool reports the media data itself is damagedBring the notes and the original file for inspection, and set up prevention for the next recording

Step one is the discipline the whole guide depends on, and it comes before any test. Copy the damaged file into another folder, and do every test and every repair attempt on the copy. Do not overwrite the original, do not rename it, and do not delete it. A repair tool that writes a wrong index into the original file can destroy the only chance of a second attempt. The copy is disposable; the original is not. This step is the most important habit in the guide, and it costs nothing.

Step two is the file size comparison. Look at the size of the damaged file and compare it with the length the recording was expected to run. A file of 0 bytes, or a file of only a few kilobytes, points at the zero-data layer, and the diagnosis stops there. A file with a real size — hundreds of megabytes or more — moves the diagnosis to step three. A file whose size is far below what its expected length should have produced points at the truncation layer: part of the data was never written, and the repair, if it works at all, will recover only what is there.

Step three is the ffprobe or MediaInfo reading, and it is the cleanest test in the guide. Run ffprobe on the copy of the file. If it reports `moov atom not found`, or if MediaInfo reads no tracks at all, the index layer is the working answer: the media data is present and the index was never written. If ffprobe reads tracks, shows codecs, and gives a duration, the file has structure, and the diagnosis moves to the truncation layer or the playback layer. If ffprobe cannot read the file at all, the file and disk layer is the working answer, and the storage underneath the file needs attention.

Step four is the container check. Look at what container the file is in. A traditional MP4 or MOV file supports the index layer as the most likely explanation, because that format writes its index last. An MKV or Hybrid MP4 file that will not open points at the truncation layer or the file and disk layer, because those formats should still have played after a crash. A file that turns out to be FLV with a single audio track is not this shape at all, and it belongs on the diagnostic road that deals with track mapping and codec recognition instead.

Step five is the reference file comparison, and it decides whether step six is worth attempting. Find a short clip recorded on the same machine, with the same settings, that plays normally. Use ffprobe to read its codec, resolution, frame rate, and container, and compare them with the settings the damaged recording was made with. All of them have to match. If any one of them does not match, the chance of a successful rebuild falls sharply, and the attempt should not be forced. The reference file is the tool's map: a map drawn for a different codec, a different resolution, or a different frame rate points at the wrong places in the damaged file.

Step six is the repair attempt, and it runs only on the copy. The open-source tool untrunc is the example used in the sources: it takes the healthy reference file and the damaged file, and writes a new file with a rebuilt index. The command form given in the sources is `untrunc working.mp4 broken.mp4`, with the reference file first and the damaged file second, producing a new file with a fixed name. The tool has no preview, so the result has to be checked by opening the repaired file and watching it: does it play, does the sound stay in sync with the picture, and does it play for its full length. If the repair works, check the full length — a file that plays and then stops partway through is a truncation recovery, not a complete recovery. If the repair does not work, do not run tool after tool on the same copy. Change the reference file and try once more. Running different tools over the same copy in turn makes it impossible to tell which attempt changed what.

Step seven is the stop line. Stop when the seven steps have not identified a layer, when the file is 0 bytes or all zeros, or when a repair tool reports that the media data itself is damaged. Stop also when the file will not open on a different computer and the disk shows error messages. At that point, bring the notes from the seven steps — the file size, the ffprobe output, the container, the reference file details, and the result of the repair attempt — along with the original file, for inspection. Do not delete the original recording before the layer is identified. It is the comparison material, and without it the inspection has nothing to work from. On the prevention side, the next recording should use MKV or Hybrid MP4, available in OBS from version 30.2 onwards, and be remuxed to MP4 after the recording finishes using OBS File, then Remux Recordings. Long recordings should start with a check that the disk has enough free space.

Six Misconceptions That Mislead This Diagnosis

Misconception one: a file that will not open means the footage is gone. This is wrong, and it is the most expensive mistake in this guide, because it leads people to delete the file. A traditional MP4 recording interrupted by a crash will not open very often for one reason only: the index was never written, while the media data is still inside the file. The file size is the first piece of evidence. A file with a real size may still hold its data; only a file of 0 bytes, or a file whose contents are all zeros, is genuinely empty. Deleting a file that will not open, before checking its size and its ffprobe reading, throws away a recording that a repair tool might have rebuilt.

Misconception two: converting the file with ffmpeg will fix it. This is wrong. The command `ffmpeg -i broken.mp4 -c copy fixed.mp4` needs to read the index before it can find the frames to copy, and without an index it reports the same `moov atom not found` error as every player. Converting the format is a comparison test, not a repair: it can confirm that the index is missing, but it cannot create one. The index has to be rebuilt first, with a repair tool and a matching reference file, and only then can ffmpeg be used on the repaired file. Running the conversion first and treating its failure as proof that the file is unrecoverable skips the step that actually matters.

Misconception three: the `+faststart` flag can rebuild an index. This is wrong, and one of the sources names it directly as a common misunderstanding. The flag `-movflags +faststart` moves an index that already exists from the end of the file to the start, so that a file can start playing sooner when streamed online. If the index does not exist, there is nothing to move. The flag creates nothing. A file with no index stays a file with no index after `+faststart`, and the error message stays the same.

Misconception four: OBS Remux Recordings can save a crashed MP4. This is wrong. Remuxing repackages the streams that are already in a file, and to find those streams it has to read the index. A traditional MP4 with no index cannot be opened by Remux Recordings either. What Remux Recordings can save is an MKV file and an unfinished Hybrid MP4 file, because their structure is still there to be read. The confusion comes from the fact that Remux Recordings does rescue files after a crash — but only files in formats whose structure survives a crash. It is a tool for formats that were designed to survive, not a tool for formats that were not.

Misconception five: a repair tool will always save the file. This is wrong. A repair tool can only rebuild an index. It cannot rebuild media data that was never written, data that has been overwritten, or data on a disk that has itself failed. A file of 0 bytes, a file whose data has been overwritten, and a file on a damaged disk are all beyond a repair tool, and the tool will say so if it is allowed to: it reports that there is nothing to rebuild from, or that the media data itself is damaged. The diagnosis has to separate a missing index from missing data before any repair is attempted, because the tool only helps with the first one.

Misconception six: recording in MP4 and recording in MKV give the same result, so the format does not matter. This is wrong, and the difference is not picture quality. The difference is the crash structure: a traditional MP4 interrupted by a crash will not open, while an MKV interrupted by the same crash usually still plays. That is a difference in fault tolerance, not in how good the picture looks. Choosing the format before a long recording is itself a form of prevention, and it is the cheapest prevention in this guide — it costs nothing and it decides the fate of the file before anything goes wrong.

Comparison Table: What Each Result Points At

The table below brings the tests together. Each row starts from a result that the reader can actually see — a file size, a ffprobe message, a container format, a repair outcome — and ends at the layer that result points at. It is meant to be read after the seven steps, as a check on the diagnosis, not as a shortcut that replaces them.

Result seen during diagnosisLayer it points atWhat to do next
File has size, ffprobe reports `moov atom not found`, container is traditional MP4 or MOVFirst layer: index layerTry a repair tool on a copy, with a matching reference file
File has size, ffprobe reads tracks but duration is shorter than the recording should have runSecond layer: truncation layerRepair may recover what was written; the missing tail was never written
File is 0 bytes or all zerosThird layer: zero-data layerStop; no repair tool can rebuild data that does not exist
MKV or Hybrid MP4 file will not open after the same crash that a traditional MP4 file survived in another formatFourth layer: container layer, then second or fifth layerThe format rules out the index layer; check truncation and the disk
File size suddenly smaller, disk shows errors, file unreadable on a different computerFifth layer: file and disk layerStop repair attempts; the storage itself needs inspection
Repair tool produces a file that plays, in sync, for its full lengthFirst layer confirmedKeep the repaired file and the original; check the full length before using it
Repair tool produces a file that plays and then stops partway throughSecond layer confirmedThe recovered part is everything that was written; the rest is gone
Repair tool reports the media data itself is damagedFifth layer confirmedStop; an index rebuild cannot fix damaged data

The last three rows matter because they describe what a repair attempt actually proves. A repair that works proves the index layer. A repair that recovers only part of the file proves the truncation layer. A repair tool that reports damaged media data proves the file and disk layer. None of those outcomes is a failure of the tool. They are all answers, and the guide is written so that each answer points at a different next step.

What the Sources Disagree About

The sources consulted for this guide do not all say the same thing, and the differences have to be written out rather than smoothed over. The first disagreement is whether a crashed MP4 can be saved at all. An OBS forum reply from the era of OBS 0.472b, around 2013, described a file with no moov atom as completely unusable. The repair-tool sources describe the opposite: as long as the media data is still in the file, an index can be rebuilt. The two statements are not contradicting each other once the dates are in view. The old reply describes the tools and the OBS version of its time, and the variable frame rate and variable bitrate of OBS recordings limited what the tools of that era could do. The newer sources describe current repair tools. This guide follows the newer picture while keeping the old reply visible, because the old reply is still the first thing a search returns, and a reader who finds it deserves to know why it no longer describes the current situation.

The second disagreement is about prevention: whether to record in MKV or in Hybrid MP4. One source calls MKV the most reliable road, because its structure survives an interruption with the least fuss. Another source notes that OBS 32 made Hybrid MP4 the default on Windows and Linux, and Hybrid MOV the default on macOS, and presents Hybrid MP4 as the practical starting point. Both are right, and the choice is a trade-off rather than a single correct answer. MKV leans towards recovery first. Hybrid MP4 leans towards compatibility with editing programs first. This guide presents the trade-off and lets the reader choose by priority, rather than naming one format as the only correct answer.

The third disagreement is about the repair tool against re-recording. The commercial repair-tool sources present index rebuilding as the way forward. Other sources point out that repair tools have a clear ceiling: frames that were genuinely never written cannot be rebuilt. The two positions cover different situations. When the index is missing and the data is present, a repair tool is useful. When the data itself is missing, a repair tool is useless, and the honest answer is that the recording has to be made again. This guide puts the layer diagnosis before the repair attempt for exactly that reason: the tool is not the first step, the layer is.

The fourth disagreement is about how similar the reference file has to be. One guide lists five matching requirements — codec, resolution, frame rate, container version, and an undamaged reference file. Another guide says the same device and the same settings are enough. The two statements differ in strictness but point in the same direction: the closer the reference file matches, the better the chance of a rebuild. This guide writes the five matching requirements as a checklist, because a checklist can be tested, while a general instruction to find a healthy clip cannot.

Boundary: Shapes This Guide Does Not Cover

The boundary table below lists the shapes that look close to this one but belong elsewhere. Each row gives the shape, the guide it belongs with, and the reason it is not this guide. The table is part of the diagnosis: if the shape in front of the reader matches a row here better than it matches the shape in the opening section, the reader is on the wrong guide and should switch.

ShapeWhich guide it belongs withWhy it is not this guide
Recording file opens and plays, but has no sound at all#503, recording file with no soundFile structure is complete; the problem is that the audio track was never written
Recording file has sound at the start, then goes silent halfway through#505, mid-recording silenceFile opens; the problem is that the audio track breaks partway through
Recording file plays in VLC with sound, but the audio track is missing in editing software#506, track mapping and codecFile opens; the problem is that the editing software does not recognise the audio track
Finished export has sound but no picture#500, video trackAn output file problem, not a recording interrupted mid-way
Export errors, stops, and never finishes#476, failed outputThe output process failed; the recording file itself is not the problem
System crashes during a render or a creative workload, and the question is why it crashed#147, crash under loadThis guide does not cover the cause of the crash, only the file left behind
Recording or livestream stutters, encoder overload, dropped frames#171, render, encoding, and network frame dropsThe problem is stuttering, not a file that will not open
Recording file has sound, but it is distorted or breaking up#311, game audio distortion and dropoutsSound quality is degraded, not a file that will not open
Recording file audio drifts further out of sync towards the end#496, variable frame rate driftThe audio track exists; its timing is wrong, not its presence
Overlay will not appear, or the record button will not respond#460, overlay switches, shortcuts, and permissionsThe recording never started

Two rows in that table deserve a second look, because they are the ones most often confused with this shape. The first is the recording file that opens and plays with no sound at all. That file has a complete structure: its index was written, its tracks can be read, and the picture plays. The fault is that the audio track was never written into it. The file in this guide has no readable structure at all, and the fault is that the index was never written. The two faults sit in different layers, they are tested with different tools, and they are fixed — when they can be fixed — in different ways. The second is the export that errors and stops halfway. That file is a finished product that failed during output, and its diagnosis starts with the output process. The file in this guide is a recording that was interrupted during capture, and its diagnosis starts with the file size and the ffprobe reading. Confusing the two sends the reader to the wrong set of tests.

When to Stop Testing

Stop when the seven steps have not identified a layer. A file that has been copied, measured, read with ffprobe, checked for its container, compared with a reference file, and put through a repair tool on a copy — and still gives no clear answer — has told the reader everything the home tests can tell. Further attempts at that point are guessing, and guessing on the only copy of a recording is how a recoverable file becomes an unrecoverable one.

Stop when the file is 0 bytes or all zeros. There is no media data to recover, and no tool changes that. Stop when a repair tool reports that the media data itself is damaged, or when the file cannot be read on a different computer and the disk shows error messages. In all of those cases the storage underneath the file is the problem, and the file is evidence for a storage inspection rather than material for another repair attempt.

Stop also when the repair tool has been tried with a matching reference file and has failed, and a second try with a different reference file has failed too. Two failed attempts with two different reference files is an answer: the index cannot be rebuilt from the material available. Trying a third, fourth, and fifth tool on the same copy does not add information. It adds risk, because each tool writes its own output and each run makes it harder to tell what changed and when.

The original file should not be deleted before the layer is identified, whatever the outcome of the tests. It is the comparison material for any inspection, and it is the only source a repair tool can work from. Keep it, keep the notes from the seven steps, and bring both along. The notes are part of the diagnosis: the file size, the ffprobe output, the container format, the reference file details, and the result of the repair attempt together say more than any one of them alone.

What to Bring for Inspection

Bring the original damaged file, on the drive it was recorded on if possible, and do not bring only a copy that has already been through a repair tool. Bring the notes from the seven steps: the file size, the expected recording length, the ffprobe or MediaInfo output, the container format, and the details of the healthy reference file that was used, including its codec, resolution, frame rate, and container. Bring the repaired file too, if a repair attempt produced one, and note whether it played for its full length and whether the sound stayed in sync with the picture.

Bring a short account of the interruption itself: what happened at the moment the recording stopped — a crash, a power cut, a forced shutdown, or a disk that filled up — and what the capture program was set to record in, including the container format and the codec. Bring the name of the capture program and its version, because the recording format and the remux behaviour differ between versions, and the version is part of the evidence. Do not bring a list of players that were tried. The players are not evidence. The file size, the ffprobe reading, and the container are.

For inspection, HK GPU Fix is at Dali Plaza 1209, Shek Mun. The phone number is 2186 8010 and WhatsApp is 6558 6806. The published inspection fee range is HK$400 to HK$2,800, and no price is estimated before inspection. There is no Mong Kok shop and no on-site service.

Frequently Asked Questions

Why does my recording file have a size but still refuse to open?

Because the file holds media data without the index that maps it. A traditional MP4 file writes its media data continuously while recording and writes its index only when the recording stops. A crash, a power cut, or a forced shutdown interrupts the recording before that final step, so the file has its picture and sound data inside it but no map telling a player where each frame sits. A player reads the index first, and without it the player cannot find even the first frame. The file size is the clue that the data may still be there: a file with a real size holds something, while a file of 0 bytes holds nothing.

What does ffprobe mean when it reports `moov atom not found`?

It means the file has media data but no index. The moov atom is the index section of an MP4 file: it records the tracks, the codecs, the duration, and the position and size of every frame. When ffprobe cannot find it, the player cannot find it either, and that is why no player opens the file. The message is one of the cleanest tests in this guide because it has only one meaning in this shape: the index was never written. It does not mean the media data is gone. It means the map is gone, and the next question is whether the data underneath the missing map is still intact.

Can I fix the file by converting it with ffmpeg?

Converting the file with ffmpeg does not fix it, because ffmpeg needs the same index that the players need. The command `ffmpeg -i broken.mp4 -c copy fixed.mp4` reads the index to find the frames it is supposed to copy, and without an index it reports the same `moov atom not found` error. The conversion is useful as a comparison test — its failure confirms that the index is missing — but it is not a repair. The index has to be rebuilt first with a repair tool and a matching reference file. Only after that rebuild can ffmpeg be used on the repaired file, for example to repackage it into a different container.

What is a reference file, and why does it have to match so closely?

A reference file is a short clip recorded on the same machine, with the same settings, that plays normally. A repair tool reads the correctly written index from the reference file and applies its structure — the codec parameters, the track layout, and the frame size table — to the media data inside the damaged file. The match has to be close because the rebuilt index points at positions inside the damaged file, and those positions only line up when the codec, the resolution, the frame rate, and the container are the same. A reference file recorded with different settings produces an index that points at the wrong places, and the repaired file will not play either. The five matching requirements are a checklist, not a suggestion.

Why should I work on a copy and never touch the original file?

Because a repair tool that writes a wrong index can destroy the only chance of a second attempt. The original file is the only source of media data, and once it is overwritten or altered, the data it held cannot be got back. A copy is disposable: if a repair attempt fails on the copy, the original is still there, and a different reference file can be tried. The rule costs nothing — copying a file takes a moment — and it protects the one thing that cannot be replaced. Every test and every repair attempt in this guide runs on the copy, and the original stays untouched until the layer is identified.

Does recording in MKV really protect against this problem?

MKV protects against this exact problem because its structure is written continuously as the recording runs, rather than in a final step at the end. A crash leaves an MKV recording playable, missing only the last few seconds, while the same crash leaves a traditional MP4 recording unopenable. OBS documentation states that an unfinished MKV recording remains playable and recoverable, and it warns against recording directly to traditional MP4 for the same reason. Hybrid MP4, available in OBS from version 30.2 onwards, offers a middle road: its segmented structure survives a crash, though its chapter markers are written only at the final step and an interrupted file will have none. Neither format is a promise that no recording will ever be lost — the sources state plainly that recovery is not guaranteed — but the format decides the odds before the recording starts.

Why does OBS Remux Recordings not save my crashed MP4?

Because remuxing repackages streams that are already in a file, and finding those streams requires reading the index. A traditional MP4 with no index cannot be opened by Remux Recordings, for the same reason it cannot be opened by a player or by ffmpeg. What Remux Recordings can save is an MKV file and an unfinished Hybrid MP4 file, because their structure is still there to be read after a crash. The confusion is understandable: Remux Recordings does rescue files after a crash, but only files in formats whose structure survives a crash. It is a tool for formats designed to survive, not a repair tool for a missing index.

My repaired file plays but stops partway through. Did the repair fail?

The repair did not fail. It recovered everything that was actually written, and the rest of the recording was never written in the first place. This is the truncation layer: the disk filled up, or the writing fell behind during the recording, so the media data itself stops partway through. A repaired file that plays up to one point and then ends is the correct outcome for a truncated file, and it is also evidence — it confirms the truncation layer and it tells the reader how much of the recording survived. The missing tail cannot be rebuilt by any repair tool, because a tool rebuilds an index, not media data that was never written.

The file is 0 bytes. Is there anything at all I can do?

A file of 0 bytes holds no media data, and no repair tool can rebuild an index for data that does not exist. The useful action is to confirm the reading — check the size, and check the contents in a hex viewer to confirm that the file is empty or all zeros — and then stop, keep the file as a record of what happened, and turn to prevention. For the next recording, use MKV or Hybrid MP4, check that the disk has enough free space before a long recording starts, and consider the remux step after the recording finishes. The 0-byte file is an answer, not a problem to keep working on.

Should I keep trying different repair tools until one of them works?

Trying tool after tool on the same copy is the wrong approach, and it adds risk without adding information. Each tool writes its own output, and after several runs it becomes impossible to tell which attempt changed what. The guide allows two attempts: one with a matching reference file, and a second with a different reference file if the first fails. If both fail, that is an answer — the index cannot be rebuilt from the material available — and the next step is to bring the original file and the notes from the seven steps for inspection. A third, fourth, and fifth tool run on the same copy does not change the material. It only changes the copy.

Sources

The sources below were consulted for this guide. Commercial repair-tool pages are cited as sources for the mechanism and the repair method, not as recommendations, and their fees are not presented as advice. Forum replies are dated where the date matters, because an old reply describes the tools of its time.

  1. nasrtech.dev, "OBS Recording Corrupted After a Crash? Repair the MP4" — https://www.nasrtech.dev/tools/video-repair/obs-recording/ — the moov atom is written only when recording stops; OBS warns against recording directly to traditional MP4; Remux Recordings cannot save this kind of file; Hybrid MP4 files remain recoverable after a crash; MKV files retain the recording up to the crash; 0-byte or all-zero files cannot be repaired.
  2. nasrtech.dev, "FFmpeg 'Detected Only With Low Score of 1, Misdetection Possible' on an MP4" — https://www.nasrtech.dev/tools/video-repair/ffmpeg-misdetection-possible/ — ffprobe reporting `moov atom not found` means the file has media data but no descriptive section; no ffmpeg flag repairs it; untrunc with a healthy reference file recorded on the same machine with the same settings is one free method.
  3. amazemend.com, "How to Fix Moov Atom Not Found in MP4/MOV" — https://www.amazemend.com/blogs/fix-moov-atom-not-found-error-in-videos-easily — the first step is to back up the original and work on a copy; interrupted files fall into three situations that need different handling; the `+faststart` flag moves an existing moov atom and cannot create one that does not exist.
  4. obsproject.com, OBS Forums, "Corrupted .Mp4 file, OBS crashed before finishing file." — https://obsproject.com/forum/threads/corrupted-mp4-file-obs-crashed-before-finishing-file.2325/ — a user recorded a 4.4 GB file that would not open after OBS crashed; a reply from the era of OBS 0.472b, around 2013, described a file without a moov atom as unusable and noted that OBS does not use a fixed frame rate or a fixed bitrate. That reply describes its era and is not a conclusion about current versions.
  5. unifab.ai, "MKV vs MP4 in OBS: Hybrid and Fragmented MP4 Compared" — https://unifab.ai/resource/mkv-vs-mp4-obs — Hybrid MP4 is the default on Windows and Linux in OBS 32, and Hybrid MOV is the default on macOS; crash experiments in OBS 30.2.4 showed traditional MP4 depending on a clean finish while MKV and segmented methods retained far more usable media; chapter markers are written at the final step, so an interrupted file has none; recoverable media does not equal fully recoverable metadata.
  6. onestream.live, "MKV vs MP4: The Recording Mistake Killing Pre-Recorded Videos" — https://onestream.live/blog/mkv-vs-mp4-for-pre-recorded-streaming/ — the MP4 index is written last, so a crash before the finish leaves nothing; MKV is fault-tolerant by design and retains the recording up to the crash, missing only a few seconds; recording in MKV and remuxing to MP4 afterwards repackages without re-encoding; OBS 30.2 added Hybrid MP4, which imitates the crash resilience of MKV, while MKV remains the most reliable road.
  7. rottenwifi.com, "Best OBS Recording Format for a 24/7 Stream: MKV, MP4 & Remuxing" — https://rottenwifi.com/obs-recording-format-settings-to-protect-local-backups-of-a-24-7-stream/ — a secondhand quotation of OBS documentation stating that unfinished MKV recordings remain playable and recoverable, traditional MP4 and MOV recordings may not be recoverable, and Hybrid MP4 can be recovered after an interrupted write; Hybrid MP4 supports H.264, HEVC, and AV1, and Hybrid MOV supports H.264, HEVC, and ProRes.
  8. gitvaults.com, "Repair corrupted MP4 videos using Untrunc on Windows" — https://www.gitvaults.com/guides/repair-corrupted-mp4-untrunc-windows/ — updated 2026-11-17; untrunc needs a reference video with the same codec, resolution, frame rate, and container version as the damaged file; the reference provides the correct header, which untrunc copies into the damaged file; the first step is always to work on a copy of the damaged file; no guarantee applies, and success depends on the extent of the damage and how closely the reference file matches.
  9. streamsalvage.com, "untrunc: Repair Broken MP4 Files Without the Command Line" — https://www.streamsalvage.com/guides/untrunc-alternative — untrunc is a free open-source tool that repairs MP4 and MOV files whose moov atom was never written; its method is a reference file recorded on the same device with the same settings; the footage was never lost, only the map; Linux and macOS builds need compiling from source, and Windows users generally use an unofficial precompiled binary or WSL; the tool has no preview, so the output file has to be opened and checked for audio-video sync by hand.

A recording file that will not open after a crash is not automatically a lost recording. Check the size first, then the ffprobe reading, then the container. Those three tests say whether the data is still there, whether the index is the missing piece, and whether a repair is worth attempting — and they say it before any tool is run.

Related articles

Related services

If you need Power connector repair, see these service pages: