public static void WriteToProtoBufFile <T>(this T value, string path) where T : new()
{
using (var file = File.Create(path))
{
ProtoBufSerializer.Serialize(file, value);
}
}
public void ProtobufDeserializeAndDeserialize()
{
MemoryStream ms = new MemoryStream();
PSerializer.Serialize <Test>(ms, s_Test);
ms.Seek(0, SeekOrigin.Begin);
PSerializer.Deserialize <Test>(ms);
ms.Dispose();
}
private static void Main()
{
Serializer.PrepareSerializer <Test>();
Serializer.PrepareSerializer <Test1>();
PSerializer.PrepareSerializer <Test>();
PSerializer.PrepareSerializer <Test1>();
BenchmarkRunner.Run <TestClass>();
Console.ReadKey();
}
public static T ReadFromProtoBufFile <T>(this string path) where T : new()
{
T result;
using (var file = File.OpenRead(path))
{
result = ProtoBufSerializer.Deserialize <T>(file);
}
return(result);
}
/// <summary>
/// Deserializes the specified stream.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="stream">The stream.</param>
/// <param name="channel">The channel.</param>
/// <returns></returns>
private RedisMessage Deserialize <T>(MemoryStream stream, string channel)
{
var obj = Serializer.Deserialize <ChannelMessage <T> >(stream);
if (obj != null)
{
return(new RedisMessage(channel, obj.MachineName, obj.ProcessName, obj.ProcessId, obj.AppDomainName, obj.AppDomainId, obj.Date, stream.Length, obj.HostTenantId, obj.Message.ToString( )));
}
return(null);
}
public void should_read_message_from_protobuf()
{
var transportMessage = TestDataBuilder.CreateTransportMessage <FakeCommand>();
var stream = new MemoryStream();
Serializer.Serialize(stream, transportMessage);
var inputStream = new CodedInputStream(stream.GetBuffer(), 0, (int)stream.Length);
var deserialized = inputStream.ReadTransportMessage();
deserialized.Id.ShouldEqual(transportMessage.Id);
deserialized.MessageTypeId.ShouldEqual(transportMessage.MessageTypeId);
deserialized.GetContentBytes().ShouldEqual(transportMessage.GetContentBytes());
deserialized.Originator.ShouldEqualDeeply(transportMessage.Originator);
deserialized.Environment.ShouldEqual(transportMessage.Environment);
deserialized.WasPersisted.ShouldEqual(transportMessage.WasPersisted);
}
private void Deserialize <T>(MemoryStream stream, string channel)
{
var obj = Serializer.Deserialize <ChannelMessage <T> >(stream);
if (obj != null)
{
var jss = new JavaScriptSerializer( );
jss.MaxJsonLength = int.MaxValue;
jss.RecursionLimit = int.MaxValue;
var jsonObject = jss.Deserialize <dynamic>(obj.Message.ToString( )) as IDictionary <string, object>;
if (jsonObject != null)
{
var root = new ProfilerTrace(jsonObject, "web.png");
_dispatcher.Invoke(() => ProfilerTraceModel.Add(root, Guid.Empty));
var child = jsonObject["Root"] as IDictionary <string, object>;
Parse(child, root.Id);
}
}
}
void ProtoBuf <T>(T item, UnmanagedMemoryStream ms)
{
ProtoBufSerializer.Serialize(ms, item);
}
public void Serialize(Stream output)
{
var saveGame = this.SaveGame;
if (IsSupportedPlatform(this.Platform) == false)
{
throw new InvalidOperationException("unsupported platform");
}
var endian = this.Platform.GetEndian();
var compressionScheme = this.Platform.GetCompressionScheme();
byte[] innerUncompressedBytes;
using (var innerUncompressedData = new MemoryStream())
{
if (this.PlayerStats != null)
{
saveGame.StatsData = this.PlayerStats.Serialize(endian);
}
ProtoSerializer.Serialize(innerUncompressedData, saveGame);
innerUncompressedData.Position = 0;
innerUncompressedBytes = innerUncompressedData.ReadBytes((uint)innerUncompressedData.Length);
}
byte[] innerCompressedBytes;
using (var innerCompressedData = new MemoryStream())
{
var hash = CRC32.Hash(innerUncompressedBytes, 0, innerUncompressedBytes.Length);
innerCompressedData.WriteValueS32(0, Endian.Big);
innerCompressedData.WriteString("WSG");
innerCompressedData.WriteValueU32(2, endian);
innerCompressedData.WriteValueU32(hash, endian);
innerCompressedData.WriteValueS32(innerUncompressedBytes.Length, endian);
var encoder = new Huffman.Encoder();
encoder.Build(innerUncompressedBytes);
innerCompressedData.WriteBytes(encoder.Encode(innerUncompressedBytes));
innerCompressedData.Position = 0;
innerCompressedData.WriteValueU32((uint)(innerCompressedData.Length - 4), Endian.Big);
innerCompressedData.Position = 0;
innerCompressedBytes = innerCompressedData.ReadBytes((uint)innerCompressedData.Length);
}
byte[] compressedBytes;
if (innerCompressedBytes.Length <= BlockSize)
{
if (compressionScheme == CompressionScheme.LZO)
{
compressedBytes = new byte[innerCompressedBytes.Length +
(innerCompressedBytes.Length / 16) + 64 + 3];
var actualCompressedSize = compressedBytes.Length;
var result = MiniLZO.LZO.Compress(
innerCompressedBytes,
0,
innerCompressedBytes.Length,
compressedBytes,
0,
ref actualCompressedSize,
new MiniLZO.CompressWorkBuffer());
if (result != MiniLZO.ErrorCode.Success)
{
throw new SaveCorruptionException(string.Format("LZO compression failure ({0})", result));
}
Array.Resize(ref compressedBytes, actualCompressedSize);
}
else if (compressionScheme == CompressionScheme.Zlib)
{
using (var temp = new MemoryStream())
{
var zlib = new DeflaterOutputStream(temp);
zlib.WriteBytes(innerCompressedBytes);
zlib.Finish();
temp.Flush();
temp.Position = 0;
compressedBytes = temp.ReadBytes((uint)temp.Length);
}
}
else
{
throw new InvalidOperationException("unsupported compression scheme");
}
}
else
{
if (compressionScheme == CompressionScheme.LZO)
{
int innerCompressedOffset = 0;
int innerCompressedSizeLeft = innerCompressedBytes.Length;
using (var blockData = new MemoryStream())
{
var blockCount = (innerCompressedSizeLeft + BlockSize) / BlockSize;
blockData.WriteValueS32(blockCount, Endian.Big);
blockData.Position = 4 + (blockCount * 8);
var blockInfos = new List <Tuple <uint, uint> >();
while (innerCompressedSizeLeft > 0)
{
var blockUncompressedSize = Math.Min(BlockSize, innerCompressedSizeLeft);
compressedBytes = new byte[blockUncompressedSize +
(blockUncompressedSize / 16) + 64 + 3];
var actualCompressedSize = compressedBytes.Length;
var result = MiniLZO.LZO.Compress(
innerCompressedBytes,
innerCompressedOffset,
blockUncompressedSize,
compressedBytes,
0,
ref actualCompressedSize,
new MiniLZO.CompressWorkBuffer());
if (result != MiniLZO.ErrorCode.Success)
{
throw new SaveCorruptionException(string.Format("LZO compression failure ({0})", result));
}
blockData.Write(compressedBytes, 0, actualCompressedSize);
blockInfos.Add(new Tuple <uint, uint>((uint)actualCompressedSize, BlockSize));
innerCompressedOffset += blockUncompressedSize;
innerCompressedSizeLeft -= blockUncompressedSize;
}
blockData.Position = 4;
foreach (var blockInfo in blockInfos)
{
blockData.WriteValueU32(blockInfo.Item1, Endian.Big);
blockData.WriteValueU32(blockInfo.Item2, Endian.Big);
}
blockData.Position = 0;
compressedBytes = blockData.ReadBytes((uint)blockData.Length);
}
}
else if (compressionScheme == CompressionScheme.Zlib)
{
int innerCompressedOffset = 0;
int innerCompressedSizeLeft = innerCompressedBytes.Length;
using (var blockData = new MemoryStream())
{
var blockCount = (innerCompressedSizeLeft + BlockSize) / BlockSize;
blockData.WriteValueS32(blockCount, Endian.Big);
blockData.Position = 4 + (blockCount * 8);
var blockInfos = new List <Tuple <uint, uint> >();
while (innerCompressedSizeLeft > 0)
{
var blockUncompressedSize = Math.Min(BlockSize, innerCompressedSizeLeft);
using (var temp = new MemoryStream())
{
var zlib = new DeflaterOutputStream(temp);
zlib.Write(innerCompressedBytes, innerCompressedOffset, blockUncompressedSize);
zlib.Finish();
temp.Flush();
temp.Position = 0;
compressedBytes = temp.ReadBytes((uint)temp.Length);
}
blockData.WriteBytes(compressedBytes);
blockInfos.Add(new Tuple <uint, uint>((uint)compressedBytes.Length, BlockSize));
innerCompressedOffset += blockUncompressedSize;
innerCompressedSizeLeft -= blockUncompressedSize;
}
blockData.Position = 4;
foreach (var blockInfo in blockInfos)
{
blockData.WriteValueU32(blockInfo.Item1, Endian.Big);
blockData.WriteValueU32(blockInfo.Item2, Endian.Big);
}
blockData.Position = 0;
compressedBytes = blockData.ReadBytes((uint)blockData.Length);
}
}
else
{
throw new InvalidOperationException("unsupported platform");
}
}
byte[] uncompressedBytes;
using (var uncompressedData = new MemoryStream())
{
uncompressedData.WriteValueS32(innerCompressedBytes.Length, Endian.Big);
uncompressedData.WriteBytes(compressedBytes);
uncompressedData.Position = 0;
uncompressedBytes = uncompressedData.ReadBytes((uint)uncompressedData.Length);
}
byte[] computedHash;
using (var sha1 = new System.Security.Cryptography.SHA1Managed())
{
computedHash = sha1.ComputeHash(uncompressedBytes);
}
output.WriteBytes(computedHash);
output.WriteBytes(uncompressedBytes);
}
public static SaveFile Deserialize(Stream input, Platform platform, DeserializeSettings settings)
{
if (IsSupportedPlatform(platform) == false)
{
throw new ArgumentException("unsupported platform", "platform");
}
if (input.Position + 20 > input.Length)
{
throw new SaveCorruptionException("not enough data for save header");
}
var check = input.ReadValueU32(Endian.Big);
if (check == 0x434F4E20)
{
throw new SaveFormatException("cannot load XBOX 360 CON files, extract save using Modio or equivalent");
}
input.Seek(-4, SeekOrigin.Current);
var compressionScheme = platform.GetCompressionScheme();
var readSha1Hash = input.ReadBytes(20);
using (var data = input.ReadToMemoryStream(input.Length - 20))
{
byte[] computedSha1Hash;
using (var sha1 = new System.Security.Cryptography.SHA1Managed())
{
computedSha1Hash = sha1.ComputeHash(data);
}
if ((settings & DeserializeSettings.IgnoreSha1Mismatch) == 0 &&
readSha1Hash.SequenceEqual(computedSha1Hash) == false)
{
throw new SaveCorruptionException("invalid SHA1 hash");
}
data.Position = 0;
var uncompressedSize = data.ReadValueU32(Endian.Big);
var uncompressedBytes = new byte[uncompressedSize];
if (uncompressedSize <= BlockSize)
{
if (compressionScheme == CompressionScheme.LZO)
{
var actualUncompressedSize = (int)uncompressedSize;
var compressedSize = (uint)(data.Length - 4);
var compressedBytes = data.ReadBytes(compressedSize);
var result = MiniLZO.LZO.Decompress(compressedBytes,
0,
(int)compressedSize,
uncompressedBytes,
0,
ref actualUncompressedSize);
if (result != MiniLZO.ErrorCode.Success)
{
throw new SaveCorruptionException(string.Format("LZO decompression failure ({0})", result));
}
if (actualUncompressedSize != (int)uncompressedSize)
{
throw new SaveCorruptionException("LZO decompression failure (uncompressed size mismatch)");
}
}
else if (compressionScheme == CompressionScheme.Zlib)
{
var compressedSize = (uint)(data.Length - 4);
using (var temp = data.ReadToMemoryStream(compressedSize))
{
var zlib = new InflaterInputStream(temp);
try
{
if (zlib.Read(uncompressedBytes, 0, uncompressedBytes.Length) !=
uncompressedBytes.Length)
{
throw new SaveCorruptionException(
"zlib decompression failure (uncompressed size mismatch)");
}
}
catch (ICSharpCode.SharpZipLib.SharpZipBaseException e)
{
throw new SaveCorruptionException(
string.Format("zlib decompression failure ({0})", e.Message),
e);
}
}
}
else
{
throw new InvalidOperationException("unsupported compression scheme");
}
}
else
{
if (compressionScheme == CompressionScheme.LZO)
{
var blockCount = data.ReadValueU32(Endian.Big);
var blockInfos = new List <Tuple <uint, uint> >();
for (uint i = 0; i < blockCount; i++)
{
var blockCompressedSize = data.ReadValueU32(Endian.Big);
var blockUncompressedSize = data.ReadValueU32(Endian.Big);
blockInfos.Add(new Tuple <uint, uint>(blockCompressedSize, blockUncompressedSize));
}
int uncompressedOffset = 0;
int uncompressedSizeLeft = (int)uncompressedSize;
foreach (var blockInfo in blockInfos)
{
var blockUncompressedSize = Math.Min((int)blockInfo.Item2, uncompressedSizeLeft);
var actualUncompressedSize = blockUncompressedSize;
var compressedSize = (int)blockInfo.Item1;
var compressedBytes = data.ReadBytes(compressedSize);
var result = MiniLZO.LZO.Decompress(compressedBytes,
0,
compressedSize,
uncompressedBytes,
uncompressedOffset,
ref actualUncompressedSize);
if (result != MiniLZO.ErrorCode.Success)
{
throw new SaveCorruptionException(string.Format("LZO decompression failure ({0})",
result));
}
if (actualUncompressedSize != blockUncompressedSize)
{
throw new SaveCorruptionException(
"LZO decompression failure (uncompressed size mismatch)");
}
uncompressedOffset += blockUncompressedSize;
uncompressedSizeLeft -= blockUncompressedSize;
}
if (uncompressedSizeLeft != 0)
{
throw new SaveCorruptionException("LZO decompression failure (uncompressed size left != 0)");
}
}
else if (compressionScheme == CompressionScheme.Zlib)
{
var blockCount = data.ReadValueU32(Endian.Big);
var blockInfos = new List <Tuple <uint, uint> >();
for (uint i = 0; i < blockCount; i++)
{
var blockCompressedSize = data.ReadValueU32(Endian.Big);
var blockUncompressedSize = data.ReadValueU32(Endian.Big);
blockInfos.Add(new Tuple <uint, uint>(blockCompressedSize, blockUncompressedSize));
}
int uncompressedOffset = 0;
int uncompressedSizeLeft = (int)uncompressedSize;
foreach (var blockInfo in blockInfos)
{
var blockUncompressedSize = Math.Min((int)blockInfo.Item2, uncompressedSizeLeft);
int actualUncompressedSize;
var compressedSize = (int)blockInfo.Item1;
using (var temp = data.ReadToMemoryStream(compressedSize))
{
var zlib = new InflaterInputStream(temp);
try
{
actualUncompressedSize = zlib.Read(uncompressedBytes,
uncompressedOffset,
uncompressedBytes.Length);
}
catch (ICSharpCode.SharpZipLib.SharpZipBaseException e)
{
throw new SaveCorruptionException(string.Format("zlib decompression failure ({0})",
e.Message),
e);
}
}
if (actualUncompressedSize != blockUncompressedSize)
{
throw new SaveCorruptionException(
"zlib decompression failure (uncompressed size mismatch)");
}
uncompressedOffset += blockUncompressedSize;
uncompressedSizeLeft -= blockUncompressedSize;
}
if (uncompressedSizeLeft != 0)
{
throw new SaveCorruptionException("zlib decompression failure (uncompressed size left != 0)");
}
}
else
{
throw new InvalidOperationException("unsupported platform");
}
}
using (var outerData = new MemoryStream(uncompressedBytes))
{
var endian = platform.GetEndian();
var innerSize = outerData.ReadValueU32(Endian.Big);
var magic = outerData.ReadString(3);
if (magic != "WSG")
{
throw new SaveCorruptionException("invalid magic");
}
var version = outerData.ReadValueU32(endian);
if (version != 2)
{
throw new SaveCorruptionException("invalid or unsupported version");
}
var readCRC32Hash = outerData.ReadValueU32(endian);
var innerUncompressedSize = outerData.ReadValueS32(endian);
var innerCompressedBytes = outerData.ReadBytes(innerSize - 3 - 4 - 4 - 4);
var innerUncompressedBytes = Huffman.Decoder.Decode(innerCompressedBytes,
innerUncompressedSize);
if (innerUncompressedBytes.Length != innerUncompressedSize)
{
throw new SaveCorruptionException("huffman decompression failure");
}
var computedCRC32Hash = CRC32.Hash(innerUncompressedBytes, 0, innerUncompressedBytes.Length);
if ((settings & DeserializeSettings.IgnoreCrc32Mismatch) == 0 &&
computedCRC32Hash != readCRC32Hash)
{
throw new SaveCorruptionException("invalid CRC32 hash");
}
using (var innerUncompressedData = new MemoryStream(innerUncompressedBytes))
{
var saveGame = ProtoSerializer.Deserialize <WillowTwoSave.WillowTwoPlayerSaveGame>(
innerUncompressedData);
PlayerStats playerStats = null;
if (saveGame.StatsData != null &&
PlayerStats.IsSupportedVersion(saveGame.StatsData, endian) == true)
{
playerStats = new PlayerStats();
playerStats.Deserialize(saveGame.StatsData, endian);
}
if ((settings & DeserializeSettings.IgnoreReencodeMismatch) == 0)
{
using (var testData = new MemoryStream())
{
byte[] oldStatsData = saveGame.StatsData;
if (playerStats != null)
{
saveGame.StatsData = playerStats.Serialize(endian);
}
ProtoSerializer.Serialize(testData, saveGame);
if (playerStats != null)
{
saveGame.StatsData = oldStatsData;
}
testData.Position = 0;
var testBytes = testData.ReadBytes((uint)testData.Length);
if (innerUncompressedBytes.SequenceEqual(testBytes) == false)
{
throw new SaveCorruptionException("reencode mismatch");
}
}
}
return(new SaveFile()
{
Platform = platform,
SaveGame = saveGame,
PlayerStats = playerStats,
});
}
}
}
}
public void Serialize(Stream output)
{
var saveGame = this.SaveGame;
if (IsSupportedPlatform(this.Platform) == false)
{
throw new InvalidOperationException("unsupported platform");
}
var endian = this.Platform.GetEndian();
var compressionScheme = this.Platform.GetCompressionScheme();
byte[] innerUncompressedBytes;
using (var innerUncompressedData = new MemoryStream())
{
if (this.PlayerStats != null)
{
saveGame.StatsData = this.PlayerStats.Serialize(endian);
}
ProtoSerializer.Serialize(innerUncompressedData, saveGame);
innerUncompressedData.Position = 0;
innerUncompressedBytes = innerUncompressedData.ReadBytes((int)innerUncompressedData.Length);
}
byte[] innerCompressedBytes;
using (var innerCompressedData = new MemoryStream())
{
var hash = CRC32.Hash(innerUncompressedBytes, 0, innerUncompressedBytes.Length);
if (compressionScheme != CompressionScheme.None)
{
innerCompressedData.WriteValueS32(0, Endian.Big);
}
innerCompressedData.WriteString("WSG");
innerCompressedData.WriteValueU32(2, endian);
innerCompressedData.WriteValueU32(hash, endian);
innerCompressedData.WriteValueS32(innerUncompressedBytes.Length, endian);
var encoder = new Huffman.Encoder();
encoder.Build(innerUncompressedBytes);
innerCompressedData.WriteBytes(encoder.Encode(innerUncompressedBytes));
if (compressionScheme != CompressionScheme.None)
{
innerCompressedData.Position = 0;
innerCompressedData.WriteValueU32((uint)(innerCompressedData.Length - 4), Endian.Big);
}
innerCompressedData.Position = 0;
innerCompressedBytes = innerCompressedData.ReadBytes((int)innerCompressedData.Length);
}
if (compressionScheme == CompressionScheme.None)
{
output.WriteBytes(innerCompressedBytes);
}
else
{
Wrap(output, innerCompressedBytes, compressionScheme);
}
}
public static SaveFile Deserialize(Stream input, Platform platform, DeserializeSettings settings)
{
if (IsSupportedPlatform(platform) == false)
{
throw new ArgumentException("unsupported platform", nameof(platform));
}
if (input.Position + 20 > input.Length)
{
throw new SaveCorruptionException("not enough data for save header");
}
var check = input.ReadValueU32(Endian.Big);
if (check == 0x434F4E20)
{
throw new SaveFormatException("cannot load XBOX 360 CON files, extract save using Modio or equivalent");
}
input.Seek(-4, SeekOrigin.Current);
var compressionScheme = platform.GetCompressionScheme();
byte[] uncompressedBytes;
if (compressionScheme == CompressionScheme.None)
{
uncompressedBytes = input.ReadBytes((int)input.Length);
}
else
{
uncompressedBytes = Unwrap(input, compressionScheme, settings);
}
using (var outerData = new MemoryStream(uncompressedBytes))
{
var endian = platform.GetEndian();
uint innerSize = compressionScheme == CompressionScheme.None
? (uint)outerData.Length
: outerData.ReadValueU32(Endian.Big);
var magic = outerData.ReadString(3);
if (magic != "WSG")
{
throw new SaveCorruptionException("invalid magic");
}
var version = outerData.ReadValueU32(endian);
if (version != 2)
{
throw new SaveCorruptionException("invalid or unsupported version");
}
var readCRC32Hash = outerData.ReadValueU32(endian);
var innerUncompressedSize = outerData.ReadValueS32(endian);
var innerCompressedBytes = outerData.ReadBytes((int)(innerSize - 3 - 4 - 4 - 4));
var innerUncompressedBytes = Huffman.Decoder.Decode(innerCompressedBytes,
innerUncompressedSize);
if (innerUncompressedBytes.Length != innerUncompressedSize)
{
throw new SaveCorruptionException("huffman decompression failure");
}
var computedCRC32Hash = CRC32.Hash(innerUncompressedBytes, 0, innerUncompressedBytes.Length);
if ((settings & DeserializeSettings.IgnoreCrc32Mismatch) == 0 &&
computedCRC32Hash != readCRC32Hash)
{
throw new SaveCorruptionException("invalid CRC32 hash");
}
using (var innerUncompressedData = new MemoryStream(innerUncompressedBytes))
{
var saveGame = ProtoSerializer.Deserialize <WillowTwoSave.WillowTwoPlayerSaveGame>(
innerUncompressedData);
PlayerStats playerStats = null;
if (saveGame.StatsData != null &&
PlayerStats.IsSupportedVersion(saveGame.StatsData, endian) == true)
{
playerStats = new PlayerStats();
playerStats.Deserialize(saveGame.StatsData, endian);
}
if ((settings & DeserializeSettings.IgnoreReencodeMismatch) == 0)
{
using (var testData = new MemoryStream())
{
byte[] oldStatsData = saveGame.StatsData;
if (playerStats != null)
{
saveGame.StatsData = playerStats.Serialize(endian);
}
ProtoSerializer.Serialize(testData, saveGame);
if (playerStats != null)
{
saveGame.StatsData = oldStatsData;
}
testData.Position = 0;
var testBytes = testData.ReadBytes((int)testData.Length);
if (innerUncompressedBytes.SequenceEqual(testBytes) == false)
{
throw new SaveCorruptionException("reencode mismatch");
}
}
}
return(new SaveFile()
{
Platform = platform,
SaveGame = saveGame,
PlayerStats = playerStats,
});
}
}
}
