Optimizing verification

CUETools.AccurateRip/AccurateRip.cs

@@ -16,11 +16,13 @@ namespace CUETools.AccurateRip
 			this.proxy = proxy;
 			_toc = toc;
 			_accDisks = new List<AccDisk>();
-			_crc32 = new Crc32();
+			//_crc32 = new Crc32();
 			_hasLogCRC = false;
 			_CRCLOG = new uint[_toc.AudioTracks + 1];
-			for (int i = 0; i <= _toc.AudioTracks; i++)
+			_CRCMASK = new uint[_toc.AudioTracks + 1];
-				_CRCLOG[i] = 0;
+			_CRCMASK[0] = 0xffffffff ^ Crc32.Combine(0xffffffff, 0, (int)_toc.AudioLength * 588 * 4);
+			for (int iTrack = 1; iTrack <= _toc.AudioTracks; iTrack++)
+				_CRCMASK[iTrack] = 0xffffffff ^ Crc32.Combine(0xffffffff, 0, (int)_toc[iTrack + _toc.FirstAudio - 1].Length * 588 * 4);
 			Init();
 		}
 
@@ -160,39 +162,50 @@ namespace CUETools.AccurateRip
 			return CRC32(iTrack, 0);
 		}
 
+		public uint GetCRC32(uint crcA, int lenA, uint crcB, int lenB)
+		{
+			int lenAXB = (int)_toc.AudioLength * 588 * 4;
+			int lenXB = lenAXB - lenA;
+			int lenX = lenXB - lenB;
+			uint crcAXB = CRC32(0, 0) ^ _CRCMASK[0];
+			uint crcXB = Crc32.Combine(crcA, crcAXB, lenXB);
+			uint crcX = Crc32.Substract(crcXB, crcB, lenB);
+			return Crc32.Combine(0xffffffff, crcX, lenX) ^ 0xffffffff;
+		}
+
 		public uint CRC32(int iTrack, int oi)
 		{
 			if (_CacheCRC32[iTrack, _arOffsetRange + oi] == 0)
 			{
-				uint crc = 0xffffffff;
+				uint crc = 0;
 				if (iTrack == 0)
 				{
 					for (iTrack = 0; iTrack <= _toc.AudioTracks; iTrack++)
 					{
 						int trackLength = (int)(iTrack > 0 ? _toc[iTrack + _toc.FirstAudio - 1].Length : _toc[_toc.FirstAudio].Pregap) * 588 * 4;
 						if (oi < 0 && iTrack == 0)
-							crc = _crc32.Combine(crc, 0, -oi * 4);
+							crc = Crc32.Combine(crc, 0, -oi * 4);
 						if (trackLength == 0)
 							continue;
 						if (oi > 0 && (iTrack == 0 || (iTrack == 1 && _toc[_toc.FirstAudio].Pregap == 0)))
 						{
 							// Calculate track CRC skipping first oi samples by 'subtracting' their CRC
-							crc = _crc32.Combine(_CRC32[iTrack, oi], _CRC32[iTrack, 0], trackLength - oi * 4);
+							crc = Crc32.Combine(_CRC32[iTrack, oi], _CRC32[iTrack, 0], trackLength - oi * 4);
-							// Use 0xffffffff as an initial state
-							crc = _crc32.Combine(0xffffffff, crc, trackLength - oi * 4);
 						}
 						else if (oi < 0 && iTrack == _toc.AudioTracks)
 						{
-							crc = _crc32.Combine(crc, _CRC32[iTrack, 20 * 588 + oi], trackLength + oi * 4);
+							crc = Crc32.Combine(crc, _CRC32[iTrack, 20 * 588 + oi], trackLength + oi * 4);
 						}
 						else
 						{
-							crc = _crc32.Combine(crc, _CRC32[iTrack, 0], trackLength);
+							crc = Crc32.Combine(crc, _CRC32[iTrack, 0], trackLength);
 						}
 						if (oi > 0 && iTrack == _toc.AudioTracks)
-							crc = _crc32.Combine(crc, 0, oi * 4);
+							crc = Crc32.Combine(crc, 0, oi * 4);
 					}
 					iTrack = 0;
+					// Use 0xffffffff as an initial state
+					crc ^= _CRCMASK[0];
 				}
 				else
 				{
@@ -200,31 +213,27 @@ namespace CUETools.AccurateRip
 					if (oi > 0)
 					{
 						// Calculate track CRC skipping first oi samples by 'subtracting' their CRC
-						crc = _crc32.Combine(_CRC32[iTrack, oi], _CRC32[iTrack, 0], trackLength - oi * 4);
+						crc = Crc32.Combine(_CRC32[iTrack, oi], _CRC32[iTrack, 0], trackLength - oi * 4);
-						// Use 0xffffffff as an initial state
-						crc = _crc32.Combine(0xffffffff, crc, trackLength - oi * 4);
 						// Add oi samples from next track CRC
+						crc = Crc32.Combine(crc, 0, oi * 4);
 						if (iTrack < _toc.AudioTracks)
-							crc = _crc32.Combine(crc, _CRC32[iTrack + 1, oi], oi * 4);
+							crc ^= _CRC32[iTrack + 1, oi];
-						else
-							crc = _crc32.Combine(crc, 0, oi * 4);
 					}
 					else if (oi < 0)
 					{
 						// Calculate CRC of previous track's last oi samples by 'subtracting' it's last CRCs
-						crc = _crc32.Combine(_CRC32[iTrack - 1, 20 * 588 + oi], _CRC32[iTrack - 1, 0], -oi * 4);
+						crc = Crc32.Combine(_CRC32[iTrack - 1, 20 * 588 + oi], _CRC32[iTrack - 1, 0], -oi * 4);
-						// Use 0xffffffff as an initial state
-						crc = _crc32.Combine(0xffffffff, crc, -oi * 4);
 						// Add this track's CRC without last oi samples
-						crc = _crc32.Combine(crc, _CRC32[iTrack, 20 * 588 + oi], trackLength + oi * 4);
+						crc = Crc32.Combine(crc, _CRC32[iTrack, 20 * 588 + oi], trackLength + oi * 4);
 					}
 					else // oi == 0
 					{
+						crc = _CRC32[iTrack, 0];
+					}
 					// Use 0xffffffff as an initial state
-						crc = _crc32.Combine(0xffffffff, _CRC32[iTrack, 0], trackLength);
+					crc ^= _CRCMASK[iTrack];
 				}
-				}
+				_CacheCRC32[iTrack, _arOffsetRange + oi] = crc;
-				_CacheCRC32[iTrack, _arOffsetRange + oi] = crc ^ 0xffffffff;
 			}
 			return _CacheCRC32[iTrack, _arOffsetRange + oi];
 		}
@@ -245,7 +254,7 @@ namespace CUETools.AccurateRip
 					{
 						int trackLength = (int)(iTrack > 0 ? _toc[iTrack + _toc.FirstAudio - 1].Length : _toc[_toc.FirstAudio].Pregap) * 588 * 4
 							- _CRCNL[iTrack, 0] * 2;
-						crc = _crc32.Combine(crc, _CRCWN[iTrack, 0], trackLength);
+						crc = Crc32.Combine(crc, _CRCWN[iTrack, 0], trackLength);
 					}
 					iTrack = 0;
 				}
@@ -257,15 +266,15 @@ namespace CUETools.AccurateRip
 						int nonzeroPrevLength = trackLength - oi * 4 -
 							(_CRCNL[iTrack, 0] - _CRCNL[iTrack, oi]) * 2;
 						// Calculate track CRC skipping first oi samples by 'subtracting' their CRC
-						crc = _crc32.Combine(
+						crc = Crc32.Combine(
 							_CRCWN[iTrack, oi],
 							_CRCWN[iTrack, 0],
 							nonzeroPrevLength);
 						// Use 0xffffffff as an initial state
-						crc = _crc32.Combine(0xffffffff, crc, nonzeroPrevLength);
+						crc = Crc32.Combine(0xffffffff, crc, nonzeroPrevLength);
 						// Add oi samples from next track CRC
 						if (iTrack < _toc.AudioTracks)
-							crc = _crc32.Combine(crc,
+							crc = Crc32.Combine(crc,
 								_CRCWN[iTrack + 1, oi],
 								oi * 4 - _CRCNL[iTrack + 1, oi] * 2);
 					}
@@ -274,21 +283,21 @@ namespace CUETools.AccurateRip
 						int nonzeroPrevLength = -oi * 4 -
 							(_CRCNL[iTrack - 1, 0] - _CRCNL[iTrack - 1, 20 * 588 + oi]) * 2;
 						// Calculate CRC of previous track's last oi samples by 'subtracting' it's last CRCs
-						crc = _crc32.Combine(
+						crc = Crc32.Combine(
 							_CRCWN[iTrack - 1, 20 * 588 + oi],
 							_CRCWN[iTrack - 1, 0],
 							nonzeroPrevLength);
 						// Use 0xffffffff as an initial state
-						crc = _crc32.Combine(0xffffffff, crc, nonzeroPrevLength);
+						crc = Crc32.Combine(0xffffffff, crc, nonzeroPrevLength);
 						// Add this track's CRC without last oi samples
-						crc = _crc32.Combine(crc,
+						crc = Crc32.Combine(crc,
 							_CRCWN[iTrack, 20 * 588 + oi],
 							trackLength + oi * 4 - _CRCNL[iTrack, 20 * 588 + oi] * 2);
 					}
 					else // oi == 0
 					{
 						// Use 0xffffffff as an initial state
-						crc = _crc32.Combine(0xffffffff, _CRCWN[iTrack, 0], trackLength - _CRCNL[iTrack, 0] * 2);
+						crc = Crc32.Combine(0xffffffff, _CRCWN[iTrack, 0], trackLength - _CRCNL[iTrack, 0] * 2);
 					}
 				}
 				_CacheCRCWN[iTrack, _arOffsetRange + oi] = crc ^ 0xffffffff;
@@ -307,6 +316,85 @@ namespace CUETools.AccurateRip
 			_CRCLOG[iTrack] = value;
 		}
 
+		private ushort[,] syndrome = new ushort[1,1];
+		private byte[] parity = new byte[1];
+		private ushort[] expTbl = new ushort[1];
+		private ushort[] logTbl = new ushort[1];
+		private int stride = 1, stridecount, npar;
+		private bool calcSyn = false;
+		private bool calcParity = false;
+
+		public void CalcSyndrome(ushort[] expTbl, ushort[] logTbl, ushort[,] syndrome, byte[] parity, int stride, int stridecount, int npar, bool calcParity, bool calcSyn)
+		{
+			if (npar != 8)
+				throw new NotSupportedException();
+			this.syndrome = syndrome;
+			this.parity = parity;
+			this.logTbl = logTbl;
+			this.expTbl = expTbl;
+			this.stride = stride;
+			this.stridecount = stridecount;
+			this.npar = npar;
+			this.calcSyn = calcSyn;
+			this.calcParity = calcParity;
+		}
+
+		private unsafe static void CalcSyn8(ushort* exp, ushort* log, ushort* syn, uint lo, uint n)
+		{
+			syn[0] ^= (ushort)lo;
+			uint idx = log[lo] + n; syn[1] ^= exp[(idx & 0xffff) + (idx >> 16)];
+			idx += n; syn[2] ^= exp[(idx & 0xffff) + (idx >> 16)];
+			idx += n; syn[3] ^= exp[(idx & 0xffff) + (idx >> 16)];
+			idx += n; syn[4] ^= exp[(idx & 0xffff) + (idx >> 16)];
+			idx += n; syn[5] ^= exp[(idx & 0xffff) + (idx >> 16)];
+			idx += n; syn[6] ^= exp[(idx & 0xffff) + (idx >> 16)];
+			idx += n; syn[7] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		}
+
+#if alternateSynCalc
+		private unsafe static void CalcSyn8Alt(ushort* exp, ushort* log, ushort* syn, uint lo, uint n)
+		{
+			uint idx = log[lo] + 7 * n;
+			ulong x = exp[(idx & 0xffff) + (idx >> 16)];
+			x <<= 16; idx -= n; x ^= exp[(idx & 0xffff) + (idx >> 16)];
+			x <<= 16; idx -= n; x ^= exp[(idx & 0xffff) + (idx >> 16)];
+			x <<= 16; idx -= n; x ^= exp[(idx & 0xffff) + (idx >> 16)];
+			((ulong*)syn)[1] ^= x;
+			idx -= n; x = exp[(idx & 0xffff) + (idx >> 16)];
+			x <<= 16; idx -= n; x ^= exp[(idx & 0xffff) + (idx >> 16)];
+			x <<= 16; idx -= n; x ^= exp[(idx & 0xffff) + (idx >> 16)];
+			((ulong*)syn)[0] ^= (x << 16) + lo;
+		}
+#endif
+
+		private unsafe static void CalcPar8(ushort* exp, ushort* log, ushort* wr, uint lo)
+		{
+			uint ib = wr[0] ^ lo;
+			if (ib != 0)
+			{
+				ushort* myexp = exp + log[ib];
+				wr[0] = (ushort)(wr[1] ^ myexp[19483]);
+				wr[1] = (ushort)(wr[2] ^ myexp[41576]);
+				wr[2] = (ushort)(wr[3] ^ myexp[9460]);
+				wr[3] = (ushort)(wr[4] ^ myexp[52075]);
+				wr[4] = (ushort)(wr[5] ^ myexp[9467]);
+				wr[5] = (ushort)(wr[6] ^ myexp[41590]);
+				wr[6] = (ushort)(wr[7] ^ myexp[19504]);
+				wr[7] = myexp[28];
+			}
+			else
+			{
+				wr[0] = wr[1];
+				wr[1] = wr[2];
+				wr[2] = wr[3];
+				wr[3] = wr[4];
+				wr[4] = wr[5];
+				wr[5] = wr[6];
+				wr[6] = wr[7];
+				wr[7] = 0;
+			}
+		}
+
 		/// <summary>
 		/// This function calculates three different CRCs and also 
 		/// collects some additional information for the purposes of 
@@ -322,16 +410,20 @@ namespace CUETools.AccurateRip
 		/// <param name="count"></param>
 		/// <param name="currentOffset"></param>
 		/// <param name="offs"></param>
