示例#1
0
		internal int deflateSetDictionary(ZStream strm, byte[] dictionary, int dictLength)
		{
			int length = dictLength;
			int index = 0;
			
			if (dictionary == null || status != INIT_STATE)
				return Z_STREAM_ERROR;
			
			strm.adler = strm._adler.adler32(strm.adler, dictionary, 0, dictLength);
			
			if (length < MIN_MATCH)
				return Z_OK;
			if (length > w_size - MIN_LOOKAHEAD)
			{
				length = w_size - MIN_LOOKAHEAD;
				index = dictLength - length; // use the tail of the dictionary
			}
			Array.Copy(dictionary, index, window, 0, length);
			strstart = length;
			block_start = length;
			
			// Insert all strings in the hash table (except for the last two bytes).
			// s->lookahead stays null, so s->ins_h will be recomputed at the next
			// call of fill_window.
			
			ins_h = window[0] & 0xff;
			ins_h = (((ins_h) << hash_shift) ^ (window[1] & 0xff)) & hash_mask;
			
			for (int n = 0; n <= length - MIN_MATCH; n++)
			{
				ins_h = (((ins_h) << hash_shift) ^ (window[(n) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
				prev[n & w_mask] = head[ins_h];
				head[ins_h] = (short) n;
			}
			return Z_OK;
		}
示例#2
0
		internal int deflate(ZStream strm, int flush)
		{
			int old_flush;
			
			if (flush > Z_FINISH || flush < 0)
			{
				return Z_STREAM_ERROR;
			}
			
			if (strm.next_out == null || (strm.next_in == null && strm.avail_in != 0) || (status == FINISH_STATE && flush != Z_FINISH))
			{
				strm.msg = z_errmsg[Z_NEED_DICT - (Z_STREAM_ERROR)];
				return Z_STREAM_ERROR;
			}
			if (strm.avail_out == 0)
			{
				strm.msg = z_errmsg[Z_NEED_DICT - (Z_BUF_ERROR)];
				return Z_BUF_ERROR;
			}
			
			this.strm = strm; // just in case
			old_flush = last_flush;
			last_flush = flush;
			
			// Write the zlib header
			if (status == INIT_STATE)
			{
				int header = (Z_DEFLATED + ((w_bits - 8) << 4)) << 8;
				int level_flags = ((level - 1) & 0xff) >> 1;
				
				if (level_flags > 3)
					level_flags = 3;
				header |= (level_flags << 6);
				if (strstart != 0)
					header |= PRESET_DICT;
				header += 31 - (header % 31);
				
				status = BUSY_STATE;
				putShortMSB(header);
				
				
				// Save the adler32 of the preset dictionary:
				if (strstart != 0)
				{
					putShortMSB((int) (SupportClass.URShift(strm.adler, 16)));
					putShortMSB((int) (strm.adler & 0xffff));
				}
				strm.adler = strm._adler.adler32(0, null, 0, 0);
			}
			
			// Flush as much pending output as possible
			if (pending != 0)
			{
				strm.flush_pending();
				if (strm.avail_out == 0)
				{
					//System.out.println("  avail_out==0");
					// Since avail_out is 0, deflate will be called again with
					// more output space, but possibly with both pending and
					// avail_in equal to zero. There won't be anything to do,
					// but this is not an error situation so make sure we
					// return OK instead of BUF_ERROR at next call of deflate:
					last_flush = - 1;
					return Z_OK;
				}
				
				// Make sure there is something to do and avoid duplicate consecutive
				// flushes. For repeated and useless calls with Z_FINISH, we keep
				// returning Z_STREAM_END instead of Z_BUFF_ERROR.
			}
			else if (strm.avail_in == 0 && flush <= old_flush && flush != Z_FINISH)
			{
				strm.msg = z_errmsg[Z_NEED_DICT - (Z_BUF_ERROR)];
				return Z_BUF_ERROR;
			}
			
			// User must not provide more input after the first FINISH:
			if (status == FINISH_STATE && strm.avail_in != 0)
			{
				strm.msg = z_errmsg[Z_NEED_DICT - (Z_BUF_ERROR)];
				return Z_BUF_ERROR;
			}
			
			// Start a new block or continue the current one.
			if (strm.avail_in != 0 || lookahead != 0 || (flush != Z_NO_FLUSH && status != FINISH_STATE))
			{
				int bstate = - 1;
				switch (config_table[level].func)
				{
					
					case STORED: 
						bstate = deflate_stored(flush);
						break;
					
					case FAST: 
						bstate = deflate_fast(flush);
						break;
					
					case SLOW: 
						bstate = deflate_slow(flush);
						break;
					
					default: 
						break;
					
				}
				
				if (bstate == FinishStarted || bstate == FinishDone)
				{
					status = FINISH_STATE;
				}
				if (bstate == NeedMore || bstate == FinishStarted)
				{
					if (strm.avail_out == 0)
					{
						last_flush = - 1; // avoid BUF_ERROR next call, see above
					}
					return Z_OK;
					// If flush != Z_NO_FLUSH && avail_out == 0, the next call
					// of deflate should use the same flush parameter to make sure
					// that the flush is complete. So we don't have to output an
					// empty block here, this will be done at next call. This also
					// ensures that for a very small output buffer, we emit at most
					// one empty block.
				}
				
				if (bstate == BlockDone)
				{
					if (flush == Z_PARTIAL_FLUSH)
					{
						_tr_align();
					}
					else
					{
						// FULL_FLUSH or SYNC_FLUSH
						_tr_stored_block(0, 0, false);
						// For a full flush, this empty block will be recognized
						// as a special marker by inflate_sync().
						if (flush == Z_FULL_FLUSH)
						{
							//state.head[s.hash_size-1]=0;
							for (int i = 0; i < hash_size; i++)
							// forget history
								head[i] = 0;
						}
					}
					strm.flush_pending();
					if (strm.avail_out == 0)
					{
						last_flush = - 1; // avoid BUF_ERROR at next call, see above
						return Z_OK;
					}
				}
			}
			
			if (flush != Z_FINISH)
				return Z_OK;
			if (noheader != 0)
				return Z_STREAM_END;
			
			// Write the zlib trailer (adler32)
			putShortMSB((int) (SupportClass.URShift(strm.adler, 16)));
			putShortMSB((int) (strm.adler & 0xffff));
			strm.flush_pending();
			
			// If avail_out is zero, the application will call deflate again
			// to flush the rest.
			noheader = - 1; // write the trailer only once!
			return pending != 0?Z_OK:Z_STREAM_END;
		}
示例#3
0
		internal int deflateReset(ZStream strm)
		{
			strm.total_in = strm.total_out = 0;
			strm.msg = null; //
			strm.data_type = Z_UNKNOWN;
			
			pending = 0;
			pending_out = 0;
			
			if (noheader < 0)
			{
				noheader = 0; // was set to -1 by deflate(..., Z_FINISH);
			}
			status = (noheader != 0)?BUSY_STATE:INIT_STATE;
			strm.adler = strm._adler.adler32(0, null, 0, 0);
			
			last_flush = Z_NO_FLUSH;
			
			tr_init();
			lm_init();
			return Z_OK;
		}
示例#4
0
		internal int deflateParams(ZStream strm, int _level, int _strategy)
		{
			int err = Z_OK;
			
			if (_level == Z_DEFAULT_COMPRESSION)
			{
				_level = 6;
			}
			if (_level < 0 || _level > 9 || _strategy < 0 || _strategy > Z_HUFFMAN_ONLY)
			{
				return Z_STREAM_ERROR;
			}
			
			if (config_table[level].func != config_table[_level].func && strm.total_in != 0)
			{
				// Flush the last buffer:
				err = strm.deflate(Z_PARTIAL_FLUSH);
			}
			
			if (level != _level)
			{
				level = _level;
				max_lazy_match = config_table[level].max_lazy;
				good_match = config_table[level].good_length;
				nice_match = config_table[level].nice_length;
				max_chain_length = config_table[level].max_chain;
			}
			strategy = _strategy;
			return err;
		}
示例#5
0
		internal void  reset(ZStream z, long[] c)
		{
			if (c != null)
				c[0] = check;
			if (mode == BTREE || mode == DTREE)
			{
				blens = null;
			}
			if (mode == CODES)
			{
				codes.free(z);
			}
			mode = TYPE;
			bitk = 0;
			bitb = 0;
			read = write = 0;
			
			if (checkfn != null)
				z.adler = check = z._adler.adler32(0L, null, 0, 0);
		}
示例#6
0
		internal int deflateInit2(ZStream strm, int level, int method, int windowBits, int memLevel, int strategy)
		{
			int noheader = 0;
			//    byte[] my_version=ZLIB_VERSION;
			
			//
			//  if (version == null || version[0] != my_version[0]
			//  || stream_size != sizeof(z_stream)) {
			//  return Z_VERSION_ERROR;
			//  }
			
			strm.msg = null;
			
			if (level == Z_DEFAULT_COMPRESSION)
				level = 6;
			
			if (windowBits < 0)
			{
				// undocumented feature: suppress zlib header
				noheader = 1;
				windowBits = - windowBits;
			}
			
			if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || windowBits < 9 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_HUFFMAN_ONLY)
			{
				return Z_STREAM_ERROR;
			}
			
			strm.dstate = (Deflate) this;
			
			this.noheader = noheader;
			w_bits = windowBits;
			w_size = 1 << w_bits;
			w_mask = w_size - 1;
			
			hash_bits = memLevel + 7;
			hash_size = 1 << hash_bits;
			hash_mask = hash_size - 1;
			hash_shift = ((hash_bits + MIN_MATCH - 1) / MIN_MATCH);
			
			window = new byte[w_size * 2];
			prev = new short[w_size];
			head = new short[hash_size];
			
			lit_bufsize = 1 << (memLevel + 6); // 16K elements by default
			
			// We overlay pending_buf and d_buf+l_buf. This works since the average
			// output size for (length,distance) codes is <= 24 bits.
			pending_buf = new byte[lit_bufsize * 4];
			pending_buf_size = lit_bufsize * 4;
			
			d_buf = lit_bufsize;
			l_buf = (1 + 2) * lit_bufsize;
			
			this.level = level;
			
			//System.out.println("level="+level);
			
			this.strategy = strategy;
			this.method = (byte) method;
			
			return deflateReset(strm);
		}
示例#7
0
		internal static int inflate_trees_fixed(int[] bl, int[] bd, int[][] tl, int[][] td, ZStream z)
		{
			bl[0] = fixed_bl;
			bd[0] = fixed_bd;
			tl[0] = fixed_tl;
			td[0] = fixed_td;
			return Z_OK;
		}
示例#8
0
		internal void  free(ZStream z)
		{
			//  ZFREE(z, c);
		}
示例#9
0
		internal static int inflate_trees_bits(int[] c, int[] bb, int[] tb, int[] hp, ZStream z)
		{
			int r;
			int[] hn = new int[1]; // hufts used in space
			int[] v = new int[19]; // work area for huft_build 
			
			r = huft_build(c, 0, 19, 19, null, null, tb, bb, hp, hn, v);
			
			if (r == Z_DATA_ERROR)
			{
				z.msg = "oversubscribed dynamic bit lengths tree";
			}
			else if (r == Z_BUF_ERROR || bb[0] == 0)
			{
				z.msg = "incomplete dynamic bit lengths tree";
				r = Z_DATA_ERROR;
			}
			return r;
		}
示例#10
0
		internal static int inflate_trees_dynamic(int nl, int nd, int[] c, int[] bl, int[] bd, int[] tl, int[] td, int[] hp, ZStream z)
		{
			int r;
			int[] hn = new int[1]; // hufts used in space
			int[] v = new int[288]; // work area for huft_build
			
			// build literal/length tree
			r = huft_build(c, 0, nl, 257, cplens, cplext, tl, bl, hp, hn, v);
			if (r != Z_OK || bl[0] == 0)
			{
				if (r == Z_DATA_ERROR)
				{
					z.msg = "oversubscribed literal/length tree";
				}
				else if (r != Z_MEM_ERROR)
				{
					z.msg = "incomplete literal/length tree";
					r = Z_DATA_ERROR;
				}
				return r;
			}
			
			// build distance tree
			r = huft_build(c, nl, nd, 0, cpdist, cpdext, td, bd, hp, hn, v);
			
			if (r != Z_OK || (bd[0] == 0 && nl > 257))
			{
				if (r == Z_DATA_ERROR)
				{
					z.msg = "oversubscribed distance tree";
				}
				else if (r == Z_BUF_ERROR)
				{
					z.msg = "incomplete distance tree";
					r = Z_DATA_ERROR;
				}
				else if (r != Z_MEM_ERROR)
				{
					z.msg = "empty distance tree with lengths";
					r = Z_DATA_ERROR;
				}
				return r;
			}
			
			return Z_OK;
		}
示例#11
0
		// copy as much as possible from the sliding window to the output area
		internal int inflate_flush(ZStream z, int r)
		{
			int n;
			int p;
			int q;
			
			// local copies of source and destination pointers
			p = z.next_out_index;
			q = read;
			
			// compute number of bytes to copy as far as end of window
			n = (int) ((q <= write?write:end) - q);
			if (n > z.avail_out)
				n = z.avail_out;
			if (n != 0 && r == Z_BUF_ERROR)
				r = Z_OK;
			
			// update counters
			z.avail_out -= n;
			z.total_out += n;
			
			// update check information
			if (checkfn != null)
				z.adler = check = z._adler.adler32(check, window, q, n);
			
			// copy as far as end of window
			Array.Copy(window, q, z.next_out, p, n);
			p += n;
			q += n;
			
			// see if more to copy at beginning of window
			if (q == end)
			{
				// wrap pointers
				q = 0;
				if (write == end)
					write = 0;
				
				// compute bytes to copy
				n = write - q;
				if (n > z.avail_out)
					n = z.avail_out;
				if (n != 0 && r == Z_BUF_ERROR)
					r = Z_OK;
				
				// update counters
				z.avail_out -= n;
				z.total_out += n;
				
				// update check information
				if (checkfn != null)
					z.adler = check = z._adler.adler32(check, window, q, n);
				
				// copy
				Array.Copy(window, q, z.next_out, p, n);
				p += n;
				q += n;
			}
			
			// update pointers
			z.next_out_index = p;
			read = q;
			
			// done
			return r;
		}
示例#12
0
		internal void  free(ZStream z)
		{
			reset(z, null);
			window = null;
			hufts = null;
			//ZFREE(z, s);
		}
示例#13
0
		internal int proc(ZStream z, int r)
		{
			int t; // temporary storage
			int b; // bit buffer
			int k; // bits in bit buffer
			int p; // input data pointer
			int n; // bytes available there
			int q; // output window write pointer
			int m; // bytes to end of window or read pointer
			
			// copy input/output information to locals (UPDATE macro restores)
			{
				p = z.next_in_index; n = z.avail_in; b = bitb; k = bitk;
			}
			{
				q = write; m = (int) (q < read?read - q - 1:end - q);
			}
			
			// process input based on current state
			while (true)
			{
				switch (mode)
				{
					
					case TYPE: 
						
						while (k < (3))
						{
							if (n != 0)
							{
								r = Z_OK;
							}
							else
							{
								bitb = b; bitk = k;
								z.avail_in = n;
								z.total_in += p - z.next_in_index; z.next_in_index = p;
								write = q;
								return inflate_flush(z, r);
							}
							;
							n--;
							b |= (z.next_in[p++] & 0xff) << k;
							k += 8;
						}
						t = (int) (b & 7);
						last = t & 1;
						
						switch (SupportClass.URShift(t, 1))
						{
							
							case 0:  // stored 
								{
									b = SupportClass.URShift(b, (3)); k -= (3);
								}
								t = k & 7; // go to byte boundary
								
								{
									b = SupportClass.URShift(b, (t)); k -= (t);
								}
								mode = LENS; // get length of stored block
								break;
							
							case 1:  // fixed
								{
									int[] bl = new int[1];
									int[] bd = new int[1];
									int[][] tl = new int[1][];
									int[][] td = new int[1][];
									
									InfTree.inflate_trees_fixed(bl, bd, tl, td, z);
									codes = new InfCodes(bl[0], bd[0], tl[0], td[0], z);
								}
								
								{
									b = SupportClass.URShift(b, (3)); k -= (3);
								}
								
								mode = CODES;
								break;
							
							case 2:  // dynamic
								
								{
									b = SupportClass.URShift(b, (3)); k -= (3);
								}
								
								mode = TABLE;
								break;
							
							case 3:  // illegal
								
								{
									b = SupportClass.URShift(b, (3)); k -= (3);
								}
								mode = BAD;
								z.msg = "invalid block type";
								r = Z_DATA_ERROR;
								
								bitb = b; bitk = k;
								z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
								write = q;
								return inflate_flush(z, r);
							}
						break;
					
					case LENS: 
						
						while (k < (32))
						{
							if (n != 0)
							{
								r = Z_OK;
							}
							else
							{
								bitb = b; bitk = k;
								z.avail_in = n;
								z.total_in += p - z.next_in_index; z.next_in_index = p;
								write = q;
								return inflate_flush(z, r);
							}
							;
							n--;
							b |= (z.next_in[p++] & 0xff) << k;
							k += 8;
						}
						
						if (((SupportClass.URShift((~ b), 16)) & 0xffff) != (b & 0xffff))
						{
							mode = BAD;
							z.msg = "invalid stored block lengths";
							r = Z_DATA_ERROR;
							
							bitb = b; bitk = k;
							z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
							write = q;
							return inflate_flush(z, r);
						}
						left = (b & 0xffff);
						b = k = 0; // dump bits
						mode = left != 0?STORED:(last != 0?DRY:TYPE);
						break;
					
					case STORED: 
						if (n == 0)
						{
							bitb = b; bitk = k;
							z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
							write = q;
							return inflate_flush(z, r);
						}
						
						if (m == 0)
						{
							if (q == end && read != 0)
							{
								q = 0; m = (int) (q < read?read - q - 1:end - q);
							}
							if (m == 0)
							{
								write = q;
								r = inflate_flush(z, r);
								q = write; m = (int) (q < read?read - q - 1:end - q);
								if (q == end && read != 0)
								{
									q = 0; m = (int) (q < read?read - q - 1:end - q);
								}
								if (m == 0)
								{
									bitb = b; bitk = k;
									z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
									write = q;
									return inflate_flush(z, r);
								}
							}
						}
						r = Z_OK;
						
						t = left;
						if (t > n)
							t = n;
						if (t > m)
							t = m;
						Array.Copy(z.next_in, p, window, q, t);
						p += t; n -= t;
						q += t; m -= t;
						if ((left -= t) != 0)
							break;
						mode = last != 0?DRY:TYPE;
						break;
					
					case TABLE: 
						
						while (k < (14))
						{
							if (n != 0)
							{
								r = Z_OK;
							}
							else
							{
								bitb = b; bitk = k;
								z.avail_in = n;
								z.total_in += p - z.next_in_index; z.next_in_index = p;
								write = q;
								return inflate_flush(z, r);
							}
							;
							n--;
							b |= (z.next_in[p++] & 0xff) << k;
							k += 8;
						}
						
						table = t = (b & 0x3fff);
						if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
						{
							mode = BAD;
							z.msg = "too many length or distance symbols";
							r = Z_DATA_ERROR;
							
							bitb = b; bitk = k;
							z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
							write = q;
							return inflate_flush(z, r);
						}
						t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
						blens = new int[t];
						
						{
							b = SupportClass.URShift(b, (14)); k -= (14);
						}
						
						index = 0;
						mode = BTREE;
						goto case BTREE;
					
					case BTREE: 
						while (index < 4 + (SupportClass.URShift(table, 10)))
						{
							while (k < (3))
							{
								if (n != 0)
								{
									r = Z_OK;
								}
								else
								{
									bitb = b; bitk = k;
									z.avail_in = n;
									z.total_in += p - z.next_in_index; z.next_in_index = p;
									write = q;
									return inflate_flush(z, r);
								}
								;
								n--;
								b |= (z.next_in[p++] & 0xff) << k;
								k += 8;
							}
							
							blens[border[index++]] = b & 7;
							
							{
								b = SupportClass.URShift(b, (3)); k -= (3);
							}
						}
						
						while (index < 19)
						{
							blens[border[index++]] = 0;
						}
						
						bb[0] = 7;
						t = InfTree.inflate_trees_bits(blens, bb, tb, hufts, z);
						if (t != Z_OK)
						{
							r = t;
							if (r == Z_DATA_ERROR)
							{
								blens = null;
								mode = BAD;
							}
							
							bitb = b; bitk = k;
							z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
							write = q;
							return inflate_flush(z, r);
						}
						
						index = 0;
						mode = DTREE;
						goto case DTREE;
					
					case DTREE: 
						while (true)
						{
							t = table;
							if (!(index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f)))
							{
								break;
							}
							
							
							int i, j, c;
							
							t = bb[0];
							
							while (k < (t))
							{
								if (n != 0)
								{
									r = Z_OK;
								}
								else
								{
									bitb = b; bitk = k;
									z.avail_in = n;
									z.total_in += p - z.next_in_index; z.next_in_index = p;
									write = q;
									return inflate_flush(z, r);
								}
								;
								n--;
								b |= (z.next_in[p++] & 0xff) << k;
								k += 8;
							}
							
							if (tb[0] == - 1)
							{
								//System.err.println("null...");
							}
							
							t = hufts[(tb[0] + (b & inflate_mask[t])) * 3 + 1];
							c = hufts[(tb[0] + (b & inflate_mask[t])) * 3 + 2];
							
							if (c < 16)
							{
								b = SupportClass.URShift(b, (t)); k -= (t);
								blens[index++] = c;
							}
							else
							{
								// c == 16..18
								i = c == 18?7:c - 14;
								j = c == 18?11:3;
								
								while (k < (t + i))
								{
									if (n != 0)
									{
										r = Z_OK;
									}
									else
									{
										bitb = b; bitk = k;
										z.avail_in = n;
										z.total_in += p - z.next_in_index; z.next_in_index = p;
										write = q;
										return inflate_flush(z, r);
									}
									;
									n--;
									b |= (z.next_in[p++] & 0xff) << k;
									k += 8;
								}
								
								b = SupportClass.URShift(b, (t)); k -= (t);
								
								j += (b & inflate_mask[i]);
								
								b = SupportClass.URShift(b, (i)); k -= (i);
								
								i = index;
								t = table;
								if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || (c == 16 && i < 1))
								{
									blens = null;
									mode = BAD;
									z.msg = "invalid bit length repeat";
									r = Z_DATA_ERROR;
									
									bitb = b; bitk = k;
									z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
									write = q;
									return inflate_flush(z, r);
								}
								
								c = c == 16?blens[i - 1]:0;
								do 
								{
									blens[i++] = c;
								}
								while (--j != 0);
								index = i;
							}
						}
						
						tb[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; // must be <= 9 for lookahead assumptions
							bd[0] = 6; // must be <= 9 for lookahead assumptions
							t = table;
							t = InfTree.inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), blens, bl, bd, tl, td, hufts, z);
							if (t != Z_OK)
							{
								if (t == Z_DATA_ERROR)
								{
									blens = null;
									mode = BAD;
								}
								r = t;
								
								bitb = b; bitk = k;
								z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
								write = q;
								return inflate_flush(z, r);
							}
							
							codes = new InfCodes(bl[0], bd[0], hufts, tl[0], hufts, td[0], z);
						}
						blens = null;
						mode = CODES;
						goto case CODES;
					
					case CODES: 
						bitb = b; bitk = k;
						z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
						write = q;
						
						if ((r = codes.proc(this, z, r)) != Z_STREAM_END)
						{
							return inflate_flush(z, r);
						}
						r = Z_OK;
						codes.free(z);
						
						p = z.next_in_index; n = z.avail_in; b = bitb; k = bitk;
						q = write; m = (int) (q < read?read - q - 1:end - q);
						
						if (last == 0)
						{
							mode = TYPE;
							break;
						}
						mode = DRY;
						goto case DRY;
					
					case DRY: 
						write = q;
						r = inflate_flush(z, r);
						q = write; m = (int) (q < read?read - q - 1:end - q);
						if (read != write)
						{
							bitb = b; bitk = k;
							z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
							write = q;
							return inflate_flush(z, r);
						}
						mode = DONE;
						goto case DONE;
					
					case DONE: 
						r = Z_STREAM_END;
						
						bitb = b; bitk = k;
						z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
						write = q;
						return inflate_flush(z, r);
					
					case BAD: 
						r = Z_DATA_ERROR;
						
						bitb = b; bitk = k;
						z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
						write = q;
						return inflate_flush(z, r);
					
					
					default: 
						r = Z_STREAM_ERROR;
						
						bitb = b; bitk = k;
						z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
						write = q;
						return inflate_flush(z, r);
					
				}
			}
		}
