niko
320 lines
7.1 KiB
C#
320 lines
7.1 KiB
C#
using System;
|
|
|
|
namespace ICSharpCode.SharpZipLib.Zip.Compression
|
|
{
|
|
// Token: 0x0200003F RID: 63
|
|
public class Deflater
|
|
{
|
|
// Token: 0x06000278 RID: 632 RVA: 0x0000CE3A File Offset: 0x0000BE3A
|
|
public Deflater()
|
|
: this(-1, false)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000279 RID: 633 RVA: 0x0000CE44 File Offset: 0x0000BE44
|
|
public Deflater(int level)
|
|
: this(level, false)
|
|
{
|
|
}
|
|
|
|
// Token: 0x0600027A RID: 634 RVA: 0x0000CE50 File Offset: 0x0000BE50
|
|
public Deflater(int level, bool noZlibHeaderOrFooter)
|
|
{
|
|
if (level == -1)
|
|
{
|
|
level = 6;
|
|
}
|
|
else if (level < 0 || level > 9)
|
|
{
|
|
throw new ArgumentOutOfRangeException("level");
|
|
}
|
|
this.pending = new DeflaterPending();
|
|
this.engine = new DeflaterEngine(this.pending);
|
|
this.noZlibHeaderOrFooter = noZlibHeaderOrFooter;
|
|
this.SetStrategy(DeflateStrategy.Default);
|
|
this.SetLevel(level);
|
|
this.Reset();
|
|
}
|
|
|
|
// Token: 0x0600027B RID: 635 RVA: 0x0000CEB7 File Offset: 0x0000BEB7
|
|
public void Reset()
|
|
{
|
|
this.state = (this.noZlibHeaderOrFooter ? 16 : 0);
|
|
this.totalOut = 0L;
|
|
this.pending.Reset();
|
|
this.engine.Reset();
|
|
}
|
|
|
|
// Token: 0x1700008C RID: 140
|
|
// (get) Token: 0x0600027C RID: 636 RVA: 0x0000CEEA File Offset: 0x0000BEEA
|
|
public int Adler
|
|
{
|
|
get
|
|
{
|
|
return this.engine.Adler;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700008D RID: 141
|
|
// (get) Token: 0x0600027D RID: 637 RVA: 0x0000CEF7 File Offset: 0x0000BEF7
|
|
public long TotalIn
|
|
{
|
|
get
|
|
{
|
|
return this.engine.TotalIn;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700008E RID: 142
|
|
// (get) Token: 0x0600027E RID: 638 RVA: 0x0000CF04 File Offset: 0x0000BF04
|
|
public long TotalOut
|
|
{
|
|
get
|
|
{
|
|
return this.totalOut;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600027F RID: 639 RVA: 0x0000CF0C File Offset: 0x0000BF0C
|
|
public void Flush()
|
|
{
|
|
this.state |= 4;
|
|
}
|
|
|
|
// Token: 0x06000280 RID: 640 RVA: 0x0000CF1C File Offset: 0x0000BF1C
|
|
public void Finish()
|
|
{
|
|
this.state |= 12;
|
|
}
|
|
|
|
// Token: 0x1700008F RID: 143
|
|
// (get) Token: 0x06000281 RID: 641 RVA: 0x0000CF2D File Offset: 0x0000BF2D
|
|
public bool IsFinished
|
|
{
|
|
get
|
|
{
|
|
return this.state == 30 && this.pending.IsFlushed;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000090 RID: 144
|
|
// (get) Token: 0x06000282 RID: 642 RVA: 0x0000CF46 File Offset: 0x0000BF46
|
|
public bool IsNeedingInput
|
|
{
|
|
get
|
|
{
|
|
return this.engine.NeedsInput();
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000283 RID: 643 RVA: 0x0000CF53 File Offset: 0x0000BF53
|
|
public void SetInput(byte[] input)
|
|
{
|
|
this.SetInput(input, 0, input.Length);
|
|
}
|
|
|
|
// Token: 0x06000284 RID: 644 RVA: 0x0000CF60 File Offset: 0x0000BF60
|
|
public void SetInput(byte[] input, int offset, int count)
|
|
{
|
|
if ((this.state & 8) != 0)
|
|
{
|
|
throw new InvalidOperationException("Finish() already called");
|
|
}
|
|
this.engine.SetInput(input, offset, count);
|
|
}
|
|
|
|
// Token: 0x06000285 RID: 645 RVA: 0x0000CF85 File Offset: 0x0000BF85
|
|
public void SetLevel(int level)
|
|
{
|
|
if (level == -1)
|
|
{
|
|
level = 6;
|
|
}
|
|
else if (level < 0 || level > 9)
|
|
{
|
|
throw new ArgumentOutOfRangeException("level");
|
|
}
|
|
if (this.level != level)
|
|
{
|
|
this.level = level;
|
|
this.engine.SetLevel(level);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000286 RID: 646 RVA: 0x0000CFC0 File Offset: 0x0000BFC0
|
|
public int GetLevel()
|
|
{
|
|
return this.level;
|
|
}
|
|
|
|
// Token: 0x06000287 RID: 647 RVA: 0x0000CFC8 File Offset: 0x0000BFC8
|
|
public void SetStrategy(DeflateStrategy strategy)
|
|
{
|
|
this.engine.Strategy = strategy;
|
|
}
|
|
|
|
// Token: 0x06000288 RID: 648 RVA: 0x0000CFD6 File Offset: 0x0000BFD6
|
|
public int Deflate(byte[] output)
|
|
{
|
|
return this.Deflate(output, 0, output.Length);
|
|
}
|
|
|
|
// Token: 0x06000289 RID: 649 RVA: 0x0000CFE4 File Offset: 0x0000BFE4
|
|
public int Deflate(byte[] output, int offset, int length)
|
|
{
|
|
int num = length;
|
|
if (this.state == 127)
|
|
{
|
|
throw new InvalidOperationException("Deflater closed");
|
|
}
|
|
if (this.state < 16)
|
|
{
|
|
int num2 = 30720;
|
|
int num3 = this.level - 1 >> 1;
|
|
if (num3 < 0 || num3 > 3)
|
|
{
|
|
num3 = 3;
|
|
}
|
|
num2 |= num3 << 6;
|
|
if ((this.state & 1) != 0)
|
|
{
|
|
num2 |= 32;
|
|
}
|
|
num2 += 31 - num2 % 31;
|
|
this.pending.WriteShortMSB(num2);
|
|
if ((this.state & 1) != 0)
|
|
{
|
|
int adler = this.engine.Adler;
|
|
this.engine.ResetAdler();
|
|
this.pending.WriteShortMSB(adler >> 16);
|
|
this.pending.WriteShortMSB(adler & 65535);
|
|
}
|
|
this.state = 16 | (this.state & 12);
|
|
}
|
|
for (;;)
|
|
{
|
|
int num4 = this.pending.Flush(output, offset, length);
|
|
offset += num4;
|
|
this.totalOut += (long)num4;
|
|
length -= num4;
|
|
if (length == 0 || this.state == 30)
|
|
{
|
|
goto IL_1DE;
|
|
}
|
|
if (!this.engine.Deflate((this.state & 4) != 0, (this.state & 8) != 0))
|
|
{
|
|
if (this.state == 16)
|
|
{
|
|
break;
|
|
}
|
|
if (this.state == 20)
|
|
{
|
|
if (this.level != 0)
|
|
{
|
|
for (int i = 8 + (-this.pending.BitCount & 7); i > 0; i -= 10)
|
|
{
|
|
this.pending.WriteBits(2, 10);
|
|
}
|
|
}
|
|
this.state = 16;
|
|
}
|
|
else if (this.state == 28)
|
|
{
|
|
this.pending.AlignToByte();
|
|
if (!this.noZlibHeaderOrFooter)
|
|
{
|
|
int adler2 = this.engine.Adler;
|
|
this.pending.WriteShortMSB(adler2 >> 16);
|
|
this.pending.WriteShortMSB(adler2 & 65535);
|
|
}
|
|
this.state = 30;
|
|
}
|
|
}
|
|
}
|
|
return num - length;
|
|
IL_1DE:
|
|
return num - length;
|
|
}
|
|
|
|
// Token: 0x0600028A RID: 650 RVA: 0x0000D1D2 File Offset: 0x0000C1D2
|
|
public void SetDictionary(byte[] dictionary)
|
|
{
|
|
this.SetDictionary(dictionary, 0, dictionary.Length);
|
|
}
|
|
|
|
// Token: 0x0600028B RID: 651 RVA: 0x0000D1DF File Offset: 0x0000C1DF
|
|
public void SetDictionary(byte[] dictionary, int index, int count)
|
|
{
|
|
if (this.state != 0)
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
this.state = 1;
|
|
this.engine.SetDictionary(dictionary, index, count);
|
|
}
|
|
|
|
// Token: 0x0400015A RID: 346
|
|
public const int BEST_COMPRESSION = 9;
|
|
|
|
// Token: 0x0400015B RID: 347
|
|
public const int BEST_SPEED = 1;
|
|
|
|
// Token: 0x0400015C RID: 348
|
|
public const int DEFAULT_COMPRESSION = -1;
|
|
|
|
// Token: 0x0400015D RID: 349
|
|
public const int NO_COMPRESSION = 0;
|
|
|
|
// Token: 0x0400015E RID: 350
|
|
public const int DEFLATED = 8;
|
|
|
|
// Token: 0x0400015F RID: 351
|
|
private const int IS_SETDICT = 1;
|
|
|
|
// Token: 0x04000160 RID: 352
|
|
private const int IS_FLUSHING = 4;
|
|
|
|
// Token: 0x04000161 RID: 353
|
|
private const int IS_FINISHING = 8;
|
|
|
|
// Token: 0x04000162 RID: 354
|
|
private const int INIT_STATE = 0;
|
|
|
|
// Token: 0x04000163 RID: 355
|
|
private const int SETDICT_STATE = 1;
|
|
|
|
// Token: 0x04000164 RID: 356
|
|
private const int BUSY_STATE = 16;
|
|
|
|
// Token: 0x04000165 RID: 357
|
|
private const int FLUSHING_STATE = 20;
|
|
|
|
// Token: 0x04000166 RID: 358
|
|
private const int FINISHING_STATE = 28;
|
|
|
|
// Token: 0x04000167 RID: 359
|
|
private const int FINISHED_STATE = 30;
|
|
|
|
// Token: 0x04000168 RID: 360
|
|
private const int CLOSED_STATE = 127;
|
|
|
|
// Token: 0x04000169 RID: 361
|
|
private int level;
|
|
|
|
// Token: 0x0400016A RID: 362
|
|
private bool noZlibHeaderOrFooter;
|
|
|
|
// Token: 0x0400016B RID: 363
|
|
private int state;
|
|
|
|
// Token: 0x0400016C RID: 364
|
|
private long totalOut;
|
|
|
|
// Token: 0x0400016D RID: 365
|
|
private DeflaterPending pending;
|
|
|
|
// Token: 0x0400016E RID: 366
|
|
private DeflaterEngine engine;
|
|
}
|
|
}
|