-		public unsafe void CalculateCRCs(uint* pSampleBuff, int count, int currentOffset, int offs)
+		public unsafe void CalculateCRCs(uint* t, ushort* exp, ushort* log, ushort* syn, ushort* wr, uint* pSampleBuff, int count, int currentOffset, int offs)
 		{
+			int currentStride = ((int)_sampleCount * 2) / stride;
+			bool doSyn = currentStride >= 1 && currentStride <= stridecount && calcSyn;
+			bool doPar = currentStride >= 1 && currentStride <= stridecount && calcParity;
+			uint n = (uint)(stridecount - currentStride);
+
 			uint crcar = _CRCAR[_currentTrack, 0];
 			uint crcsm = _CRCSM[_currentTrack, 0];
 			uint crc32 = _CRC32[_currentTrack, 0];
 			uint crcwn = _CRCWN[_currentTrack, 0];
 			int crcnl = _CRCNL[_currentTrack, 0];
 			int peak = _Peak[_currentTrack];
-			fixed (uint* t = _crc32.table)
+			//fixed (ushort* exp = expTbl, log = logTbl, synptr = syndrome)
-			{
 			for (int i = 0; i < count; i++)
 			{
 				if (offs >= 0)
@@ -360,6 +452,9 @@ namespace CUETools.AccurateRip
 				int pk = ((int)(lo << 16)) >> 16;
 				peak = Math.Max(peak, (pk << 1) ^ (pk >> 31));
 
+				if (doSyn && lo != 0) CalcSyn8(exp, log, syn + i * 16, lo, n);
+				if (doPar) CalcPar8(exp, log, wr + i * 16, lo);
+
 				uint hi = sample >> 16;
 				crc32 = (crc32 >> 8) ^ t[(byte)(crc32 ^ hi)];
 				crc32 = (crc32 >> 8) ^ t[(byte)(crc32 ^ (hi >> 8))];
@@ -372,7 +467,9 @@ namespace CUETools.AccurateRip
 
 				pk = ((int)(hi << 16)) >> 16;
 				peak = Math.Max(peak, (pk << 1) ^ (pk >> 31));
-				}
+
+				if (doSyn && hi != 0) CalcSyn8(exp, log, syn + i * 16 + 8, hi, n);
+				if (doPar) CalcPar8(exp, log, wr + i * 16 + 8, hi);
 			}
 
 			_CRCAR[_currentTrack, 0] = crcar;
@@ -383,11 +480,41 @@ namespace CUETools.AccurateRip
 			_Peak[_currentTrack] = peak;
 		}
 
-		public void Write(AudioBuffer sampleBuffer)
+		private long _samplesRemTrack = 0;
+
+		public long Position
+		{
+			get
+			{
+				return _sampleCount;
+			}
+			set
+			{
+				_sampleCount = value;
+				int tempLocation = (int)_toc[_toc.FirstAudio][0].Start * 588;
+				for (int iTrack = 0; iTrack <= _toc.AudioTracks; iTrack++)
+				{
+					int tempLen = (int)(iTrack == 0 ? _toc[_toc.FirstAudio].Pregap : _toc[_toc.FirstAudio + iTrack - 1].Length) * 588;
+					if (tempLocation + tempLen > _sampleCount)
+					{
+						_currentTrack = iTrack;
+						_samplesRemTrack = tempLocation + tempLen - _sampleCount;
+						return;
+					}
+					tempLocation += tempLen;
+				}
+				throw new ArgumentOutOfRangeException();
+			}
+		}
+
+		public unsafe void Write(AudioBuffer sampleBuffer)
 		{
 			sampleBuffer.Prepare(this);
 
 			int pos = 0;
+			fixed (uint* t = Crc32.table)
+			fixed (ushort* exp = expTbl, log = logTbl, synptr1 = syndrome)
+			fixed (byte* pSampleBuff = &sampleBuffer.Bytes[0], bpar = parity)
 				while (pos < sampleBuffer.Length)
 				{
 					// Process no more than there is in the buffer, no more than there is in this track, and no more than up to a sector boundary.
@@ -396,26 +523,79 @@ namespace CUETools.AccurateRip
 					int currentOffset = (int)_sampleCount - (int)(_currentTrack > 0 ? _toc[_currentTrack + _toc.FirstAudio - 1].Start * 588 : 0);
 					int currentSector = currentOffset / 588;
 					int remaingSectors = (int)(_samplesRemTrack - 1) / 588;
+					uint* samples = ((uint*)pSampleBuff) + pos;
+					int currentPart = ((int)_sampleCount * 2) % stride;
+					ushort* synptr = synptr1 + npar * currentPart;
+					ushort* wr = ((ushort*)bpar) + npar * currentPart;
 
-				unsafe
-				{
-					fixed (byte* pSampleBuff = &sampleBuffer.Bytes[pos * 4])
-					{
-						uint* samples = (uint*)pSampleBuff;
 					if (currentSector < 10)
-							CalculateCRCs(samples, copyCount, currentOffset, currentOffset);
+						CalculateCRCs(t, exp, log, synptr, wr, samples, copyCount, currentOffset, currentOffset);
 					else if (remaingSectors < 10)
-							CalculateCRCs(samples, copyCount, currentOffset, 20 * 588 - (int)_samplesRemTrack);
+						CalculateCRCs(t, exp, log, synptr, wr, samples, copyCount, currentOffset, 20 * 588 - (int)_samplesRemTrack);
 					else if (currentSector >= 445 && currentSector <= 455)
-							CalculateCRCs(samples, copyCount, currentOffset, 20 * 588 + currentOffset - 445 * 588);
+						CalculateCRCs(t, exp, log, synptr, wr, samples, copyCount, currentOffset, 20 * 588 + currentOffset - 445 * 588);
 					else
-							CalculateCRCs(samples, copyCount, currentOffset, -1);
+						CalculateCRCs(t, exp, log, synptr, wr, samples, copyCount, currentOffset, -1);
-					}
+
-				}
 					pos += copyCount;
 					_samplesRemTrack -= copyCount;
 					_sampleCount += copyCount;
-				CheckPosition();
+
+					while (_samplesRemTrack <= 0)
+					{
+						if (++_currentTrack > _toc.AudioTracks)
+							return;
+						_samplesRemTrack = _toc[_currentTrack + _toc.FirstAudio - 1].Length * 588;
+					}
+				}
+		}
+
+		public void Combine(AccurateRipVerify part, int start, int end)
+		{
+			for (int iTrack = 0; iTrack <= _toc.AudioTracks; iTrack++)
+			{
+				int tempLocation = (int) (iTrack == 0 ? _toc[_toc.FirstAudio][0].Start : _toc[_toc.FirstAudio + iTrack - 1].Start) * 588;
+				int tempLen = (int) (iTrack == 0 ? _toc[_toc.FirstAudio].Pregap : _toc[_toc.FirstAudio + iTrack - 1].Length) * 588;
+				int trStart = Math.Max(tempLocation, start);
+				int trEnd = Math.Min(tempLocation + tempLen, end);
+				if (trStart >= trEnd)
+					continue;
+
+				uint crcar = _CRCAR[iTrack, 0];
+				uint crcsm = _CRCSM[iTrack, 0];
+				uint crc32 = _CRC32[iTrack, 0];
+				uint crcwn = _CRCWN[iTrack, 0];
+				int crcnl = _CRCNL[iTrack, 0];
+				_CRCAR[iTrack, 0] = crcar + part._CRCAR[iTrack, 0];
+				_CRCSM[iTrack, 0] = crcsm + part._CRCSM[iTrack, 0];
+				_CRCNL[iTrack, 0] = crcnl + part._CRCNL[iTrack, 0];
+				_CRC32[iTrack, 0] = Crc32.Combine(crc32, part._CRC32[iTrack, 0], 4 * (trEnd - trStart));
+				_CRCWN[iTrack, 0] = Crc32.Combine(crcwn, part._CRCWN[iTrack, 0], 4 * (trEnd - trStart) - 2 * part._CRCNL[iTrack, 0]);
+				for (int i = 1; i < 31 * 588; i++)
+				{
+					int currentOffset;
+					if (i < 10 * 588)
+					{
+						currentOffset = tempLocation + i;
+					}
+					else if (i < 20 * 588)
+					{
+						currentOffset = tempLocation + tempLen + i - 20 * 588;
+					}
+					else
+					{
+						currentOffset = tempLocation + i - 20 * 588 + 445 * 588;
+					}
+					if (currentOffset <= trStart)
+						continue;
+
+					_CRCAR[iTrack, i] = crcar + part._CRCAR[iTrack, i];
+					_CRCSM[iTrack, i] = crcsm + part._CRCSM[iTrack, i];
+					_CRCNL[iTrack, i] = crcnl + part._CRCNL[iTrack, i];
+					_CRC32[iTrack, i] = Crc32.Combine(crc32, part._CRC32[iTrack, i], 4 * (currentOffset - trStart));
+					_CRCWN[iTrack, i] = Crc32.Combine(crcwn, part._CRCWN[iTrack, i], 4 * (currentOffset - trStart) - 2 * part._CRCNL[iTrack, i]);
+				}
+				_Peak[iTrack] = Math.Max(_Peak[iTrack], part._Peak[iTrack]);
 			}
 		}
 
@@ -430,19 +610,7 @@ namespace CUETools.AccurateRip
 			_CRCNL = new int[_toc.AudioTracks + 1, 31 * 588];
 			_Peak = new int[_toc.AudioTracks + 1];
 			_currentTrack = 0;
-			_sampleCount = _toc[_toc.FirstAudio][0].Start * 588;
+			Position = _toc[_toc.FirstAudio][0].Start * 588;
-			_samplesRemTrack = _toc[_toc.FirstAudio].Pregap * 588;
-			CheckPosition();
-		}
-
-		private void CheckPosition()
-		{
-			while (_samplesRemTrack <= 0)
-			{
-				if (++_currentTrack > _toc.AudioTracks)
-					return;
-				_samplesRemTrack = _toc[_currentTrack + _toc.FirstAudio - 1].Length * 588;
-			}
 		}
 
 		private uint readIntLE(byte[] data, int pos)
@@ -938,23 +1106,22 @@ namespace CUETools.AccurateRip
 		}
 
 		CDImageLayout _toc;
-		long _sampleCount, _finalSampleCount, _samplesRemTrack;
+		long _sampleCount, _finalSampleCount;
 		int _currentTrack;
 		private List<AccDisk> _accDisks;
 		private HttpStatusCode _accResult;
-		private uint[,] _CRCAR;
+		internal uint[,] _CRCAR;
-		private uint[,] _CRCSM;
+		internal uint[,] _CRCSM;
-		private uint[,] _CRC32;
+		internal uint[,] _CRC32;
-		private uint[,] _CRCWN;
+		internal uint[,] _CRCWN;
-		private int[,] _CRCNL;
+		internal int[,] _CRCNL;
 		private uint[,] _CacheCRCWN;
 		private uint[,] _CacheCRC32;
-		private int[] _Peak;
+		internal int[] _Peak;
 		private uint[] _CRCLOG;
+		private uint[] _CRCMASK;
 		private IWebProxy proxy;
 
-		Crc32 _crc32;
-
 		private bool _hasLogCRC;
 
 		private const int _arOffsetRange = 5 * 588 - 1;

CUETools.CDRepair/CDRepair.cs

@@ -1,8 +1,11 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Text;
+using CUETools.CDImage;
 using CUETools.Codecs;
 using CUETools.Parity;
+using CUETools.AccurateRip;
 
 namespace CUETools.CDRepair
 {
@@ -12,8 +15,7 @@ namespace CUETools.CDRepair
 		protected int finalSampleCount;
 		protected Galois galois;
 		protected RsDecode rs;
-		protected Crc32 crc32;
+		//protected uint crc;
-		protected uint crc;
 		protected int[] encodeGx;
 		protected int stride;
 		protected int laststride;
@@ -28,7 +30,7 @@ namespace CUETools.CDRepair
 			sampleCount = 0;
 			galois = Galois16.instance;
 			rs = new RsDecode16(npar, galois);
-			crc32 = new Crc32();
+			//crc32 = new Crc32();
 			//crc = 0xffffffff;
 			encodeGx = galois.makeEncodeGxLog(npar);
 			laststride = stride + (finalSampleCount * 2) % stride;
@@ -104,14 +106,6 @@ namespace CUETools.CDRepair
 				return npar;
 			}
 		}
-
-		public uint CRC
-		{
-			get
-			{
-				return crc32.Combine(0xffffffff, crc, stride * 2 * stridecount) ^ 0xffffffff;
-			}
-		}
 	}
 
 	public class CDRepairEncode : CDRepair
@@ -122,26 +116,29 @@ namespace CUETools.CDRepair
 		protected ushort[] leadout;
 		protected bool verify;
 		protected bool encode;
-		protected uint crcA, crcB;
+		protected AccurateRipVerify ar;
 
-		public CDRepairEncode(int finalSampleCount, int stride, int npar, bool verify, bool encode)
+		public CDRepairEncode(int finalSampleCount, int stride, int npar, bool verify, bool encode, AccurateRipVerify ar)
 		    : base (finalSampleCount, stride, npar)
 		{
+			this.ar = ar;
 			this.verify = verify;
 			this.encode = encode;
 			parity = new byte[stride * npar * 2];
 			if (verify)
-			{
 				syndrome = new ushort[stride, npar];
+			else
+				syndrome = new ushort[1, npar];
+
+			ar.CalcSyndrome(galois.ExpTbl, galois.LogTbl, syndrome, parity, stride, stridecount, npar, encode, verify);
+
 			leadin = new ushort[stride * 2];
 			leadout = new ushort[stride + laststride];
-			} else
-				syndrome = new ushort[1, npar];
 		}
 
 		private unsafe void ProcessStride(int currentStride, int currentPart, int count, ushort* data)
 		{
-			fixed (uint* crct = crc32.table)
+			fixed (uint* crct = Crc32.table)
 			fixed (byte* bpar = parity)
 			fixed (ushort* exp = galois.ExpTbl, log = galois.LogTbl, synptr = syndrome)
 			fixed (int* gx = encodeGx)
@@ -152,8 +149,8 @@ namespace CUETools.CDRepair
 					ushort* wr = ((ushort*)par) + part * npar;
 					ushort dd = data[pos];
 
-					crc = (crc >> 8) ^ crct[(byte)(crc ^ dd)];
+					//crc = (crc >> 8) ^ crct[(byte)(crc ^ dd)];
-					crc = (crc >> 8) ^ crct[(byte)(crc ^ (dd >> 8))];
+					//crc = (crc >> 8) ^ crct[(byte)(crc ^ (dd >> 8))];
 
 					if (verify)
 					{
@@ -180,70 +177,68 @@ namespace CUETools.CDRepair
 				}
 		}
 
