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.
