internal int deflate(ZStream strm, int flush)
        {
            if (flush > 4 || flush < 0)
            {
                return(-2);
            }
            if (strm.next_out == null || (strm.next_in == null && strm.avail_in != 0) || (this.status == 666 && flush != 4))
            {
                strm.msg = Deflate.z_errmsg[4];
                return(-2);
            }
            if (strm.avail_out == 0)
            {
                strm.msg = Deflate.z_errmsg[7];
                return(-5);
            }
            this.strm = strm;
            int num = this.last_flush;

            this.last_flush = flush;
            if (this.status == 42)
            {
                int num2 = 8 + (this.w_bits - 8 << 4) << 8;
                int num3 = (this.level - 1 & 255) >> 1;
                if (num3 > 3)
                {
                    num3 = 3;
                }
                num2 |= num3 << 6;
                if (this.strstart != 0)
                {
                    num2 |= 32;
                }
                num2       += 31 - num2 % 31;
                this.status = 113;
                this.putShortMSB(num2);
                if (this.strstart != 0)
                {
                    this.putShortMSB((int)SupportClass.URShift(strm.adler, 16));
                    this.putShortMSB((int)(strm.adler & 65535L));
                }
                strm.adler = strm._adler.adler32(0L, null, 0, 0);
            }
            if (this.pending != 0)
            {
                strm.flush_pending();
                if (strm.avail_out == 0)
                {
                    this.last_flush = -1;
                    return(0);
                }
            }
            else if (strm.avail_in == 0 && flush <= num && flush != 4)
            {
                strm.msg = Deflate.z_errmsg[7];
                return(-5);
            }
            if (this.status == 666 && strm.avail_in != 0)
            {
                strm.msg = Deflate.z_errmsg[7];
                return(-5);
            }
            if (strm.avail_in != 0 || this.lookahead != 0 || (flush != 0 && this.status != 666))
            {
                int num4 = -1;
                switch (Deflate.config_table[this.level].func)
                {
                case 0:
                    num4 = this.deflate_stored(flush);
                    break;

                case 1:
                    num4 = this.deflate_fast(flush);
                    break;

                case 2:
                    num4 = this.deflate_slow(flush);
                    break;
                }
                if (num4 == 2 || num4 == 3)
                {
                    this.status = 666;
                }
                if (num4 == 0 || num4 == 2)
                {
                    if (strm.avail_out == 0)
                    {
                        this.last_flush = -1;
                    }
                    return(0);
                }
                if (num4 == 1)
                {
                    if (flush == 1)
                    {
                        this._tr_align();
                    }
                    else
                    {
                        this._tr_stored_block(0, 0, false);
                        if (flush == 3)
                        {
                            for (int i = 0; i < this.hash_size; i++)
                            {
                                this.head[i] = 0;
                            }
                        }
                    }
                    strm.flush_pending();
                    if (strm.avail_out == 0)
                    {
                        this.last_flush = -1;
                        return(0);
                    }
                }
            }
            if (flush != 4)
            {
                return(0);
            }
            if (this.noheader != 0)
            {
                return(1);
            }
            this.putShortMSB((int)SupportClass.URShift(strm.adler, 16));
            this.putShortMSB((int)(strm.adler & 65535L));
            strm.flush_pending();
            this.noheader = -1;
            if (this.pending == 0)
            {
                return(1);
            }
            return(0);
        }
Exemple #2
0
        internal int deflate(ZStream strm, int flush)
        {
            if ((flush > 4) || (flush < 0))
            {
                return -2;
            }
            if (((strm.next_out == null) || ((strm.next_in == null) && (strm.avail_in != 0))) || ((this.status == 0x29a) && (flush != 4)))
            {
                strm.msg = Deflate.z_errmsg[4];
                return -2;
            }
            if (strm.avail_out == 0)
            {
                strm.msg = Deflate.z_errmsg[7];
                return -5;
            }
            this.strm = strm;
            int num1 = this.last_flush;
            this.last_flush = flush;
            if (this.status == 0x2a)
            {
                int num2 = (8 + ((this.w_bits - 8) << 4)) << 8;
                int num3 = ((this.level - 1) & 0xff) >> 1;
                if (num3 > 3)
                {
                    num3 = 3;
                }
                num2 |= num3 << 6;
                if (this.strstart != 0)
                {
                    num2 |= 0x20;
                }
                num2 += 0x1f - (num2 % 0x1f);
                this.status = 0x71;
                this.putShortMSB(num2);
                if (this.strstart != 0)
                {
                    this.putShortMSB((int) SupportClass.URShift(strm.adler, 0x10));
                    this.putShortMSB(((int) strm.adler) & 0xffff);
                }
                strm.adler = strm._adler.adler32((long) 0, null, 0, 0);
            }
            if (this.pending != 0)
            {
                strm.flush_pending();
                if (strm.avail_out == 0)
                {
                    this.last_flush = -1;
                    return 0;
                }
            }
            else if (((strm.avail_in == 0) && (flush <= num1)) && (flush != 4))
            {
                strm.msg = Deflate.z_errmsg[7];
                return -5;
            }
            if ((this.status == 0x29a) && (strm.avail_in != 0))
            {
                strm.msg = Deflate.z_errmsg[7];
                return -5;
            }
            if (((strm.avail_in != 0) || (this.lookahead != 0)) || ((flush != 0) && (this.status != 0x29a)))
            {
                int num4 = -1;
                switch (Deflate.config_table[this.level].func)
                {
                    case 0:
                        num4 = this.deflate_stored(flush);
                        break;

                    case 1:
                        num4 = this.deflate_fast(flush);
                        break;

                    case 2:
                        num4 = this.deflate_slow(flush);
                        break;
                }
                switch (num4)
                {
                    case 2:
                    case 3:
                        this.status = 0x29a;
                        break;
                }
                switch (num4)
                {
                    case 0:
                    case 2:
                        if (strm.avail_out == 0)
                        {
                            this.last_flush = -1;
                        }
                        return 0;

                    default:
                        if (num4 == 1)
                        {
                            if (flush == 1)
                            {
                                this._tr_align();
                            }
                            else
                            {
                                this._tr_stored_block(0, 0, false);
                                if (flush == 3)
                                {
                                    for (int num5 = 0; num5 < this.hash_size; num5++)
                                    {
                                        this.head[num5] = 0;
                                    }
                                }
                            }
                            strm.flush_pending();
                            if (strm.avail_out == 0)
                            {
                                this.last_flush = -1;
                                return 0;
                            }
                        }
                        break;
                }
            }
            if (flush == 4)
            {
                if (this.noheader != 0)
                {
                    return 1;
                }
                this.putShortMSB((int) SupportClass.URShift(strm.adler, 0x10));
                this.putShortMSB(((int) strm.adler) & 0xffff);
                strm.flush_pending();
                this.noheader = -1;
                if (this.pending == 0)
                {
                    return 1;
                }
            }
            return 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;
		}