-		private unsafe void ProcessStride8(int currentStride, int currentPart, int count, ushort* data)
+		//private unsafe void ProcessStride8(int currentStride, int currentPart, int count, ushort* data, byte* bpar, ushort* synptr, ushort* exp, ushort* log)
-		{
+		//{
-			fixed (uint* crct = crc32.table)
+		//    int n = stridecount - currentStride;
-			fixed (byte* bpar = parity)
-			fixed (ushort* exp = galois.ExpTbl, log = galois.LogTbl, synptr = syndrome)
-				for (int pos = 0; pos < count; pos++)
-				{
-					ushort* par = (ushort*)bpar;
-					int part = currentPart + pos;
-					ushort* wr = par + part * 8;
-					ushort dd = data[pos];
 
-					crc = (crc >> 8) ^ crct[(byte)(crc ^ dd)];
+		//    for (int pos = 0; pos < count; pos++)
-					crc = (crc >> 8) ^ crct[(byte)(crc ^ (dd >> 8))];
+		//    {
+		//        int part = currentPart + pos;
+		//        ushort dd = data[pos];
 
-					if (encode)
+		//        //crc = (crc >> 8) ^ crct[(byte)(crc ^ dd)];
-					{
+		//        //crc = (crc >> 8) ^ crct[(byte)(crc ^ (dd >> 8))];
-						int ib = wr[0] ^ dd;
-						if (ib != 0)
-						{
-							ushort* myexp = exp + log[ib];
-							wr[0] = (ushort)(wr[1] ^ myexp[19483]);
-							wr[1] = (ushort)(wr[2] ^ myexp[41576]);
-							wr[2] = (ushort)(wr[3] ^ myexp[9460]);
-							wr[3] = (ushort)(wr[4] ^ myexp[52075]);
-							wr[4] = (ushort)(wr[5] ^ myexp[9467]);
-							wr[5] = (ushort)(wr[6] ^ myexp[41590]);
-							wr[6] = (ushort)(wr[7] ^ myexp[19504]);
-							wr[7] = myexp[28];
-						}
-						else
-						{
-							wr[0] = wr[1];
-							wr[1] = wr[2];
-							wr[2] = wr[3];
-							wr[3] = wr[4];
-							wr[4] = wr[5];
-							wr[5] = wr[6];
-							wr[6] = wr[7];
-							wr[7] = 0;
-						}
-					}
 
-					// syn[i] += data[pos] * α^(n*i)
+		//        //if (encode)
-					if (verify && dd != 0)
+		//        //{
-					{
+		//        //    ushort* wr = ((ushort*)bpar) + part * 8;
-						int n = stridecount - currentStride;
+		//        //    int ib = wr[0] ^ dd;
-						ushort* syn = synptr + part * 8;
+		//        //    if (ib != 0)
-						syn[0] ^= dd;
+		//        //    {
-						int idx = log[dd];
+		//        //        ushort* myexp = exp + log[ib];
-						idx += n; syn[1] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //        wr[0] = (ushort)(wr[1] ^ myexp[19483]);
-						idx += n; syn[2] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //        wr[1] = (ushort)(wr[2] ^ myexp[41576]);
-						idx += n; syn[3] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //        wr[2] = (ushort)(wr[3] ^ myexp[9460]);
-						idx += n; syn[4] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //        wr[3] = (ushort)(wr[4] ^ myexp[52075]);
-						idx += n; syn[5] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //        wr[4] = (ushort)(wr[5] ^ myexp[9467]);
-						idx += n; syn[6] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //        wr[5] = (ushort)(wr[6] ^ myexp[41590]);
-						idx += n; syn[7] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //        wr[6] = (ushort)(wr[7] ^ myexp[19504]);
-					}
+		//        //        wr[7] = myexp[28];
-				}
+		//        //    }
-		}
+		//        //    else
+		//        //    {
+		//        //        wr[0] = wr[1];
+		//        //        wr[1] = wr[2];
+		//        //        wr[2] = wr[3];
+		//        //        wr[3] = wr[4];
+		//        //        wr[4] = wr[5];
+		//        //        wr[5] = wr[6];
+		//        //        wr[6] = wr[7];
+		//        //        wr[7] = 0;
+		//        //    }
+		//        //}
+
+		//        // syn[i] += data[pos] * α^(n*i)
+
+		//        //if (verify && dd != 0)
+		//        //{
+		//        //    ushort* syn = synptr + part * 8;
+		//        //    syn[0] ^= dd;
+		//        //    int idx = log[dd];
+		//        //    idx += n; syn[1] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //    idx += n; syn[2] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //    idx += n; syn[3] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //    idx += n; syn[4] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //    idx += n; syn[5] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //    idx += n; syn[6] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //    idx += n; syn[7] ^= exp[(idx & 0xffff) + (idx >> 16)];
+		//        //}
+		//    }
+		//}
 
 		private unsafe void ProcessStride16(int currentStride, int currentPart, int count, ushort* data)
 		{
-			fixed (uint* crct = crc32.table)
+			fixed (uint* crct = Crc32.table)
 			fixed (byte* bpar = parity)
 			fixed (ushort* exp = galois.ExpTbl, log = galois.LogTbl, synptr = syndrome)
 				for (int pos = 0; pos < count; pos++)
@@ -253,8 +248,8 @@ namespace CUETools.CDRepair
 					ushort* wr = par + part * 16;
 					ushort dd = data[pos];
 
-					crc = (crc >> 8) ^ crct[(byte)(crc ^ dd)];
+					//crc = (crc >> 8) ^ crct[(byte)(crc ^ dd)];
-					crc = (crc >> 8) ^ crct[(byte)(crc ^ (dd >> 8))];
+					//crc = (crc >> 8) ^ crct[(byte)(crc ^ (dd >> 8))];
 
 					int ib = wr[0] ^ dd;
 					if (ib != 0)
@@ -344,16 +339,6 @@ namespace CUETools.CDRepair
 					int copyCount = Math.Min((sampleBuffer.Length - offs) * 2, stride - currentPart);
 					ushort* data = ((ushort*)bytes) + offs * 2;
 
-					if (verify)
-					{
-						// remember CRC after leadin
-						if (sampleCount * 2 == stride * 2)
-							crcA = crc;
-
-						// remember CRC before leadout
-						if ((finalSampleCount - sampleCount) * 2 == stride + laststride)
-							crcB = crc;
-
 					if (currentStride < 2)
 						for (int pos = 0; pos < copyCount; pos++)
 							leadin[sampleCount * 2 + pos] = data[pos];
@@ -365,15 +350,12 @@ namespace CUETools.CDRepair
 							if (remaining < stride + laststride)
 								leadout[remaining] = data[pos];
 						}
-					}
 
 					if (currentStride >= 1 && currentStride <= stridecount)
 					{
-						if (npar == 8)
+						if (npar == 16)
-							ProcessStride8(currentStride, currentPart, copyCount, data);
-						else if (npar == 16)
 							ProcessStride16(currentStride, currentPart, copyCount, data);
-						else
+						else if (npar != 8)
 							ProcessStride(currentStride, currentPart, copyCount, data);
 					}
 
@@ -388,13 +370,21 @@ namespace CUETools.CDRepair
 			return VerifyParity(npar, parity2, 0, parity2.Length, actualOffset);
 		}
 
+		public uint CRC
+		{
+			get
+			{
+				return OffsettedCRC(0);
+			}
+		}
+
 		private unsafe uint OffsettedCRC(int actualOffset)
 		{
-			fixed (uint* crct = crc32.table)
+			fixed (uint* crct = Crc32.table)
 			{
 				// calculate leadin CRC
 				uint crc0 = 0;
-				for (int off = stride - 2 * actualOffset; off < 2 * stride; off++)
+				for (int off = 0; off < stride - 2 * actualOffset; off++)
 				{
 					ushort dd = leadin[off];
 					crc0 = (crc0 >> 8) ^ crct[(byte)(crc0 ^ dd)];
@@ -402,26 +392,14 @@ namespace CUETools.CDRepair
 				}
 				// calculate leadout CRC
 				uint crc2 = 0;
-				for (int off = laststride + stride - 1; off >= laststride + 2 * actualOffset; off--)
+				for (int off = laststride + 2 * actualOffset - 1; off >= 0; off--)
 				{
 					ushort dd = leadout[off];
 					crc2 = (crc2 >> 8) ^ crct[(byte)(crc2 ^ dd)];
 					crc2 = (crc2 >> 8) ^ crct[(byte)(crc2 ^ (dd >> 8))];
 				}
 
-				// calculate middle CRC
+				return ar.GetCRC32(crc0, (stride - 2 * actualOffset) * 2, crc2, (laststride + 2 * actualOffset) * 2);
-				uint crc1 = crc32.Combine(crcA, crcB, (stridecount - 2) * stride * 2);
-				// calculate offsettedCRC as sum of 0xffffffff, crc0, crc1, crc2;
-				return crc32.Combine(
-					0xffffffff,
-					crc32.Combine(
-						crc32.Combine(
-							crc0,
-							crc1,
-							(stridecount - 2) * stride * 2),
-						crc2,
-						(stride - 2 * actualOffset) * 2),
-					stridecount * stride * 2) ^ 0xffffffff;
 			}
 		}
 
@@ -509,7 +487,7 @@ namespace CUETools.CDRepair
 			fix.sigma = new int[stride, npar / 2 + 2];
 			fix.omega = new int[stride, npar / 2 + 1];
 			fix.errpos = new int[stride, npar / 2];
-			fix.erroff = new int[stride, npar / 2];
+			//fix.erroff = new int[stride, npar / 2];
 			fix.errors = new int[stride];
 
 			fixed (byte* par = &parity2[pos])
@@ -563,7 +541,7 @@ namespace CUETools.CDRepair
 
 					if (err != 0)
 					{
-						fixed (int* s = &fix.sigma[part, 0], o = &fix.omega[part, 0], e = &fix.errpos[part, 0], f = &fix.erroff[part, 0])
+						fixed (int* s = &fix.sigma[part, 0], o = &fix.omega[part, 0], e = &fix.errpos[part, 0])
 						{
 							fix.errors[part] = rs.calcSigmaMBM(s, syn);
 							fix.hasErrors = true;
@@ -571,11 +549,7 @@ namespace CUETools.CDRepair
 							if (fix.errors[part] <= 0 || !rs.chienSearch(e, stridecount + npar, fix.errors[part], s))
 								fix.canRecover = false;
 							else
-							{
 								galois.mulPoly(o, s, syn, npar / 2 + 1, npar, npar);
-								for (int i = 0; i < fix.errors[part]; i++)
-									f[i] = galois.toPos(stridecount + npar, e[i]);
-							}
 						}
 					}
 					else
@@ -603,14 +577,88 @@ namespace CUETools.CDRepair
 		internal int[,] sigma;
 		internal int[,] omega;
 		internal int[,] errpos;
-		internal int[,] erroff;
+		internal int[] erroffsorted;
+		internal ushort[] forneysorted;
+		internal int erroffcount;
 		internal int[] errors;
+		private BitArray affectedSectorArray;
+		private int nexterroff;
+		uint crc = 0;
 
 		public CDRepairFix(CDRepairEncode decode)
 			: base(decode)
 		{
 		}
 
+		public string AffectedSectors
+		{
+			get
+			{
+				StringBuilder sb = new StringBuilder();
+				SortErrors();
+				for (int i = 0; i < erroffcount; i++)
+				{
+					int j;
+					for (j = i + 1; j < erroffcount; j++)
+						if (erroffsorted[j] - erroffsorted[j - 1] > 2 * 588 * 5)
+							break;
+					uint sec1 = (uint)erroffsorted[i] / 2 / 588;
+					uint sec2 = (uint)erroffsorted[j - 1] / 2 / 588;
+					if (sb.Length != 0) sb.Append(",");
+					sb.Append(CDImageLayout.TimeToString(sec1));
+					if (sec1 != sec2) sb.Append("-");
+					if (sec1 != sec2) sb.Append(CDImageLayout.TimeToString(sec2));
+					i = j - 1;
+				}
+				return sb.ToString();
+			}
+		}
+
+		public BitArray AffectedSectorArray
+		{
+			get
+			{
+				if (affectedSectorArray == null)
+				{
+					affectedSectorArray = new BitArray(finalSampleCount / 588 + 1);
+					SortErrors();
+					for (int i = 0; i < erroffcount; i++)
+						affectedSectorArray[erroffsorted[i] / 2 / 588] = true;
+				}
+				return affectedSectorArray;
+			}
+		}
+
+		private int GetErrOff(int part, int i)
+		{
+			return (2 + galois.toPos(stridecount + npar, errpos[part, i]) - (stride + part + ActualOffset * 2) / stride) * stride + part;
+		}
+
+		private unsafe void SortErrors()
+		{
+			if (erroffsorted != null)
+				return;
+			erroffcount = 0;
+			erroffsorted = new int[errpos.GetLength(0) * errpos.GetLength(1)];
+			forneysorted = new ushort[errpos.GetLength(0) * errpos.GetLength(1)];
+			for (int part = 0; part < stride; part++)
+			{
+				fixed (int* s = &sigma[part, 0], o = &omega[part, 0])
+					for (int i = 0; i < errors[part]; i++)
+					{
+						erroffsorted[erroffcount] = GetErrOff(part, i);
+						if (erroffsorted[erroffcount] >= 0 && erroffsorted[erroffcount] < finalSampleCount * 2)
+						{
+							forneysorted[erroffcount] = (ushort)rs.doForney(errors[part], errpos[part, i], s, o);
+							erroffcount++;
+						}
+					}
+			}
+			Array.Sort<int, ushort>(erroffsorted, forneysorted, 0, erroffcount);
+			// assert erroffcount == CorrectableErrors
+			nexterroff = 0;
+		}
+
 		new public unsafe void Write(AudioBuffer sampleBuffer)
 		{
 			sampleBuffer.Prepare(this);
@@ -621,21 +669,18 @@ namespace CUETools.CDRepair
 			int firstPos = Math.Max(0, stride - sampleCount * 2 - ActualOffset * 2);
 			int lastPos = Math.Min(sampleBuffer.ByteLength >> 1, (finalSampleCount - sampleCount) * 2 - laststride - ActualOffset * 2);
 
+			SortErrors();
+
 			fixed (byte* bytes = sampleBuffer.Bytes)
-			fixed (uint* t = crc32.table)
+			fixed (uint* t = Crc32.table)
 			{
 				ushort* data = (ushort*)bytes;
 				for (int pos = firstPos; pos < lastPos; pos++)
 				{
-					int part = (sampleCount * 2 + pos) % stride;
+					if (sampleCount * 2 + pos == erroffsorted[nexterroff] && nexterroff < erroffsorted.Length)
-					int nerrors = errors[part];
+						data[pos] ^= forneysorted[nexterroff++];
-					fixed (int* s = &sigma[part, 0], o = &omega[part, 0], f = &erroff[part, 0])
-						for (int i = 0; i < nerrors; i++)
-							if (f[i] == (sampleCount * 2 + ActualOffset * 2 + pos) / stride - 1)
-								data[pos] ^= (ushort)rs.doForney(nerrors, errpos[part, i], s, o);
 					
 					ushort dd = data[pos];
-
 					crc = (crc >> 8) ^ t[(byte)(crc ^ dd)];
 					crc = (crc >> 8) ^ t[(byte)(crc ^ (dd >> 8))];
 				}
@@ -674,5 +719,13 @@ namespace CUETools.CDRepair
 				return actualOffset;
 			}
 		}
