There is an awesome free tool for preventing corrupted files that I think everyone should
at least know about. What I'm talking about are PAR2 files. It's kind of a niche thing,
so while some of you may have heard of this before,
many of you probably haven't. But it can be incredibly useful and potentially a lifesaver.
So what I'm going to do is go over what these special files do and why you might
want to use them, and also talk about some free programs that will allow you
to create these files for yourself. So what exactly do these files do? Well put simply,
they contain special recovery data that you put alongside the file. And then it
can repair any kind of damage or even missing data from that original file.
It's easier if I just show you. So let's say for example, I want to protect this
here video file from corruption. Why don't I go to the computer and show you how I would do
that. All right so the program I have here is called Multipar, which is for Windows,
and don't worry if this looks complicated. I can explain the important options later.
So right now what I'll do is use this video as an example. I can drag this in,
and don't worry about these settings. These are fine, I'm just going to mess
around with these so I can show you. And then click Create, and it will create all these
weird looking Par2 files here. Don't worry about what these numbers mean right now.
Par is short for something called Parchive, which is just the overall recovery method,
and there is par1, but it's obsolete. Anyway, so I can play this video fine if I double-click it and
give it a second. So it opens up and plays, and there it is. But what if we go in and corrupt it a
little bit? So I'll open it just in Notepad++ and delete this one character, this null character.
Delete that out. And now let's see what happens if we try to play it.
Now you can see it's just a black image. It's totally messed up just from deleting
that single character. And something like this really could happen if you have a
bunch of files stored on a backup hard drive for example, for a long time, even an SSD.
There might be what's called a flipped bit, where it can be caused by anything
from a cosmic ray to a magnetic field or just degrading over time. And it's also known as
bit rot. You can actually look this up. It's a known issue that you will want to account for,
and it's also why everyone says to keep multiple copies of backups, so for stuff like this.
Now what I'm showing you will help you with this one issue,
but you still want to have multiple copies of backups for other reasons. Anyway,
so we have these recovery files. So if I double click on any of them, Multipar opens,
and you can see it says ready to recover using one recovery block. So I can hit repair,
give it a second, close that out, and if I try to play the video again. It's fine again.
It fixed that one tiny little issue. It was able to find that that was the problem and
do it. It also keeps a copy of the corrupted file, but you can just delete that once it's
done. But that's not the coolest thing. So let me do that same thing again and open this
up again. And notice you'll see how it says ready to recover using one recovery block.
So what the program does is divides the file into different segments it's calling
blocks. And you can see here that there are 1039 blocks in the video file and one
of them's messed up. So it's saying 1038 out of 1039 are good. So since
we messed up the file in one spot, there is one block that's damaged.
But you can see that these recovery files have more than one block in them. This one has 78,
77, and also 77. 232 total. And these are recovery blocks. And any of these
blocks can be used to repair any damaged blocks in the original file. So this
means I can repair a lot more than just one block, but I can actually do 232.
So let's go into this video and just mess around. Let's delete all bunch of random crap,
selecting all sorts, big swaths of it. Look at all this I'm selecting, delete that out, over here.
Just keep scrolling down and I'll save that. So now let me run this recovery file again. And look,
it says now using eight recovery blocks, but it doesn't matter what I deleted or what I messed up.
As long as there's enough blocks to repair it,
doesn't matter what was messed up. But here's the really cool thing. It doesn't matter what
recovery files I use. If I delete all of them, except for this middle one here, and I run it.
It can still recover the file as long as it has enough blocks in there.
And there's eight damaged blocks and it has 77 in the recovery,
more than enough. And here's something that's even cooler. We can even go into this recovery file
and delete a whole bunch out of it and just corrupt it.
The recovery file even. So now we have the original file and recovery file are messed up.
And if I run the recovery file now, you can notice it actually recognizes
that it's damaged and there's some recovery blocks not there,
but also that the original file is. So I can still hit repair because it still works. Look,
one recovery file complete and there's 74 blocks now. Remember before it said 77.
So it just reduced the number of blocks that can be used for recovery,
but there's still more than the eight that was required. And look,
it was still able to repair that video. So in other words, any of the recovery data can
be used to repair any part of a corrupted file. Doesn't matter what's located where.
This is actually something called "Reed-Solomon Error Correction." And as far as I'm concerned,
it's absolutely magic. I have no idea how it works. I'm not qualified to explain it.
It just does. Also, one thing to clarify is it checks and repairs entire segments at a time.
So if I open up this file, and mess up a small part at the beginning, so let's mess up these.
And then if I run the thing, you can see there's one recovery block. So
one damaged block. Now if I delete something else pretty close to it.
Delete that also near the beginning, you can see it still only needs one recovery
block because those parts that I messed up were all part of the same segment within this file.
I don't know where the divisions are, but there's a thousand of them.
So it's not like here only 75 individual characters or bytes can be repaired. No,
it's 75 separate blocks. But get ready to have your mind blown. So say we have a bunch of files,
a group of files that we want to keep together, like these 10 audio files.
I can actually drag all of these into Multipar and it will actually create the recovery files
for all of these files as a group. So I'll just keep this the same. I can click create,
and now we have a few recovery files. But now I'll just completely delete one of
these audio files. Totally gone. But if I run the recovery file, you can see it recognizes
that there's an entire file missing and it can still repair it because look,
there's 28 recovery blocks that are required for this particular file, but there's 83 available.
Now, what if I delete maybe one too many files? Let's see if this is enough to overwhelm it. Yeah.
Now you can see that it cannot actually repair the file. So this bar here. The green represents
how many good blocks are in the total. The yellow one is how many recovery blocks are available. And
this red one is how many short you are from how many you need, to be able to repair everything.
Now, how do you get more blocks? You'd set that at the beginning. I'll explain that
next. But one final quick thing I want to mention is let's say you mess up the name,
like it's misnamed. If you do it, it'll actually recognize that. Look misnamed
and it renames it. You don't actually need any recovery blocks to do that.
It just does it automatically. All right so let me explain these different settings in
this window. Probably the most important one is this redundancy slider here. And
this is the percentage of data that will be able to be recovered. Or I
should say the percentage of blocks, if they're damaged, that can be recovered.
And you could put this all the way up to a hundred percent. So if literally
the whole thing is gone, the whole file is gone, it can reconstruct it. And also,
usually the percentage you choose is going to be the amount of space that it's going to take
up as a percentage of the original file. So this file is a hundred megabytes or so.
And you can see if I get it right at 50 percent, it's a little bit more than 50 percent of the
original. In addition to percentage, you'll notice as the percentage changes, the number of recovery
blocks also changes. So this will give you how many actual blocks you can repair. Another thing
I'll point out is if you have multiple files, it will tell you down here, based on this percentage
of redundancy, how many files you'll be able to fully reconstruct if they are completely missing.
It gives you a range because some of these files are different size. So if it's all
these small files, it'll be four. But if it's these big ones, it'll be two. Now,
this block count here, this is how many total blocks the file will be
divided into. And when I say divided into, it's basically creating a map.
It's not actually splitting the file. So you can change this if you want,
but it really doesn't matter unless you maybe really wanted to control the size of the recovery
files. But I'm not going to explain how all that would work. You can also customize the number of
recovery files. And if the files are big enough, it'll actually increase this automatically.
And now you'll see as I drag this up, it actually increases the number of recovery
files by some amount based on the percentage. But you can also increase the number manually
if you want. But remember, increasing this number of recovery files doesn't
change how much data can be recovered. That's what the redundancy slider is for.
This number of recovery files is literally just how many files the recovery files are
actually split into. This stuff on the left isn't too important. This is for example,
if you want to fit it on an optical disk. It'll then fill the rest of it
with redundancy of recovery files. And this sizing scheme is if you
really want to control how the recovery files are sized, but I never touch that.
And then finally this efficiency thing is just the ratio of how much data can
be recovered compared to how much space the recovery files are taking
up. But it's usually pretty close to 100%. If you click options here,
there's a bunch of advanced stuff, but you probably won't need to ever change any of this.
I don't think I've ever looked in here. And frankly, I'm not even sure what some
of these things do, so I'm not going to get into it. But you can look through
their settings for system, GUI, client behavior, automated tasks,
and you can look through these if you want. Oh and as for how these files are named.
So the smallest and first one doesn't actually contain any recovery data.
It's basically just an index of the files and the recovery blocks in these other files. But
I believe all of these files actually have a copy of this index anyway for redundancy,
so I'm not sure it's super important. As for the rest of the recovery files here,
the number here before the plus sign is the index of the first block in it.
And the number after the plus sign is how many recovery blocks are in this file. So with these,
the first one starts at block 000 and has 78 blocks. This one starts
at block number 78 and has 77. This one starts at 155 and has 77 more.
Not super important to know this, but I figure you were wondering.
Now like I said before, Multipar is just one example of a program that can be used
to create Par2 files, but there are several others out there for different platforms. I
can mention some later, but I also want to point out a very similar recovery feature
in a program called WinRAR. Yes that's right. The program that you probably never
bought a license key for has a really cool recovery feature for archives you create.
So for example, I do actually have a WinRAR license, I'm proud to say. And if you go
into it and create a RAR archive of files, you may notice an option to add recovery
record. And this will actually include some recovery data in the archive in
case anything gets corrupted. It doesn't use Par2 files, but it's the same idea.
And it also uses that same Reed-Solomon error correction. And you can go into
the advanced tab and choose how much of a percentage you want to be the
recovery record. Similar to that redundancy option we saw in Multipar. And with this,
it's stored inside the archive. You don't have to worry about separate files or anything like that.
So I just wanted to point that out because it's really easy,
and it's a feature I think most people don't know about. And if you're wondering,
unfortunately 7-zip, a free archive program that a lot of people also use,
it does not have a recovery feature like WinRAR. Just so you know. Now as for other programs for
creating Par2 files, like I said, multipar is only for Windows but there are other options.
Wikipedia actually has a list of them which summarizes them well. So
I can just show that here. Some of these are command line only, some have GUIs,
but some are not maintained anymore. Like QuickPar hasn't been updated since 2004,
but Multipar is still being updated. It looks like this one, Par2Deep, which is cross-platform and
has a GUI, might be worth trying if you're on Mac or Linux, but it does run on Python.
So you'll need to know how to install Python scripts. It has an MSI installer for Windows,
but if you're using Windows you may as well use Multipar. I think that's the best one in
my opinion. But maybe you know about a better option that I didn't know about,
and you can let us know down in the comments.
Anyway so hopefully this video comes in handy, especially if you do a lot
of archiving of important files that you're not going to touch for a while. You might
be happy to know that you can prevent them from getting corrupted or having
bit rot or anything like that. So let me know what you think down in the comments.
If you enjoyed this video, be sure to give it a big thumbs up. And if you want to keep watching,
the next video I'd recommend is one where I talked about an interesting internet connector
called SFP that not a lot of people have heard of, but it's really cool. So I'll put that link
right there. So thanks so much for watching everyone, and I'll see you in the next one.