Exemple #4
0
        internal int deflate(ZStream strm, int flush)
        {
            if ((flush > 4) || (flush < 0))
            {
                return(-2);
            }
            if (((strm.next_out == null) || ((strm.next_in == null) && (strm.avail_in != 0))) || ((this.status == 0x29a) && (flush != 4)))
            {
                strm.msg = Deflate.z_errmsg[4];
                return(-2);
            }
            if (strm.avail_out == 0)
            {
                strm.msg = Deflate.z_errmsg[7];
                return(-5);
            }
            this.strm = strm;
            int num1 = this.last_flush;

            this.last_flush = flush;
            if (this.status == 0x2a)
            {
                int num2 = (8 + ((this.w_bits - 8) << 4)) << 8;
                int num3 = ((this.level - 1) & 0xff) >> 1;
                if (num3 > 3)
                {
                    num3 = 3;
                }
                num2 |= num3 << 6;
                if (this.strstart != 0)
                {
                    num2 |= 0x20;
                }
                num2       += 0x1f - (num2 % 0x1f);
                this.status = 0x71;
                this.putShortMSB(num2);
                if (this.strstart != 0)
                {
                    this.putShortMSB((int)SupportClass.URShift(strm.adler, 0x10));
                    this.putShortMSB(((int)strm.adler) & 0xffff);
                }
                strm.adler = strm._adler.adler32((long)0, null, 0, 0);
            }
            if (this.pending != 0)
            {
                strm.flush_pending();
                if (strm.avail_out == 0)
                {
                    this.last_flush = -1;
                    return(0);
                }
            }
            else if (((strm.avail_in == 0) && (flush <= num1)) && (flush != 4))
            {
                strm.msg = Deflate.z_errmsg[7];
                return(-5);
            }
            if ((this.status == 0x29a) && (strm.avail_in != 0))
            {
                strm.msg = Deflate.z_errmsg[7];
                return(-5);
            }
            if (((strm.avail_in != 0) || (this.lookahead != 0)) || ((flush != 0) && (this.status != 0x29a)))
            {
                int num4 = -1;
                switch (Deflate.config_table[this.level].func)
                {
                case 0:
                    num4 = this.deflate_stored(flush);
                    break;

                case 1:
                    num4 = this.deflate_fast(flush);
                    break;

                case 2:
                    num4 = this.deflate_slow(flush);
                    break;
                }
                switch (num4)
                {
                case 2:
                case 3:
                    this.status = 0x29a;
                    break;
                }
                switch (num4)
                {
                case 0:
                case 2:
                    if (strm.avail_out == 0)
                    {
                        this.last_flush = -1;
                    }
                    return(0);

                default:
                    if (num4 == 1)
                    {
                        if (flush == 1)
                        {
                            this._tr_align();
                        }
                        else
                        {
                            this._tr_stored_block(0, 0, false);
                            if (flush == 3)
                            {
                                for (int num5 = 0; num5 < this.hash_size; num5++)
                                {
                                    this.head[num5] = 0;
                                }
                            }
                        }
                        strm.flush_pending();
                        if (strm.avail_out == 0)
                        {
                            this.last_flush = -1;
                            return(0);
                        }
                    }
                    break;
                }
            }
            if (flush == 4)
            {
                if (this.noheader != 0)
                {
                    return(1);
                }
                this.putShortMSB((int)SupportClass.URShift(strm.adler, 0x10));
                this.putShortMSB(((int)strm.adler) & 0xffff);
                strm.flush_pending();
                this.noheader = -1;
                if (this.pending == 0)
                {
                    return(1);
                }
            }
            return(0);
        }