This one is for Spath :

At the C1 stage of the CIRC decoder, up to two wrong bytes can be detected and corrected. Up to three wrong bytes can be detected but not corrected. What happens if four or five bytes are wrong ?
Can they be detected, or is the whole frame flagged as being wrong ?

Background : I'm trying to understand why I only get an integer number of wrong C1 frames when a burst error occurs on the CD, in order to finish my article about "finding the internal error correction ability of your drive".

*guesses* at 4 wrong bytes - the resulting word is only 2 bytes off of a new word - and thus will be corrected into an incorrect word. does that make sense?

edit - its usually all about the distance of the code

I don't think so. Parity bytes act as CRC. They are 32 bits, so there is one chance out of 4,294,967,296 that it could happen.

The error will be detected, but I'd like to know if the wrong bytes can still be sorted from the right ones.

spath will be back soon to answer your question

Too late BobHere was first : http://www.digital-inn.de/showthread.php?postid=55222. Thanks anyway

> Too late BobHere was first :

As usual a long, detailed and partially wrong
answer. Just consider that the whole frame is
flagged as bad for >2 errors.

Just saw I forgot to answer the second part :

> Up to three wrong bytes can be detected but
> not corrected. What happens if four or five
> bytes are wrong ? Can they be detected, or is
> the whole frame flagged as being wrong ?

First, up to 4 wrong bytes can be 100%
detected, not 3. For 5 and more wrong bytes,
you have a chance not to see the errors at all.
For 3 and more errors you cannot locate them
any more, so the whole frame is flagged as
erasure.

PS: for the good of your other forum try
asking BobHere to get a bit of _practical_
knowledge, because he's usually just
repeating what he has read and sometimes
misunderstood.

Ok. If errored symbols locations aren't known in advance, code can correct up to half as many errors as there are redundant symbols.

When error location is known in advance (thanks "side info" in demod, previous stage), it's called erasure, code is twice as powerful at erasure correction than at error correction. So C1 (as C2) can correct up to 4 erasures that happen to be "wrong bytes" "detected but not corrected" (flagged) by previous stage (EFM lookup for C1, C1 for C2).

BTW, any combination of errors and erasures can be corrected as long as 2E + S ≤ redundant symbols (E = errors, S = erasures).

Well, previous logic (for both codes) says if 3 or 4 and flagged: corrected, if more: still flagged*, if 3 or more and unflagged: 'undetected'.

I was talking about actual implementations of CIRC, not theory ; in practice,
using erasures at C1 stage is a bad idea, which is why nobody does it.

Oh, why shouldn't be done? What's practice then when unrecognized 14-bit patterns arrive at lookup?

Thanks.

It's just too dangerous for little gain. A RS stage in erasure mode
has a higher miscorrection/misdetection probability than in pure
error mode, so if such a thing happens at C1 stage, you get to C2
stage with unflagged error, which quickly leads to audible clics.

Also at C1 stage you cannot get good erasure info, since only
codewords that cannot be demodulated will be flagged. In practice
most of the bad codewords seen by the demodulator still fulfill
the runlength requirements, which means that C1 erasures would
work for only 9 codewords.

Nowadays almost every manufacturer uses a single pass 2/4 CIRC
strategy. With this configuration, when an unknown codeword is
detected by the demodulator, it is just demodulated as an arbitrarily
chosen value.

You're calling symbols codewords.

Got EFM table and realize about poor erasure info for C1 now.
Yours is practical knowledge indeed.

Yes, distance between nonbinary code two codewords is the number of symbols in which sequences differ. For RS, minimum distance corresponds to number of redundant symbols + 1, so C1/C2 dmin = 5 (encoder 'changes' each of the 4 parity symbols if 1 input byte does). From this, we can say that closest valid codeword to 4 corrupt symbols one could be* 1 "byte" off.

However, your miscorrection won't take place since whole codeword will be flagged if error mode or corrected if erasure.

What? Please don't try fighting nonsense with worse nonsense (please, no more nonsense!).

Ckin2001 is just a byte off from minimum distance and basically describes miscorrection concept, your chance for a 4 corrupted symbols codeword to be miscorrected is 'off' by 1/(2^8)^32) and actual reason is in post above, after rest of fair real facts to disagree with him.

RS ECC parity symbols have nothing to do with CRC (former are coefficients of residual from dividing shifted message polynomial by code generator over a GF, latter is an EDC in which codeword is divisible by check poly over a ring).

By nature, RS miscorrection ocurrs only when actually corrupted symbols total can be separated in a correctable quantity and that just enough to make original codeword misdetectable, obviously never smaller than minimum distance.

You mean... if previously detected, will be corrected (as erasures).