diff --git a/CUETools.AccurateRip/AccurateRip.cs b/CUETools.AccurateRip/AccurateRip.cs index a9d236a..5816a60 100644 --- a/CUETools.AccurateRip/AccurateRip.cs +++ b/CUETools.AccurateRip/AccurateRip.cs @@ -1,11 +1,11 @@ using System; using System.Collections.Generic; -using System.Text; using System.Globalization; -using System.Net; using System.IO; -using CUETools.Codecs; +using System.Net; +using System.Text; using CUETools.CDImage; +using CUETools.Codecs; namespace CUETools.AccurateRip { @@ -23,23 +23,6 @@ namespace CUETools.AccurateRip Init(); } - unsafe private void CalculateFrame450CRCs(int* samples, int count, int iTrack, int currentOffset) - { - int s1 = Math.Min(count, Math.Max(0, 450 * 588 - _arOffsetRange - currentOffset)); - int s2 = Math.Min(count, Math.Max(0, 451 * 588 + _arOffsetRange - currentOffset)); - if (s1 < s2) - fixed (uint* FrameCRCs = &_offsetedFrame450CRC[iTrack, 0]) - for (int sj = s1; sj < s2; sj++) - { - int magicFrameOffset = (int)currentOffset + sj - 450 * 588 + 1; - int firstOffset = Math.Max(-_arOffsetRange, magicFrameOffset - 588); - int lastOffset = Math.Min(magicFrameOffset - 1, _arOffsetRange); - uint sampleValue = (uint)((samples[2 * sj] & 0xffff) + (samples[2 * sj + 1] << 16)); - for (int oi = firstOffset; oi <= lastOffset; oi++) - FrameCRCs[_arOffsetRange - oi] += sampleValue * (uint)(magicFrameOffset - oi); - } - } - public uint Confidence(int iTrack) { if (ARStatus != null) @@ -113,11 +96,6 @@ namespace CUETools.AccurateRip return ARStatus == null ? AccDisks[0].tracks[iTrack].CRC : 0U; } - public uint BackupCRC(int iTrack) - { - return _backupCRC[iTrack]; - } - public uint CRC(int iTrack) { return CRC(iTrack, 0); @@ -129,10 +107,10 @@ namespace CUETools.AccurateRip { return ((iTrack == _toc.AudioTracks - 1) - ? _offsetedCRCAR[iTrack + 1, 20 * 588 - 5 * 588] - : _offsetedCRCAR[iTrack + 1, 20 * 588]) - + ? _CRCAR[iTrack + 1, 20 * 588 - 5 * 588] + : _CRCAR[iTrack + 1, 0]) - ((iTrack == 0) - ? _offsetedCRCAR[iTrack + 1, 5 * 588 - 1] + ? _CRCAR[iTrack + 1, 5 * 588 - 1] : 0); } if (oi < 0) @@ -140,24 +118,24 @@ namespace CUETools.AccurateRip uint crc = 0; if (iTrack > 0) { - uint crcA = _offsetedCRCAR[iTrack, 20 * 588] - _offsetedCRCAR[iTrack, 20 * 588 + oi]; - uint sumA = _offsetedCRCSM[iTrack, 20 * 588] - _offsetedCRCSM[iTrack, 20 * 588 + oi]; + uint crcA = _CRCAR[iTrack, 0] - _CRCAR[iTrack, 20 * 588 + oi]; + uint sumA = _CRCSM[iTrack, 0] - _CRCSM[iTrack, 20 * 588 + oi]; uint posA = _toc[iTrack + _toc.FirstAudio - 1].Length * 588 + (uint)oi; crc = crcA - sumA * posA; } uint crcB = ((iTrack == _toc.AudioTracks - 1) - ? _offsetedCRCAR[iTrack + 1, 20 * 588 - 5 * 588 + oi] - : _offsetedCRCAR[iTrack + 1, 20 * 588 + oi]) + ? _CRCAR[iTrack + 1, 20 * 588 - 5 * 588 + oi] + : _CRCAR[iTrack + 1, 20 * 588 + oi]) - ((iTrack == 0) - ? _offsetedCRCAR[iTrack + 1, 5 * 588 - 1 + oi] + ? _CRCAR[iTrack + 1, 5 * 588 - 1 + oi] : 0); uint sumB = ((iTrack == _toc.AudioTracks - 1) - ? _offsetedCRCSM[iTrack + 1, 20 * 588 - 5 * 588 + oi] - : _offsetedCRCSM[iTrack + 1, 20 * 588 + oi]) + ? _CRCSM[iTrack + 1, 20 * 588 - 5 * 588 + oi] + : _CRCSM[iTrack + 1, 20 * 588 + oi]) - ((iTrack == 0) - ? _offsetedCRCSM[iTrack + 1, 5 * 588 - 1 + oi] + ? _CRCSM[iTrack + 1, 5 * 588 - 1 + oi] : 0); uint posB = (uint)-oi; return crc + crcB + sumB * posB; @@ -166,24 +144,24 @@ namespace CUETools.AccurateRip { uint crcA = ((iTrack == _toc.AudioTracks - 1) - ? _offsetedCRCAR[iTrack + 1, 20 * 588 - 5 * 588 + oi] - : _offsetedCRCAR[iTrack + 1, 20 * 588]) + ? _CRCAR[iTrack + 1, 20 * 588 - 5 * 588 + oi] + : _CRCAR[iTrack + 1, 0]) - ((iTrack == 0) - ? _offsetedCRCAR[iTrack + 1, 5 * 588 + oi - 1] - : _offsetedCRCAR[iTrack + 1, oi]); + ? _CRCAR[iTrack + 1, 5 * 588 + oi - 1] + : _CRCAR[iTrack + 1, oi]); uint sumA = ((iTrack == _toc.AudioTracks - 1) - ? _offsetedCRCSM[iTrack + 1, 20 * 588 - 5 * 588 + oi] - : _offsetedCRCSM[iTrack + 1, 20 * 588]) + ? _CRCSM[iTrack + 1, 20 * 588 - 5 * 588 + oi] + : _CRCSM[iTrack + 1, 0]) - ((iTrack == 0) - ? _offsetedCRCSM[iTrack + 1, 5 * 588 + oi - 1] - : _offsetedCRCSM[iTrack + 1, oi]); + ? _CRCSM[iTrack + 1, 5 * 588 + oi - 1] + : _CRCSM[iTrack + 1, oi]); uint posA = (uint)oi; uint crc = crcA - sumA * posA; if (iTrack < _toc.AudioTracks - 1) { - uint crcB = _offsetedCRCAR[iTrack + 2, oi]; - uint sumB = _offsetedCRCSM[iTrack + 2, oi]; + uint crcB = _CRCAR[iTrack + 2, oi]; + uint sumB = _CRCSM[iTrack + 2, oi]; uint posB = _toc[iTrack + _toc.FirstAudio].Length * 588 + (uint)-oi; crc += crcB + sumB * posB; } @@ -198,7 +176,7 @@ namespace CUETools.AccurateRip public uint CRC32(int iTrack, int oi) { - if (_offsetedCRC32Res[iTrack, _arOffsetRange + oi] == 0) + if (_CacheCRC32[iTrack, _arOffsetRange + oi] == 0) { uint crc = 0xffffffff; if (iTrack == 0) @@ -213,17 +191,17 @@ namespace CUETools.AccurateRip 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(_offsetedCRC32[iTrack, oi], _offsetedCRC32[iTrack, 20 * 588], 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, _offsetedCRC32[iTrack, 20 * 588 + oi], trackLength + oi * 4); + crc = _crc32.Combine(crc, _CRC32[iTrack, 20 * 588 + oi], trackLength + oi * 4); } else { - crc = _crc32.Combine(crc, _offsetedCRC32[iTrack, 20 * 588], trackLength); + crc = _crc32.Combine(crc, _CRC32[iTrack, 0], trackLength); } if (oi > 0 && iTrack == _toc.AudioTracks) crc = _crc32.Combine(crc, 0, oi * 4); @@ -236,33 +214,33 @@ namespace CUETools.AccurateRip if (oi > 0) { // Calculate track CRC skipping first oi samples by 'subtracting' their CRC - crc = _crc32.Combine(_offsetedCRC32[iTrack, oi], _offsetedCRC32[iTrack, 20 * 588], 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 if (iTrack < _toc.AudioTracks) - crc = _crc32.Combine(crc, _offsetedCRC32[iTrack + 1, oi], oi * 4); + crc = _crc32.Combine(crc, _CRC32[iTrack + 1, oi], oi * 4); 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(_offsetedCRC32[iTrack - 1, 20 * 588 + oi], _offsetedCRC32[iTrack - 1, 20 * 588], -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, _offsetedCRC32[iTrack, 20 * 588 + oi], trackLength + oi * 4); + crc = _crc32.Combine(crc, _CRC32[iTrack, 20 * 588 + oi], trackLength + oi * 4); } else // oi == 0 { // Use 0xffffffff as an initial state - crc = _crc32.Combine(0xffffffff, _offsetedCRC32[iTrack, 20 * 588], trackLength); + crc = _crc32.Combine(0xffffffff, _CRC32[iTrack, 0], trackLength); } } - _offsetedCRC32Res[iTrack, _arOffsetRange + oi] = crc ^ 0xffffffff; + _CacheCRC32[iTrack, _arOffsetRange + oi] = crc ^ 0xffffffff; } - return _offsetedCRC32Res[iTrack, _arOffsetRange + oi]; + return _CacheCRC32[iTrack, _arOffsetRange + oi]; } public uint CRCWONULL(int iTrack) @@ -272,7 +250,7 @@ namespace CUETools.AccurateRip public uint CRCWONULL(int iTrack, int oi) { - if (_offsetedCRCWNRes[iTrack, _arOffsetRange + oi] == 0) + if (_CacheCRCWN[iTrack, _arOffsetRange + oi] == 0) { uint crc = 0xffffffff; if (iTrack == 0) @@ -280,8 +258,8 @@ namespace CUETools.AccurateRip for (iTrack = 0; iTrack <= _toc.AudioTracks; iTrack++) { int trackLength = (int)(iTrack > 0 ? _toc[iTrack + _toc.FirstAudio - 1].Length : _toc[_toc.FirstAudio].Pregap) * 588 * 4 - - _offsetedCRCNulls[iTrack, 20 * 588] * 2; - crc = _crc32.Combine(crc, _offsetedCRCWN[iTrack, 20 * 588], trackLength); + - _CRCNL[iTrack, 0] * 2; + crc = _crc32.Combine(crc, _CRCWN[iTrack, 0], trackLength); } iTrack = 0; } @@ -291,45 +269,45 @@ namespace CUETools.AccurateRip if (oi > 0) { int nonzeroPrevLength = trackLength - oi * 4 - - (_offsetedCRCNulls[iTrack, 20 * 588] - _offsetedCRCNulls[iTrack, oi]) * 2; + (_CRCNL[iTrack, 0] - _CRCNL[iTrack, oi]) * 2; // Calculate track CRC skipping first oi samples by 'subtracting' their CRC crc = _crc32.Combine( - _offsetedCRCWN[iTrack, oi], - _offsetedCRCWN[iTrack, 20 * 588], + _CRCWN[iTrack, oi], + _CRCWN[iTrack, 0], nonzeroPrevLength); // Use 0xffffffff as an initial state crc = _crc32.Combine(0xffffffff, crc, nonzeroPrevLength); // Add oi samples from next track CRC if (iTrack < _toc.AudioTracks) crc = _crc32.Combine(crc, - _offsetedCRCWN[iTrack + 1, oi], - oi * 4 - _offsetedCRCNulls[iTrack + 1, oi] * 2); + _CRCWN[iTrack + 1, oi], + oi * 4 - _CRCNL[iTrack + 1, oi] * 2); } else if (oi < 0) { int nonzeroPrevLength = -oi * 4 - - (_offsetedCRCNulls[iTrack - 1, 20 * 588] - _offsetedCRCNulls[iTrack - 1, 20 * 588 + oi]) * 2; + (_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( - _offsetedCRCWN[iTrack - 1, 20 * 588 + oi], - _offsetedCRCWN[iTrack - 1, 20 * 588], + _CRCWN[iTrack - 1, 20 * 588 + oi], + _CRCWN[iTrack - 1, 0], nonzeroPrevLength); // Use 0xffffffff as an initial state crc = _crc32.Combine(0xffffffff, crc, nonzeroPrevLength); // Add this track's CRC without last oi samples crc = _crc32.Combine(crc, - _offsetedCRCWN[iTrack, 20 * 588 + oi], - trackLength + oi * 4 - _offsetedCRCNulls[iTrack, 20 * 588 + oi] * 2); + _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, _offsetedCRCWN[iTrack, 20 * 588], trackLength - _offsetedCRCNulls[iTrack, 20 * 588] * 2); + crc = _crc32.Combine(0xffffffff, _CRCWN[iTrack, 0], trackLength - _CRCNL[iTrack, 0] * 2); } } - _offsetedCRCWNRes[iTrack, _arOffsetRange + oi] = crc ^ 0xffffffff; + _CacheCRCWN[iTrack, _arOffsetRange + oi] = crc ^ 0xffffffff; } - return _offsetedCRCWNRes[iTrack, _arOffsetRange + oi]; + return _CacheCRCWN[iTrack, _arOffsetRange + oi]; } public uint CRCLOG(int iTrack) @@ -345,29 +323,52 @@ namespace CUETools.AccurateRip public uint CRC450(int iTrack, int oi) { - return _offsetedFrame450CRC[iTrack, _arOffsetRange - oi]; + uint crca = _CRCAR[iTrack + 1, 20 * 588 + 5 * 588 + oi]; + uint crcb = _CRCAR[iTrack + 1, 20 * 588 + 6 * 588 + oi]; + uint suma = _CRCSM[iTrack + 1, 20 * 588 + 5 * 588 + oi]; + uint sumb = _CRCSM[iTrack + 1, 20 * 588 + 6 * 588 + oi]; + uint offs = 450 * 588 + (uint)oi; + return crcb - crca - offs * (sumb - suma); } + /// + /// This function calculates three different CRCs and also + /// collects some additional information for the purposes of + /// offset detection. + /// + /// crcar is AccurateRip CRC + /// crc32 is CRC32 + /// crcwn is CRC32 without null samples (EAC) + /// crcsm is sum of samples + /// crcnulls is a count of null samples + /// + /// + /// + /// + /// public unsafe void CalculateCRCs(int* pSampleBuff, int count, int currentOffset, int offs) { - uint crcar = _offsetedCRCAR[_currentTrack, 20 * 588]; - uint crcsm = _offsetedCRCSM[_currentTrack, 20 * 588]; - uint crc = _offsetedCRC32[_currentTrack, 20 * 588]; - uint crcwn = _offsetedCRCWN[_currentTrack, 20 * 588]; - int crcnulls = _offsetedCRCNulls[_currentTrack, 20 * 588]; + uint crcar = _CRCAR[_currentTrack, 0]; + uint crcsm = _CRCSM[_currentTrack, 0]; + uint crc32 = _CRC32[_currentTrack, 0]; + uint crcwn = _CRCWN[_currentTrack, 0]; + int crcnulls = _CRCNL[_currentTrack, 0]; fixed (uint* t = _crc32.table) { for (int i = 0; i < count; i++) { - _offsetedCRCAR[_currentTrack, offs + i] = crcar; - _offsetedCRCSM[_currentTrack, offs + i] = crcsm; - _offsetedCRC32[_currentTrack, offs + i] = crc; - _offsetedCRCWN[_currentTrack, offs + i] = crcwn; - _offsetedCRCNulls[_currentTrack, offs + i] = crcnulls; + if (offs >= 0) + { + _CRCAR[_currentTrack, offs + i] = crcar; + _CRCSM[_currentTrack, offs + i] = crcsm; + _CRC32[_currentTrack, offs + i] = crc32; + _CRCWN[_currentTrack, offs + i] = crcwn; + _CRCNL[_currentTrack, offs + i] = crcnulls; + } uint lo = (uint)*(pSampleBuff++); - crc = (crc >> 8) ^ t[(byte)(crc ^ lo)]; - crc = (crc >> 8) ^ t[(byte)(crc ^ (lo >> 8))]; + crc32 = (crc32 >> 8) ^ t[(byte)(crc32 ^ lo)]; + crc32 = (crc32 >> 8) ^ t[(byte)(crc32 ^ (lo >> 8))]; if (lo != 0) { crcwn = (crcwn >> 8) ^ t[(byte)(crcwn ^ lo)]; @@ -376,8 +377,8 @@ namespace CUETools.AccurateRip else crcnulls++; uint hi = (uint)*(pSampleBuff++); - crc = (crc >> 8) ^ t[(byte)(crc ^ hi)]; - crc = (crc >> 8) ^ t[(byte)(crc ^ (hi >> 8))]; + crc32 = (crc32 >> 8) ^ t[(byte)(crc32 ^ hi)]; + crc32 = (crc32 >> 8) ^ t[(byte)(crc32 ^ (hi >> 8))]; if (hi != 0) { crcwn = (crcwn >> 8) ^ t[(byte)(crcwn ^ hi)]; @@ -390,57 +391,12 @@ namespace CUETools.AccurateRip crcar += sampleValue * (uint)(currentOffset + i + 1); } } - //_offsetedCRCAR[_currentTrack, offs + count] = crcar; - //_offsetedCRCSM[_currentTrack, offs + count] = crcsm; - _offsetedCRCAR[_currentTrack, 20 * 588] = crcar; - _offsetedCRCSM[_currentTrack, 20 * 588] = crcsm; - _offsetedCRC32[_currentTrack, 20 * 588] = crc; - _offsetedCRCWN[_currentTrack, 20 * 588] = crcwn; - _offsetedCRCNulls[_currentTrack, 20 * 588] = crcnulls; - } - - public unsafe void CalculateCRCs(int* pSampleBuff, int count, int currentOffset) - { - uint crcar = _offsetedCRCAR[_currentTrack, 20 * 588]; - uint crcsm = _offsetedCRCSM[_currentTrack, 20 * 588]; - uint crc = _offsetedCRC32[_currentTrack, 20 * 588]; - uint crcwn = _offsetedCRCWN[_currentTrack, 20 * 588]; - int crcnulls = _offsetedCRCNulls[_currentTrack, 20 * 588]; - fixed (uint* t = _crc32.table) - { - for (int i = 0; i < count; i++) - { - uint lo = (uint)*(pSampleBuff++); - crc = (crc >> 8) ^ t[(byte)(crc ^ lo)]; - crc = (crc >> 8) ^ t[(byte)(crc ^ (lo >> 8))]; - if (lo != 0) - { - crcwn = (crcwn >> 8) ^ t[(byte)(crcwn ^ lo)]; - crcwn = (crcwn >> 8) ^ t[(byte)(crcwn ^ (lo >> 8))]; - } - else crcnulls++; - - uint hi = (uint)*(pSampleBuff++); - crc = (crc >> 8) ^ t[(byte)(crc ^ hi)]; - crc = (crc >> 8) ^ t[(byte)(crc ^ (hi >> 8))]; - if (hi != 0) - { - crcwn = (crcwn >> 8) ^ t[(byte)(crcwn ^ hi)]; - crcwn = (crcwn >> 8) ^ t[(byte)(crcwn ^ (hi >> 8))]; - } - else crcnulls++; - - uint sampleValue = (lo & 0xffff) + (hi << 16); - crcsm += sampleValue; - crcar += sampleValue * (uint)(currentOffset + i + 1); - } - } - _offsetedCRCAR[_currentTrack, 20 * 588] = crcar; - _offsetedCRCSM[_currentTrack, 20 * 588] = crcsm; - _offsetedCRC32[_currentTrack, 20 * 588] = crc; - _offsetedCRCWN[_currentTrack, 20 * 588] = crcwn; - _offsetedCRCNulls[_currentTrack, 20 * 588] = crcnulls; + _CRCAR[_currentTrack, 0] = crcar; + _CRCSM[_currentTrack, 0] = crcsm; + _CRC32[_currentTrack, 0] = crc32; + _CRCWN[_currentTrack, 0] = crcwn; + _CRCNL[_currentTrack, 0] = crcnulls; } public void Write(AudioBuffer sampleBuffer) @@ -462,15 +418,14 @@ namespace CUETools.AccurateRip fixed (int* pSampleBuff = &sampleBuffer.Samples[pos, 0]) //fixed (byte* pByteBuff = &sampleBuffer.Bytes[pos * sampleBuffer.BlockAlign]) { - if (currentSector < 5 || (_currentTrack == 1 && currentSector < 10)) + if (currentSector < 10) CalculateCRCs(pSampleBuff, copyCount, currentOffset, currentOffset); - else if (remaingSectors < 5 || (_currentTrack == _toc.AudioTracks && remaingSectors < 10)) + else if (remaingSectors < 10) CalculateCRCs(pSampleBuff, copyCount, currentOffset, 20 * 588 - (int)_samplesRemTrack); + else if (currentSector >= 445 && currentSector <= 455) + CalculateCRCs(pSampleBuff, copyCount, currentOffset, 20 * 588 + currentOffset - 445 * 588); else - CalculateCRCs(pSampleBuff, copyCount, currentOffset); - - if (currentSector >= 440 && currentSector <= 460) - CalculateFrame450CRCs(pSampleBuff, copyCount, _currentTrack - 1, currentOffset); + CalculateCRCs(pSampleBuff, copyCount, currentOffset, -1); } } pos += copyCount; @@ -482,27 +437,19 @@ namespace CUETools.AccurateRip public void Init() { - _offsetedCRCAR = new uint[_toc.AudioTracks + 1, 20 * 588 + 1]; - _offsetedCRCSM = new uint[_toc.AudioTracks + 1, 20 * 588 + 1]; - _offsetedCRC32 = new uint[_toc.AudioTracks + 1, 20 * 588 + 1]; - _offsetedCRC32Res = new uint[_toc.AudioTracks + 1, 20 * 588 + 1]; - _offsetedCRCWN = new uint[_toc.AudioTracks + 1, 20 * 588 + 1]; - _offsetedCRCWNRes = new uint[_toc.AudioTracks + 1, 20 * 588 + 1]; - _offsetedCRCNulls = new int[_toc.AudioTracks + 1, 20 * 588 + 1]; - _offsetedFrame450CRC = new uint[_toc.AudioTracks, 20 * 588]; + _CRCAR = new uint[_toc.AudioTracks + 1, 31 * 588]; + _CRCSM = new uint[_toc.AudioTracks + 1, 31 * 588]; + _CRC32 = new uint[_toc.AudioTracks + 1, 31 * 588]; + _CacheCRC32 = new uint[_toc.AudioTracks + 1, 31 * 588]; + _CRCWN = new uint[_toc.AudioTracks + 1, 31 * 588]; + _CacheCRCWN = new uint[_toc.AudioTracks + 1, 31 * 588]; + _CRCNL = new int[_toc.AudioTracks + 1, 31 * 588]; _currentTrack = 0; _sampleCount = _toc[_toc.FirstAudio][0].Start * 588; _samplesRemTrack = _toc[_toc.FirstAudio].Pregap * 588; CheckPosition(); } - public void CreateBackup(int writeOffset) - { - _backupCRC = new uint[_toc.AudioTracks]; - for (int i = 0; i < _toc.AudioTracks; i++) - _backupCRC[i] = CRC(i, writeOffset); - } - private void CheckPosition() { while (_samplesRemTrack <= 0) @@ -985,16 +932,14 @@ namespace CUETools.AccurateRip int _currentTrack; private List _accDisks; private HttpStatusCode _accResult; - private uint[,] _offsetedCRCAR; - private uint[,] _offsetedCRCSM; - private uint[,] _offsetedCRC32; - private uint[,] _offsetedCRCWN; - private uint[,] _offsetedCRCWNRes; - private int[,] _offsetedCRCNulls; - private uint[,] _offsetedCRC32Res; - private uint[,] _offsetedFrame450CRC; + private uint[,] _CRCAR; + private uint[,] _CRCSM; + private uint[,] _CRC32; + private uint[,] _CRCWN; + private int[,] _CRCNL; + private uint[,] _CacheCRCWN; + private uint[,] _CacheCRC32; private uint[] _CRCLOG; - private uint[] _backupCRC; Crc32 _crc32; diff --git a/CUETools/CUETools.TestCodecs/AccurateRipVerifyTest.cs b/CUETools/CUETools.TestCodecs/AccurateRipVerifyTest.cs index bee1c5a..a61afb9 100644 --- a/CUETools/CUETools.TestCodecs/AccurateRipVerifyTest.cs +++ b/CUETools/CUETools.TestCodecs/AccurateRipVerifyTest.cs @@ -20,7 +20,9 @@ namespace CUETools.TestCodecs private TestContext testContextInstance; private CDImageLayout toc; + private CDImageLayout toc2; private AccurateRipVerify ar; + private AccurateRipVerify ar2; /// ///Gets or sets the test context which provides @@ -66,8 +68,14 @@ namespace CUETools.TestCodecs toc.AddTrack(new CDTrack(3, 99, 37, true, false)); toc[1][0].Start = 0; ar = new AccurateRipVerify(toc); + + toc2 = new CDImageLayout(); + toc2.AddTrack(new CDTrack(1, 0, toc.AudioLength, true, false)); + toc2.AddTrack(new CDTrack(2, toc.AudioLength, 750, true, false)); + ar2 = new AccurateRipVerify(toc2); + Random rnd = new Random(2314); - for (int sector = 0; sector < toc.AudioLength; sector++) + for (int sector = 0; sector < toc2.AudioLength; sector++) { AudioBuffer buff = new AudioBuffer(AudioPCMConfig.RedBook, 588); buff.Length = 588; @@ -76,7 +84,9 @@ namespace CUETools.TestCodecs buff.Samples[i, 0] = rnd.Next(-32768, 32767); buff.Samples[i, 1] = rnd.Next(-32768, 32767); } - ar.Write(buff); + if (sector < toc.AudioLength) + ar.Write(buff); + ar2.Write(buff); } } @@ -100,6 +110,8 @@ namespace CUETools.TestCodecs Assert.AreEqual(0474131972, ar.CRC32(1), "CRC32[1] was not set correctly."); Assert.AreEqual(1685633822, ar.CRC32(2), "CRC32[2] was not set correctly."); Assert.AreEqual(2747309238, ar.CRC32(3), "CRC32[3] was not set correctly."); + + Assert.AreEqual(2884775698, ar2.CRC32(1), "CRC32[1](2) was not set correctly."); } /// @@ -116,6 +128,8 @@ namespace CUETools.TestCodecs Assert.AreEqual(4050516109, ar.CRC32(2, -1), "CRC32[2][-1] was not set correctly."); Assert.AreEqual(1860362251, ar.CRC32(3, 15), "CRC32[3][15] was not set correctly."); Assert.AreEqual(0761448415, ar.CRC32(3, -1), "CRC32[3][-1] was not set correctly."); + + Assert.AreEqual(1987827634, ar2.CRC32(1, -7), "CRC32[1,13](2) was not set correctly."); } /// @@ -163,6 +177,18 @@ namespace CUETools.TestCodecs Assert.AreEqual(0474131972, ar.CRCWONULL(1), "CRC32WONULL[1] was not set correctly."); Assert.AreEqual(1405611463, ar.CRCWONULL(2), "CRC32WONULL[2] was not set correctly."); Assert.AreEqual(2747309238, ar.CRCWONULL(3), "CRC32WONULL[3] was not set correctly."); + Assert.AreEqual(0509527097, ar2.CRCWONULL(1), "CRC32WONULL[1](2) was not set correctly."); + } + + /// + ///A test for CRC450 + /// + [TestMethod()] + public void CRC450Test() + { + Assert.AreEqual(1480802016, ar2.CRC450(1, 00), "CRC450[1,00] was not set correctly."); + Assert.AreEqual(2012115554, ar2.CRC450(1, 55), "CRC450[1,55] was not set correctly."); + Assert.AreEqual(1483829604, ar2.CRC450(1, -3), "CRC450[1,-3] was not set correctly."); } }