public void decodeTest16() { RsDecode16 target = new RsDecode16(4); byte[] data = new byte[1024]; byte[] parity = new byte[] { 193, 3, 222, 151, 9, 2, 128, 246 }; byte[] dataplus = new byte[data.Length + parity.Length]; Random rnd = new Random(2314); rnd.NextBytes(data); Array.Copy(data, 0, dataplus, 0, data.Length); Array.Copy(parity, 0, dataplus, data.Length, parity.Length); for (int i = 0; i < 1000; i++) { int pos1 = (int)(rnd.NextDouble() * 1023); int pos2 = (int)(rnd.NextDouble() * 1023); if (Math.Abs(pos1 - pos2) < 4) pos2 = (pos1 + 4) % 1024; dataplus[pos1] = (byte)(rnd.NextDouble() * 255); dataplus[pos2] = (byte)(rnd.NextDouble() * 255); if (data[pos1] == dataplus[pos1]) dataplus[pos1] ^= 1; if (data[pos2] == dataplus[pos2]) dataplus[pos2] ^= 8; //dataplus[(int)(rnd.NextDouble() * 1023)] = (byte)(rnd.NextDouble() * 255); int errors; bool ok = target.decode(dataplus, 0, dataplus.Length, false, out errors); byte[] fixed_data = new byte[data.Length]; Array.Copy(dataplus, fixed_data, data.Length); Assert.AreEqual(true, ok, "Fail"); Assert.AreEqual(2, errors, "Errors"); CollectionAssert.AreEqual(data, fixed_data); } }
public unsafe CDRepairFix VerifyParity(ushort[,] syn2, uint crc, int actualOffset) { int npar2 = syn2.GetLength(1); int npar = Math.Min(AccurateRipVerify.maxNpar, npar2); var erroff = new int[stride * npar / 2]; var forney = new ushort[stride * npar / 2]; var syn1 = ar.GetSyndrome(npar, -1, -actualOffset); var rs = new RsDecode16(npar, this.galois); CDRepairFix fix = new CDRepairFix(this, npar); fix.actualOffset = actualOffset; fix.correctableErrors = 0; fix.hasErrors = false; fix.canRecover = true; fixed (ushort *psyn2 = syn2, psyn1 = syn1) { int sfLen = npar / 2 + 2; int ofLen = npar / 2 + 1; int efLen = npar / 2; int* _sigma = stackalloc int[npar / 2 + 2]; int* _omega = stackalloc int[npar / 2 + 1]; int* _errpos = stackalloc int[npar / 2]; int* syn = stackalloc int[npar]; int offset = fix.actualOffset; for (int part2 = 0; part2 < stride; part2++) { ushort* syn1part = psyn1 + part2 * npar; ushort* syn2part = psyn2 + part2 * npar; int err = 0; for (int i = 0; i < npar; i++) { var synI = syn1part[i] ^ syn2part[i]; syn[i] = synI; err |= synI; } if (err != 0) { int errcount = rs.calcSigmaMBM(_sigma, syn); fix.hasErrors = true; if (errcount <= 0 || errcount > efLen || !rs.chienSearch(_errpos, stridecount, errcount, _sigma)) { fix.canRecover = false; return fix; } galois.mulPoly(_omega, _sigma, syn, ofLen, sfLen, npar); for (int i = 0; i < errcount; i++) { int pos = galois.toPos(stridecount, _errpos[i]) * stride + part2; int erroffi = stride + pos + pregap * 2 - actualOffset * 2; ushort diff = (ushort)this.galois.doForney(errcount, _errpos[i], _sigma, _omega); if (erroffi < pregap * 2 || erroffi >= finalSampleCount * 2) { fix.canRecover = false; return fix; } crc ^= Crc32.Combine(Crc32.ComputeChecksum(Crc32.ComputeChecksum(0, (byte)diff), (byte)(diff >> 8)), 0, (stridecount * stride - pos - 1) * 2); erroff[fix.correctableErrors] = erroffi; forney[fix.correctableErrors] = diff; fix.correctableErrors++; } } } crc ^= ar.CTDBCRC(-actualOffset); if (crc != 0) { fix.canRecover = false; return fix; } } fix.erroffsorted = new int[fix.correctableErrors]; fix.forneysorted = new ushort[fix.correctableErrors]; for (int i = 0; i < fix.correctableErrors; i++) { fix.erroffsorted[i] = erroff[i]; fix.forneysorted[i] = forney[i]; } Array.Sort<int, ushort>(fix.erroffsorted, fix.forneysorted, 0, fix.correctableErrors); return fix; }
public unsafe bool FindOffset(ushort[,] syn2, uint expectedCRC, out int actualOffset, out bool hasErrors) { int npar2 = syn2.GetLength(1); int npar = Math.Min(AccurateRipVerify.maxNpar, npar2); if (npar2 != npar) throw new Exception("npar mismatch"); if (ar.Position != ar.FinalSampleCount) throw new Exception("ar.Position != ar.FinalSampleCount"); var rs = new RsDecode16(npar, this.galois); fixed (ushort* syn2part = syn2) { int* _sigma = stackalloc int[npar]; int* _errpos = stackalloc int[npar]; int* syn = stackalloc int[npar]; int bestOffset = 0; int bestOffsetErrors = npar / 2; // fast search for (int offset = 1 - stride / 2; offset < stride / 2; offset++) { var syn1 = ar.GetSyndrome(npar, 1, -offset); int err = 0; for (int i = 0; i < npar; i++) { int synI = syn1[0, i] ^ syn2part[i]; syn[i] = synI; err |= synI; } if (err == 0) { actualOffset = offset; hasErrors = ar.CTDBCRC(-offset) != expectedCRC; return true; } int err_count = rs.calcSigmaMBM(_sigma, syn); if (err_count > 0 && err_count < bestOffsetErrors && rs.chienSearch(_errpos, stridecount, err_count, _sigma)) { bestOffset = offset; bestOffsetErrors = err_count; } } if (bestOffsetErrors < npar / 2) { actualOffset = bestOffset; hasErrors = true; return true; } } actualOffset = 0; hasErrors = true; return false; }