|
public static Calculate ( string text ) : |
||
| text | string | |
| return | ||
/// <inheritdoc/>
public byte[] Read(IDataStorerEntry entry)
{
Validation.NotNull("Entry", entry);
ZipReadOnlyStorerEntry zip64Entry = entry as ZipReadOnlyStorerEntry;
if (zip64Entry == null)
{
throw new InvalidEntryException(entry.Path);
}
byte[] data = null;
int count = (int)zip64Entry.Size;
if (zip64Entry.CompressionMethod == CompressionMethod.Store)
{
data = new byte[count];
Buffer.BlockCopy(this.zipFileData, (int)zip64Entry.FileOffset, data, 0, count);
}
else
{
data = ZLibUtils.Inflate(this.zipFileData, (int)zip64Entry.FileOffset, (int)zip64Entry.CompressedSize, count);
}
if (zip64Entry.CRC32 != CRC32.Calculate(data))
{
throw new InvalidEntryException(entry.Path);
}
return(data);
}
public static UDPPackage Parse(byte[] bytes)
{
Stream stream = new MemoryStream(bytes);
BinaryReader reader = new BinaryReader(stream);
uint crc = reader.ReadUInt32();
uint checkCRC = CRC32.Calculate(reader.ReadBytes(bytes.Length - 4));
if (crc != checkCRC)
{
return(new UDPPackage()); //пакет битый
}
stream.Position = 4;
uint sign = reader.ReadUInt32();
ushort parts = reader.ReadUInt16();
BytesList body = new BytesList();
if (parts == 0)
{
body.Add(reader.ReadBytes(bytes.Length - 4 - 4 - 2));
return(new UDPPackage(body, sign));
}
else
{
ushort part = reader.ReadUInt16();
ushort partsPackageId = reader.ReadUInt16();
body.Add(reader.ReadBytes(bytes.Length - 4 - 4 - 2 - 2 - 2));
return(new UDPPackage(partsPackageId, parts, part, body, sign));
}
}
public void Calculate_Set1_Stream()
{
using (Stream stream = new MemoryStream(_testByteArray_1))
{
string result = CRC32.Calculate(stream);
Assert.AreEqual(_crc32StringResult_1, result);
}
}
public static uint HashFilename(string name, PackageHashType type)
{
var padding = name.Length % 4 != 0 ? 4 - name.Length % 4 : 0;
var paddedLength = name.Length + padding;
// Avoid stack overflows by only allocating small buffers on the stack, and larger ones on the heap.
// 64 chars covers most real filenames.
var upperPaddedName = paddedLength < 64 ? stackalloc char[paddedLength] : new char[paddedLength];
name.AsSpan().ToUpperInvariant(upperPaddedName);
switch (type)
{
case PackageHashType.Classic:
{
for (var p = 0; p < padding; p++)
{
upperPaddedName[paddedLength - 1 - p] = '\0';
}
var asciiBytes = paddedLength < 64 ? stackalloc byte[paddedLength] : new byte[paddedLength];
Encoding.ASCII.GetBytes(upperPaddedName, asciiBytes);
var data = MemoryMarshal.Cast <byte, uint>(asciiBytes);
var result = 0u;
foreach (var next in data)
{
result = ((result << 1) | (result >> 31)) + next;
}
return(result);
}
case PackageHashType.CRC32:
{
var length = name.Length;
var lengthRoundedDownToFour = length / 4 * 4;
if (length != lengthRoundedDownToFour)
{
upperPaddedName[length] = (char)(length - lengthRoundedDownToFour);
for (var p = 1; p < padding; p++)
{
upperPaddedName[length + p] = upperPaddedName[lengthRoundedDownToFour];
}
}
var asciiBytes = paddedLength < 64 ? stackalloc byte[paddedLength] : new byte[paddedLength];
Encoding.ASCII.GetBytes(upperPaddedName, asciiBytes);
return(CRC32.Calculate(asciiBytes));
}
default: throw new NotImplementedException($"Unknown hash type `{type}`");
}
}
public void TestCRC32()
{
CRC32 crc32 = new CRC32();
UInt32[] data = Byte2Uint32(new byte[] { 0x7E, 0x05, 0x00, 105, 16, 1, 14, 0 }, 0, 8);
UInt32 crcValue = crc32.Calculate(data, data.Length);
UInt32 bt0 = (crcValue & 0xFF);
UInt32 bt1 = ((crcValue >> 8) & 0xFF);
UInt32 bt2 = ((crcValue >> 16) & 0xFF);
UInt32 bt3 = ((crcValue >> 24) & 0xFF);
}
private bool DetectTurboGECD()
{
//approach taken from mednafen DetectGECD()
//check for appropriate structure
var toc = _disc.TOC;
if (toc.FirstRecordedTrackNumber != 1)
{
return(false);
}
if (!toc.TOCItems[1].IsData)
{
return(false);
}
//some have a signature
if (StringAt("HACKER CD ROM SYSTEM", 0x8, 0x10))
{
return(true);
}
//some are more confusing
if (!StringAt("CD001", 0x1, 0x10))
{
return(false);
}
byte[] sector20 = ReadDataSectorCached(20);
var zecrc = CRC32.Calculate(sector20);
//known_crcs
if (zecrc == 0xd7b47c06)
{
return(true); // AV Tanjou
}
if (zecrc == 0x86aec522)
{
return(true); // Bishoujo Jyanshi [...]
}
if (zecrc == 0xc8d1b5ef)
{
return(true); // CD Bishoujo [...]
}
if (zecrc == 0x0bdbde64)
{
return(true); // CD Pachisuro [...]
}
return(false);
}
public void Calculate_Set1_Path()
{
string path = PathUtils.GetTempFileName(".txt");
File.WriteAllText(path, _testString_1);
try
{
string result = CRC32.Calculate(new FileInfo(path));
Assert.AreEqual(_crc32StringResult_1, result);
}
finally
{
File.Delete(path);
}
}
public UDPPackage(BytesList body, UInt32 sign = 0)
{
this.Body = body;
this.Sign = sign;
BytesList preCRCData = new BytesList();
preCRCData.AddUInt(this.Sign);
preCRCData.AddUShort(this.Parts);//==0
preCRCData.Add(body);
this.CRC = CRC32.Calculate(preCRCData);
this.FullData.AddUInt(this.CRC);
this.FullData.Add(preCRCData);
}
/// <summary>
/// Convert command to byte array.
/// </summary>
/// <returns></returns>
public byte[] ToArray()
{
// generate byte array of the payload.
var payload = GeneratePayload();
if (payload.Length > LEN_MAX_PAYLOAD)
{
throw new InvalidDataException("the length of the payload is out-of-range.");
}
byte[] output = null;
using (MemoryStream mem = new MemoryStream())
{
using (BinaryWriter wr = new BinaryWriter(mem))
{
// write package header (uint8).
wr.Write(HEADER);
// write package length (uint16).
wr.Write((UInt16)(payload.Length + LEN_API_ID + LEN_FRAME_ID + LEN_COMMAND));
// write API Identifier
wr.Write(API_IDENTIFIER_COMMAND);
// write frame ID
wr.Write(FrameID);
// write command (uint8).
wr.Write((byte)this.Command);
// write payload.
if (payload.Length > 0)
{
wr.Write(payload);
}
// calculate CRC32 of the package.
var pack = mem.ToArray();
CRC32 crc = new CRC32();
var crcval = crc.Calculate(pack, pack.Length);
wr.Write(crcval);
}
output = mem.ToArray();
}
return(output);
}
public static uint HashFilename(string name, PackageHashType type)
{
switch (type)
{
case PackageHashType.Classic:
{
name = name.ToUpperInvariant();
if (name.Length % 4 != 0)
{
name = name.PadRight(name.Length + (4 - name.Length % 4), '\0');
}
using (var ms = new MemoryStream(Encoding.ASCII.GetBytes(name)))
{
var len = name.Length >> 2;
uint result = 0;
while (len-- != 0)
{
result = ((result << 1) | (result >> 31)) + ms.ReadUInt32();
}
return(result);
}
}
case PackageHashType.CRC32:
{
name = name.ToUpperInvariant();
var l = name.Length;
var a = l >> 2;
if ((l & 3) != 0)
{
name += (char)(l - (a << 2));
var i = 3 - (l & 3);
while (i-- != 0)
{
name += name[a << 2];
}
}
return(CRC32.Calculate(Encoding.ASCII.GetBytes(name)));
}
default: throw new NotImplementedException("Unknown hash type `{0}`".F(type));
}
}
private static byte[] ReadChunkData(Stream stream, int length, string type)
{
byte[] data = new byte[length];
if (stream.Read(data, 0, data.Length) != data.Length)
throw new MetaParseException($"Unable to read full PNG chunk \"{type}\" data");
byte[] crc32 = new byte[4];
if (stream.Read(crc32, 0, crc32.Length) != crc32.Length)
throw new MetaParseException($"Unable to read full PNG chunk \"{type}\" CRC32");
byte[] crcData = type.Select(c => (byte)c).Concat(data).ToArray();
uint calculated = CRC32.Calculate(crcData, 0, crcData.Length, 0);
uint given = BitConverter.ToUInt32(crc32.Reverse().ToArray(), 0);
if (calculated != given)
throw new MetaParseException($"Checksum verification failure of PNG chunk \"{type}\"");
return data;
}
public static uint HashFilename(string name, PackageHashType type)
{
switch (type)
{
case PackageHashType.Classic:
{
name = name.ToUpperInvariant();
if (name.Length % 4 != 0)
{
name = name.PadRight(name.Length + (4 - name.Length % 4), '\0');
}
var result = 0u;
var data = Encoding.ASCII.GetBytes(name);
var i = 0;
while (i < data.Length)
{
var next = (uint)(data[i++] | data[i++] << 8 | data[i++] << 16 | data[i++] << 24);
result = ((result << 1) | (result >> 31)) + next;
}
return(result);
}
case PackageHashType.CRC32:
{
name = name.ToUpperInvariant();
var l = name.Length;
var a = l >> 2;
if ((l & 3) != 0)
{
name += (char)(l - (a << 2));
var i = 3 - (l & 3);
while (i-- != 0)
{
name += name[a << 2];
}
}
return(CRC32.Calculate(Encoding.ASCII.GetBytes(name)));
}
default: throw new NotImplementedException($"Unknown hash type `{type}`");
}
}
public void BufferStressTest()
{
var r = new Random(8675309);
using var zw = new ZwinderBuffer(new RewindConfig
{
BufferSize = 1,
TargetFrameLength = 1
});
var buff = new byte[40000];
for (int round = 0; round < 10; round++)
{
for (int i = 0; i < 500; i++)
{
zw.Capture(i, s =>
{
var length = r.Next(40000);
var bw = new BinaryWriter(s);
var bytes = buff.AsSpan(0, length);
r.NextBytes(bytes);
bw.Write(length);
bw.Write(bytes);
bw.Write(CRC32.Calculate(bytes));
});
}
for (int i = 0; i < zw.Count; i++)
{
var info = zw.GetState(i);
var s = info.GetReadStream();
var br = new BinaryReader(s);
var length = info.Size;
if (length != br.ReadInt32() + 8)
{
throw new Exception("Length field corrupted");
}
var bytes = buff.AsSpan(0, length - 8);
br.Read(bytes);
if (br.ReadUInt32() != CRC32.Calculate(bytes))
{
throw new Exception("Data or CRC field corrupted");
}
}
}
}
public void CompressCallback(object threadContext)
{
var context = (WriterThreadContext)threadContext;
while (QueuedChunks.Count > 0)
{
bool result = QueuedChunks.TryDequeue(out var chunk, 250);
if (!result)
{
continue;
}
using (MemoryStream mem = new MemoryStream())
{
foreach (var file in chunk.Value)
{
using (Stream fileStream = file.GetStream())
fileStream.CopyTo(mem);
}
mem.Position = 0;
using (Stream compressedBuffer = context.Compressor.GetStream(mem))
{
chunk.Key.Crc32 = CRC32.Calculate(compressedBuffer);
chunk.Key.CompressedLength = (ulong)compressedBuffer.Length;
compressedBuffer.Position = 0;
lock (context.ArchiveStream)
{
chunk.Key.Offset = (ulong)context.ArchiveStream.Position;
compressedBuffer.CopyTo(context.ArchiveStream);
}
}
}
//Aggressive GC collections
GC.Collect();
}
}
public UDPPackage(ushort partsPackageId, ushort parts, ushort part, BytesList body, UInt32 sign = 0)
{
this.PartsPackageId = partsPackageId;
this.Parts = parts;
this.Part = part;
this.Body = body;
this.Sign = sign;
BytesList preCRCData = new BytesList();
preCRCData.AddUInt(this.Sign);
preCRCData.AddUShort(this.Parts);//!=0
preCRCData.AddUShort(this.Part);
preCRCData.AddUShort(this.PartsPackageId);
preCRCData.Add(body);
this.CRC = CRC32.Calculate(preCRCData);
this.FullData.AddUInt(this.CRC);
this.FullData.Add(preCRCData);
}
private void Comport_DataReceived1(object sender, SerialDataReceivedEventArgs e)
{
int Len = Sp.BytesToRead;
for (int i = 0; i < Len; i++)
{
byte bt = (byte)Sp.ReadByte();
FrameRecvByteQueue.Enqueue(bt);
}
while (FrameRecvByteQueue.Count > 0)
{
byte bt = FrameRecvByteQueue.Dequeue();
if (bt == PACKAGE_HEADER && TempList.Count == 0)
{
TempList.Add(bt);
continue;
}
if (TempList.Count > 0) //说明发现了包
{
TempList.Add(bt);
if (TempList.Count == 3)
{
ExpectLength = TempList[1] + TempList[2] * 256;
}
else if (TempList.Count >= (7 + ExpectLength))
{
byte[] dataList = TempList.ToArray();
UInt32 Crc32 = (UInt32)(dataList[dataList.Length - 4] + (dataList[dataList.Length - 3] << 8) + (dataList[dataList.Length - 2] << 16) + (dataList[dataList.Length - 1] << 24));
UInt32 CalcCrc32 = Crc32Instance.Calculate(dataList, 0, dataList.Length - 4);
if (Crc32 == CalcCrc32) //校验成功
{
ProcessPackage(dataList);
}
ExpectLength = 0;
TempList = new List <byte>();
}
}
}
}
public void CRC32_1Arg_Checksum()
{
Assert.AreEqual(64128641, CRC32.Calculate(ArrayUtils.CreateArray((byte)255, 100)));
}
public void Submit(string statName, int statValue)
{
Submit((int)CRC32.Calculate(statName), statValue);
}
public void CRC32_4Args_Checksum()
{
byte[] data = ArrayUtils.CreateArray((byte)255, 100);
Assert.AreEqual(2307493135, CRC32.Calculate(data, data, data, data));
}
public void Calculate_Set2_ByteArray()
{
string result = CRC32.Calculate(_testByteArray_2);
Assert.AreEqual(_crc32StringResult_2, result);
}
public void Flush()
{
var fullSaveName = SavePath + Path.DirectorySeparatorChar + SaveName + SaveExtension;
_saveFile = new FileStream(fullSaveName, FileMode.OpenOrCreate);
_saveWriter = new BinaryWriter(_saveFile);
switch (SaveType)
{
case SaveType.DoubutsuNoMoriPlus:
case SaveType.AnimalCrossing:
case SaveType.DoubutsuNoMoriEPlus:
case SaveType.AnimalForestEPlus:
Write(SaveDataStartOffset + SaveInfo.SaveOffsets.Checksum,
new UInt16BEChecksum().Calculate(
SaveData.Skip(SaveDataStartOffset).Take(SaveInfo.SaveOffsets.SaveSize).ToArray(),
(uint)SaveInfo.SaveOffsets.Checksum), IsBigEndian);
SaveData.Skip(SaveDataStartOffset).Take(SaveInfo.SaveOffsets.SaveSize).ToArray().CopyTo(
SaveData,
SaveDataStartOffset + SaveInfo.SaveOffsets.SaveSize);
break;
case SaveType.WildWorld:
Write(SaveDataStartOffset + SaveInfo.SaveOffsets.Checksum,
new UInt16LEChecksum().Calculate(
SaveData.Skip(SaveDataStartOffset).Take(SaveInfo.SaveOffsets.SaveSize).ToArray(),
(uint)SaveInfo.SaveOffsets.Checksum), IsBigEndian);
SaveData.Skip(SaveDataStartOffset).Take(SaveInfo.SaveOffsets.SaveSize).ToArray().CopyTo(
SaveData,
SaveDataStartOffset + SaveInfo.SaveOffsets.SaveSize);
break;
case SaveType.DoubutsuNoMori:
case SaveType.DongwuSenlin:
Write(SaveDataStartOffset + SaveInfo.SaveOffsets.Checksum,
new UInt16BEChecksum().Calculate(
SaveData.Skip(SaveDataStartOffset).Take(0xF980).ToArray(),
(uint)SaveInfo.SaveOffsets.Checksum), IsBigEndian);
SaveData.Skip(SaveDataStartOffset).Take(SaveInfo.SaveOffsets.SaveSize).ToArray().CopyTo(
SaveData,
SaveDataStartOffset + SaveInfo.SaveOffsets.SaveSize);
break;
case SaveType.CityFolk:
var crc32 = new CRC32();
for (var i = 0; i < 4; i++)
{
var playerDataOffset = SaveDataStartOffset + i * 0x86C0 + 0x1140;
var playerCrc32 =
crc32.Calculate(SaveData.Skip(playerDataOffset + 4).Take(0x759C).ToArray());
Write(playerDataOffset, playerCrc32, true);
}
Write(SaveDataStartOffset + 0x5EC60,
crc32.Calculate(SaveData.Skip(SaveDataStartOffset + 0x5EC64).Take(0x1497C).ToArray()),
true);
Write(SaveDataStartOffset + 0x5EB04,
crc32.Calculate(SaveData.Skip(SaveDataStartOffset + 0x5EB08).Take(0x152).ToArray(),
0x12141018), true);
Write(SaveDataStartOffset + 0x73600,
crc32.Calculate(SaveData.Skip(SaveDataStartOffset + 0x73604).Take(0x19BD1C).ToArray()),
true);
Write(SaveDataStartOffset,
crc32.Calculate(SaveData.Skip(SaveDataStartOffset + 4).Take(0x1C).ToArray()), true);
Write(SaveDataStartOffset + 0x20,
crc32.Calculate(SaveData.Skip(SaveDataStartOffset + 0x24).Take(0x111C).ToArray()), true);
break;
case SaveType.NewLeaf:
var crc32Reflected = new NewLeafCRC32Reflected();
Write(SaveDataStartOffset,
crc32Reflected.Calculate(SaveData.Skip(SaveDataStartOffset + 4).Take(0x1C).ToArray()));
for (var i = 0; i < 4; i++)
{
var dataOffset = SaveDataStartOffset + 0x20 + i * 0x9F10;
Write(dataOffset,
crc32Reflected.Calculate(SaveData.Skip(dataOffset + 4).Take(0x6B64).ToArray()));
var dataOffset2 = SaveDataStartOffset + 0x20 + 0x6B68 + i * 0x9F10;
Write(dataOffset2,
crc32Reflected.Calculate(SaveData.Skip(dataOffset2 + 4).Take(0x33A4).ToArray()));
}
Write(SaveDataStartOffset + 0x27C60,
crc32Reflected.Calculate(SaveData.Skip(SaveDataStartOffset + 0x27C60 + 4).Take(0x218B0)
.ToArray()));
Write(SaveDataStartOffset + 0x49520,
crc32Reflected.Calculate(SaveData.Skip(SaveDataStartOffset + 0x49520 + 4).Take(0x44B8)
.ToArray()));
Write(SaveDataStartOffset + 0x4D9DC,
crc32Reflected.Calculate(SaveData.Skip(SaveDataStartOffset + 0x4D9DC + 4).Take(0x1E420)
.ToArray()));
Write(SaveDataStartOffset + 0x6BE00,
crc32Reflected.Calculate(SaveData.Skip(SaveDataStartOffset + 0x6BE00 + 4).Take(0x20)
.ToArray()));
Write(SaveDataStartOffset + 0x6BE24,
crc32Reflected.Calculate(SaveData.Skip(SaveDataStartOffset + 0x6BE24 + 4).Take(0x13AF8)
.ToArray()));
break;
case SaveType.WelcomeAmiibo:
var wCrc32Reflected = new NewLeafCRC32Reflected();
var wCrc32Normal = new NewLeafCRC32Normal();
// Reflected CRC32 Implementation Checksums
Write(SaveDataStartOffset,
wCrc32Reflected.Calculate(SaveData.Skip(SaveDataStartOffset + 4).Take(0x1C).ToArray()));
for (var i = 0; i < 4; i++)
{
var dataOffset = SaveDataStartOffset + 0x20 + i * 0xA480;
Write(dataOffset,
wCrc32Reflected.Calculate(SaveData.Skip(dataOffset + 4).Take(0x6B84).ToArray()));
var dataOffset2 = SaveDataStartOffset + 0x20 + 0x6B88 + i * 0xA480;
Write(dataOffset2,
wCrc32Reflected.Calculate(SaveData.Skip(dataOffset2 + 4).Take(0x38F4).ToArray()));
}
Write(SaveDataStartOffset + 0x29220,
wCrc32Reflected.Calculate(SaveData.Skip(SaveDataStartOffset + 0x29220 + 4).Take(0x22BC8)
.ToArray()));
Write(SaveDataStartOffset + 0x4BE00,
wCrc32Reflected.Calculate(SaveData.Skip(SaveDataStartOffset + 0x4BE00 + 4).Take(0x44B8)
.ToArray()));
Write(SaveDataStartOffset + 0x533A4,
wCrc32Reflected.Calculate(SaveData.Skip(SaveDataStartOffset + 0x533A4 + 4).Take(0x1E4D8)
.ToArray()));
Write(SaveDataStartOffset + 0x71880,
wCrc32Reflected.Calculate(SaveData.Skip(SaveDataStartOffset + 0x71880 + 4).Take(0x20)
.ToArray()));
Write(SaveDataStartOffset + 0x718A4,
wCrc32Reflected.Calculate(SaveData.Skip(SaveDataStartOffset + 0x718A4 + 4).Take(0xBE4)
.ToArray()));
Write(SaveDataStartOffset + 0x738D4,
wCrc32Reflected.Calculate(SaveData.Skip(SaveDataStartOffset + 0x738D4 + 4).Take(0x16188)
.ToArray()));
// Normal CRC32 Implementation Checksums
Write(SaveDataStartOffset + 0x502BC,
wCrc32Normal.Calculate(SaveData.Skip(SaveDataStartOffset + 0x502BC + 4).Take(0x28F0)
.ToArray()));
Write(SaveDataStartOffset + 0x52BB0,
wCrc32Normal.Calculate(SaveData.Skip(SaveDataStartOffset + 0x52BB0 + 4).Take(0x7F0)
.ToArray()));
Write(SaveDataStartOffset + 0x7248C,
wCrc32Normal.Calculate(SaveData.Skip(SaveDataStartOffset + 0x7248C + 4).Take(0x1444)
.ToArray()));
break;
}
_saveWriter.Write(SaveType == SaveType.DoubutsuNoMori && _byteswap
? SaveDataManager.ByteSwap(SaveData)
: SaveData); // Doubutsu no Mori is dword byteswapped
_saveWriter.Flush();
_saveFile.Flush();
_saveWriter.Close();
_saveFile.Close();
_saveWriter.Dispose();
_saveFile.Dispose();
ChangesMade = false;
}
public static uint CalculateHash(byte[] Data)
{
return(crc.Calculate(Data));
}
public void AddDefinition(string statName, string description, StatisticType type)
{
AddDefinition((int)CRC32.Calculate(statName), description, type);
}
public void Calculate_Stream_Null()
{
Assert.Throws <ArgumentNullException>(() => CRC32.Calculate((Stream)null));
}
public void Calculate_Path_Null()
{
Assert.Throws <ArgumentNullException>(() => CRC32.Calculate((FileInfo)null));
}
public void Calculate_ByteArray_Null()
{
Assert.Throws <ArgumentNullException>(() => CRC32.Calculate((byte[])null));
}
static string Hash_CRC32(byte[] data) => $"{CRC32.Calculate(data):X8}";
/// <inheritdoc/>
public IDataStorerEntry Add(string path, params byte[] data)
{
Validation.NotNull("Path", path);
Validation.NotNull("Data", data);
string normalizedPath = path.Replace('\\', '/');
int pos = normalizedPath.IndexOf(':');
if (pos >= 0)
{
normalizedPath = normalizedPath.Remove(0, pos + 1);
}
normalizedPath = normalizedPath.Trim('/');
int uncompressedLength = data.Length;
int compressedLength;
byte[] compressedData;
CompressionMethod compressionMethod;
if (this.enableCompression)
{
Deflater deflater = new Deflater(Deflater.DEFLATED);
deflater.SetInput(data, 0, uncompressedLength);
deflater.Finish();
compressedData = new byte[uncompressedLength];
compressedLength = deflater.Deflate(compressedData, 0, uncompressedLength);
if (deflater.IsFinished && compressedLength <= uncompressedLength)
{
// Use deflate
compressionMethod = CompressionMethod.Deflate;
}
else
{
// Force to store
compressedData = data;
compressedLength = uncompressedLength;
compressionMethod = CompressionMethod.Store;
}
}
else
{
// Only store
compressedData = data;
compressedLength = uncompressedLength;
compressionMethod = CompressionMethod.Store;
}
uint uncompressedSize = (uint)uncompressedLength;
uint compressedSize = (uint)compressedLength;
uint crc32 = CRC32.Calculate(data);
uint headerOffset = (uint)this.zipFileWriter.Position;
ZipWriteOnlyStorerEntry fileEntry = new ZipWriteOnlyStorerEntry(
normalizedPath,
uncompressedSize,
compressionMethod,
compressedSize,
headerOffset,
crc32,
DateTime.Now,
comment ?? ""
);
this.WriteFileHeader(this.zipFileWriter, fileEntry, false);
this.zipFileWriter.WriteBytes(compressedData, 0, compressedLength);
this.entries.AddLast(fileEntry);
return(fileEntry);
}
public void CRC32_4EmptyArg_Zero()
{
Assert.AreEqual(0, CRC32.Calculate(new byte[0], new byte[0], new byte[0], new byte[0]));
}
static string Hash_CRC32(byte[] data)
{
return(string.Format("{0:X8}", CRC32.Calculate(data)));
}