示例#14
0
		internal InfCodes(int bl, int bd, int[] tl, int[] td, ZStream z)
		{
			mode = START;
			lbits = (byte) bl;
			dbits = (byte) bd;
			ltree = tl;
			ltree_index = 0;
			dtree = td;
			dtree_index = 0;
		}
示例#15
0
		internal int deflateInit(ZStream strm, int level, int bits)
		{
			return deflateInit2(strm, level, Z_DEFLATED, bits, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
		}
示例#16
0
		internal int proc(InfBlocks s, ZStream z, int r)
		{
			int j; // temporary storage
			 //int[] t; // temporary pointer
			int tindex; // temporary pointer
			int e; // extra bits or operation
			int b = 0; // bit buffer
			int k = 0; // bits in bit buffer
			int p = 0; // input data pointer
			int n; // bytes available there
			int q; // output window write pointer
			int m; // bytes to end of window or read pointer
			int f; // pointer to copy strings from
			
			// copy input/output information to locals (UPDATE macro restores)
			p = z.next_in_index; n = z.avail_in; b = s.bitb; k = s.bitk;
			q = s.write; m = q < s.read?s.read - q - 1:s.end - q;
			
			// process input and output based on current state
			while (true)
			{
				switch (mode)
				{
					
					// waiting for "i:"=input, "o:"=output, "x:"=nothing
					case START:  // x: set up for LEN
						if (m >= 258 && n >= 10)
						{
							
							s.bitb = b; s.bitk = k;
							z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
							s.write = q;
							r = inflate_fast(lbits, dbits, ltree, ltree_index, dtree, dtree_index, s, z);
							
							p = z.next_in_index; n = z.avail_in; b = s.bitb; k = s.bitk;
							q = s.write; m = q < s.read?s.read - q - 1:s.end - q;
							
							if (r != Z_OK)
							{
								mode = r == Z_STREAM_END?WASH:BADCODE;
								break;
							}
						}
						need = lbits;
						tree = ltree;
						tree_index = ltree_index;
						
						mode = LEN;
						goto case LEN;
					
					case LEN:  // i: get length/literal/eob next
						j = need;
						
						while (k < (j))
						{
							if (n != 0)
								r = Z_OK;
							else
							{
								
								s.bitb = b; s.bitk = k;
								z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
								s.write = q;
								return s.inflate_flush(z, r);
							}
							n--;
							b |= (z.next_in[p++] & 0xff) << k;
							k += 8;
						}
						
						tindex = (tree_index + (b & inflate_mask[j])) * 3;
						
						b = SupportClass.URShift(b, (tree[tindex + 1]));
						k -= (tree[tindex + 1]);
						
						e = tree[tindex];
						
						if (e == 0)
						{
							// literal
							lit = tree[tindex + 2];
							mode = LIT;
							break;
						}
						if ((e & 16) != 0)
						{
							// length
							get_Renamed = e & 15;
							len = tree[tindex + 2];
							mode = LENEXT;
							break;
						}
						if ((e & 64) == 0)
						{
							// next table
							need = e;
							tree_index = tindex / 3 + tree[tindex + 2];
							break;
						}
						if ((e & 32) != 0)
						{
							// end of block
							mode = WASH;
							break;
						}
						mode = BADCODE; // invalid code
						z.msg = "invalid literal/length code";
						r = Z_DATA_ERROR;
						
						s.bitb = b; s.bitk = k;
						z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
						s.write = q;
						return s.inflate_flush(z, r);
					
					
					case LENEXT:  // i: getting length extra (have base)
						j = get_Renamed;
						
						while (k < (j))
						{
							if (n != 0)
								r = Z_OK;
							else
							{
								
								s.bitb = b; s.bitk = k;
								z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
								s.write = q;
								return s.inflate_flush(z, r);
							}
							n--; b |= (z.next_in[p++] & 0xff) << k;
							k += 8;
						}
						
						len += (b & inflate_mask[j]);
						
						b >>= j;
						k -= j;
						
						need = dbits;
						tree = dtree;
						tree_index = dtree_index;
						mode = DIST;
						goto case DIST;
					
					case DIST:  // i: get distance next
						j = need;
						
						while (k < (j))
						{
							if (n != 0)
								r = Z_OK;
							else
							{
								
								s.bitb = b; s.bitk = k;
								z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
								s.write = q;
								return s.inflate_flush(z, r);
							}
							n--; b |= (z.next_in[p++] & 0xff) << k;
							k += 8;
						}
						
						tindex = (tree_index + (b & inflate_mask[j])) * 3;
						
						b >>= tree[tindex + 1];
						k -= tree[tindex + 1];
						
						e = (tree[tindex]);
						if ((e & 16) != 0)
						{
							// distance
							get_Renamed = e & 15;
							dist = tree[tindex + 2];
							mode = DISTEXT;
							break;
						}
						if ((e & 64) == 0)
						{
							// next table
							need = e;
							tree_index = tindex / 3 + tree[tindex + 2];
							break;
						}
						mode = BADCODE; // invalid code
						z.msg = "invalid distance code";
						r = Z_DATA_ERROR;
						
						s.bitb = b; s.bitk = k;
						z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
						s.write = q;
						return s.inflate_flush(z, r);
					
					
					case DISTEXT:  // i: getting distance extra
						j = get_Renamed;
						
						while (k < (j))
						{
							if (n != 0)
								r = Z_OK;
							else
							{
								
								s.bitb = b; s.bitk = k;
								z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
								s.write = q;
								return s.inflate_flush(z, r);
							}
							n--; b |= (z.next_in[p++] & 0xff) << k;
							k += 8;
						}
						
						dist += (b & inflate_mask[j]);
						
						b >>= j;
						k -= j;
						
						mode = COPY;
						goto case COPY;
					
					case COPY:  // o: copying bytes in window, waiting for space
						f = q - dist;
						while (f < 0)
						{
							// modulo window size-"while" instead
							f += s.end; // of "if" handles invalid distances
						}
						while (len != 0)
						{
							
							if (m == 0)
							{
								if (q == s.end && s.read != 0)
								{
									q = 0; m = q < s.read?s.read - q - 1:s.end - q;
								}
								if (m == 0)
								{
									s.write = q; r = s.inflate_flush(z, r);
									q = s.write; m = q < s.read?s.read - q - 1:s.end - q;
									
									if (q == s.end && s.read != 0)
									{
										q = 0; m = q < s.read?s.read - q - 1:s.end - q;
									}
									
									if (m == 0)
									{
										s.bitb = b; s.bitk = k;
										z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
										s.write = q;
										return s.inflate_flush(z, r);
									}
								}
							}
							
							s.window[q++] = s.window[f++]; m--;
							
							if (f == s.end)
								f = 0;
							len--;
						}
						mode = START;
						break;
					
					case LIT:  // o: got literal, waiting for output space
						if (m == 0)
						{
							if (q == s.end && s.read != 0)
							{
								q = 0; m = q < s.read?s.read - q - 1:s.end - q;
							}
							if (m == 0)
							{
								s.write = q; r = s.inflate_flush(z, r);
								q = s.write; m = q < s.read?s.read - q - 1:s.end - q;
								
								if (q == s.end && s.read != 0)
								{
									q = 0; m = q < s.read?s.read - q - 1:s.end - q;
								}
								if (m == 0)
								{
									s.bitb = b; s.bitk = k;
									z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
									s.write = q;
									return s.inflate_flush(z, r);
								}
							}
						}
						r = Z_OK;
						
						s.window[q++] = (byte) lit; m--;
						
						mode = START;
						break;
					
					case WASH:  // o: got eob, possibly more output
						if (k > 7)
						{
							// return unused byte, if any
							k -= 8;
							n++;
							p--; // can always return one
						}
						
						s.write = q; r = s.inflate_flush(z, r);
						q = s.write; m = q < s.read?s.read - q - 1:s.end - q;
						
						if (s.read != s.write)
						{
							s.bitb = b; s.bitk = k;
							z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
							s.write = q;
							return s.inflate_flush(z, r);
						}
						mode = END;
						goto case END;
					
					case END: 
						r = Z_STREAM_END;
						s.bitb = b; s.bitk = k;
						z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
						s.write = q;
						return s.inflate_flush(z, r);
					
					
					case BADCODE:  // x: got error
						
						r = Z_DATA_ERROR;
						
						s.bitb = b; s.bitk = k;
						z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
						s.write = q;
						return s.inflate_flush(z, r);
					
					
					default: 
						r = Z_STREAM_ERROR;
						
						s.bitb = b; s.bitk = k;
						z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
						s.write = q;
						return s.inflate_flush(z, r);
					
				}
			}
		}
示例#17
0
		internal int deflateInit(ZStream strm, int level)
		{
			return deflateInit(strm, level, MAX_WBITS);
		}
示例#18
0
		// Called with number of bytes left to write in window at least 258
		// (the maximum string length) and number of input bytes available
		// at least ten.  The ten bytes are six bytes for the longest length/
		// distance pair plus four bytes for overloading the bit buffer.
		
		internal int inflate_fast(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index, InfBlocks s, ZStream z)
		{
			int t; // temporary pointer
			int[] tp; // temporary pointer
			int tp_index; // temporary pointer
			int e; // extra bits or operation
			int b; // bit buffer
			int k; // bits in bit buffer
			int p; // input data pointer
			int n; // bytes available there
			int q; // output window write pointer
			int m; // bytes to end of window or read pointer
			int ml; // mask for literal/length tree
			int md; // mask for distance tree
			int c; // bytes to copy
			int d; // distance back to copy from
			int r; // copy source pointer
			
			// load input, output, bit values
			p = z.next_in_index; n = z.avail_in; b = s.bitb; k = s.bitk;
			q = s.write; m = q < s.read?s.read - q - 1:s.end - q;
			
			// initialize masks
			ml = inflate_mask[bl];
			md = inflate_mask[bd];
			
			// do until not enough input or output space for fast loop
			do 
			{
				// assume called with m >= 258 && n >= 10
				// get literal/length code
				while (k < (20))
				{
					// max bits for literal/length code
					n--;
					b |= (z.next_in[p++] & 0xff) << k; k += 8;
				}
				
				t = b & ml;
				tp = tl;
				tp_index = tl_index;
				if ((e = tp[(tp_index + t) * 3]) == 0)
				{
					b >>= (tp[(tp_index + t) * 3 + 1]); k -= (tp[(tp_index + t) * 3 + 1]);
					
					s.window[q++] = (byte) tp[(tp_index + t) * 3 + 2];
					m--;
					continue;
				}
				do 
				{
					
					b >>= (tp[(tp_index + t) * 3 + 1]); k -= (tp[(tp_index + t) * 3 + 1]);
					
					if ((e & 16) != 0)
					{
						e &= 15;
						c = tp[(tp_index + t) * 3 + 2] + ((int) b & inflate_mask[e]);
						
						b >>= e; k -= e;
						
						// decode distance base of block to copy
						while (k < (15))
						{
							// max bits for distance code
							n--;
							b |= (z.next_in[p++] & 0xff) << k; k += 8;
						}
						
						t = b & md;
						tp = td;
						tp_index = td_index;
						e = tp[(tp_index + t) * 3];
						
						do 
						{
							
							b >>= (tp[(tp_index + t) * 3 + 1]); k -= (tp[(tp_index + t) * 3 + 1]);
							
							if ((e & 16) != 0)
							{
								// get extra bits to add to distance base
								e &= 15;
								while (k < (e))
								{
									// get extra bits (up to 13)
									n--;
									b |= (z.next_in[p++] & 0xff) << k; k += 8;
								}
								
								d = tp[(tp_index + t) * 3 + 2] + (b & inflate_mask[e]);
								
								b >>= (e); k -= (e);
								
								// do the copy
								m -= c;
								if (q >= d)
								{
									// offset before dest
									//  just copy
									r = q - d;
									if (q - r > 0 && 2 > (q - r))
									{
										s.window[q++] = s.window[r++]; c--; // minimum count is three,
										s.window[q++] = s.window[r++]; c--; // so unroll loop a little
									}
									else
									{
										Array.Copy(s.window, r, s.window, q, 2);
										q += 2; r += 2; c -= 2;
									}
								}
								else
								{
									// else offset after destination
									r = q - d;
									do 
									{
										r += s.end; // force pointer in window
									}
									while (r < 0); // covers invalid distances
									e = s.end - r;
									if (c > e)
									{
										// if source crosses,
										c -= e; // wrapped copy
										if (q - r > 0 && e > (q - r))
										{
											do 
											{
												s.window[q++] = s.window[r++];
											}
											while (--e != 0);
										}
										else
										{
											Array.Copy(s.window, r, s.window, q, e);
											q += e; r += e; e = 0;
										}
										r = 0; // copy rest from start of window
									}
								}
								
								// copy all or what's left
								if (q - r > 0 && c > (q - r))
								{
									do 
									{
										s.window[q++] = s.window[r++];
									}
									while (--c != 0);
								}
								else
								{
									Array.Copy(s.window, r, s.window, q, c);
									q += c; r += c; c = 0;
								}
								break;
							}
							else if ((e & 64) == 0)
							{
								t += tp[(tp_index + t) * 3 + 2];
								t += (b & inflate_mask[e]);
								e = tp[(tp_index + t) * 3];
							}
							else
							{
								z.msg = "invalid distance code";
								
								c = z.avail_in - n; c = (k >> 3) < c?k >> 3:c; n += c; p -= c; k -= (c << 3);
								
								s.bitb = b; s.bitk = k;
								z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
								s.write = q;
								
								return Z_DATA_ERROR;
							}
						}
						while (true);
						break;
					}
					
					if ((e & 64) == 0)
					{
						t += tp[(tp_index + t) * 3 + 2];
						t += (b & inflate_mask[e]);
						if ((e = tp[(tp_index + t) * 3]) == 0)
						{
							
							b >>= (tp[(tp_index + t) * 3 + 1]); k -= (tp[(tp_index + t) * 3 + 1]);
							
							s.window[q++] = (byte) tp[(tp_index + t) * 3 + 2];
							m--;
							break;
						}
					}
					else if ((e & 32) != 0)
					{
						
						c = z.avail_in - n; c = (k >> 3) < c?k >> 3:c; n += c; p -= c; k -= (c << 3);
						
						s.bitb = b; s.bitk = k;
						z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
						s.write = q;
						
						return Z_STREAM_END;
					}
					else
					{
						z.msg = "invalid literal/length code";
						
						c = z.avail_in - n; c = (k >> 3) < c?k >> 3:c; n += c; p -= c; k -= (c << 3);
						
						s.bitb = b; s.bitk = k;
						z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
						s.write = q;
						
						return Z_DATA_ERROR;
					}
				}
				while (true);
			}
			while (m >= 258 && n >= 10);
			
			// not enough input or output--restore pointers and return
			c = z.avail_in - n; c = (k >> 3) < c?k >> 3:c; n += c; p -= c; k -= (c << 3);
			
			s.bitb = b; s.bitk = k;
			z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p;
			s.write = q;
			
			return Z_OK;
		}
示例#19
0
		internal long check; // check on output 
		
		internal InfBlocks(ZStream z, System.Object checkfn, int w)
		{
			hufts = new int[MANY * 3];
			window = new byte[w];
			end = w;
			this.checkfn = checkfn;
			mode = TYPE;
			reset(z, null);
		}