+
+		public uint CRC
+		{
+			get
+			{
+				return 0xffffffff ^ Crc32.Combine(0xffffffff, crc, stride * stridecount * 2);
+			}
+		}
 	}
 }

CUETools.CDRepair/CUETools.CDRepair.csproj

@@ -42,6 +42,14 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\CUETools.AccurateRip\CUETools.AccurateRip.csproj">
+      <Project>{5802C7E9-157E-4124-946D-70B5AE48A5A1}</Project>
+      <Name>CUETools.AccurateRip</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\CUETools.CDImage\CUETools.CDImage.csproj">
+      <Project>{1DD41038-D885-46C5-8DDE-E0B82F066584}</Project>
+      <Name>CUETools.CDImage</Name>
+    </ProjectReference>
     <ProjectReference Include="..\CUETools.Codecs\CUETools.Codecs.csproj">
       <Project>{6458A13A-30EF-45A9-9D58-E5031B17BEE2}</Project>
       <Name>CUETools.Codecs</Name>

CUETools.CTDB/CUETools.CTDB.csproj

@@ -47,6 +47,10 @@
     <Compile Include="UploadHelper\UploadFile.cs" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\CUETools.AccurateRip\CUETools.AccurateRip.csproj">
+      <Project>{5802C7E9-157E-4124-946D-70B5AE48A5A1}</Project>
+      <Name>CUETools.AccurateRip</Name>
+    </ProjectReference>
     <ProjectReference Include="..\CUETools.CDImage\CUETools.CDImage.csproj">
       <Project>{1DD41038-D885-46C5-8DDE-E0B82F066584}</Project>
       <Name>CUETools.CDImage</Name>

CUETools.CTDB/CUEToolsDB.cs

@@ -8,6 +8,7 @@ using System.Net;
 using System.Xml;
 using System.Text;
 using CUETools.CDImage;
+using CUETools.AccurateRip;
 using CUETools.CDRepair;
 using Krystalware.UploadHelper;
 
@@ -364,12 +365,12 @@ namespace CUETools.CTDB
 			}
 		}
 
-		public void Init(bool encode)
+		public void Init(bool encode, AccurateRipVerify ar)
 		{
 			int npar = 8;
 			foreach (DBEntry entry in entries)
 				npar = Math.Max(npar, entry.npar);
-			verify = new CDRepairEncode(length, 10 * 588 * 2, npar, entries.Count > 0, encode);
+			verify = new CDRepairEncode(length, 10 * 588 * 2, npar, entries.Count > 0, encode, ar);
 		}
 
 		public int Total

CUETools.Codecs/CRCs/CRC32.cs

