This article is from the CD-Recordable FAQ, by Andy McFadden (firstname.lastname@example.org) with numerous contributions by others.
The following was part of an e-mail message from Jeff Arnold back in
"I do not recommend making "copies of copies" with SNAPSHOT. The reason
this does not always work is because many CDROM readers do not perform
error correction of the data when doing raw sectors reads. As a result,
you end up with errors on the copy that may or may not be correctable.
When you make a second-generation copy of the same disc, you will make a
disc that has all of the errors of the first copy, plus all of the new
errors from the second reading of the disc. The cumulative errors from
multiple copies will result in a disc that is no longer readable."
This initially generated some confusion, so further explanation is needed.
The heart of the problem is the way that that the data is read from
the source device. When a program does "raw" sector reads, it gets the
entire 2352-byte block, which includes the CD-ROM error correction data
(ECC) for the sector. Instead of applying the ECC to the sector data,
many drives just hand back the entire block, including any errors that
couldn't be corrected by the first C1/C2 layer of error correction (see
section (2-17)). When the block is written to the CD-R, the uncorrected
errors are written along with it.
The problem can be avoided completely by using "cooked" reads and writes.
Rather than create an exact duplicate of the 2352-byte source sector, cooked
reads pull off the error-corrected 2048-byte sector. The CD recorder
regenerates the appropriate error correction when the data is written.
Some drives and some software will error-correct the 2048 bytes of CD-ROM
data read in "raw" mode. This limits the risk of generation loss to errors
introduced in the ECC bytes. If the software also regenerates the ECC,
it is effectively emulating "cooked" reads and writes in "raw" mode.
This begs the question, why not just use cooked writes all the time?
First of all, some older recorders (e.g. Philips CDD2000 and HP4020i)
didn't support cooked writes. (Some others will do cooked but can't do
raw, e.g. the Pinnacle RCD-5040.) Second, not all discs use 2048-byte
MODE-1 sectors. There is no true "cooked" mode for MODE-2 data tracks;
even a block length of 2336 is considered raw, so using cooked reads won't
prevent generation loss.
It is important to emphasize that the error correction included in the data
sector is a *second* layer of protection. A clean original disc may well
have no uncorrectable errors, and will yield an exact duplicate even when
copying in "raw" mode. After a few generations, though, the duplicates are
likely to suffer some generation loss.
The original version of this quote went on to comment that Plextor and Sony
CD-ROM drives were not recommended for making copies of copies. The reason
they were singled out is because they are the only drives that explicitly
warned about this problem in their programming manuals. It is possible
that *all* CD-ROM drives behave the same way. (In fact, it is arguably the
correct behavior... you want raw data, you get raw data.)
The final answer to this question is, you can safely make copies of copies,
so long as the disc is a MODE-1 CD-ROM and you're using "cooked" writes.
Copies made with "raw" writes may suffer generation loss because of
Audio tracks don't have the second layer of ECC, and will be susceptible to
the same generation loss as data discs duplicated in "raw" mode. Some
drives may turn off some error-correcting features, such as dropped-sample
interpolation, during digital audio extraction, or may only use them when
extracting at 1x. If you want to find out what your drive is capable of,
try extracting the same track from a CD several times at different speeds,
then do a binary comparison on the results. PC owners can use the DOS "FC"
command to do this, as described in section (3-3).
It's worth noting that the C1/C2 error correction present on all types
of CDs is pretty good, so it is entirely possible to make multi-generation
copies with no errors whatsoever. The "cooked" approach for CD-ROMs just
happens to be safer.