// netz.compress.ICompress implementation
public long Compress(string file, string zipFile)
{
long length = -1;
FileStream ifs = null;
FileStream ofs = null;
try
{
ifs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read);
ofs = File.Open(zipFile, FileMode.Create, FileAccess.Write, FileShare.None);
DeflaterOutputStream dos = new DeflaterOutputStream(ofs, new Deflater(Deflater.BEST_COMPRESSION));
byte[] buff = new byte[ifs.Length];
while(true)
{
int r = ifs.Read(buff, 0, buff.Length);
if(r <= 0) break;
dos.Write(buff, 0, r);
}
dos.Flush();
dos.Finish();
length = dos.Length;
dos.Close();
}
finally
{
if(ifs != null) ifs.Close();
if(ofs != null) ofs.Close();
}
return length;
}
public void TestInflateDeflate()
{
MemoryStream ms = new MemoryStream();
Deflater deflater = new Deflater(6);
DeflaterOutputStream outStream = new DeflaterOutputStream(ms, deflater);
byte[] buf = new byte[1000000];
System.Random rnd = new Random();
rnd.NextBytes(buf);
outStream.Write(buf, 0, buf.Length);
outStream.Flush();
outStream.Finish();
ms.Seek(0, SeekOrigin.Begin);
InflaterInputStream inStream = new InflaterInputStream(ms);
byte[] buf2 = new byte[buf.Length];
int pos = 0;
while (true) {
int numRead = inStream.Read(buf2, pos, 4096);
if (numRead <= 0) {
break;
}
pos += numRead;
}
for (int i = 0; i < buf.Length; ++i) {
Assertion.AssertEquals(buf2[i], buf[i]);
}
}
public static byte[] CompressZlib(byte[] input)
{
MemoryStream m = new MemoryStream();
DeflaterOutputStream zipStream = new DeflaterOutputStream(m, new ICSharpCode.SharpZipLib.Zip.Compression.Deflater(8));
zipStream.Write(input, 0, input.Length);
zipStream.Finish();
return m.ToArray();
}
internal static Byte[] Deflate(Byte[] b)
{
System.IO.MemoryStream ms = new System.IO.MemoryStream();
DeflaterOutputStream outStream =new DeflaterOutputStream( ms);
outStream.Write(b, 0, b.Length);
outStream.Flush();
outStream.Finish();
Byte[] result=ms.ToArray();
outStream.Close();
ms.Close();
return result;
}
/*
* Name function: Compress
* Purpose: compress a part of the byte array into a Zlib Block
* Input: - buffer: byte array
* - offset: starting offset inside the array
* - count: num of bytes to compress starting from the offset
* Output: compressed byte array block, the structure is:
* - magic word
* - max segment size
* - total compressed size
* - total uncompressed size
* - segment list
* - compressed data list
*/
public static byte[] Compress(byte[] buffer, int offset, int count)
{
if(buffer == null)
throw new ArgumentNullException();
if (count < 0)
throw new FormatException();
if (offset + count > buffer.Length)
throw new IndexOutOfRangeException();
MemoryStream headBlock = new MemoryStream();
MemoryStream dataBlock = new MemoryStream();
DeflaterOutputStream zipStream;
int numSeg = (int)Math.Ceiling((double)count / (double)maxSegmentSize);
headBlock.WriteValueU32(magic);
headBlock.WriteValueU32(maxSegmentSize);
headBlock.WriteValueU32(0x0); //total compressed size, still to calculate
headBlock.WriteValueS32(count); //total uncompressed size
for (int i = count; i > 0; i -= (int)maxSegmentSize)
{
int copyBytes = Math.Min(i, (int)maxSegmentSize);
uint precCompSize = (uint)dataBlock.Length;
zipStream = new DeflaterOutputStream(dataBlock);
zipStream.Write(buffer, offset + (count - i), copyBytes);
zipStream.Flush();
zipStream.Finish();
headBlock.WriteValueU32((uint)dataBlock.Length - precCompSize); //compressed segment size
headBlock.WriteValueS32(copyBytes); //uncompressed segment size
//Console.WriteLine(" Segment size: {0}, total read: {1}, compr size: {2}", maxSegmentSize, copyBytes, (uint)dataBlock.Length - precCompSize);
}
headBlock.Seek(8, SeekOrigin.Begin);
headBlock.WriteValueS32((int)dataBlock.Length); // total compressed size
byte[] finalBlock = new byte[headBlock.Length + dataBlock.Length];
Buffer.BlockCopy(headBlock.ToArray(), 0, finalBlock, 0, (int)headBlock.Length);
Buffer.BlockCopy(dataBlock.ToArray(), 0, finalBlock, (int)headBlock.Length, (int)dataBlock.Length);
headBlock.Close();
dataBlock.Close();
return finalBlock;
}
/// <summary>
/// ѹ�����ݣ����ѹ����ֵΪ-1��ʾ��������������ѹ������
/// </summary>
/// <param name="val">ԭʼ������</param>
/// <returns>ѹ����������</returns>
public byte[] Compress(byte[] val)
{
byte[] buf;
if (overSize != -1 && val.Length > overSize) {
using (MemoryStream destStream = new MemoryStream()) {
Deflater deflater = new Deflater(Deflater.DEFAULT_COMPRESSION, true);
using (DeflaterOutputStream compressStream = new DeflaterOutputStream(destStream, deflater)) {
compressStream.Write(val, 0, val.Length);
compressStream.Finish();
buf = new byte[destStream.Length + 1];
destStream.ToArray().CopyTo(buf, 1);
}
buf[0] = 1; // ��ѹ����־
return buf;
}
}
else {
buf = new byte[val.Length + 1];
val.CopyTo(buf, 1);
buf[0] = 0; // δѹ����־
return buf;
}
}
/// <summary>
/// Compresses data using zlib.
/// </summary>
/// <param name="data">The data to compress</param>
/// <returns>A byte array containing the compressed data</returns>
public static byte[] Compress(string data)
{
// Commented out below as it loses extended ASCII (127+) and replaces with a ?
// byte[] bytes = ASCIIEncoding.ASCII.GetBytes(data);
// Encoding using default terminal extended ascii codepage 437
byte[] bytes = Encoding.GetEncoding(437).GetBytes(data);
byte[] returnBytes;
using (var stream = new MemoryStream())
{
using (var compressedStream = new DeflaterOutputStream(stream))
{
compressedStream.Write(bytes, 0, bytes.Length);
compressedStream.Finish();
stream.Position = 0;
returnBytes = new byte[stream.Length];
stream.Read(returnBytes, 0, returnBytes.Length);
}
}
return returnBytes;
}
/// <summary>
/// Creates the static library.
/// </summary>
/// <param name='dataFile'>
/// Data file.
/// </param>
/// <param name='needZeroEnd'>
/// Need zero end.
/// </param>
public void CreateStaticLibrary(String dataFile, bool needZeroEnd)
{
// Generate the pretty name
this.SymbolName = GetSymbolName (dataFile);
// If we need a zero at the end (for text files), add 1 byte
int size = (int)new FileInfo (dataFile).Length;
byte[] fileBuffer = File.ReadAllBytes (dataFile);
this.Logger.LogInfo ("Embedding '" + dataFile + "'...");
// Use raw file
this.InputSize = size;
byte[] dataBuffer = fileBuffer;
if (this.Compress) {
// Compress the data file if required
using (MemoryStream stream = new MemoryStream()) {
using (DeflaterOutputStream deflate = new DeflaterOutputStream(stream)) {
int n = 0, len = 0;
while (n < size) {
len = Math.Min (size - n, CHUNK);
deflate.Write (fileBuffer, n, len);
n += CHUNK;
}
if (needZeroEnd) {
deflate.WriteByte (0);
}
deflate.Finish ();
}
dataBuffer = stream.ToArray ();
stream.Close ();
}
} else if (needZeroEnd) {
this.InputSize = size + 1;
dataBuffer = new byte[this.InputSize];
Array.Copy(fileBuffer, dataBuffer, size);
dataBuffer[size] = 0;
}
this.OutputSize = dataBuffer.Length;
if (this.Compress) {
this.Logger.LogInfo ("Compression ratio: " + Math.Floor(100.0 * this.OutputSize / this.InputSize) + "%");
}
// Compute the names
String sFile = Path.Combine (this.OutputDirectory, this.SymbolName + ".s");
String oFile = Path.Combine (this.OutputDirectory, this.SymbolName + ".o");
String aFile = Path.Combine (this.OutputDirectory, this.SymbolName + ".a");
this.OutputFile = Path.Combine (this.OutputDirectory, "lib" + this.SymbolName + ".a");
// (1) Create the assembly source file
this.Logger.LogDebug ("Create assembly file '" + Path.GetFileName (sFile) + "'...");
String content = String.Format (CultureInfo.CurrentCulture, TEMPLATE, this.SymbolName, this.OutputSize, SPACER_BYTE);
File.WriteAllText (sFile, content);
// (2) Create the object file
this.Logger.LogDebug ("Create object file '" + Path.GetFileName (oFile) + "'...");
using (ProcessHelper helper = new ProcessHelper("cc", string.Format("{0} -c -o \"{1}\" \"{2}\"", this.ArchitectureFlags ?? String.Empty, oFile, sFile))) {
helper.Logger = this.Logger;
helper.Execute ();
}
// (3) Create the static library
this.Logger.LogDebug ("Create library file '" + Path.GetFileName (aFile) + "'...");
using (ProcessHelper helper = new ProcessHelper("libtool", string.Format("-o \"{0}\" \"{1}\"", aFile, oFile))) {
helper.Logger = this.Logger;
helper.Execute ();
}
// (4) Swap binary content
this.Logger.LogDebug ("Swaping content to '" + Path.GetFileName (this.OutputFile) + "'...");
// Not quite memory-efficient, but simpler to code
byte[] outputBuffer = File.ReadAllBytes (aFile);
// Search for the beginning and the end of the spacer zone
int start = Locate (outputBuffer, new[] {SPACER_BYTE, SPACER_BYTE, SPACER_BYTE, SPACER_BYTE});
// Insert the data file content into the static library
Array.Copy (dataBuffer, 0, outputBuffer, start, dataBuffer.Length);
// Write the result on the disk
File.WriteAllBytes (this.OutputFile, outputBuffer);
}
static void GenerateBundles (ArrayList files)
{
string temp_s = "temp.s"; // Path.GetTempFileName ();
string temp_c = "temp.c";
string temp_o = "temp.o";
if (compile_only)
temp_c = output;
if (object_out != null)
temp_o = object_out;
try {
ArrayList c_bundle_names = new ArrayList ();
ArrayList config_names = new ArrayList ();
byte [] buffer = new byte [8192];
using (StreamWriter ts = new StreamWriter (File.Create (temp_s))) {
using (StreamWriter tc = new StreamWriter (File.Create (temp_c))) {
string prog = null;
tc.WriteLine ("/* This source code was produced by mkbundle, do not edit */");
tc.WriteLine ("#include <mono/metadata/assembly.h>\n");
if (compress) {
tc.WriteLine ("typedef struct _compressed_data {");
tc.WriteLine ("\tMonoBundledAssembly assembly;");
tc.WriteLine ("\tint compressed_size;");
tc.WriteLine ("} CompressedAssembly;\n");
}
foreach (string url in files){
string fname = new Uri (url).LocalPath;
string aname = Path.GetFileName (fname);
string encoded = aname.Replace ("-", "_").Replace (".", "_");
if (prog == null)
prog = aname;
Console.WriteLine (" embedding: " + fname);
Stream stream = File.OpenRead (fname);
long real_size = stream.Length;
int n;
if (compress) {
MemoryStream ms = new MemoryStream ();
DeflaterOutputStream deflate = new DeflaterOutputStream (ms);
while ((n = stream.Read (buffer, 0, 8192)) != 0){
deflate.Write (buffer, 0, n);
}
stream.Close ();
deflate.Finish ();
byte [] bytes = ms.GetBuffer ();
stream = new MemoryStream (bytes, 0, (int) ms.Length, false, false);
}
WriteSymbol (ts, "assembly_data_" + encoded, stream.Length);
while ((n = stream.Read (buffer, 0, 8192)) != 0){
for (int i = 0; i < n; i++){
ts.Write ("\t.byte {0}\n", buffer [i]);
}
}
ts.WriteLine ();
if (compress) {
tc.WriteLine ("extern const unsigned char assembly_data_{0} [];", encoded);
tc.WriteLine ("static CompressedAssembly assembly_bundle_{0} = {{{{\"{1}\"," +
" assembly_data_{0}, {2}}}, {3}}};",
encoded, aname, real_size, stream.Length);
double ratio = ((double) stream.Length * 100) / real_size;
Console.WriteLine (" compression ratio: {0:.00}%", ratio);
} else {
tc.WriteLine ("extern const unsigned char assembly_data_{0} [];", encoded);
tc.WriteLine ("static const MonoBundledAssembly assembly_bundle_{0} = {{\"{1}\", assembly_data_{0}, {2}}};",
encoded, aname, real_size);
}
stream.Close ();
c_bundle_names.Add ("assembly_bundle_" + encoded);
try {
FileStream cf = File.OpenRead (fname + ".config");
Console.WriteLine (" config from: " + fname + ".config");
tc.WriteLine ("extern const unsigned char assembly_config_{0} [];", encoded);
WriteSymbol (ts, "assembly_config_" + encoded, cf.Length);
while ((n = cf.Read (buffer, 0, 8192)) != 0){
for (int i = 0; i < n; i++){
ts.Write ("\t.byte {0}\n", buffer [i]);
}
}
ts.WriteLine ();
config_names.Add (new string[] {aname, encoded});
} catch (FileNotFoundException) {
/* we ignore if the config file doesn't exist */
}
}
if (config_file != null){
FileStream conf;
try {
conf = File.OpenRead (config_file);
} catch {
Error (String.Format ("Failure to open {0}", config_file));
return;
}
Console.WriteLine ("System config from: " + config_file);
tc.WriteLine ("extern const unsigned char system_config;");
WriteSymbol (ts, "system_config", config_file.Length);
int n;
while ((n = conf.Read (buffer, 0, 8192)) != 0){
for (int i = 0; i < n; i++){
ts.Write ("\t.byte {0}\n", buffer [i]);
}
}
// null terminator
ts.Write ("\t.byte 0\n");
ts.WriteLine ();
}
if (machine_config_file != null){
FileStream conf;
try {
conf = File.OpenRead (machine_config_file);
} catch {
Error (String.Format ("Failure to open {0}", machine_config_file));
return;
}
Console.WriteLine ("Machine config from: " + machine_config_file);
tc.WriteLine ("extern const unsigned char machine_config;");
WriteSymbol (ts, "machine_config", machine_config_file.Length);
int n;
while ((n = conf.Read (buffer, 0, 8192)) != 0){
for (int i = 0; i < n; i++){
ts.Write ("\t.byte {0}\n", buffer [i]);
}
}
// null terminator
ts.Write ("\t.byte 0\n");
ts.WriteLine ();
}
ts.Close ();
Console.WriteLine ("Compiling:");
string cmd = String.Format ("{0} -o {1} {2} ", GetEnv ("AS", "as"), temp_o, temp_s);
int ret = Execute (cmd);
if (ret != 0){
Error ("[Fail]");
return;
}
if (compress)
tc.WriteLine ("\nstatic const CompressedAssembly *compressed [] = {");
else
tc.WriteLine ("\nstatic const MonoBundledAssembly *bundled [] = {");
foreach (string c in c_bundle_names){
tc.WriteLine ("\t&{0},", c);
}
tc.WriteLine ("\tNULL\n};\n");
tc.WriteLine ("static char *image_name = \"{0}\";", prog);
tc.WriteLine ("\nstatic void install_dll_config_files (void) {\n");
foreach (string[] ass in config_names){
tc.WriteLine ("\tmono_register_config_for_assembly (\"{0}\", assembly_config_{1});\n", ass [0], ass [1]);
}
if (config_file != null)
tc.WriteLine ("\tmono_config_parse_memory (&system_config);\n");
if (machine_config_file != null)
tc.WriteLine ("\tmono_register_machine_config (&machine_config);\n");
tc.WriteLine ("}\n");
if (config_dir != null)
tc.WriteLine ("static const char *config_dir = \"{0}\";", config_dir);
else
tc.WriteLine ("static const char *config_dir = NULL;");
Stream template_stream;
if (compress) {
template_stream = Assembly.GetAssembly (typeof(MakeBundle)).GetManifestResourceStream ("template_z.c");
} else {
template_stream = Assembly.GetAssembly (typeof(MakeBundle)).GetManifestResourceStream ("template.c");
}
StreamReader s = new StreamReader (template_stream);
string template = s.ReadToEnd ();
tc.Write (template);
if (!nomain) {
Stream template_main_stream = Assembly.GetAssembly (typeof(MakeBundle)).GetManifestResourceStream ("template_main.c");
StreamReader st = new StreamReader (template_main_stream);
string maintemplate = st.ReadToEnd ();
tc.Write (maintemplate);
}
tc.Close ();
if (compile_only)
return;
string zlib = (compress ? "-lz" : "");
string debugging = "-g";
string cc = GetEnv ("CC", IsUnix ? "cc" : "gcc -mno-cygwin");
if (style == "linux")
debugging = "-ggdb";
if (static_link) {
string smonolib;
if (style == "osx")
smonolib = "`pkg-config --variable=libdir mono-2`/libmono-2.0.a ";
else
smonolib = "-Wl,-Bstatic -lmono-2.0 -Wl,-Bdynamic ";
cmd = String.Format ("{4} -o {2} -Wall `pkg-config --cflags mono-2` {0} {3} " +
"`pkg-config --libs-only-L mono-2` " + smonolib +
"`pkg-config --libs-only-l mono-2 | sed -e \"s/\\-lmono-2.0 //\"` {1}",
temp_c, temp_o, output, zlib, cc);
} else {
cmd = String.Format ("{4} " + debugging + " -o {2} -Wall {0} `pkg-config --cflags --libs mono-2` {3} {1}",
temp_c, temp_o, output, zlib, cc);
}
ret = Execute (cmd);
if (ret != 0){
Error ("[Fail]");
return;
}
Console.WriteLine ("Done");
}
}
} finally {
if (!keeptemp){
if (object_out == null){
File.Delete (temp_o);
}
if (!compile_only){
File.Delete (temp_c);
}
File.Delete (temp_s);
}
}
}
protected MemoryStream CompressBuffer(byte[] buf, int index, int length)
{
if (length < MIN_COMPRESS_LENGTH) return null;
MemoryStream ms = new MemoryStream(buf.Length);
DeflaterOutputStream dos = new DeflaterOutputStream(ms);
dos.WriteByte( (byte)(length & 0xff ));
dos.WriteByte( (byte)((length >> 8) & 0xff ));
dos.WriteByte( (byte)((length >> 16) & 0xff ));
dos.WriteByte( 0 );
dos.Write( buf, index, length );
dos.Finish();
if (ms.Length > length+4) return null;
return ms;
}
internal string WriteObject(byte[] aContent, EObjectType aType)
{
byte zero = 0;
byte space = (byte)' ';
byte[] type = Object.TypeBytes(aType);
byte[] length = ASCIIEncoding.ASCII.GetBytes(aContent.Length.ToString());
byte[] obj = new byte[type.Length + length.Length + aContent.Length + 2];
Array.Copy(type, 0, obj, 0, type.Length);
obj[type.Length] = space;
Array.Copy(length, 0, obj, type.Length + 1, length.Length);
obj[type.Length + length.Length + 1] = zero;
Array.Copy(aContent, 0, obj, type.Length + length.Length + 2, aContent.Length);
string id = Hash.String(iHash.Compute(obj));
DirectoryInfo folder = iFolderObjects.CreateSubdirectory(id.Substring(0, 2));
String path = Path.Combine(folder.FullName, id.Substring(2));
if (File.Exists(path))
{
return (id);
}
var file = new FileStream(path, FileMode.CreateNew, FileAccess.Write);
DeflaterOutputStream deflater = new DeflaterOutputStream(file);
using (var writer = new BinaryWriter(deflater))
{
writer.Write(obj);
deflater.Finish();
}
return (id);
}
private void writeCMV(string outFilename)
{
byte[] target, compressed;
ExtensionType extension;
DeflaterOutputStream zipOutStream;
MemoryStream stream;
MemoryStream memoryStream;
cols = Columns;
rows = Rows;
if (frames.Count == 0)
{
throw new CMVException("There are no frames to save.");
}
if (cols == 0 || rows == 0)
{
throw new CMVException(String.Format("Invalid columns ({0}), rows ({1}) combination", cols, rows));
}
extension = checkExtension(outFilename);
stream = new MemoryStream();
byte[] intBytes = new byte[4];
intBytes = BitConverter.GetBytes((Int32)version);
stream.Write(intBytes, 0, 4);
intBytes = BitConverter.GetBytes((Int32)cols);
stream.Write(intBytes, 0, 4);
intBytes = BitConverter.GetBytes((Int32)rows);
stream.Write(intBytes, 0, 4);
intBytes = BitConverter.GetBytes((Int32)delayRate);
stream.Write(intBytes, 0, 4);
// Sounds
if (version == 10001)
{
intBytes = BitConverter.GetBytes((Int32)numSounds);
stream.Write(intBytes, 0, 4);
stream.Write(soundNames, 0, soundNames.Length);
stream.Write(soundTimings, 0, soundTimings.Length);
}
//int frameSize = (int)(cols * rows);
//frameSize += frameSize;
byte[] chunk;
int i = 0;
int framesInChunk;
int compressedChunkSize;
byte[] frame;
while(i < frames.Count)
{
if ((frames.Count - i) > FRAMES_PER_CHUNK)
{
framesInChunk = FRAMES_PER_CHUNK;
}
else
{
framesInChunk = (Int32)(frames.Count - i);
}
memoryStream = new MemoryStream();
zipOutStream = new DeflaterOutputStream(memoryStream, new Deflater(Deflater.BEST_COMPRESSION));
for (int j = 0; j < framesInChunk; j++)
{
frame = frames[i + j].Frame;
zipOutStream.Write(frame, 0, frame.Length);
}
zipOutStream.Finish();
compressedChunkSize = (Int32)memoryStream.Length;
intBytes = BitConverter.GetBytes((Int32)compressedChunkSize);
stream.Write(intBytes, 0, 4);
chunk = memoryStream.ToArray();
stream.Write(chunk, 0, chunk.Length);
i = i + framesInChunk;
zipOutStream.Close();
}
target = stream.ToArray();
stream.Close();
if (extension == ExtensionType.CCMV)
{
compressed = new byte[0];
memoryStream = new MemoryStream(target);
zipOutStream = new DeflaterOutputStream(memoryStream);
zipOutStream.Write(target, 0, target.Length);
compressed = new byte[memoryStream.Length];
memoryStream.Position = 0;
memoryStream.Read(compressed, 0, (Int32)memoryStream.Length);
File.WriteAllBytes(outFilename, compressed);
}
else
{
File.WriteAllBytes(outFilename, target);
}
stream.Close();
stream.Dispose();
}
public static int Deflate(byte[] inBuffer, ref byte[] outBuffer)
{
int newLen = 0, flagOffset = 1;
outBuffer[0] = inBuffer[0];
if (inBuffer[0] == 0)
{
flagOffset = 2;
outBuffer[1] = inBuffer[1];
}
if (inBuffer.Length > 30)
{
using (MemoryStream ms = new MemoryStream())
{
Deflater deflater = new Deflater(Deflater.DEFAULT_COMPRESSION, false);
using (DeflaterOutputStream outStream = new DeflaterOutputStream(ms, deflater))
{
outStream.IsStreamOwner = false;
outStream.Write(inBuffer, flagOffset, inBuffer.Length - flagOffset);
outStream.Flush();
outStream.Finish();
}
ms.Position = 0;
ms.Read(outBuffer, flagOffset + 1, (int)ms.Length);
newLen = (int)ms.Length + flagOffset + 1;
outBuffer[flagOffset] = 0x5a;
}
}
else
{
Buffer.BlockCopy(inBuffer, flagOffset, outBuffer, flagOffset + 1, inBuffer.Length - flagOffset);
outBuffer[flagOffset] = 0xa5;
newLen = inBuffer.Length + 1;
}
return newLen;
}
MemoryStream Deflate(byte[] data, int level, bool zlib)
{
MemoryStream memoryStream = new MemoryStream();
Deflater deflater = new Deflater(level, !zlib);
using ( DeflaterOutputStream outStream = new DeflaterOutputStream(memoryStream, deflater) )
{
outStream.IsStreamOwner = false;
outStream.Write(data, 0, data.Length);
outStream.Flush();
outStream.Finish();
}
return memoryStream;
}
private static void WriteDataChunks()
{
byte[] pixels = _image.ToByteArray();
byte[] data = new byte[_image.PixelWidth * _image.PixelHeight * 4 + _image.PixelHeight];
int rowLength = _image.PixelWidth * 4 + 1;
for (int y = 0; y < _image.PixelHeight; y++)
{
byte compression = 0;
if (y > 0)
{
compression = 2;
}
data[y * rowLength] = compression;
for (int x = 0; x < _image.PixelWidth; x++)
{
// Calculate the offset for the new array.
int dataOffset = y * rowLength + x * 4 + 1;
// Calculate the offset for the original pixel array.
int pixelOffset = (y * _image.PixelWidth + x) * 4;
data[dataOffset + 0] = pixels[pixelOffset + 0];
data[dataOffset + 1] = pixels[pixelOffset + 1];
data[dataOffset + 2] = pixels[pixelOffset + 2];
data[dataOffset + 3] = pixels[pixelOffset + 3];
if (y > 0)
{
int lastOffset = ((y - 1) * _image.PixelWidth + x) * 4;
data[dataOffset + 0] -= pixels[lastOffset + 0];
data[dataOffset + 1] -= pixels[lastOffset + 1];
data[dataOffset + 2] -= pixels[lastOffset + 2];
data[dataOffset + 3] -= pixels[lastOffset + 3];
}
}
}
byte[] buffer = null;
int bufferLength = 0;
MemoryStream memoryStream = null;
try
{
memoryStream = new MemoryStream();
using (DeflaterOutputStream zStream = new DeflaterOutputStream(memoryStream))
{
zStream.Write(data, 0, data.Length);
zStream.Flush();
zStream.Finish();
bufferLength = (int)memoryStream.Length;
buffer = memoryStream.GetBuffer();
}
}
finally
{
if (memoryStream != null)
{
memoryStream.Dispose();
}
}
int numChunks = bufferLength / MaxBlockSize;
if (bufferLength % MaxBlockSize != 0)
{
numChunks++;
}
for (int i = 0; i < numChunks; i++)
{
int length = bufferLength - i * MaxBlockSize;
if (length > MaxBlockSize)
{
length = MaxBlockSize;
}
WriteChunk(PngChunkTypes.Data, buffer, i * MaxBlockSize, length);
}
}
private static byte[] getOutputByCompress(byte[] toByteArray) {
int unCompressedLength = 0;
int compressedLength = 0;
byte[] input = toByteArray;
unCompressedLength = input.Length;
MemoryStream memoryStream = new MemoryStream();
Deflater compressor = new Deflater();
DeflaterOutputStream defos = new DeflaterOutputStream(memoryStream, compressor);
defos.Write(input, 0, input.Length);
defos.Flush();
defos.Finish();
byte[] output = memoryStream.ToArray();
compressedLength = output.Length;
memoryStream.Close();
defos.Close();
//set compress flag and compressedLength, unCompressedLength
byte[] sendData = new byte[output.Length + TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfInt() + TransferUtil.getLengthOfInt()];
sendData[0] = TransferObject.COMPRESS_FLAG; //0:normal; 1:compress
TransferOutputStream fos = new TransferOutputStream(sendData);
fos.skipAByte();
fos.writeInt(unCompressedLength);
fos.writeInt(compressedLength);
Array.Copy(output, 0, sendData, TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfInt() + TransferUtil.getLengthOfInt(), output.Length);
return sendData;
}
public static void Serialize(Stream stream, PiaFile piaFile)
{
if (stream == null)
throw new ArgumentNullException("Stream");
if (piaFile == null)
throw new ArgumentNullException("PiaFile");
try
{
// Header
var headerString = piaFile.Header.ToString();
var headerBytes = Encoding.Default.GetBytes(headerString);
stream.Write(headerBytes, 0, headerBytes.Length);
// Nodes
var nodeString = _serializeNode(piaFile);
var nodeBytes = Encoding.Default.GetBytes(nodeString);
// Deflation
byte[] deflatedBytes;
var deflater = new Deflater(Deflater.DEFAULT_COMPRESSION);
using (var ms = new MemoryStream())
{
var deflateStream = new DeflaterOutputStream(ms, deflater);
deflateStream.Write(nodeBytes, 0, nodeBytes.Length);
deflateStream.Finish();
deflatedBytes = ms.ToArray();
}
// Checksum
var checkSum = new byte[12];
BitConverter.GetBytes(deflater.Adler).CopyTo(checkSum, 0); // Adler
BitConverter.GetBytes(nodeBytes.Length).CopyTo(checkSum, 4); // InflatedSize
BitConverter.GetBytes(deflatedBytes.Length).CopyTo(checkSum, 8); // DeflatedSize
stream.Write(checkSum, 0, checkSum.Length);
// Final write
stream.Write(deflatedBytes, 0, deflatedBytes.Length);
}
catch (Exception)
{
throw;
}
}
public void ZipBlob()
{
MemoryStream sourceStream = new MemoryStream(new byte[] { 12, 34, 56, 78 });
MemoryStream compressedStream = new MemoryStream();
DeflaterOutputStream deflaterStream = new DeflaterOutputStream(compressedStream);
StreamUtils.Copy(sourceStream, deflaterStream, new byte[4096]);
deflaterStream.Finish();
compressedStream.Capacity = (int) compressedStream.Length;
StructInstance instance = PrepareInstance(
"struct A { blob q [len=FileSize, encoding=zlib]; }",
compressedStream.GetBuffer());
BlobCell cell = (BlobCell) instance.Cells[0];
Assert.AreEqual(4, cell.DataStream.Length);
}
/// <summary>
/// see <see cref="SwfDotNet.IO.Tags.BaseTag">base class</see>
/// </summary>
public override void UpdateData(byte version)
{
if (version < 2)
return;
// Compression process
int lenghtOfCompressedBlock = 0;
byte[] compressArray = null;
MemoryStream unCompressedStream = new MemoryStream();
BufferedBinaryWriter unCompressedWriter = new BufferedBinaryWriter(unCompressedStream);
if (this._bitmapFormat == 3)
{
this._colorMapData.WriteTo(unCompressedWriter);
}
else if (this._bitmapFormat == 4 || this._bitmapFormat == 5)
{
this._bitmapColorData.WriteTo(unCompressedWriter);
}
MemoryStream compressedStream = new MemoryStream();
DeflaterOutputStream ouput = new DeflaterOutputStream(compressedStream);
byte[] unCompressArray = unCompressedStream.ToArray();
ouput.Write(unCompressArray, 0, unCompressArray.Length);
ouput.Finish();
compressArray = compressedStream.ToArray();
lenghtOfCompressedBlock = compressArray.Length;
ouput.Close();
unCompressedStream.Close();
//Writing process
MemoryStream m = new MemoryStream();
BufferedBinaryWriter w = new BufferedBinaryWriter(m);
RecordHeader rh = new RecordHeader(TagCode, GetSizeOf(lenghtOfCompressedBlock));
rh.WriteTo(w);
w.Write(this._characterId);
w.Write(this._bitmapFormat);
w.Write(this._bitmapWidth);
w.Write(this._bitmapHeight);
if (this._bitmapFormat == 3)
{
w.Write(this._bitmapColorTableSize);
w.Write(compressArray);
}
else if (this._bitmapFormat == 4 || this._bitmapFormat == 5)
{
w.Write(compressArray);
}
w.Flush();
// write to data array
_data = m.ToArray();
}
/// <summary>
/// Compression through zlib
/// </summary>
public CString ZCompress()
{
// Do Compression
try
{
MemoryStream MemStream = new MemoryStream();
DeflaterOutputStream DefStream = new DeflaterOutputStream(MemStream, new Deflater(Deflater.DEFAULT_COMPRESSION, false));
DefStream.Write(mBuffer.ToArray(), 0, mBuffer.Count);
DefStream.Finish();
DefStream.Close();
// Recreate Buffer
mBuffer = MemStream.ToArray().ToList();
}
catch (Exception e)
{
}
return this;
}