@@ -4,16 +4,16 @@ using System.Text;
 
 namespace CUETools.Codecs
 {
-	public class Crc32
+	public static class Crc32
 	{
-		public uint[] table = new uint[256];
+		public static readonly uint[] table;
 
-		public uint ComputeChecksum(uint crc, byte val)
+		public static uint ComputeChecksum(uint crc, byte val)
 		{
 			return (crc >> 8) ^ table[(crc & 0xff) ^ val];
 		}
 
-		public unsafe uint ComputeChecksum(uint crc, byte* bytes, int count)
+		public static unsafe uint ComputeChecksum(uint crc, byte* bytes, int count)
 		{
 			fixed (uint *t = table)
 				for (int i = 0; i < count; i++)
@@ -21,19 +21,19 @@ namespace CUETools.Codecs
 			return crc;
 		}
 
-		public unsafe uint ComputeChecksum(uint crc, byte[] bytes, int pos, int count)
+		public static unsafe uint ComputeChecksum(uint crc, byte[] bytes, int pos, int count)
 		{
 			fixed (byte* pbytes = &bytes[pos])
 				return ComputeChecksum(crc, pbytes, count);
 		}
 
-		public uint ComputeChecksum(uint crc, uint s)
+		public static uint ComputeChecksum(uint crc, uint s)
 		{
 			return ComputeChecksum(ComputeChecksum(ComputeChecksum(ComputeChecksum(
 				crc, (byte)s), (byte)(s >> 8)), (byte)(s >> 16)), (byte)(s >> 24));
 		}
 
-		public unsafe uint ComputeChecksum(uint crc, int * samples, int count)
+		public static unsafe uint ComputeChecksum(uint crc, int* samples, int count)
 		{
 			for (int i = 0; i < count; i++)
 			{
@@ -44,7 +44,7 @@ namespace CUETools.Codecs
 			return crc;
 		}
 
-		uint Reflect(uint val, int ch)
+		static uint Reflect(uint val, int ch)
 		{
 			uint value = 0;
 			// Swap bit 0 for bit 7
@@ -60,8 +60,66 @@ namespace CUETools.Codecs
 
 		const uint ulPolynomial = 0x04c11db7;
 
-		public Crc32()
+		private static readonly uint[,] combineTable;
+		private static readonly uint[,] substractTable;
+
+#if need_invert_binary_matrix
+		static unsafe void invert_binary_matrix(uint* mat, uint* inv, int rows)
 		{
+			int cols, i, j;
+			uint tmp;
+
+			cols = rows;
+
+			for (i = 0; i < rows; i++) inv[i] = (1U << i);
+
+			/* First -- convert into upper triangular */
+
+			for (i = 0; i < cols; i++)
+			{
+
+				/* Swap rows if we ave a zero i,i element.  If we can't swap, then the 
+				   matrix was not invertible */
+
+				if ((mat[i] & (1 << i)) == 0)
+				{
+					for (j = i + 1; j < rows && (mat[j] & (1 << i)) == 0; j++) ;
+					if (j == rows)
+						throw new Exception("Matrix not invertible");
+					tmp = mat[i]; mat[i] = mat[j]; mat[j] = tmp;
+					tmp = inv[i]; inv[i] = inv[j]; inv[j] = tmp;
+				}
+
+				/* Now for each j>i, add A_ji*Ai to Aj */
+				for (j = i + 1; j != rows; j++)
+				{
+					if ((mat[j] & (1 << i)) != 0)
+					{
+						mat[j] ^= mat[i];
+						inv[j] ^= inv[i];
+					}
+				}
+			}
+
+			/* Now the matrix is upper triangular.  Start at the top and multiply down */
+
+			for (i = rows - 1; i >= 0; i--)
+			{
+				for (j = 0; j < i; j++)
+				{
+					if ((mat[j] & (1 << i)) != 0)
+					{
+						/*        mat[j] ^= mat[i]; */
+						inv[j] ^= inv[i];
+					}
+				}
+			}
+		}
+#endif
+
+		static unsafe Crc32()
+		{
+			table = new uint[256];
 			for (uint i = 0; i < table.Length; i++)
 			{
 				table[i] = Reflect(i, 8) << 24;
@@ -69,11 +127,33 @@ namespace CUETools.Codecs
 					table[i] = (table[i] << 1) ^ ((table[i] & (1U << 31)) == 0 ? 0 : ulPolynomial);
 				table[i] = Reflect(table[i], 32);
 			}
+			combineTable = new uint[GF2_DIM, GF2_DIM];
+			substractTable = new uint[GF2_DIM, GF2_DIM];
+			combineTable[0, 0] = 0xedb88320;           /* CRC-32 polynomial */
+			substractTable[0, 31] = 0xdb710641;
+			for (int n = 1; n < GF2_DIM; n++)
+			{
+				combineTable[0, n] = 1U << (n - 1);
+				substractTable[0, n - 1] = 1U << n;
+			}
+			fixed (uint* ct = &combineTable[0, 0], st = &substractTable[0, 0])
+			{
+				//for (int i = 0; i < GF2_DIM; i++)
+				//	st[32 + i] = ct[i];
+				//invert_binary_matrix(st + 32, st, GF2_DIM);
+
+				for (int i = 1; i < GF2_DIM; i++)
+				{
+					gf2_matrix_square(ct + i * 32, ct + (i - 1) * 32);
+					gf2_matrix_square(st + i * 32, st + (i - 1) * 32);
+				}
+			}
 		}
 
 		const int GF2_DIM = 32;
+		//const int GF2_DIM2 = 67;
 
-		private unsafe uint gf2_matrix_times(uint* mat, uint vec)
+		private static unsafe uint gf2_matrix_times(uint* mat, uint vec)
 		{
 			return *(mat++) * (vec & 1) ^
 			*(mat++) * ((vec >>= 1) & 1) ^
@@ -110,63 +190,67 @@ namespace CUETools.Codecs
 		}
 
 		/* ========================================================================= */
-		private unsafe void gf2_matrix_square(uint *square, uint *mat)
+		private static unsafe void gf2_matrix_square(uint *square, uint *mat)
 		{
 			for (int n = 0; n < GF2_DIM; n++)
 				square[n] = gf2_matrix_times(mat, mat[n]);
 		}
 
-
+		public static unsafe uint Combine(uint crc1, uint crc2, long len2)
-		public unsafe uint Combine(uint crc1, uint crc2, long len2)
 		{
-			int n;
-			uint row;
-			uint* even = stackalloc uint[GF2_DIM];    /* even-power-of-two zeros operator */
-			uint* odd = stackalloc uint[GF2_DIM];     /* odd-power-of-two zeros operator */
-
 			/* degenerate case */
 			if (len2 == 0)
 				return crc1;
+			if (crc1 == 0)
+				return crc2;
+			if (len2 < 0)
+				throw new ArgumentException("crc.Combine length cannot be negative", "len2");
 
-			/* put operator for one zero bit in odd */
+			fixed (uint* ct = &combineTable[0, 0])
-			odd[0] = 0xedb88320;           /* CRC-32 polynomial */
+			{
-			row = 1;
+				int n = 3;
-			for (n = 1; n < GF2_DIM; n++) {
+				do
-				odd[n] = row;
+				{
-				row <<= 1;
-			}
-
-			/* put operator for two zero bits in even */
-			gf2_matrix_square(even, odd);
-
-			/* put operator for four zero bits in odd */
-			gf2_matrix_square(odd, even);
-
-			/* apply len2 zeros to crc1 (first square will put the operator for one
-			   zero byte, eight zero bits, in even) */
-			do {
 					/* apply zeros operator for this bit of len2 */
-				gf2_matrix_square(even, odd);
 					if ((len2 & 1) != 0)
-					crc1 = gf2_matrix_times(even, crc1);
+						crc1 = gf2_matrix_times(ct + 32 * n, crc1);
 					len2 >>= 1;
-
+					n = (n + 1) & (GF2_DIM - 1);
-				/* if no more bits set, then done */
-				if (len2 == 0)
-					break;
-
-				/* another iteration of the loop with odd and even swapped */
-				gf2_matrix_square(odd, even);
-				if ((len2 & 1) != 0)
-					crc1 = gf2_matrix_times(odd, crc1);
-				len2 >>= 1;
-
 					/* if no more bits set, then done */
 				} while (len2 != 0);
+			}
 
 			/* return combined crc */
 			crc1 ^= crc2;
 			return crc1;
 		}
+
+		public static unsafe uint Substract(uint crc1, uint crc2, long len2)
+		{
+			/* degenerate case */
+			if (len2 == 0)
+				return crc1;
+			if (len2 < 0)
+				throw new ArgumentException("crc.Combine length cannot be negative", "len2");
+
+			crc1 ^= crc2;
+
+			fixed (uint* st = &substractTable[0, 0])
+			{
+				int n = 3;
+				do
+				{
+					/* apply zeros operator for this bit of len2 */
+					if ((len2 & 1) != 0)
+						crc1 = gf2_matrix_times(st + 32 * n, crc1);
+					len2 >>= 1;
+					n = (n + 1) & (GF2_DIM - 1);
+					/* if no more bits set, then done */
+				} while (len2 != 0);
+			}
+
+			/* return combined crc */
+			return crc1;
+		}
 	}
 }

CUETools.Codecs/Codecs.cs

@@ -2134,7 +2134,7 @@ namespace CUETools.Codecs
 				_bufferPos = 0;
 				_haveData = false;
 				_close = false;
-				Go();
+				//Go();
 				//throw new Exception("not supported");
 			}
 		}

CUETools.Processor/Processor.cs

@@ -742,7 +742,7 @@ namespace CUETools.Processor
 		{
 			return name;
 		}
-		public string name;
+		public string name { get; set; }
 		public bool builtin;
 		public List<CUEAction> conditions;
 		public string code;
@@ -1562,8 +1562,7 @@ string status = processor.Go();
 	public class CUEToolsProgressEventArgs : EventArgs
 	{
 		public string status = string.Empty;
-		public double percentTrck = 0;
+		public double percent = 0.0;
-		public double percentDisk = 0.0;
 		public int offset = 0;
 		public string input = string.Empty;
 		public string output = string.Empty;
@@ -1601,8 +1600,8 @@ string status = processor.Go();
 		private bool _paddedToFrame, _truncated4608, _usePregapForFirstTrackInSingleFile;
 		private int _writeOffset;
 		private CUEAction _action;
-		private bool _useAccurateRip = false;
+		internal bool _useAccurateRip = false;
-		private bool _useCUEToolsDB = false;
+		internal bool _useCUEToolsDB = false;
 		private bool _useCUEToolsDBFix = false;
 		private bool _useCUEToolsDBSibmit = false;
 		private bool _processed = false;
@@ -1790,7 +1789,7 @@ string status = processor.Go();
 
 			if (useFreedb)
 			{
-				ShowProgress("Looking up album via Freedb...", 0.0, 0.0, null, null);
+				ShowProgress("Looking up album via Freedb...", 0.0, null, null);
 
 				FreedbHelper m_freedb = new FreedbHelper();
 
@@ -1809,7 +1808,7 @@ string status = processor.Go();
 					code = m_freedb.Query(AccurateRipVerify.CalculateCDDBQuery(_toc), out queryResult, out coll);
 					if (code == FreedbHelper.ResponseCodes.CODE_200)
 					{
-						ShowProgress("Looking up album via Freedb... " + queryResult.Discid, 0.5, 0.0, null, null);
+						ShowProgress("Looking up album via Freedb... " + queryResult.Discid, 0.5, null, null);
 						code = m_freedb.Read(queryResult, out cdEntry);
 						if (code == FreedbHelper.ResponseCodes.CODE_210)
 							Releases.Add(cdEntry);
@@ -1821,7 +1820,7 @@ string status = processor.Go();
 							int i = 0;
 							foreach (QueryResult qr in coll)
 							{
-								ShowProgress("Looking up album via freedb... " + qr.Discid, 0.0, (++i + 0.0) / coll.Count, null, null);
+								ShowProgress("Looking up album via freedb... " + qr.Discid, (++i + 0.0) / coll.Count, null, null);
 								CheckStop();
 								code = m_freedb.Read(qr, out cdEntry);
 								if (code == FreedbHelper.ResponseCodes.CODE_210)
@@ -1838,7 +1837,7 @@ string status = processor.Go();
 
 			if (useMusicBrainz)
 			{
-				ShowProgress("Looking up album via MusicBrainz...", 0.0, 0.0, null, null);
+				ShowProgress("Looking up album via MusicBrainz...", 0.0, null, null);
 
 				StringCollection DiscIds = new StringCollection();
 				DiscIds.Add(_toc.MusicBrainzId);
@@ -2672,20 +2671,20 @@ string status = processor.Go();
 
 		public void UseCUEToolsDB(bool submit, string userAgent)
 		{
-			ShowProgress((string)"Contacting CUETools database...", 0, 0, null, null);
+			ShowProgress((string)"Contacting CUETools database...", 0, null, null);
 
 			_CUEToolsDB = new CUEToolsDB(_toc, proxy);
 			_CUEToolsDB.UploadHelper.onProgress += new EventHandler<Krystalware.UploadHelper.UploadProgressEventArgs>(UploadProgress);
 			_CUEToolsDB.ContactDB(userAgent);
 
-			ShowProgress("", 0.0, 0.0, null, null);
+			ShowProgress("", 0.0, null, null);
 			_useCUEToolsDB = true;
 			_useCUEToolsDBSibmit = submit;
 		}
 
 		public void UseAccurateRip()
 		{
-			ShowProgress((string)"Contacting AccurateRip database...", 0, 0, null, null);
+			ShowProgress((string)"Contacting AccurateRip database...", 0, null, null);
 			if (!_toc[_toc.TrackCount].IsAudio && DataTrackLength == 0 && _minDataTrackLength.HasValue && _accurateRipId == null && _config.bruteForceDTL)
 			{
 				uint minDTL = _minDataTrackLength.Value;
@@ -2699,7 +2698,7 @@ string status = processor.Go();
 						DataTrackLength = dtl;
 						break;
 					}
-					ShowProgress((string)"Contacting AccurateRip database...", 0, (dtl - minDTL) / 75.0, null, null);
+					ShowProgress((string)"Contacting AccurateRip database...", (dtl - minDTL) / 75.0, null, null);
 					CheckStop();
 					lock (this)
 					{
@@ -2764,26 +2763,24 @@ string status = processor.Go();
 			return _archive.Decompress(fileName);
 		}
 
-		private void ShowProgress(string status, double percentTrack, double percentDisk, string input, string output)
+		private void ShowProgress(string status, double percent, string input, string output)
 		{
 			if (this.CUEToolsProgress == null)
 				return;
 			_progress.status = status;
-			_progress.percentTrck = percentTrack;
+			_progress.percent = percent;
-			_progress.percentDisk = percentDisk;
 			_progress.offset = 0;
 			_progress.input = input;
 			_progress.output = output;
 			this.CUEToolsProgress(this, _progress);
 		}
 
-		private void ShowProgress(string status, double percentTrack, int diskOffset, int diskLength, string input, string output)
+		private void ShowProgress(string status, int diskOffset, int diskLength, string input, string output)
 		{
 			if (this.CUEToolsProgress == null)
 				return;
 			_progress.status = status;
-			_progress.percentTrck = percentTrack;
+			_progress.percent = (double)diskOffset / diskLength;
-			_progress.percentDisk = (double)diskOffset / diskLength;
 			_progress.offset = diskOffset;
 			_progress.input = input;
 			_progress.output = output;
@@ -2795,35 +2792,33 @@ string status = processor.Go();
 			CheckStop();
 			if (this.CUEToolsProgress == null)
 				return;
-			_progress.percentDisk = 0;
+			_progress.percent = e.percent;
-			_progress.percentTrck = e.percent;
 			_progress.offset = 0;
 			_progress.status = e.uri;
 			this.CUEToolsProgress(this, _progress);
 		}
 
-		private void CDReadProgress(object sender, ReadProgressArgs e)
+		//private void CDReadProgress(object sender, ReadProgressArgs e)
-		{
+		//{
-			CheckStop();
+		//    CheckStop();
-			if (this.CUEToolsProgress == null)
+		//    if (this.CUEToolsProgress == null)
-				return;
+		//        return;
-			ICDRipper audioSource = (ICDRipper)sender;
+		//    ICDRipper audioSource = (ICDRipper)sender;
-			int processed = e.Position - e.PassStart;
+		//    int processed = e.Position - e.PassStart;
-			TimeSpan elapsed = DateTime.Now - e.PassTime;
+		//    TimeSpan elapsed = DateTime.Now - e.PassTime;
-			double speed = elapsed.TotalSeconds > 0 ? processed / elapsed.TotalSeconds / 75 : 1.0;
+		//    double speed = elapsed.TotalSeconds > 0 ? processed / elapsed.TotalSeconds / 75 : 1.0;
-			_progress.percentDisk = (double)(e.PassStart + (processed + e.Pass * (e.PassEnd - e.PassStart)) / (audioSource.CorrectionQuality + 1)) / audioSource.TOC.AudioLength;
+		//    _progress.percentDisk = (double)(e.PassStart + (processed + e.Pass * (e.PassEnd - e.PassStart)) / (audioSource.CorrectionQuality + 1)) / audioSource.TOC.AudioLength;
-			_progress.percentTrck = (double) (e.Position - e.PassStart) / (e.PassEnd - e.PassStart);
+		//    _progress.percentTrck = (double) (e.Position - e.PassStart) / (e.PassEnd - e.PassStart);
-			_progress.offset = 0;
+		//    _progress.offset = 0;
-			_progress.status = string.Format("Ripping @{0:00.00}x {1}", speed, e.Pass > 0 ? " (Retry " + e.Pass.ToString() + ")" : "");
+		//    _progress.status = string.Format("Ripping @{0:00.00}x {1}", speed, e.Pass > 0 ? " (Retry " + e.Pass.ToString() + ")" : "");
-			this.CUEToolsProgress(this, _progress);
+		//    this.CUEToolsProgress(this, _progress);
-		}
+		//}
 
 		private void MusicBrainz_LookupProgress(object sender, XmlRequestEventArgs e)
 		{
 			if (this.CUEToolsProgress == null)
 				return;
-			_progress.percentDisk = (1.0 + _progress.percentDisk) / 2;
+			_progress.percent = (1.0 + _progress.percent) / 2;
-			_progress.percentTrck = 0;
 			_progress.offset = 0;
 			_progress.input = e.Uri.ToString();
 			_progress.output = null;
@@ -2836,7 +2831,7 @@ string status = processor.Go();
 			CheckStop();
 			if (this.CUEToolsProgress == null)
 				return;
-			_progress.percentTrck = e.PercentComplete / 100;
+			_progress.percent = e.PercentComplete / 100;
 			this.CUEToolsProgress(this, _progress);
 		}
 
@@ -3128,7 +3123,7 @@ string status = processor.Go();
 
 		private int GetSampleLength(string path, out TagLib.File fileInfo)
 		{
-			ShowProgress("Analyzing input file...", 0.0, 0.0, path, null);
+			ShowProgress("Analyzing input file...", 0.0, path, null);
 
 			if (Path.GetExtension(path) == ".dummy" || Path.GetExtension(path) == ".bin")
 			{
@@ -3581,8 +3576,9 @@ string status = processor.Go();
 					entry.toc.Pregap != _toc.Pregap ? string.Format("Has pregap length {0}", CDImageLayout.TimeToString(entry.toc.Pregap)) :
 					entry.toc.AudioLength != _toc.AudioLength ? string.Format("Has audio length {0}", CDImageLayout.TimeToString(entry.toc.AudioLength)) :
 					((entry.toc.TrackOffsets != _toc.TrackOffsets) ? dataTrackInfo + ", " : "") + 
-						((!entry.hasErrors) ? "Accurately ripped" :
+						//((!entry.hasErrors) ? "Accurately ripped" :
-						entry.canRecover ? string.Format("Differs in {0} samples", entry.repair.CorrectableErrors) :
+						((!entry.hasErrors) ? string.Format("Accurately ripped, offset {0}", -entry.offset) :
+						entry.canRecover ? string.Format("Differs in {0} samples @{1}", entry.repair.CorrectableErrors, entry.repair.AffectedSectors) :
 						(entry.httpStatus == 0 || entry.httpStatus == HttpStatusCode.OK) ? "No match" :
 						entry.httpStatus.ToString());
 				sw.WriteLine("        [{0:x8}] ({1}) {2}", entry.crc, conf, status);
@@ -4067,7 +4063,7 @@ string status = processor.Go();
 		{
 			if (_useAccurateRip)
 			{
-				ShowProgress((string)"Generating AccurateRip report...", 0, 0, null, null);
+				ShowProgress((string)"Generating AccurateRip report...", 0, null, null);
 				if (_action == CUEAction.Verify && _config.writeArTagsOnVerify && _writeOffset == 0 && !_isArchive && !_isCD)
 				{
 					uint tracksMatch;
@@ -4354,9 +4350,9 @@ string status = processor.Go();
 			if (_useAccurateRip)
 				_arVerify.Init();
 			if (_useCUEToolsDB && !_useCUEToolsDBFix)
-				_CUEToolsDB.Init(_useCUEToolsDBSibmit);
+				_CUEToolsDB.Init(_useCUEToolsDBSibmit, _arVerify);
 
-			ShowProgress(String.Format("{2} track {0:00} ({1:00}%)...", 0, 0, noOutput ? "Verifying" : "Writing"), 0, 0.0, null, null);
+			ShowProgress(String.Format("{2} track {0:00} ({1:00}%)...", 0, 0, noOutput ? "Verifying" : "Writing"), 0.0, null, null);
 
 #if !DEBUG
 			try
@@ -4431,8 +4427,8 @@ string status = processor.Go();
 							if (trackLength > 0 && !_isCD)
 							{
 								double trackPercent = (double)currentOffset / trackLength;
-								ShowProgress(String.Format("{2} track {0:00} ({1:00}%)...", iIndex > 0 ? iTrack + 1 : iTrack, (uint)(100 * trackPercent),
+								ShowProgress(String.Format("{2} track {0:00} ({1:00}%)...", iIndex > 0 ? iTrack + 1 : iTrack, (int)(100*trackPercent),
-									noOutput ? "Verifying" : "Writing"), trackPercent, (int)diskOffset, (int)diskLength,
+									noOutput ? "Verifying" : "Writing"), (int)diskOffset, (int)diskLength,
 									_isCD ? string.Format("{0}: {1:00} - {2}", audioSource.Path, iTrack + 1, _tracks[iTrack].Title) : audioSource.Path, discardOutput ? null : audioDest.Path);
 							}
 
@@ -4512,33 +4508,45 @@ string status = processor.Go();
 			ApplyWriteOffset();
 
 			hdcdDecoder = null;
-			if (_config.detectHDCD && CUEProcessorPlugins.hdcd != null)
-			{
-				try { hdcdDecoder = Activator.CreateInstance(CUEProcessorPlugins.hdcd, 2, 44100, 20, false) as IAudioDest; }
-				catch { }
-			}
 			if (_useAccurateRip)
 				_arVerify.Init();
 			if (_useCUEToolsDB && !_useCUEToolsDBFix)
-				_CUEToolsDB.Init(_useCUEToolsDBSibmit);
+				_CUEToolsDB.Init(_useCUEToolsDBSibmit, _arVerify);
 
-			ShowProgress(String.Format("{2} track {0:00} ({1:00}%)...", 0, 0, "Verifying"), 0, 0.0, null, null);
+			ShowProgress(String.Format("Verifying ({0:00}%)...", 0), 0.0, null, null);
 
 			AudioBuffer sampleBuffer = new AudioBuffer(AudioPCMConfig.RedBook, 0x10000);
-			IAudioSource audioSource = new CUESheetAudio(this);
+
-			if (_isCD || _config.separateDecodingThread)
+			List<CUEToolsVerifyTask> tasks = new List<CUEToolsVerifyTask>();
-				audioSource = new AudioPipe(audioSource, 0x10000);
+			// also make sure all sources are seekable!!!
+			// use overlapped io with large buffers?
+			// ar.verify in each thread?
+			int nThreads = 1;// _isCD || !_config.separateDecodingThread || _useCUEToolsDB || _config.detectHDCD ? 1 : Environment.ProcessorCount;
+
+			int diskLength = 588 * (int)_toc.AudioLength;
+			tasks.Add(new CUEToolsVerifyTask(this, 0, diskLength / nThreads, _arVerify, _CUEToolsDB));
+			for (int iThread = 1; iThread < nThreads; iThread++)
+				tasks.Add(new CUEToolsVerifyTask(this, iThread * diskLength / nThreads, (iThread + 1) * diskLength / nThreads));
 
 #if !DEBUG
 			try
 #endif
 			{
 				int lastProgress = -588 * 75;
+				int diskOffset = 0;
+				int sourcesActive;
 				do
 				{
-					if (audioSource.Position - lastProgress >= 588 * 75)
+					sourcesActive = 0;
+					for (int iSource = 0; iSource < tasks.Count; iSource++)
 					{
-						lastProgress = (int)audioSource.Position;
+						CUEToolsVerifyTask task = tasks[iSource];
+						if (task.Remaining == 0)
+							continue;
+						sourcesActive++;
+						if (tasks.Count == 1 && task.source.Position - lastProgress >= 588 * 75)
+						{
+							lastProgress = (int)task.source.Position;
 							int pos = 0;
 							int trackStart = 0;
 							int trackLength = (int)_toc.Pregap * 588;
@@ -4551,15 +4559,13 @@ string status = processor.Go();
 										trackStart = pos;
 										trackLength = (int)_toc[_toc.FirstAudio + iTrack].Length * 588;
 									}
-								if (audioSource.Position < pos + indexLen)
+									if (task.source.Position < pos + indexLen)
 									{
 										if (trackLength > 0 && !_isCD)
 										{
-										double trackPercent = (double)(audioSource.Position - trackStart) / trackLength;
+											double trackPercent = (double)(task.source.Position - trackStart) / trackLength;
-										int diskLength = 588 * (int)_toc.AudioLength;
+											ShowProgress(String.Format("{2} track {0:00} ({1:00}%)...", iIndex > 0 ? iTrack + 1 : iTrack, (int)(100*trackPercent),
-										int diskOffset = (int)audioSource.Position;
+												"Verifying"), diskOffset, diskLength, task.source.Path, null);
-										ShowProgress(String.Format("{2} track {0:00} ({1:00}%)...", iIndex > 0 ? iTrack + 1 : iTrack, (uint)(100 * trackPercent),
-											"Verifying"), trackPercent, diskOffset, diskLength, audioSource.Path, null);
 										}
 										iTrack = TrackCount;
 										break;
@@ -4567,38 +4573,33 @@ string status = processor.Go();
 									pos += indexLen;
 								}
 						}
-
+						else if (tasks.Count > 1)
-					int copyCount = audioSource.Read(sampleBuffer, -1);
-					if (copyCount == 0)
-						break;
-
-					if (_useCUEToolsDB) // !_useCUEToolsDBFix
-						_CUEToolsDB.Verify.Write(sampleBuffer);
-					if (_useAccurateRip)
-						_arVerify.Write(sampleBuffer);
-					if (hdcdDecoder != null)
 						{
-						hdcdDecoder.Write(sampleBuffer);
+							ShowProgress(String.Format("Verifying ({0:00}%)...", (uint)(100.0 * diskOffset / diskLength)),
-						if (_config.wait750FramesForHDCD && audioSource.Position > 750 * 588 && string.Format("{0:s}", hdcdDecoder) == "")
+								diskOffset, diskLength, InputPath, null);
-							hdcdDecoder = null;
 						}
 
+						int copyCount = task.Step(sampleBuffer);
+
+						diskOffset += copyCount;
+
 						CheckStop();
-				} while (true);
+					}
+				} while (sourcesActive > 0);
 			}
 #if !DEBUG
 			catch (Exception ex)
 			{
-				hdcdDecoder = null;
+				tasks.ForEach(t => t.TryClose());
-				if (audioSource != null)
+				tasks.Clear();
-					try { audioSource.Close(); }
-					catch { }
-				audioSource = null;
 				throw ex;
 			}
 #endif
-			if (audioSource != null)
+			hdcdDecoder = tasks[0].hdcd;
-				audioSource.Close();
+			for (int iThread = 1; iThread < nThreads; iThread++)
+				tasks[0].Combine(tasks[iThread]);
+			tasks.ForEach(t => t.Close());
+			tasks.Clear();
 		}
 
 		private void DetectGaps()
@@ -4632,8 +4633,8 @@ string status = processor.Go();
 		{
 			pathIn = Path.GetFullPath(pathIn);
 			List<FileGroupInfo> fileGroups = CUESheet.ScanFolder(_config, Path.GetDirectoryName(pathIn));
-			FileGroupInfo fileGroup = FileGroupInfo.WhichContains(fileGroups, pathIn, FileGroupInfoType.TrackFiles)
+			FileGroupInfo fileGroup = fileGroups.Find(f => f.type == FileGroupInfoType.TrackFiles && f.Contains(pathIn)) ??
-				?? FileGroupInfo.WhichContains(fileGroups, pathIn, FileGroupInfoType.FileWithCUE);
+				fileGroups.Find(f => f.type == FileGroupInfoType.FileWithCUE && f.Contains(pathIn));
 			return fileGroup == null ? null : CreateDummyCUESheet(_config, fileGroup);
 		}
 
@@ -4832,7 +4833,7 @@ string status = processor.Go();
 					throw new StopException();
 				if (_pause)
 				{
-					ShowProgress("Paused...", 0, 0, null, null);
+					ShowProgress("Paused...", 0, null, null);
 					Monitor.Wait(this);
 				}
 			}
@@ -5474,14 +5475,22 @@ string status = processor.Go();
 						if (CTDB.DBStatus != null)
 							return CTDB.DBStatus;
 						bool useAR = _useAccurateRip;
-						_useAccurateRip = false;
+						_useAccurateRip = true;
 						Go();
 						_useAccurateRip = useAR;
 						List<CUEToolsSourceFile> choices = new List<CUEToolsSourceFile>();
 						foreach (DBEntry entry in CTDB.Entries)
 							if (!entry.hasErrors || entry.canRecover)
 							{
-								CUEToolsSourceFile choice = new CUEToolsSourceFile(entry.Status, new StringReader(""));
+								StringBuilder sb = new StringBuilder();
+								if (entry.hasErrors)
+								{
+									sb.AppendFormat("Affected positions:\n");
+									for (int sec = 0; sec < entry.repair.AffectedSectorArray.Length; sec++)
+										if (entry.repair.AffectedSectorArray[sec])
+											sb.AppendFormat("{0}\n", CDImageLayout.TimeToString((uint)sec));
+								}
+								CUEToolsSourceFile choice = new CUEToolsSourceFile(entry.Status, new StringReader(sb.ToString()));
 								choice.data = entry;
 								choices.Add(choice);
 							}
@@ -5597,21 +5606,7 @@ string status = processor.Go();
 		{
 			if (type != FileGroupInfoType.TrackFiles)
 				return main.FullName.ToLower() == pathIn.ToLower();
-			bool found = false;
+			return null != files.Find(file => file.FullName.ToLower() == pathIn.ToLower());
-			foreach (FileSystemInfo file in files)
-				if (file.FullName.ToLower() == pathIn.ToLower())
-					found = true;
-			return found;
-		}
-
-		public static FileGroupInfo WhichContains(IEnumerable<FileGroupInfo> fileGroups, string pathIn, FileGroupInfoType type)
-		{
-			foreach (FileGroupInfo fileGroup in fileGroups)
-			{
-				if (fileGroup.type == type && fileGroup.Contains(pathIn))
-					return fileGroup;
-			}
-			return null;
 		}
 	}
 
@@ -5782,6 +5777,7 @@ string status = processor.Go();
 		CUESheet cueSheet;
 		IAudioSource currentAudio;
 		int currentSource;
+		long nextPos;
 		long _samplePos, _sampleLen;
 
 		public CUESheetAudio(CUESheet cueSheet)
@@ -5790,10 +5786,9 @@ string status = processor.Go();
 			this.currentAudio = null;
 			this._samplePos = 0;
 			this._sampleLen = 0;
-			this.currentSource = 0;
+			this.currentSource = -1;
-			for (int iSource = 0; iSource < cueSheet._sources.Count; iSource++)
+			this.nextPos = 0;
-				this._sampleLen += cueSheet._sources[iSource].Length;
+			cueSheet._sources.ForEach(s => this._sampleLen += s.Length);
-			this.currentAudio = cueSheet.GetAudioSource(0, false);
 		}
 
 		public void Close()
@@ -5813,6 +5808,8 @@ string status = processor.Go();
 			}
 			set
 			{
+				if (value == _samplePos)
+					return;
 				long sourceStart = 0;
 				for (int iSource = 0; iSource < cueSheet._sources.Count; iSource++)
 				{
@@ -5820,11 +5817,12 @@ string status = processor.Go();
 					{
 						if (iSource != currentSource)
 						{
-							currentAudio.Close();
+							if (currentAudio != null) currentAudio.Close();
 							currentSource = iSource;
 							currentAudio = cueSheet.GetAudioSource(currentSource, false);
+							nextPos = sourceStart + cueSheet._sources[currentSource].Length;
 						}
-						currentAudio.Position = value - sourceStart;
+						currentAudio.Position = value - sourceStart + cueSheet._sources[currentSource].Offset;
 						_samplePos = value;
 						return;
 					}
@@ -5869,8 +5867,7 @@ string status = processor.Go();
 		public int Read(AudioBuffer buff, int maxLength)
 		{
 			buff.Prepare(this, maxLength);
-
+			while (_samplePos >= nextPos)
-			if (currentAudio.Remaining == 0)
 			{
 				currentSource++;
 				if (currentSource >= cueSheet._sources.Count)
@@ -5878,13 +5875,112 @@ string status = processor.Go();
 					buff.Length = 0;
 					return 0;
 				}
+				if (currentAudio != null)
 					currentAudio.Close();
 				currentAudio = cueSheet.GetAudioSource(currentSource, false);
+				int offset = (int)(_samplePos - nextPos);
+				if (offset != 0)
+					currentAudio.Position += offset;
+				nextPos += cueSheet._sources[currentSource].Length;
+			}
+			int count = (int)(nextPos - _samplePos);
+			if (maxLength >= 0)
+				count = Math.Min(count, maxLength);
+			count = currentAudio.Read(buff, count);
+			_samplePos += count;
+			return count;
+		}
 	}
 
-			int res = currentAudio.Read(buff, maxLength);
+	internal class CUEToolsVerifyTask
-			_samplePos += res;
+	{
-			return res;
+		private CUESheet cueSheet;
+		public IAudioSource source { get; private set; }
+		public int start { get; private set; }
+		public int end { get; private set; }
+		public AccurateRipVerify ar { get; private set; }
+		public CUEToolsDB ctdb { get; private set; }
+		public IAudioDest hdcd { get; private set; }
+
+		public CUEToolsVerifyTask(CUESheet cueSheet, int start, int end)
+			: this(cueSheet, start, end, cueSheet._useAccurateRip ? new AccurateRipVerify(cueSheet.TOC, null) : null, null, null)
+		{
 		}
+
+		public CUEToolsVerifyTask(CUESheet cueSheet, int start, int end, AccurateRipVerify ar, CUEToolsDB ctdb)
+			: this(cueSheet, start, end, ar, ctdb, null)
+		{
+			if (cueSheet.Config.detectHDCD && CUEProcessorPlugins.hdcd != null)
+			{
+				try { this.hdcd = Activator.CreateInstance(CUEProcessorPlugins.hdcd, 2, 44100, 20, false) as IAudioDest; }
+				catch { this.hdcd = null; }
+			}
+		}
+
+		private CUEToolsVerifyTask(CUESheet cueSheet, int start, int end, AccurateRipVerify ar, CUEToolsDB ctdb, IAudioDest hdcd)
+		{
+			this.cueSheet = cueSheet;
+			this.start = start;
+			this.end = end;
+			this.source = new CUESheetAudio(cueSheet);
+			if (cueSheet.IsCD || cueSheet.Config.separateDecodingThread)
+				this.source = new AudioPipe(this.source, 0x10000);
+			this.source.Position = start;
+			this.ar = cueSheet._useAccurateRip ? ar : null;
+			this.ctdb = cueSheet._useCUEToolsDB ? ctdb : null;
+			this.hdcd = hdcd;
+			if (this.ar != null)
+				this.ar.Position = start;
+		}
+
+		public bool TryClose()
+		{
+			try { Close(); }
+			catch { return false; }
+			return true;
+		}
+
+		public void Close()
+		{
+			if (this.source != null)
+			{
+				this.source.Close();
+				this.source = null;
+			}
+			if (this.ar != null)
+			{
+				//this.ar.Close(); can't! throws
+				this.ar = null;
+			}
+		}
+
+		public int Step(AudioBuffer sampleBuffer)
+		{
+			if (Remaining == 0)
+				return 0;
+			int copyCount = source.Read(sampleBuffer, Remaining);
+			if (copyCount == 0)
+				return 0;
+
+			if (ctdb != null) // !_useCUEToolsDBFix
+				ctdb.Verify.Write(sampleBuffer);
+			if (ar != null)
+				ar.Write( sampleBuffer);
+			if (hdcd != null)
+			{
+				hdcd.Write(sampleBuffer);
+				if (cueSheet.Config.wait750FramesForHDCD && source.Position > start + 750 * 588 && string.Format("{0:s}", hdcd) == "")
+					hdcd = null;
+			}
+			return copyCount;
+		}
+
+		public void Combine(CUEToolsVerifyTask task)
+		{
+			if (ar != null)
+				ar.Combine(task.ar, task.start, task.end);
+		}
+
+		public int Remaining { get { return end - (int)source.Position; } }
 	}
 }

CUETools/CUETools.TestCodecs/Crc32Test.cs

@@ -69,15 +69,15 @@ namespace CUETools.TestCodecs
 		[TestMethod()]
 		public void CombineTest()
 		{
-			Crc32 crc32 = new Crc32();
 			int lenAB = testBytes.Length;
 			int lenA = 7;
 			int lenB = lenAB - lenA;
-			uint crcAB = crc32.ComputeChecksum(0, testBytes, 0, lenAB);
+			uint crcAB = Crc32.ComputeChecksum(0, testBytes, 0, lenAB);
-			uint crcA = crc32.ComputeChecksum(0, testBytes, 0, lenA);
+			uint crcA = Crc32.ComputeChecksum(0, testBytes, 0, lenA);
-			uint crcB = crc32.ComputeChecksum(0, testBytes, lenA, lenB);
+			uint crcB = Crc32.ComputeChecksum(0, testBytes, lenA, lenB);
-			Assert.AreEqual<uint>(crcAB, crc32.Combine(crcA, crcB, lenB), "CRC32 was not combined correctly.");
+			Assert.AreEqual<uint>(crcAB, Crc32.Combine(crcA, crcB, lenB), "CRC32 was not combined correctly.");
-			Assert.AreEqual<uint>(crcB, crc32.Combine(crcA, crcAB, lenB), "CRC32 was not substracted correctly.");
+			Assert.AreEqual<uint>(crcB, Crc32.Combine(crcA, crcAB, lenB), "CRC32 was not substracted correctly.");
+			Assert.AreEqual<uint>(crcA, Crc32.Substract(crcAB, crcB, lenB), "CRC32 was not substracted correctly.");
 		}
 
 		/// <summary>
@@ -86,8 +86,7 @@ namespace CUETools.TestCodecs
 		[TestMethod()]
 		public void ComputeChecksumTest()
 		{
-			Crc32 crc32 = new Crc32();
+			uint actual = Crc32.ComputeChecksum(0xffffffff, testBytes, 0, testBytes.Length) ^ 0xffffffff;
-			uint actual = crc32.ComputeChecksum(0xffffffff, testBytes, 0, testBytes.Length) ^ 0xffffffff;
 			Assert.AreEqual<uint>(2028688632, actual, "CRC32 was not combined correctly.");
 		}
 	}

CUETools/CUETools.TestParity/CDRepairDecodeTest.cs

@@ -2,6 +2,8 @@
 using CUETools.CDRepair;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using CUETools.Codecs;
+using CUETools.CDImage;
+using CUETools.AccurateRip;
 
 namespace CUETools.TestParity
 {
@@ -15,7 +17,7 @@ namespace CUETools.TestParity
 	public class CDRepairDecodeTest
 	{
 
-		const int finalSampleCount = 44100 * 60 * 10 + 20; // 10 minutes long
+		const int finalSampleCount = 44100 * 60 * 10; // 10 minutes long
 		//const int stride = finalSampleCount * 2 / 32768;
 		const int stride = 10 * 588 * 2;
 		const int npar = 8;
@@ -25,6 +27,8 @@ namespace CUETools.TestParity
 		static byte[] parity;
 		static uint crc;
 		const int offset = 48;
+		static AccurateRipVerify ar;
+		static CDImageLayout toc;
 		//const int offset = 5 * 588 - 5;
 		//const int offset = 2000;
 
@@ -54,6 +58,9 @@ namespace CUETools.TestParity
 		[ClassInitialize()]
 		public static void MyClassInitialize(TestContext testContext)
 		{
+			toc = new CDImageLayout(1, 1, 1, string.Format("0 {0}", (finalSampleCount / 588).ToString()));
+			ar = new AccurateRipVerify(toc, null);
+
 			new Random(2423).NextBytes(wav);
 			new Random(2423).NextBytes(wav2);
 			Random rnd = new Random(987);
@@ -61,10 +68,12 @@ namespace CUETools.TestParity
 				wav2[(int)(rnd.NextDouble() * (wav2.Length - 1))] = (byte)(rnd.NextDouble() * 255);
 
 			AudioBuffer buff = new AudioBuffer(AudioPCMConfig.RedBook, 0);
-			CDRepairEncode encode = new CDRepairEncode(finalSampleCount, stride, npar, false, true);
+			CDRepairEncode encode = new CDRepairEncode(finalSampleCount, stride, npar, false, true, ar);
 			buff.Prepare(wav, finalSampleCount);
 			encode.Write(buff);
 			encode.Close();
+			ar.Init();
+			ar.Write(buff);
 			parity = encode.Parity;
 			crc = encode.CRC;
 		}
@@ -97,10 +106,12 @@ namespace CUETools.TestParity
 		public void CDRepairDecodeOriginalTest()
 		{
 			AudioBuffer buff = new AudioBuffer(AudioPCMConfig.RedBook, 0);
-			CDRepairEncode decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false);
+			CDRepairEncode decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false, ar);
 			buff.Prepare(wav, finalSampleCount);
 			decode.Write(buff);
 			decode.Close();
+			ar.Init();
+			ar.Write(buff);
 			int actualOffset;
 			bool hasErrors;
 			Assert.IsTrue(decode.FindOffset(npar, parity, 0, crc, out actualOffset, out hasErrors));
@@ -115,10 +126,12 @@ namespace CUETools.TestParity
 		public void CDRepairDecodeModifiedTest()
 		{
 			AudioBuffer buff = new AudioBuffer(AudioPCMConfig.RedBook, 0);
-			CDRepairEncode decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false);
+			CDRepairEncode decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false, ar);
 			buff.Prepare(wav2, finalSampleCount);
 			decode.Write(buff);
 			decode.Close();
+			ar.Init();
+			ar.Write(buff);
 			int actualOffset;
 			bool hasErrors;
 			Assert.IsTrue(decode.FindOffset(npar, parity, 0, crc, out actualOffset, out hasErrors));
@@ -136,9 +149,11 @@ namespace CUETools.TestParity
 		public void CDRepairDecodePositiveOffsetTest()
 		{
 			AudioBuffer buff = new AudioBuffer(AudioPCMConfig.RedBook, 0);
-			CDRepairEncode decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false);
+			CDRepairEncode decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false, ar);
 			Array.Copy(wav, offset * 4, wav3, 0, (finalSampleCount - offset) * 4);
 			buff.Prepare(wav3, finalSampleCount);
+			ar.Init();
+			ar.Write(buff);
 			decode.Write(buff);
 			decode.Close();
 			int actualOffset;
@@ -155,10 +170,13 @@ namespace CUETools.TestParity
 		public void CDRepairDecodeNegativeOffsetTest()
 		{
 			AudioBuffer buff = new AudioBuffer(AudioPCMConfig.RedBook, 0);
-			CDRepairEncode decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false);
+			CDRepairEncode decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false, ar);
+			ar.Init();
 			buff.Prepare(new byte[offset * 4], offset);
+			ar.Write(buff);
 			decode.Write(buff);
 			buff.Prepare(wav, finalSampleCount - offset);
+			ar.Write(buff);
 			decode.Write(buff);
 			decode.Close();
 			int actualOffset;
@@ -175,9 +193,11 @@ namespace CUETools.TestParity
 		public void CDRepairDecodePositiveOffsetErrorsTest()
 		{
 			AudioBuffer buff = new AudioBuffer(AudioPCMConfig.RedBook, 0);
-			CDRepairEncode decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false);
+			CDRepairEncode decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false, ar);
 			Array.Copy(wav2, offset * 4, wav3, 0, (finalSampleCount - offset) * 4);
 			buff.Prepare(wav3, finalSampleCount);
+			ar.Init();
+			ar.Write(buff);
 			decode.Write(buff);
 			decode.Close();
 			int actualOffset;
@@ -197,10 +217,13 @@ namespace CUETools.TestParity
 		public void CDRepairDecodeNegativeOffsetErrorsTest()
 		{
 			AudioBuffer buff = new AudioBuffer(AudioPCMConfig.RedBook, 0);
-			CDRepairEncode decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false);
+			CDRepairEncode decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false, ar);
 			buff.Prepare(new byte[offset * 4], offset);
+			ar.Init();
+			ar.Write(buff);
 			decode.Write(buff);
 			buff.Prepare(wav2, finalSampleCount - offset);
+			ar.Write(buff);
 			decode.Write(buff);
 			decode.Close();
 			int actualOffset;

CUETools/CUETools.TestParity/CDRepairEncodeTest.cs

@@ -1,6 +1,8 @@
 using System;
 using CUETools.CDRepair;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using CUETools.AccurateRip;
+using CUETools.CDImage;
 using CUETools.Codecs;
 
 namespace CUETools.TestParity
@@ -32,6 +34,8 @@ namespace CUETools.TestParity
 
 		const int npar = 8;
 		static byte[] wav = new byte[finalSampleCount * 4];
+		static AccurateRipVerify ar;
+		static CDImageLayout toc;
 
 		private TestContext testContextInstance;
 
@@ -59,6 +63,8 @@ namespace CUETools.TestParity
 		[ClassInitialize()]
 		public static void MyClassInitialize(TestContext testContext)
 		{
+			toc = new CDImageLayout(1, 1, 1, string.Format("0 {0}", (finalSampleCount / 588).ToString()));
+			ar = new AccurateRipVerify(toc, null);
 			new Random(2423).NextBytes(wav);
 		}
 
@@ -90,8 +96,10 @@ namespace CUETools.TestParity
 		public void CDRepairEncodeWriteTest()
 		{
 			AudioBuffer buff = new AudioBuffer(AudioPCMConfig.RedBook, 0);
-			CDRepairEncode encode = new CDRepairEncode(finalSampleCount, stride, npar, false, true);
+			CDRepairEncode encode = new CDRepairEncode(finalSampleCount, stride, npar, false, true, ar);
 			buff.Prepare(wav, finalSampleCount);
+			ar.Init();
+			ar.Write(buff);
 			encode.Write(buff);
 			encode.Close();
 			Assert.AreEqual<byte>(8, encode.Parity[0]);

CUETools/CUETools.TestParity/CDRepairTest.cs

@@ -1,6 +1,8 @@
 using System;
 using CUETools.Codecs;
 using CUETools.CDRepair;
+using CUETools.AccurateRip;
+using CUETools.CDImage;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 namespace CUETools.TestParity
 {
@@ -30,6 +32,8 @@ namespace CUETools.TestParity
 		static CDRepairFix fix;
 		static CDRepairFix fix2;
 		const int offset = 48;
+		static AccurateRipVerify ar, ar2;
+		static CDImageLayout toc;
 
 		/// <summary>
 		///Gets or sets the test context which provides
@@ -55,6 +59,10 @@ namespace CUETools.TestParity
 		[ClassInitialize()]
 		public static void MyClassInitialize(TestContext testContext)
 		{
+			toc = new CDImageLayout(1, 1, 1, string.Format("0 {0}", (finalSampleCount / 588).ToString()));
+			ar = new AccurateRipVerify(toc, null);
+			ar2 = new AccurateRipVerify(toc, null);
+
 			new Random(2423).NextBytes(wav);
 			new Random(2423).NextBytes(wav2);
 			Random rnd = new Random(987);
@@ -62,14 +70,16 @@ namespace CUETools.TestParity
 				wav2[(int)(rnd.NextDouble() * (wav2.Length - 1))] = (byte)(rnd.NextDouble() * 255);
 
 			AudioBuffer buff = new AudioBuffer(AudioPCMConfig.RedBook, 0);
-			CDRepairEncode encode = new CDRepairEncode(finalSampleCount, stride, npar, false, true);
+			CDRepairEncode encode = new CDRepairEncode(finalSampleCount, stride, npar, false, true, ar);
 			buff.Prepare(wav, finalSampleCount);
+			ar.Init();
+			ar.Write(buff);
 			encode.Write(buff);
 			encode.Close();
 			parity = encode.Parity;
 			crc = encode.CRC;
 
-			decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false);
+			decode = new CDRepairEncode(finalSampleCount, stride, npar, true, false, ar);
 			buff.Prepare(wav2, finalSampleCount);
 			decode.Write(buff);
 			decode.Close();
@@ -79,10 +89,13 @@ namespace CUETools.TestParity
 			decode.FindOffset(npar, parity, 0, crc, out actualOffset, out hasErrors);
 			fix = decode.VerifyParity(parity, actualOffset);
 
-			decode2 = new CDRepairEncode(finalSampleCount, stride, npar, true, false);
+			decode2 = new CDRepairEncode(finalSampleCount, stride, npar, true, false, ar2);
 			buff.Prepare(new byte[offset * 4], offset);
+			ar2.Init();
+			ar2.Write(buff);
 			decode2.Write(buff);
 			buff.Prepare(wav2, finalSampleCount - offset);
+			ar2.Write(buff);
 			decode2.Write(buff);
 			decode2.Close();
 			decode2.FindOffset(npar, parity, 0, crc, out actualOffset, out hasErrors);

CUETools/CUETools.TestParity/CUETools.TestParity.csproj

@@ -50,9 +50,14 @@
     <Compile Include="RsEncode8Test.cs" />
   </ItemGroup>
   <ItemGroup>
-    <Content Include="AuthoringTests.txt" />
+    <ProjectReference Include="..\..\CUETools.AccurateRip\CUETools.AccurateRip.csproj">
-  </ItemGroup>
+      <Project>{5802C7E9-157E-4124-946D-70B5AE48A5A1}</Project>
-  <ItemGroup>
+      <Name>CUETools.AccurateRip</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\CUETools.CDImage\CUETools.CDImage.csproj">
+      <Project>{1DD41038-D885-46C5-8DDE-E0B82F066584}</Project>
+      <Name>CUETools.CDImage</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\CUETools.CDRepair\CUETools.CDRepair.csproj">
       <Project>{C4869B37-EBB1-47BB-9406-B1209BEAB84B}</Project>
       <Name>CUETools.CDRepair</Name>

CUETools/frmBatch.Designer.cs

@@ -33,13 +33,12 @@ namespace JDP
 			this.txtInputFile = new System.Windows.Forms.TextBox();
 			this.txtOutputFile = new System.Windows.Forms.TextBox();
 			this.tableLayoutPanel1 = new System.Windows.Forms.TableLayoutPanel();
-			this.progressBar1 = new System.Windows.Forms.ProgressBar();
 			this.tableLayoutPanel1.SuspendLayout();
 			this.SuspendLayout();
 			// 
 			// progressBar2
 			// 
-			this.progressBar2.Location = new System.Drawing.Point(3, 29);
+			this.progressBar2.Location = new System.Drawing.Point(3, 3);
 			this.progressBar2.MinimumSize = new System.Drawing.Size(440, 20);
 			this.progressBar2.Name = "progressBar2";
 			this.progressBar2.Size = new System.Drawing.Size(609, 20);
@@ -49,7 +48,7 @@ namespace JDP
 			// 
 			this.textBox1.BackColor = System.Drawing.SystemColors.Control;
 			this.textBox1.Font = new System.Drawing.Font("Courier New", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
-			this.textBox1.Location = new System.Drawing.Point(3, 115);
+			this.textBox1.Location = new System.Drawing.Point(3, 75);
 			this.textBox1.MaxLength = 0;
 			this.textBox1.MinimumSize = new System.Drawing.Size(600, 200);
 			this.textBox1.Multiline = true;
@@ -63,7 +62,7 @@ namespace JDP
 			// txtInputFile
 			// 
 			this.txtInputFile.BorderStyle = System.Windows.Forms.BorderStyle.None;
-			this.txtInputFile.Location = new System.Drawing.Point(5, 57);
+			this.txtInputFile.Location = new System.Drawing.Point(5, 31);
 			this.txtInputFile.Margin = new System.Windows.Forms.Padding(5);
 			this.txtInputFile.Name = "txtInputFile";
 			this.txtInputFile.ReadOnly = true;
@@ -74,7 +73,7 @@ namespace JDP
 			// txtOutputFile
 			// 
 			this.txtOutputFile.BorderStyle = System.Windows.Forms.BorderStyle.None;
-			this.txtOutputFile.Location = new System.Drawing.Point(5, 87);
+			this.txtOutputFile.Location = new System.Drawing.Point(5, 54);
 			this.txtOutputFile.Margin = new System.Windows.Forms.Padding(5);
 			this.txtOutputFile.Name = "txtOutputFile";
 			this.txtOutputFile.ReadOnly = true;
@@ -91,30 +90,20 @@ namespace JDP
 			this.tableLayoutPanel1.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink;
 			this.tableLayoutPanel1.ColumnCount = 1;
 			this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
-			this.tableLayoutPanel1.Controls.Add(this.textBox1, 0, 4);
+			this.tableLayoutPanel1.Controls.Add(this.textBox1, 0, 3);
-			this.tableLayoutPanel1.Controls.Add(this.progressBar1, 0, 0);
+			this.tableLayoutPanel1.Controls.Add(this.progressBar2, 0, 0);
-			this.tableLayoutPanel1.Controls.Add(this.progressBar2, 0, 1);
+			this.tableLayoutPanel1.Controls.Add(this.txtOutputFile, 0, 2);
-			this.tableLayoutPanel1.Controls.Add(this.txtOutputFile, 0, 3);
+			this.tableLayoutPanel1.Controls.Add(this.txtInputFile, 0, 1);
-			this.tableLayoutPanel1.Controls.Add(this.txtInputFile, 0, 2);
 			this.tableLayoutPanel1.Location = new System.Drawing.Point(13, 13);
 			this.tableLayoutPanel1.Name = "tableLayoutPanel1";
-			this.tableLayoutPanel1.RowCount = 5;
+			this.tableLayoutPanel1.RowCount = 4;
 			this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle());
 			this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle());
 			this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle());
 			this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle());
