public void TestInvalidChecksum()
{
byte[] testData = Encoding.ASCII.GetBytes("This is a test string");
MemoryStream compressedStream = new MemoryStream();
using (ZlibStream zs = new ZlibStream(compressedStream, CompressionMode.Compress, true))
{
zs.Write(testData, 0, testData.Length);
}
compressedStream.Seek(-2, SeekOrigin.End);
compressedStream.Write(new byte[] { 0, 0 }, 0, 2);
compressedStream.Position = 0;
Assert.Throws <InvalidDataException>(() =>
{
using (ZlibStream uzs = new ZlibStream(compressedStream, CompressionMode.Decompress, true))
{
byte[] outData = new byte[testData.Length];
uzs.Read(outData, 0, outData.Length);
Assert.Equal(testData, outData);
// Should be end of stream
Assert.Equal(-1, uzs.ReadByte());
}
});
}
/// <summary>
/// Decompresses the specified data.
/// </summary>
/// <param name="data">The compressed byte array.</param>
/// <param name="pos">The starting position into the byte array.</param>
/// <param name="Length">The number of compressed bytes to decompress.</param>
/// <returns>An uncompressed byte array</returns>
public static byte[] Decompress(byte[] data, int pos, int Length)
{
byte[] compressedData = new byte[Length];
Array.Copy(data, pos + 50, compressedData, 0, Length);
using (MemoryStream ms = new MemoryStream(compressedData))
{
using (ZlibStream inflaterInputStream = new ZlibStream(ms, CompressionMode.Decompress))
{
using (MemoryStream out1 = new MemoryStream())
{
int c;
try
{
while ((c = inflaterInputStream.ReadByte()) != -1)
{
out1.WriteByte((byte)c);
}
return(out1.ToArray());
}
catch (IOException e)
{
throw new RecordFormatException(e.ToString());
}
}
}
}
}
public static byte ReadCompressedID(byte[] compressed)
{
using (MemoryStream input = new MemoryStream(compressed))
using (ZlibStream zin = new ZlibStream(input, CompressionMode.Decompress))
{
int val = zin.ReadByte();
if (val < 0)
{
throw new InvalidDataException();
}
return((byte)val);
}
}
byte[] DecompressZlib(byte[] data, int rawSize)
{
using MemoryStream memoryStream = new MemoryStream(data);
using ZlibStream stream = new ZlibStream(memoryStream, CompressionMode.Decompress, CompressionLevel.Default);
byte[] result = new byte[rawSize];
int offset = 0;
int b;
while ((b = stream.ReadByte()) != -1)
{
result[offset++] = (byte)b;
}
return(result);
}
public void TestRoundtrip()
{
byte[] testData = Encoding.ASCII.GetBytes("This is a test string");
MemoryStream compressedStream = new MemoryStream();
using (ZlibStream zs = new ZlibStream(compressedStream, CompressionMode.Compress, true))
{
zs.Write(testData, 0, testData.Length);
}
compressedStream.Position = 0;
using (ZlibStream uzs = new ZlibStream(compressedStream, CompressionMode.Decompress, true))
{
byte[] outData = new byte[testData.Length];
uzs.Read(outData, 0, outData.Length);
Assert.Equal(testData, outData);
// Should be end of stream
Assert.Equal(-1, uzs.ReadByte());
}
}
public static void LoadCompound(BinaryReader stream, GameObject root, float voxelSize, bool first, Color32[] palette)
{
var nameLength = stream.ReadInt32();
var name = new string(stream.ReadChars(nameLength));
var px = stream.ReadInt32();
var py = stream.ReadInt32();
var pz = stream.ReadInt32();
px = -px;
// PicaVoxel doesn't support scaling of volumes, sorry!
stream.ReadInt32();
stream.ReadInt32();
stream.ReadInt32();
var pivx = stream.ReadSingle();
var pivy = stream.ReadSingle();
var pivz = stream.ReadSingle();
var sizeX = (int)stream.ReadUInt32();
var sizeY = (int)stream.ReadUInt32();
var sizeZ = (int)stream.ReadUInt32();
pivx = sizeX - pivx;
var child = Editor.Instantiate(EditorUtility.VoxelVolumePrefab, Vector3.zero, Quaternion.identity) as GameObject;
child.transform.SetParent(root.transform);
child.name = name;
child.GetComponent <Volume>().Material = EditorUtility.PicaVoxelDiffuseMaterial;
child.GetComponent <Volume>().GenerateBasic(FillMode.None);
Volume voxelVolume = child.GetComponent <Volume>();
voxelVolume.XSize = Convert.ToInt32(sizeX);
voxelVolume.YSize = Convert.ToInt32(sizeY);
voxelVolume.ZSize = Convert.ToInt32(sizeZ);
voxelVolume.Frames[0].XSize = Convert.ToInt32(sizeX);
voxelVolume.Frames[0].YSize = Convert.ToInt32(sizeY);
voxelVolume.Frames[0].ZSize = Convert.ToInt32(sizeZ);
voxelVolume.Frames[0].Voxels = new Voxel[sizeX * sizeY * sizeZ];
voxelVolume.VoxelSize = voxelSize;
var dataSize = (int)stream.ReadUInt32();
var compressedData = stream.ReadBytes(dataSize);
using (var ms = new MemoryStream(compressedData))
{
using (var gzs = new ZlibStream(ms, CompressionMode.Decompress, true))
{
for (var x = 0; x < sizeX; x++)
{
for (var z = 0; z < sizeZ; z++)
{
for (var y = 0; y < sizeY; y++)
{
var r = (byte)gzs.ReadByte();
var g = (byte)gzs.ReadByte();
var b = (byte)gzs.ReadByte();
var m = (byte)gzs.ReadByte();
if (m > 0)
{
voxelVolume.Frames[0].Voxels[(sizeX - 1 - x) + sizeX * (y + sizeY * z)] = new Voxel()
{
Color = palette == null ? new Color32(r, g, b, 255) : palette[r], Value = 128, State = VoxelState.Active
}
}
;
}
}
}
}
}
voxelVolume.CreateChunks();
voxelVolume.SaveForSerialize();
var pivot = new Vector3(pivx, pivy, pivz) * voxelSize;
voxelVolume.Pivot = pivot;
voxelVolume.UpdatePivot();
voxelVolume.transform.localPosition = (new Vector3(-sizeX + px, py, pz) * voxelSize) + pivot;
var childCount = stream.ReadUInt32();
for (var i = 0; i < childCount; i++)
{
LoadNode(stream, child, voxelSize, first, palette);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
JsonSerializer serializer)
{
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
var jo = JObject.Load(reader);
byte[] buffer = null;
BaseLayer result;
switch (jo["type"].Value <string>())
{
case "tilelayer":
result = new TileLayer();
if (jo["encoding"]?.Value <string>() == "base64")
{
buffer = Convert.FromBase64String(jo["data"].Value <string>());
jo["data"].Replace(JToken.FromObject(Array.Empty <int>()));
}
break;
case "objectgroup":
result = new ObjectLayer();
break;
case "imagelayer":
result = new ImageLayer();
break;
default:
return(null);
}
serializer.Populate(jo.CreateReader(), result);
if (result is TileLayer tl && buffer != null)
{
switch (tl.Compression)
{
case null:
tl.Data = new int[buffer.Length / sizeof(int)];
Buffer.BlockCopy(buffer, 0, tl.Data, 0, buffer.Length);
break;
case "zlib":
using (var mStream = new MemoryStream(buffer))
{
using var stream = new ZlibStream(mStream, CompressionMode.Decompress);
var bufferSize = result.Width * result.Height * sizeof(int);
Array.Resize(ref buffer, bufferSize);
stream.Read(buffer, 0, bufferSize);
if (stream.ReadByte() != -1)
{
throw new JsonException();
}
tl.Data = new int[result.Width * result.Height];
Buffer.BlockCopy(buffer, 0, tl.Data, 0, buffer.Length);
}
break;
case "gzip":
using (var mStream = new MemoryStream(buffer))
{
using var stream = new GZipStream(mStream, CompressionMode.Decompress);
var bufferSize = result.Width * result.Height * sizeof(int);
Array.Resize(ref buffer, bufferSize);
stream.Read(buffer, 0, bufferSize);
if (stream.ReadByte() != -1)
{
throw new JsonException();
}
tl.Data = new int[result.Width * result.Height];
Buffer.BlockCopy(buffer, 0, tl.Data, 0, buffer.Length);
}
break;
default:
throw new NotImplementedException($"Compression: {tl.Compression}");
}
}
return(result);
}
// args[0] - ключ для паковки / распаковки
// e - распаковать / extract
// c - запаковать / compress
// args[1] - путь до файла, который будем паковать или распаковывать / path to file
static void Main(string[] args)
{
//' на основе вот этого топака : http://www.theswamp.org/index.php?topic=41529.0
if (args.Length == 2)
{
if (File.Exists(args[1]))
{
// тут распаковываем архивчик, Extract
if ((args[0] == "e") || (args[0] == "-e"))
{
string fileName = args[1];
string ext = Path.GetExtension(fileName).ToUpper();
if ((0 == String.Compare(ext, ".PC3")) || (0 == String.Compare(ext, ".PMP")) || (0 == String.Compare(ext, ".CTB")))
{
using (FileStream fs = File.Open(fileName, FileMode.Open, FileAccess.Read))
{
fs.Seek(60L, SeekOrigin.Begin);
using (ZlibStream zs = new ZlibStream(fs, CompressionMode.Decompress))
{
// Console.WriteLine("\nStart:");
int chr;
chr = 0;
string str = "";
while (chr > -1)
{
chr = zs.ReadByte();
if (chr > -1)
{
str = str + Convert.ToChar(chr);
}
}
//Console.Write(str);
//Console.WriteLine("\nend:");
/* using (StreamReader sr = new StreamReader(zs))
* {
* //тут текстово содержание файла
* string s = sr.ReadToEnd();
* //Console.WriteLine(s);
*/
using (FileStream fs_out = File.Open(fileName + ".txt", FileMode.Create, FileAccess.ReadWrite))
{
fs_out.Write(Encoding.Default.GetBytes(str), 0, Encoding.Default.GetBytes(str).Length);
}
//}
Console.WriteLine("\n File saved to {0}.txt ", fileName);
}
}
}
else
{
Console.Write("File {0} is not a .pc3 file", args[1]);
}
}
else if ((args[0] == "c") || (args[0] == "-c"))// Тут запаковываем все обратно, COMPRESS
{
string fileName = args[1];
string ext = Path.GetExtension(fileName);
if (0 == String.Compare(ext.ToUpper(), ".TXT"))
{
using (FileStream fs = File.Open(fileName, FileMode.Open, FileAccess.Read))
{
using (StreamReader sr = new StreamReader(fs, Encoding.Default)) /*Mod by Arie add encoding*/
{
// заголовок файла, без него автокад не работает
String pref_s = "PIAFILEVERSION_2.0,PC3VER1,compress\r\npmzlibcodec";
/*
* is a good starting point, but contains several errors/lack of information
* The header size is 60 No 59
* bytes 49->52 = ZlibCodec.Adler32
* bytes 53->56 = decompresse stream size
* bytes 57->60 = compressed stream size
* Эти данные(байты) должны вычеслятся
*/
String s = sr.ReadToEnd();
//Console.Write(s);
//Byte[] ZlibCodec_Adler32 = { 157, 94, 173, 006 };
long decompresse_stream_size = fs.Length;
//тут считаем размер запакованных данных
byte[] compressed_stream_size;
using (var ms = new MemoryStream())
{
using (ZlibStream deflateStream = new ZlibStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression, false))
{
deflateStream.Write(Encoding.Default.GetBytes(s), 0, Encoding.Default.GetBytes(s).Length);
}
compressed_stream_size = ms.ToArray();
}
// Тут все пишем в файл
using (FileStream fs_out = File.Open(fileName + ".pc3", FileMode.Create, FileAccess.ReadWrite))
{
using (ZlibStream zs = new ZlibStream(fs_out, CompressionMode.Compress,
CompressionLevel.BestCompression, false))
{
fs_out.Write(Encoding.Default.GetBytes(pref_s), 0, Encoding.Default.GetBytes(pref_s).Length);
//fs_out.Write(ZlibCodec_Adler32, 0, 4);
fs_out.Write(BitConverter.GetBytes(new ZlibCodec(CompressionMode.Compress).Adler32), 0, 4);
fs_out.Write(BitConverter.GetBytes(decompresse_stream_size), 0, 4);
fs_out.Write(BitConverter.GetBytes(compressed_stream_size.Length), 0, 4);
zs.Write(Encoding.Default.GetBytes(s), 0, Encoding.Default.GetBytes(s).Length);
}
}
Console.WriteLine("\n File saved to {0}.pc3 ", fileName);
}
}
}
else
{
Console.Write("File {0} is not a .txt file", args[1]);
}
}
else
{
Console.Write("incorrect input\nFormat unzip_pc3 (AutoCAD zip/unzip .pc3 files) \n to extract: unzip_pc3 e xxx.pc3\n to Compress: unzip_pc3 c xxx.txt");
}
}
else
{
Console.Write("File {0} does not exist", args[1]);
}
}
else
{
Console.Write("incorrect input\nFormat unzip_pc3 (AutoCAD zip/unzip .pc3 files) \n to extract: unzip_pc3 e xxx.pc3\n to Compress: unzip_pc3 c xxx.txt");
}
}
void LoadCompound(BinaryReader stream)
{
if (showLogs)
{
Debug.Log("[QBT] LoadCompound");
}
int nameLength = stream.ReadInt32();
string name = new string(stream.ReadChars(nameLength));
if (showLogs)
{
Debug.Log("[QBT] name: " + name);
}
Vector3 position = new Vector3();
position.x = stream.ReadInt32();
position.y = stream.ReadInt32();
position.z = stream.ReadInt32();
Vector3 localScale = new Vector3();
localScale.x = stream.ReadUInt32();
localScale.y = stream.ReadUInt32();
localScale.z = stream.ReadUInt32();
Vector3 pivot = new Vector3();
pivot.x = stream.ReadSingle();
pivot.y = stream.ReadSingle();
pivot.z = stream.ReadSingle();
Vector3 size = new Vector3();
size.x = stream.ReadUInt32();
size.y = stream.ReadUInt32();
size.z = stream.ReadUInt32();
// Compressed voxel data size.
stream.ReadUInt32();
// TODO: voxelsData is overwrited
voxelsData = new VoxelData[(int)size.x, (int)size.y, (int)size.z];
var zlibStream = new ZlibStream(stream.BaseStream, Ionic.Zlib.CompressionMode.Decompress, true);
for (uint x = 0; x < size.x; x++)
{
for (uint z = 0; z < size.z; z++)
{
for (uint y = 0; y < size.y; y++)
{
VoxelData data = new VoxelData();
data.r = (byte)zlibStream.ReadByte();
data.g = (byte)zlibStream.ReadByte();
data.b = (byte)zlibStream.ReadByte();
data.m = (byte)zlibStream.ReadByte();
voxelsData[x, y, z] = data;
}
}
}
uint childCount = stream.ReadUInt32();
if (mergeCompounds) // if you don't need the datatree you can skip child nodes
{
for (uint i = 0; i < childCount; i++)
{
SkipNode(stream);
}
}
else
{
for (uint i = 0; i < childCount; i++)
{
LoadNode(stream);
}
}
}
void LoadMatrix(BinaryReader stream)
{
if (showLogs)
{
Debug.Log("[QBT] LoadMatrix");
}
int nameLength = stream.ReadInt32();
string name = new string(stream.ReadChars(nameLength));
if (showLogs)
{
Debug.Log("[QBT] name: " + name);
}
Vector3 position = new Vector3();
position.x = stream.ReadInt32();
position.y = stream.ReadInt32();
position.z = stream.ReadInt32();
Vector3 localScale = new Vector3();
localScale.x = stream.ReadUInt32();
localScale.y = stream.ReadUInt32();
localScale.z = stream.ReadUInt32();
Vector3 pivot = new Vector3();
pivot.x = stream.ReadSingle();
pivot.y = stream.ReadSingle();
pivot.z = stream.ReadSingle();
Vector3 size = new Vector3();
size.x = stream.ReadUInt32();
size.y = stream.ReadUInt32();
size.z = stream.ReadUInt32();
// Compressed voxel data size.
stream.ReadUInt32();
voxelsData = new VoxelData[(int)size.x, (int)size.y, (int)size.z];
var zlibStream = new ZlibStream(stream.BaseStream, Ionic.Zlib.CompressionMode.Decompress, true);
for (uint x = 0; x < size.x; x++)
{
for (uint z = 0; z < size.z; z++)
{
for (uint y = 0; y < size.y; y++)
{
VoxelData data = new VoxelData();
data.r = (byte)zlibStream.ReadByte();
data.g = (byte)zlibStream.ReadByte();
data.b = (byte)zlibStream.ReadByte();
data.m = (byte)zlibStream.ReadByte();
voxelsData[x, y, z] = data;
colors.Add(data.Color);
}
}
}
}
