private void ProcessTypeFixed(CompressionStream zip, InflaterBlocksContext state) { int[] bl = new int[1]; int[] bd = new int[1]; int[][] tl = new int[1][]; int[][] td = new int[1][]; InflaterTree.InflateTreeFixed(bl, bd, tl, td, zip); this.codes = new InflaterCodes(bl[0], bd[0], tl[0], td[0], zip); state.ShiftRight(3); this.mode = 6; }
private int Reset(CompressionStream stream) { if (stream == null) { return(-2); } stream.InputTotal = 0L; stream.OutputTotal = 0L; stream.ErrorMessage = (string)null; this.state = this.nowrap != 0 ? InflaterState.Blocks : InflaterState.Method; this.blocks.Reset(stream, (long[])null); return(0); }
internal static int InflateTreeFixed( int[] bl, int[] bd, int[][] tl, int[][] td, CompressionStream z) { bl[0] = 9; bd[0] = 5; tl[0] = InflaterTreeConstants.FixedTl; td[0] = InflaterTreeConstants.FixedTd; return(0); }
public void End() { if (this.compress) { this.zip.DeflateEnd(); } else { this.zip.InflateEnd(); } this.zip.Free(); this.zip = (CompressionStream)null; }
private int ProcessStored(CompressionStream zip, InflaterBlocksContext state, int res) { if (state.BytesCount == 0) { this.TransferBlocksState(zip, state); state.IsReturn = true; return(this.InflateFlush(zip, res)); } if (state.EndBytes == 0) { if (state.Output == this.WindowEnd && this.WindowRead != 0) { state.Output = 0; state.EndBytes = this.GetEndBytes(state); } if (state.EndBytes == 0) { this.WindowWrite = state.Output; res = this.InflateFlush(zip, res); state.Output = this.WindowWrite; state.EndBytes = this.GetEndBytes(state); if (state.Output == this.WindowEnd && this.WindowRead != 0) { state.Output = 0; state.EndBytes = this.GetEndBytes(state); } if (state.EndBytes == 0) { this.TransferBlocksState(zip, state); state.IsReturn = true; return(this.InflateFlush(zip, res)); } } } res = 0; state.Temp = this.left; if (state.Temp > state.BytesCount) { state.Temp = state.BytesCount; } if (state.Temp > state.EndBytes) { state.Temp = state.EndBytes; } Array.Copy((Array)zip.Input, state.Input, (Array)this.Window, state.Output, state.Temp); state.Input += state.Temp; state.BytesCount -= state.Temp; state.Output += state.Temp; state.EndBytes -= state.Temp; return(0); }
public int Sync(CompressionStream stream) { if (stream == null) { return(-2); } if (this.state != InflaterState.Error) { this.state = InflaterState.Error; this.marker = 0; } int inputCount = stream.InputCount; if (inputCount == 0) { return(-5); } int inputIndex = stream.InputIndex; int index; for (index = this.marker; inputCount != 0 && index < 4; --inputCount) { if ((int)stream.Input[inputIndex] == (int)Inflater.mark[index]) { ++index; } else { index = stream.Input[inputIndex] == (byte)0 ? 4 - index : 0; } ++inputIndex; } stream.InputTotal += (long)(inputIndex - stream.InputIndex); stream.InputIndex = inputIndex; stream.InputCount = inputCount; this.marker = index; if (index != 4) { return(-3); } long inputTotal = stream.InputTotal; long outputTotal = stream.OutputTotal; this.Reset(stream); stream.InputTotal = inputTotal; stream.OutputTotal = outputTotal; this.state = InflaterState.Blocks; return(0); }
private bool HandleCheckTwoState(CompressionStream stream, out ErrorCode result) { result = ErrorCode.Ok; if (stream.InputCount == 0) { result = this.error; return(false); } this.error = this.startError; --stream.InputCount; ++stream.InputTotal; this.need += (uint)((ulong)(((int)stream.Input[stream.InputIndex++] & (int)byte.MaxValue) << 8) & 65280UL); this.state = InflaterState.CheckOne; return(true); }
private bool HandleCheckFourState(CompressionStream stream, out ErrorCode result) { result = ErrorCode.Ok; if (stream.InputCount == 0) { result = this.error; return(false); } this.error = this.startError; --stream.InputCount; ++stream.InputTotal; this.need = (uint)(((int)stream.Input[stream.InputIndex++] & (int)byte.MaxValue) << 24 & -16777216); this.state = InflaterState.CheckThree; return(true); }
private bool HandleDictionaryThreeState(CompressionStream stream, out ErrorCode result) { result = ErrorCode.Ok; if (stream.InputCount == 0) { result = this.error; return(false); } this.error = this.startError; --stream.InputCount; ++stream.InputTotal; this.need += (uint)((ulong)(((int)stream.Input[stream.InputIndex++] & (int)byte.MaxValue) << 16) & 16711680UL); this.state = InflaterState.DictionaryTwo; return(true); }
internal InflaterCodes( int bl, int bd, int[] tl, int tlIndex, int[] td, int tdIndex, CompressionStream z) { this.mode = 0; this.lbits = (byte)bl; this.dbits = (byte)bd; this.ltree = tl; this.ltreeIndex = tlIndex; this.dtree = td; this.dtreeIndex = tdIndex; }
private bool HandleDictionaryOneState(CompressionStream stream, out ErrorCode result) { result = ErrorCode.Ok; if (stream.InputCount == 0) { result = this.error; return(false); } this.error = this.startError; --stream.InputCount; ++stream.InputTotal; this.need += (uint)((ulong)stream.Input[stream.InputIndex++] & (ulong)byte.MaxValue); stream.Checksum = new Adler32(this.need); this.state = InflaterState.DictionaryZero; result = ErrorCode.NeedsDictionary; return(false); }
private int Initialize( CompressionStream strm, int level, int method, int windowBits, int memLevel, int strategy) { int num = 0; strm.ErrorMessage = (string)null; if (level == -1) { level = 6; } if (windowBits < 0) { num = 1; windowBits = -windowBits; } if (memLevel < 1 || memLevel > 9 || (method != 8 || windowBits < 9) || (windowBits > 15 || level < 0 || (level > 9 || strategy < 0)) || strategy > 2) { return(-2); } strm.Deflater = this; this.noheader = num; this.wBits = windowBits; this.wSize = 1 << this.wBits; this.wMask = this.wSize - 1; this.hashBits = memLevel + 7; this.hashSize = 1 << this.hashBits; this.hashMask = this.hashSize - 1; this.hashShift = (this.hashBits + 3 - 1) / 3; this.window = new byte[this.wSize * 2]; this.prev = new short[this.wSize]; this.head = new short[this.hashSize]; this.litBufsize = 1 << memLevel + 6; this.pendingBuffer = new byte[this.litBufsize * 4]; this.pendingBufferSize = this.litBufsize * 4; this.d_buf = this.litBufsize; this.litBuf = 3 * this.litBufsize; this.level = (int)level; this.strategy = strategy; this.method = (byte)method; return(this.Reset(strm)); }
private int ProcessTable(CompressionStream zip, InflaterBlocksContext state, int res) { for (; state.Bits < 14; state.Bits += 8) { if (state.BytesCount != 0) { res = 0; --state.BytesCount; state.BitBuf |= ((int)zip.Input[state.Input++] & (int)byte.MaxValue) << state.Bits; } else { this.TransferBlocksState(zip, state); state.IsReturn = true; return(this.InflateFlush(zip, res)); } } this.table = state.Temp = state.BitBuf & 16383; if ((state.Temp & 31) > 29 || (state.Temp >> 5 & 31) > 29) { this.mode = 9; zip.ErrorMessage = "too many length or distance symbols"; res = -3; this.TransferBlocksState(zip, state); state.IsReturn = true; return(this.InflateFlush(zip, res)); } state.Temp = 258 + (state.Temp & 31) + (state.Temp >> 5 & 31); this.blens = new int[state.Temp]; if (this.blens == null || this.blens.Length < state.Temp) { this.blens = new int[state.Temp]; } else { for (int index = 0; index < state.Temp; ++index) { this.blens[index] = 0; } } state.ShiftRight(14); this.index = 0; this.mode = 4; return(0); }
private int Reset(CompressionStream strm) { strm.InputTotal = strm.OutputTotal = 0L; strm.ErrorMessage = (string)null; strm.DataType = 2; this.pending = 0; this.pendingOutput = 0; if (this.noheader < 0) { this.noheader = 0; } this.status = this.noheader != 0 ? 113 : 42; strm.Checksum = new Adler32(); this.lastFlush = 0; this.InitializeTree(); this.InitializeMatch(); return(0); }
private int ProcessType(CompressionStream zip, InflaterBlocksContext state, int res) { for (; state.Bits < 3; state.Bits += 8) { if (state.BytesCount != 0) { res = 0; --state.BytesCount; state.BitBuf |= ((int)zip.Input[state.Input++] & (int)byte.MaxValue) << state.Bits; } else { this.TransferBlocksState(zip, state); state.IsReturn = true; return(this.InflateFlush(zip, res)); } } state.Temp = state.BitBuf & 7; this.last = state.Temp & 1; switch (Utils.ShiftRight(state.Temp, 1)) { case 0: this.ProcessTypeStored(state); break; case 1: this.ProcessTypeFixed(zip, state); break; case 2: this.ProcessTypeDynamic(state); break; case 3: state.ShiftRight(3); this.mode = 9; zip.ErrorMessage = "invalid block type"; res = -3; this.TransferBlocksState(zip, state); state.IsReturn = true; return(this.InflateFlush(zip, res)); } return(0); }
private int ProcessBTree(CompressionStream zip, InflaterBlocksContext state, int res) { while (this.index < 4 + Utils.ShiftRight(this.table, 10)) { for (; state.Bits < 3; state.Bits += 8) { if (state.BytesCount != 0) { res = 0; --state.BytesCount; state.BitBuf |= ((int)zip.Input[state.Input++] & (int)byte.MaxValue) << state.Bits; } else { this.TransferBlocksState(zip, state); state.IsReturn = true; return(this.InflateFlush(zip, res)); } } this.blens[InflaterBlocks.border[this.index++]] = state.BitBuf & 7; state.ShiftRight(3); } while (this.index < 19) { this.blens[InflaterBlocks.border[this.index++]] = 0; } this.bitLengthTreeDepth[0] = 7; state.Temp = InflaterTree.InflateTreeBits(this.blens, this.bitLengthTreeDepth, this.bitLengthDecodeTree, this.hufts, zip); if (state.Temp != 0) { res = state.Temp; if (res == -3) { this.blens = (int[])null; this.mode = 9; } this.TransferBlocksState(zip, state); state.IsReturn = true; return(this.InflateFlush(zip, res)); } this.index = 0; this.mode = 5; return(0); }
private bool HandleCheckOneState(CompressionStream stream, out ErrorCode result) { result = ErrorCode.Ok; if (stream.InputCount == 0) { result = this.error; return(false); } this.error = this.startError; --stream.InputCount; ++stream.InputTotal; this.need += (uint)((ulong)stream.Input[stream.InputIndex++] & (ulong)byte.MaxValue); if ((int)this.was[0] != (int)this.need) { this.state = InflaterState.Error; stream.ErrorMessage = "incorrect data check"; this.marker = 5; return(true); } this.state = InflaterState.Done; return(true); }
public int Initialize(CompressionStream stream, int windowSize) { stream.ErrorMessage = (string)null; this.blocks = (InflaterBlocks)null; this.nowrap = 0; if (windowSize < 0) { windowSize = -windowSize; this.nowrap = 1; } if (windowSize < 8 || windowSize > 15) { this.End(stream); return(-2); } this.wbits = windowSize; Inflater inflater = this.nowrap != 0 ? (Inflater)null : this; this.blocks = new InflaterBlocks(stream, (object)inflater, 1 << windowSize); this.Reset(stream); return(0); }
public int SetDictionary(CompressionStream stream, byte[] dictionary, int dictLength) { int start = 0; int n = dictLength; if (stream == null || this.state != InflaterState.DictionaryZero) { return(-2); } if (Adler32.Get(dictionary, 0, dictLength) != stream.Checksum.Get()) { return(-3); } stream.Checksum = new Adler32(); if (n >= 1 << this.wbits) { n = (1 << this.wbits) - 1; start = dictLength - n; } this.blocks.SetDictionary(dictionary, start, n); this.state = InflaterState.Blocks; return(0); }
public int Inflate(CompressionStream stream, int flush) { if (stream == null || stream.Input == null) { return(-2); } this.startError = flush == 4 ? ErrorCode.BufferError : ErrorCode.Ok; this.error = ErrorCode.BufferError; ErrorCode result = ErrorCode.Ok; while (true) { switch (this.state) { case InflaterState.Method: if (this.HandleMethodState(stream, out result)) { break; } goto label_4; case InflaterState.Flag: if (this.HandleFlagState(stream, out result)) { break; } goto label_6; case InflaterState.DictionaryFour: if (this.HandleDictionaryFourState(stream, out result)) { break; } goto label_8; case InflaterState.DictionaryThree: if (this.HandleDictionaryThreeState(stream, out result)) { break; } goto label_10; case InflaterState.DictionaryTwo: if (this.HandleDictionaryTwoState(stream, out result)) { break; } goto label_12; case InflaterState.DictionaryOne: if (this.HandleDictionaryOneState(stream, out result)) { break; } goto label_14; case InflaterState.DictionaryZero: if (this.HandleDictionaryZeroState(stream, out result)) { break; } goto label_16; case InflaterState.Blocks: if (this.HandleBlocksState(stream, out result)) { break; } goto label_18; case InflaterState.CheckFour: if (this.HandleCheckFourState(stream, out result)) { break; } goto label_20; case InflaterState.CheckThree: if (this.HandleCheckThreeState(stream, out result)) { break; } goto label_22; case InflaterState.CheckTwo: if (this.HandleCheckThreeState(stream, out result)) { break; } goto label_24; case InflaterState.CheckOne: if (this.HandleCheckOneState(stream, out result)) { break; } goto label_26; case InflaterState.Done: goto label_27; case InflaterState.Error: goto label_28; default: goto label_29; } } label_4: return((int)result); label_6: return((int)result); label_8: return((int)result); label_10: return((int)result); label_12: return((int)result); label_14: return((int)result); label_16: return((int)result); label_18: return((int)result); label_20: return((int)result); label_22: return((int)result); label_24: return((int)result); label_26: return((int)result); label_27: return(1); label_28: return(-3); label_29: return(-2); }
internal int Process(CompressionStream zip, int res) { InflaterBlocksContext state = new InflaterBlocksContext() { Input = zip.InputIndex, BytesCount = zip.InputCount, BitBuf = this.BitBuffer, Bits = this.BitBufferLength, Output = this.WindowWrite }; state.EndBytes = this.GetEndBytes(state); int num1; int num2; int num3; int num4; int num5; int num6; while (true) { switch (this.mode) { case 0: state.IsReturn = false; num1 = this.ProcessType(zip, state, res); if (!state.IsReturn) { break; } goto label_2; case 1: state.IsReturn = false; num2 = this.ProcessLens(zip, state, ref res); if (!state.IsReturn) { break; } goto label_4; case 2: state.IsReturn = false; num3 = this.ProcessStored(zip, state, res); if (!state.IsReturn) { if ((this.left -= state.Temp) == 0) { this.mode = this.last == 0 ? 0 : 7; break; } break; } goto label_6; case 3: state.IsReturn = false; num4 = this.ProcessTable(zip, state, res); if (!state.IsReturn) { goto case 4; } else { goto label_10; } case 4: state.IsReturn = false; num5 = this.ProcessBTree(zip, state, res); if (!state.IsReturn) { goto case 5; } else { goto label_12; } case 5: state.IsReturn = false; num6 = this.ProcessDTree(zip, state, res); if (!state.IsReturn) { goto case 6; } else { goto label_14; } case 6: this.TransferBlocksState(zip, state); if ((res = this.codes.Process(this, zip, res)) == 1) { res = 0; this.codes.Free(zip); state.Input = zip.InputIndex; state.BytesCount = zip.InputCount; state.BitBuf = this.BitBuffer; state.Bits = this.BitBufferLength; state.Output = this.WindowWrite; state.EndBytes = this.GetEndBytes(state); if (this.last == 0) { this.mode = 0; break; } goto label_19; } else { goto label_16; } case 7: goto label_20; case 8: goto label_23; case 9: goto label_24; default: goto label_25; } } label_2: return(num1); label_4: return(num2); label_6: return(num3); label_10: return(num4); label_12: return(num5); label_14: return(num6); label_16: return(this.InflateFlush(zip, res)); label_19: this.mode = 7; label_20: this.WindowWrite = state.Output; res = this.InflateFlush(zip, res); state.Output = this.WindowWrite; state.EndBytes = this.GetEndBytes(state); if (this.WindowRead != this.WindowWrite) { this.TransferBlocksState(zip, state); return(this.InflateFlush(zip, res)); } this.mode = 8; label_23: res = 1; this.TransferBlocksState(zip, state); return(this.InflateFlush(zip, res)); label_24: res = -3; this.TransferBlocksState(zip, state); return(this.InflateFlush(zip, res)); label_25: res = -2; this.TransferBlocksState(zip, state); return(this.InflateFlush(zip, res)); }
public int Deflate(CompressionStream strm, int flush) { if (flush > 4 || flush < 0) { return(-2); } if (strm.Output == null || strm.Input == null && strm.InputCount != 0 || this.status == 666 && flush != 4) { strm.ErrorMessage = Deflater.errmsg[4]; return(-2); } if (strm.OutputCount == 0) { strm.ErrorMessage = Deflater.errmsg[7]; return(-5); } this.stream = strm; int lastFlush = this.lastFlush; this.lastFlush = flush; if (this.status == 42) { int num1 = 8 + (this.wBits - 8 << 4) << 8; int num2 = (this.level - 1 & (int)byte.MaxValue) >> 1; if (num2 > 3) { num2 = 3; } int num3 = num1 | num2 << 6; if (this.strstart != 0) { num3 |= 32; } int b = num3 + (31 - num3 % 31); this.status = 113; this.WriteShortMSB(b); if (this.strstart != 0) { this.WriteShortMSB((int)Utils.ShiftRight(strm.Checksum.Get(), 16)); this.WriteShortMSB((int)(strm.Checksum.Get() & (long)ushort.MaxValue)); } strm.Checksum = new Adler32(); } if (this.pending != 0) { strm.FlushPending(); if (strm.OutputCount == 0) { this.lastFlush = -1; return(0); } } else if (strm.InputCount == 0 && flush <= lastFlush && flush != 4) { strm.ErrorMessage = Deflater.errmsg[7]; return(-5); } if (this.status == 666 && strm.InputCount != 0) { strm.ErrorMessage = Deflater.errmsg[7]; return(-5); } if (strm.InputCount != 0 || this.lookahead != 0 || flush != 0 && this.status != 666) { int num = -1; switch (Deflater.Options[this.level].Function) { case DeflaterFunction.Stored: num = this.DeflateStored(flush); break; case DeflaterFunction.Fast: num = this.DeflateFast(flush); break; case DeflaterFunction.Slow: num = this.DeflateSlow(flush); break; } if (num == 2 || num == 3) { this.status = 666; } if (num == 0 || num == 2) { if (strm.OutputCount == 0) { this.lastFlush = -1; } return(0); } if (num == 1) { if (flush == 1) { this.AlignTree(); } else { this.TreeSendStoredBlock(0, 0, false); if (flush == 3) { for (int index = 0; index < this.hashSize; ++index) { this.head[index] = (short)0; } } } strm.FlushPending(); if (strm.OutputCount == 0) { this.lastFlush = -1; return(0); } } } if (flush != 4) { return(0); } if (this.noheader != 0) { return(1); } this.WriteShortMSB((int)Utils.ShiftRight(strm.Checksum.Get(), 16)); this.WriteShortMSB((int)(strm.Checksum.Get() & (long)ushort.MaxValue)); strm.FlushPending(); this.noheader = -1; return(this.pending != 0 ? 0 : 1); }
public int Initialize(CompressionStream strm, CompressionLevel level) { return(this.Initialize(strm, level, 15)); }
public int Initialize(CompressionStream strm, CompressionLevel level, int bits) { return(this.Initialize(strm, (int)level, (int)CompressionMethod.Deflated, bits, 8, 0)); }
internal void Free(CompressionStream z) { this.Reset(z, (long[])null); this.Window = (byte[])null; this.hufts = (int[])null; }
internal int Process(InflaterBlocks s, CompressionStream z, int r) { int inputIndex = z.InputIndex; int inputCount = z.InputCount; int number = s.BitBuffer; int bitBufferLength = s.BitBufferLength; int num1 = s.WindowWrite; int num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1; while (true) { switch (this.mode) { case 0: if (num2 >= 258 && inputCount >= 10) { s.BitBuffer = number; s.BitBufferLength = bitBufferLength; z.InputCount = inputCount; z.InputTotal += (long)(inputIndex - z.InputIndex); z.InputIndex = inputIndex; s.WindowWrite = num1; r = this.InflateFast((int)this.lbits, (int)this.dbits, this.ltree, this.ltreeIndex, this.dtree, this.dtreeIndex, s, z); inputIndex = z.InputIndex; inputCount = z.InputCount; number = s.BitBuffer; bitBufferLength = s.BitBufferLength; num1 = s.WindowWrite; num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1; int num3; switch (r) { case 0: goto label_6; case 1: num3 = 7; break; default: num3 = 9; break; } this.mode = num3; break; } label_6: this.need = (int)this.lbits; this.tree = this.ltree; this.treeIndex = this.ltreeIndex; this.mode = 1; goto case 1; case 1: int need1; for (need1 = this.need; bitBufferLength < need1; bitBufferLength += 8) { if (inputCount != 0) { r = 0; --inputCount; number |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << bitBufferLength; } else { s.BitBuffer = number; s.BitBufferLength = bitBufferLength; z.InputCount = inputCount; z.InputTotal += (long)(inputIndex - z.InputIndex); z.InputIndex = inputIndex; s.WindowWrite = num1; return(s.InflateFlush(z, r)); } } int index1 = (this.treeIndex + (number & InflaterCodes.inflateMask[need1])) * 3; number = Utils.ShiftRight(number, this.tree[index1 + 1]); bitBufferLength -= this.tree[index1 + 1]; int num4 = this.tree[index1]; if (num4 == 0) { this.lit = this.tree[index1 + 2]; this.mode = 6; break; } if ((num4 & 16) != 0) { this.getBits = num4 & 15; this.len = this.tree[index1 + 2]; this.mode = 2; break; } if ((num4 & 64) == 0) { this.need = num4; this.treeIndex = index1 / 3 + this.tree[index1 + 2]; break; } if ((num4 & 32) != 0) { this.mode = 7; break; } goto label_20; case 2: int getBits1; for (getBits1 = this.getBits; bitBufferLength < getBits1; bitBufferLength += 8) { if (inputCount != 0) { r = 0; --inputCount; number |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << bitBufferLength; } else { s.BitBuffer = number; s.BitBufferLength = bitBufferLength; z.InputCount = inputCount; z.InputTotal += (long)(inputIndex - z.InputIndex); z.InputIndex = inputIndex; s.WindowWrite = num1; return(s.InflateFlush(z, r)); } } this.len += number & InflaterCodes.inflateMask[getBits1]; number >>= getBits1; bitBufferLength -= getBits1; this.need = (int)this.dbits; this.tree = this.dtree; this.treeIndex = this.dtreeIndex; this.mode = 3; goto case 3; case 3: int need2; for (need2 = this.need; bitBufferLength < need2; bitBufferLength += 8) { if (inputCount != 0) { r = 0; --inputCount; number |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << bitBufferLength; } else { s.BitBuffer = number; s.BitBufferLength = bitBufferLength; z.InputCount = inputCount; z.InputTotal += (long)(inputIndex - z.InputIndex); z.InputIndex = inputIndex; s.WindowWrite = num1; return(s.InflateFlush(z, r)); } } int index2 = (this.treeIndex + (number & InflaterCodes.inflateMask[need2])) * 3; number >>= this.tree[index2 + 1]; bitBufferLength -= this.tree[index2 + 1]; int num5 = this.tree[index2]; if ((num5 & 16) != 0) { this.getBits = num5 & 15; this.dist = this.tree[index2 + 2]; this.mode = 4; break; } if ((num5 & 64) == 0) { this.need = num5; this.treeIndex = index2 / 3 + this.tree[index2 + 2]; break; } goto label_36; case 4: int getBits2; for (getBits2 = this.getBits; bitBufferLength < getBits2; bitBufferLength += 8) { if (inputCount != 0) { r = 0; --inputCount; number |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << bitBufferLength; } else { s.BitBuffer = number; s.BitBufferLength = bitBufferLength; z.InputCount = inputCount; z.InputTotal += (long)(inputIndex - z.InputIndex); z.InputIndex = inputIndex; s.WindowWrite = num1; return(s.InflateFlush(z, r)); } } this.dist += number & InflaterCodes.inflateMask[getBits2]; number >>= getBits2; bitBufferLength -= getBits2; this.mode = 5; goto case 5; case 5: int num6 = num1 - this.dist; while (num6 < 0) { num6 += s.WindowEnd; } for (; this.len != 0; --this.len) { if (num2 == 0) { if (num1 == s.WindowEnd && s.WindowRead != 0) { num1 = 0; num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1; } if (num2 == 0) { s.WindowWrite = num1; r = s.InflateFlush(z, r); num1 = s.WindowWrite; num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1; if (num1 == s.WindowEnd && s.WindowRead != 0) { num1 = 0; num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1; } if (num2 == 0) { s.BitBuffer = number; s.BitBufferLength = bitBufferLength; z.InputCount = inputCount; z.InputTotal += (long)(inputIndex - z.InputIndex); z.InputIndex = inputIndex; s.WindowWrite = num1; return(s.InflateFlush(z, r)); } } } s.Window[num1++] = s.Window[num6++]; --num2; if (num6 == s.WindowEnd) { num6 = 0; } } this.mode = 0; break; case 6: if (num2 == 0) { if (num1 == s.WindowEnd && s.WindowRead != 0) { num1 = 0; num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1; } if (num2 == 0) { s.WindowWrite = num1; r = s.InflateFlush(z, r); num1 = s.WindowWrite; num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1; if (num1 == s.WindowEnd && s.WindowRead != 0) { num1 = 0; num2 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1; } if (num2 == 0) { goto label_67; } } } r = 0; s.Window[num1++] = (byte)this.lit; --num2; this.mode = 0; break; case 7: goto label_70; case 8: goto label_75; case 9: goto label_76; default: goto label_77; } } label_20: this.mode = 9; z.ErrorMessage = "invalid literal/length code"; r = -3; s.BitBuffer = number; s.BitBufferLength = bitBufferLength; z.InputCount = inputCount; z.InputTotal += (long)(inputIndex - z.InputIndex); z.InputIndex = inputIndex; s.WindowWrite = num1; return(s.InflateFlush(z, r)); label_36: this.mode = 9; z.ErrorMessage = "invalid distance code"; r = -3; s.BitBuffer = number; s.BitBufferLength = bitBufferLength; z.InputCount = inputCount; z.InputTotal += (long)(inputIndex - z.InputIndex); z.InputIndex = inputIndex; s.WindowWrite = num1; return(s.InflateFlush(z, r)); label_67: s.BitBuffer = number; s.BitBufferLength = bitBufferLength; z.InputCount = inputCount; z.InputTotal += (long)(inputIndex - z.InputIndex); z.InputIndex = inputIndex; s.WindowWrite = num1; return(s.InflateFlush(z, r)); label_70: if (bitBufferLength > 7) { bitBufferLength -= 8; ++inputCount; --inputIndex; } s.WindowWrite = num1; r = s.InflateFlush(z, r); num1 = s.WindowWrite; int num7 = num1 < s.WindowRead ? s.WindowRead - num1 - 1 : s.WindowEnd - num1; if (s.WindowRead != s.WindowWrite) { s.BitBuffer = number; s.BitBufferLength = bitBufferLength; z.InputCount = inputCount; z.InputTotal += (long)(inputIndex - z.InputIndex); z.InputIndex = inputIndex; s.WindowWrite = num1; return(s.InflateFlush(z, r)); } this.mode = 8; label_75: r = 1; s.BitBuffer = number; s.BitBufferLength = bitBufferLength; z.InputCount = inputCount; z.InputTotal += (long)(inputIndex - z.InputIndex); z.InputIndex = inputIndex; s.WindowWrite = num1; return(s.InflateFlush(z, r)); label_76: r = -3; s.BitBuffer = number; s.BitBufferLength = bitBufferLength; z.InputCount = inputCount; z.InputTotal += (long)(inputIndex - z.InputIndex); z.InputIndex = inputIndex; s.WindowWrite = num1; return(s.InflateFlush(z, r)); label_77: r = -2; s.BitBuffer = number; s.BitBufferLength = bitBufferLength; z.InputCount = inputCount; z.InputTotal += (long)(inputIndex - z.InputIndex); z.InputIndex = inputIndex; s.WindowWrite = num1; return(s.InflateFlush(z, r)); }
internal int InflateFast( int bl, int bd, int[] tl, int tlIndex, int[] td, int tdIndex, InflaterBlocks s, CompressionStream z) { int inputIndex = z.InputIndex; int inputCount = z.InputCount; int num1 = s.BitBuffer; int num2 = s.BitBufferLength; int destinationIndex = s.WindowWrite; int num3 = destinationIndex < s.WindowRead ? s.WindowRead - destinationIndex - 1 : s.WindowEnd - destinationIndex; int num4 = InflaterCodes.inflateMask[bl]; int num5 = InflaterCodes.inflateMask[bd]; do { for (; num2 < 20; num2 += 8) { --inputCount; num1 |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << num2; } int num6 = num1 & num4; int[] numArray1 = tl; int num7 = tlIndex; int index1 = (num7 + num6) * 3; int index2; if ((index2 = numArray1[index1]) == 0) { num1 >>= numArray1[index1 + 1]; num2 -= numArray1[index1 + 1]; s.Window[destinationIndex++] = (byte)numArray1[index1 + 2]; --num3; } else { bool flag; while (true) { num1 >>= numArray1[index1 + 1]; num2 -= numArray1[index1 + 1]; if ((index2 & 16) == 0) { if ((index2 & 64) == 0) { num6 = num6 + numArray1[index1 + 2] + (num1 & InflaterCodes.inflateMask[index2]); index1 = (num7 + num6) * 3; if ((index2 = numArray1[index1]) != 0) { flag = true; } else { goto label_34; } } else { goto label_35; } } else { break; } } int index3 = index2 & 15; int length1 = numArray1[index1 + 2] + (num1 & InflaterCodes.inflateMask[index3]); int num8 = num1 >> index3; int num9; for (num9 = num2 - index3; num9 < 15; num9 += 8) { --inputCount; num8 |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << num9; } int num10 = num8 & num5; int[] numArray2 = td; int num11 = tdIndex; int index4 = (num11 + num10) * 3; int index5 = numArray2[index4]; while (true) { num8 >>= numArray2[index4 + 1]; num9 -= numArray2[index4 + 1]; if ((index5 & 16) == 0) { if ((index5 & 64) == 0) { num10 = num10 + numArray2[index4 + 2] + (num8 & InflaterCodes.inflateMask[index5]); index4 = (num11 + num10) * 3; index5 = numArray2[index4]; flag = true; } else { goto label_31; } } else { break; } } int index6; for (index6 = index5 & 15; num9 < index6; num9 += 8) { --inputCount; num8 |= ((int)z.Input[inputIndex++] & (int)byte.MaxValue) << num9; } int num12 = numArray2[index4 + 2] + (num8 & InflaterCodes.inflateMask[index6]); num1 = num8 >> index6; num2 = num9 - index6; num3 -= length1; int sourceIndex1; int num13; if (destinationIndex >= num12) { int sourceIndex2 = destinationIndex - num12; if (destinationIndex - sourceIndex2 > 0 && 2 > destinationIndex - sourceIndex2) { byte[] window1 = s.Window; int index7 = destinationIndex; int num14 = index7 + 1; byte[] window2 = s.Window; int index8 = sourceIndex2; int num15 = index8 + 1; int num16 = (int)window2[index8]; window1[index7] = (byte)num16; byte[] window3 = s.Window; int index9 = num14; destinationIndex = index9 + 1; byte[] window4 = s.Window; int index10 = num15; sourceIndex1 = index10 + 1; int num17 = (int)window4[index10]; window3[index9] = (byte)num17; length1 -= 2; } else { Array.Copy((Array)s.Window, sourceIndex2, (Array)s.Window, destinationIndex, 2); destinationIndex += 2; sourceIndex1 = sourceIndex2 + 2; length1 -= 2; } } else { sourceIndex1 = destinationIndex - num12; do { sourceIndex1 += s.WindowEnd; }while (sourceIndex1 < 0); int length2 = s.WindowEnd - sourceIndex1; if (length1 > length2) { length1 -= length2; if (destinationIndex - sourceIndex1 > 0 && length2 > destinationIndex - sourceIndex1) { do { s.Window[destinationIndex++] = s.Window[sourceIndex1++]; }while (--length2 != 0); } else { Array.Copy((Array)s.Window, sourceIndex1, (Array)s.Window, destinationIndex, length2); destinationIndex += length2; num13 = sourceIndex1 + length2; } sourceIndex1 = 0; } } if (destinationIndex - sourceIndex1 > 0 && length1 > destinationIndex - sourceIndex1) { do { s.Window[destinationIndex++] = s.Window[sourceIndex1++]; }while (--length1 != 0); goto label_39; } else { Array.Copy((Array)s.Window, sourceIndex1, (Array)s.Window, destinationIndex, length1); destinationIndex += length1; num13 = sourceIndex1 + length1; goto label_39; } label_31: z.ErrorMessage = "invalid distance code"; int num18 = z.InputCount - inputCount; int num19 = num9 >> 3 < num18 ? num9 >> 3 : num18; int num20 = inputCount + num19; int num21 = inputIndex - num19; int num22 = num9 - (num19 << 3); s.BitBuffer = num8; s.BitBufferLength = num22; z.InputCount = num20; z.InputTotal += (long)(num21 - z.InputIndex); z.InputIndex = num21; s.WindowWrite = destinationIndex; return(-3); label_34: num1 >>= numArray1[index1 + 1]; num2 -= numArray1[index1 + 1]; s.Window[destinationIndex++] = (byte)numArray1[index1 + 2]; --num3; goto label_39; label_35: if ((index2 & 32) != 0) { int num14 = z.InputCount - inputCount; int num15 = num2 >> 3 < num14 ? num2 >> 3 : num14; int num16 = inputCount + num15; int num17 = inputIndex - num15; int num23 = num2 - (num15 << 3); s.BitBuffer = num1; s.BitBufferLength = num23; z.InputCount = num16; z.InputTotal += (long)(num17 - z.InputIndex); z.InputIndex = num17; s.WindowWrite = destinationIndex; return(1); } z.ErrorMessage = "invalid literal/length code"; int num24 = z.InputCount - inputCount; int num25 = num2 >> 3 < num24 ? num2 >> 3 : num24; int num26 = inputCount + num25; int num27 = inputIndex - num25; int num28 = num2 - (num25 << 3); s.BitBuffer = num1; s.BitBufferLength = num28; z.InputCount = num26; z.InputTotal += (long)(num27 - z.InputIndex); z.InputIndex = num27; s.WindowWrite = destinationIndex; return(-3); label_39 :; } }while (num3 >= 258 && inputCount >= 10); int num29 = z.InputCount - inputCount; int num30 = num2 >> 3 < num29 ? num2 >> 3 : num29; int num31 = inputCount + num30; int num32 = inputIndex - num30; int num33 = num2 - (num30 << 3); s.BitBuffer = num1; s.BitBufferLength = num33; z.InputCount = num31; z.InputTotal += (long)(num32 - z.InputIndex); z.InputIndex = num32; s.WindowWrite = destinationIndex; return(0); }
internal void Free(CompressionStream z) { }
private int ProcessDTree(CompressionStream zip, InflaterBlocksContext state, int res) { while (true) { state.Temp = this.table; if (this.index < 258 + (state.Temp & 31) + (state.Temp >> 5 & 31)) { for (state.Temp = this.bitLengthTreeDepth[0]; state.Bits < state.Temp; state.Bits += 8) { if (state.BytesCount != 0) { res = 0; --state.BytesCount; state.BitBuf |= ((int)zip.Input[state.Input++] & (int)byte.MaxValue) << state.Bits; } else { this.TransferBlocksState(zip, state); state.IsReturn = true; return(this.InflateFlush(zip, res)); } } state.Temp = this.hufts[(this.bitLengthDecodeTree[0] + (state.BitBuf & InflaterBlocks.inflateMask[state.Temp])) * 3 + 1]; int huft = this.hufts[(this.bitLengthDecodeTree[0] + (state.BitBuf & InflaterBlocks.inflateMask[state.Temp])) * 3 + 2]; if (huft < 16) { state.ShiftRight(state.Temp); this.blens[this.index++] = huft; } else { int v = huft == 18 ? 7 : huft - 14; int num1 = huft == 18 ? 11 : 3; for (; state.Bits < state.Temp + v; state.Bits += 8) { if (state.BytesCount != 0) { res = 0; --state.BytesCount; state.BitBuf |= ((int)zip.Input[state.Input++] & (int)byte.MaxValue) << state.Bits; } else { this.TransferBlocksState(zip, state); state.IsReturn = true; return(this.InflateFlush(zip, res)); } } state.ShiftRight(state.Temp); int num2 = num1 + (state.BitBuf & InflaterBlocks.inflateMask[v]); state.ShiftRight(v); int index = this.index; state.Temp = this.table; if (index + num2 <= 258 + (state.Temp & 31) + (state.Temp >> 5 & 31) && (huft != 16 || index >= 1)) { int num3 = huft == 16 ? this.blens[index - 1] : 0; do { this.blens[index++] = num3; }while (--num2 != 0); this.index = index; } else { break; } } } else { goto label_20; } } this.blens = (int[])null; this.mode = 9; zip.ErrorMessage = "invalid bit length repeat"; res = -3; this.TransferBlocksState(zip, state); state.IsReturn = true; return(this.InflateFlush(zip, res)); label_20: this.bitLengthDecodeTree[0] = -1; int[] bl = new int[1]; int[] bd = new int[1]; int[] tl = new int[1]; int[] td = new int[1]; bl[0] = 9; bd[0] = 6; state.Temp = this.table; state.Temp = InflaterTree.InflateTreeDynamic(257 + (state.Temp & 31), 1 + (state.Temp >> 5 & 31), this.blens, bl, bd, tl, td, this.hufts, zip); if (state.Temp != 0) { if (state.Temp == -3) { this.blens = (int[])null; this.mode = 9; } res = state.Temp; this.TransferBlocksState(zip, state); state.IsReturn = true; return(this.InflateFlush(zip, res)); } this.codes = new InflaterCodes(bl[0], bd[0], this.hufts, tl[0], this.hufts, td[0], zip); this.mode = 6; return(0); }