-			this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle());
+			this.tableLayoutPanel1.Size = new System.Drawing.Size(619, 293);
-			this.tableLayoutPanel1.Size = new System.Drawing.Size(619, 333);
 			this.tableLayoutPanel1.TabIndex = 7;
 			// 
-			// progressBar1
-			// 
-			this.progressBar1.Location = new System.Drawing.Point(3, 3);
-			this.progressBar1.MinimumSize = new System.Drawing.Size(440, 20);
-			this.progressBar1.Name = "progressBar1";
-			this.progressBar1.Size = new System.Drawing.Size(609, 20);
-			this.progressBar1.TabIndex = 0;
-			// 
 			// frmBatch
 			// 
 			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
@@ -146,6 +135,5 @@ namespace JDP
 		private System.Windows.Forms.TextBox txtInputFile;
 		private System.Windows.Forms.TextBox txtOutputFile;
 		private System.Windows.Forms.TableLayoutPanel tableLayoutPanel1;
-		private System.Windows.Forms.ProgressBar progressBar1;
 	}
 }

CUETools/frmBatch.cs

@@ -59,20 +59,20 @@ namespace JDP
 		{
 			this.BeginInvoke((MethodInvoker)delegate()
 			{
-				if (e.percentDisk == 0)
+				if (e.percent == 0)
 				{
 					_startedAt = DateTime.Now;
 					Text = e.status;
 				}
-				else if (e.percentDisk > 0.02)
+				else if (e.percent > 0.02)
 				{
 					TimeSpan span = DateTime.Now - _startedAt;
-					TimeSpan eta = new TimeSpan ((long) (span.Ticks/e.percentDisk));
+					TimeSpan eta = new TimeSpan ((long) (span.Ticks/e.percent));
 					Text = String.Format("{0}, ETA {1}:{2:00}.", e.status, (int)eta.TotalMinutes, eta.Seconds);
 				} else
 					Text = e.status;
-				progressBar1.Value = Math.Max(0,Math.Min(100,(int)(e.percentTrck*100)));
+				//progressBar1.Value = Math.Max(0,Math.Min(100,(int)(e.percentTrck*100)));
-				progressBar2.Value = Math.Max(0,Math.Min(100,(int)(e.percentDisk*100)));
+				progressBar2.Value = Math.Max(0,Math.Min(100,(int)(e.percent*100)));
 				string inputSuffix = e.output != null ? "=>" : "";
 				if (e.input == null)
 					txtInputFile.Text = inputSuffix;
@@ -159,7 +159,6 @@ namespace JDP
 						Text = "Done.";
 
 					//TimeSpan span = DateTime.Now - _startedAt;
-					progressBar1.Value = 0;
 					progressBar2.Value = 0;
 					if (cueSheet.IsCD)
 					{
@@ -185,7 +184,6 @@ namespace JDP
 				{
 					Text = "Aborted.";
 					textBox1.Text += "Aborted.";
-					progressBar1.Value = 0;
 					progressBar2.Value = 0;
 				});
 			}

CUETools/frmCUETools.Designer.cs

@@ -31,7 +31,6 @@ namespace JDP {
 			this.toolStripStatusLabelProcessed = new System.Windows.Forms.ToolStripStatusLabel();
 			this.toolStripStatusLabelCTDB = new System.Windows.Forms.ToolStripStatusLabel();
 			this.toolStripStatusLabelAR = new System.Windows.Forms.ToolStripStatusLabel();
-			this.toolStripProgressBar1 = new System.Windows.Forms.ToolStripProgressBar();
 			this.toolStripProgressBar2 = new System.Windows.Forms.ToolStripProgressBar();
 			this.tableLayoutPanel1 = new System.Windows.Forms.TableLayoutPanel();
 			this.textBatchReport = new System.Windows.Forms.TextBox();
@@ -184,7 +183,6 @@ namespace JDP {
             this.toolStripStatusLabelProcessed,
             this.toolStripStatusLabelCTDB,
             this.toolStripStatusLabelAR,
-            this.toolStripProgressBar1,
             this.toolStripProgressBar2});
 			this.statusStrip1.Name = "statusStrip1";
 			this.statusStrip1.ShowItemToolTips = true;
@@ -225,13 +223,6 @@ namespace JDP {
 			this.toolStripStatusLabelAR.Name = "toolStripStatusLabelAR";
 			this.toolStripStatusLabelAR.Padding = new System.Windows.Forms.Padding(0, 0, 5, 0);
 			// 
-			// toolStripProgressBar1
-			// 
-			this.toolStripProgressBar1.AutoToolTip = true;
-			this.toolStripProgressBar1.Name = "toolStripProgressBar1";
-			resources.ApplyResources(this.toolStripProgressBar1, "toolStripProgressBar1");
-			this.toolStripProgressBar1.Style = System.Windows.Forms.ProgressBarStyle.Continuous;
-			// 
 			// toolStripProgressBar2
 			// 
 			this.toolStripProgressBar2.AutoToolTip = true;
@@ -1117,7 +1108,6 @@ namespace JDP {
 		private System.Windows.Forms.ToolStripStatusLabel toolStripStatusLabel1;
 		private System.Windows.Forms.ToolStripStatusLabel toolStripStatusLabelProcessed;
 		private System.Windows.Forms.ToolStripStatusLabel toolStripStatusLabelAR;
-		private System.Windows.Forms.ToolStripProgressBar toolStripProgressBar1;
 		private System.Windows.Forms.ToolStripProgressBar toolStripProgressBar2;
 		private System.Windows.Forms.TableLayoutPanel tableLayoutPanel4;
 		private System.Windows.Forms.ToolStripDropDownButton toolStripDropDownButtonProfile;

CUETools/frmCUETools.cs

@@ -485,10 +485,7 @@ namespace JDP {
 			{
 				if (_profile._config.checkForUpdates && DateTime.UtcNow - lastMOTD > TimeSpan.FromDays(1) && _batchReport.Length == 0)
 				{
-					this.Invoke((MethodInvoker)delegate()
+					this.Invoke((MethodInvoker)(() => toolStripStatusLabel1.Text = "Checking for updates..."));
-					{
-						toolStripStatusLabel1.Text = "Checking for updates...";
-					});
 					HttpWebRequest req = (HttpWebRequest)WebRequest.Create("http://cuetools.net/motd/motd.jpg");
 					req.Method = "GET";
 					try
@@ -595,8 +592,8 @@ namespace JDP {
 					{
 						pathIn = Path.GetFullPath(pathIn);
 						List<FileGroupInfo> fileGroups = CUESheet.ScanFolder(_profile._config, Path.GetDirectoryName(pathIn));
-						FileGroupInfo fileGroup = FileGroupInfo.WhichContains(fileGroups, pathIn, FileGroupInfoType.TrackFiles)
+						FileGroupInfo fileGroup = fileGroups.Find(f => f.type == FileGroupInfoType.TrackFiles && f.Contains(pathIn)) ??
-							?? FileGroupInfo.WhichContains(fileGroups, pathIn, FileGroupInfoType.FileWithCUE);
+							fileGroups.Find(f => f.type == FileGroupInfoType.FileWithCUE && f.Contains(pathIn));
 						if (fileGroup == null)
 							throw new Exception("doesn't seem to be part of an album");
 						string cueSheetContents;
@@ -964,33 +961,28 @@ namespace JDP {
 		public void SetStatus(object sender, CUEToolsProgressEventArgs e)
 		{
 			this.BeginInvoke((MethodInvoker)delegate() {
-				if (e.percentDisk == 0)
+				if (e.percent == 0)
 				{
 					_startedAt = DateTime.Now;
 					toolStripStatusLabelProcessed.Visible = false;
-					toolStripProgressBar1.ToolTipText = "";
 					toolStripProgressBar2.ToolTipText = "";
 				}
-				else if (e.percentDisk > 0.02)
+				else if (e.percent > 0.02)
 				{
 					TimeSpan span = DateTime.Now - _startedAt;
-					TimeSpan eta = new TimeSpan((long)(span.Ticks / e.percentDisk));
+					TimeSpan eta = new TimeSpan((long)(span.Ticks / e.percent));
+					string speedStr = "";
 					if (span.TotalSeconds > 0 && e.offset > 0)
 					{
 						double speed = e.offset / span.TotalSeconds / 44100;
-						toolStripProgressBar1.ToolTipText = String.Format("{0:00.00}x", speed);
+						speedStr = String.Format("{0:00.00}x", speed);
-					} else
+					} 
-						toolStripProgressBar1.ToolTipText = "";
 					toolStripProgressBar2.ToolTipText = String.Format("{0}:{1:00}/{2}:{3:00}", (int)span.TotalMinutes, span.Seconds, (int)eta.TotalMinutes, eta.Seconds);
-					if (FileBrowserState != FileBrowserStateEnum.Hidden)
+					toolStripStatusLabelProcessed.Text = String.Format("{0}@{1}", toolStripProgressBar2.ToolTipText, speedStr);
-					{
-						toolStripStatusLabelProcessed.Text = String.Format("{0}@{1}", toolStripProgressBar2.ToolTipText, toolStripProgressBar1.ToolTipText);
 					toolStripStatusLabelProcessed.Visible = true;
 				}
-				}
 				toolStripStatusLabel1.Text = e.status;
-				toolStripProgressBar1.Value = Math.Max(0,Math.Min(100,(int)(e.percentTrck*100)));
+				toolStripProgressBar2.Value = Math.Max(0,Math.Min(100,(int)(e.percent*100)));
-				toolStripProgressBar2.Value = Math.Max(0,Math.Min(100,(int)(e.percentDisk*100)));
 			});
 		}
 
@@ -1023,7 +1015,6 @@ namespace JDP {
 			btnStop.Visible = btnPause.Visible = running;
 			btnResume.Visible = false;
 			toolStripStatusLabel1.Text = String.Empty;
-			toolStripProgressBar1.Value = 0;
 			toolStripProgressBar2.Value = 0;
 			toolStripStatusLabelAR.Visible = false;
 			toolStripStatusLabelCTDB.Visible = false;