mirror of
https://github.com/moparisthebest/k-9
synced 2024-10-31 15:45:08 -04:00
Fixes Issue 1224
Implement DEFLATE compression for IMAP communication, enabled by default. User can disable compression for Wi-Fi, Mobile, or Other networks, if it causes problems or if uncompressed communication is faster, which is possible on Wi-Fi and wired networks, especially. "Other" is to allow for the Android platform to introduce new networking types without having to immediately change K-9 Mail. However, as those arise, new network types should be added as explicit types in K-9 Mail.
This commit is contained in:
parent
c0e4220b82
commit
ecc10e572f
@ -332,6 +332,11 @@ Welcome to K-9 Mail setup. K-9 is an open source mail client for Android origin
|
||||
<string name="account_setup_incoming_delete_policy_delete_label">Delete from server</string>
|
||||
<string name="account_setup_incoming_delete_policy_markread_label">Mark as read on server</string>
|
||||
|
||||
<string name="account_setup_incoming_compression_label">Use compression on network:</string>
|
||||
<string name="account_setup_incoming_mobile_label">Mobile</string>
|
||||
<string name="account_setup_incoming_wifi_label">Wi-Fi</string>
|
||||
<string name="account_setup_incoming_other_label">Other</string>
|
||||
|
||||
<string name="account_setup_expunge_policy_label">Expunge messages</string>
|
||||
<string name="account_setup_expunge_policy_immediately">Immediately after delete or move</string>
|
||||
<string name="account_setup_expunge_policy_on_poll">During each poll</string>
|
||||
|
@ -3,6 +3,7 @@ package com.fsck.k9;
|
||||
|
||||
import android.content.Context;
|
||||
import android.content.SharedPreferences;
|
||||
import android.net.ConnectivityManager;
|
||||
import android.net.Uri;
|
||||
import com.fsck.k9.mail.Address;
|
||||
import com.fsck.k9.mail.Folder;
|
||||
@ -12,8 +13,11 @@ import com.fsck.k9.mail.store.LocalStore;
|
||||
import com.fsck.k9.mail.store.LocalStore.LocalFolder;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
/**
|
||||
* Account stores all of the settings for a single account defined by the user. It is able to save
|
||||
@ -30,6 +34,11 @@ public class Account
|
||||
public static final int DELETE_POLICY_ON_DELETE = 2;
|
||||
public static final int DELETE_POLICY_MARK_AS_READ = 3;
|
||||
|
||||
public static final String TYPE_WIFI = "WIFI";
|
||||
public static final String TYPE_MOBILE = "MOBILE";
|
||||
public static final String TYPE_OTHER = "OTHER";
|
||||
private static String[] networkTypes = { TYPE_WIFI, TYPE_MOBILE, TYPE_OTHER };
|
||||
|
||||
/**
|
||||
* <pre>
|
||||
* 0 - Never (DELETE_POLICY_NEVER)
|
||||
@ -69,6 +78,7 @@ public class Account
|
||||
private boolean mIsSignatureBeforeQuotedText;
|
||||
private String mExpungePolicy = EXPUNGE_IMMEDIATELY;
|
||||
private int mMaxPushFolders;
|
||||
private Map<String, Boolean> compressionMap = new ConcurrentHashMap<String, Boolean>();
|
||||
|
||||
private List<Identity> identities;
|
||||
|
||||
@ -158,6 +168,13 @@ public class Account
|
||||
|
||||
mMaxPushFolders = preferences.getPreferences().getInt(mUuid + ".maxPushFolders", 10);
|
||||
|
||||
for (String type : networkTypes)
|
||||
{
|
||||
Boolean useCompression = preferences.getPreferences().getBoolean(mUuid + ".useCompression." + type,
|
||||
true);
|
||||
compressionMap.put(type, useCompression);
|
||||
}
|
||||
|
||||
// Between r418 and r431 (version 0.103), folder names were set empty if the Incoming settings were
|
||||
// opened for non-IMAP accounts. 0.103 was never a market release, so perhaps this code
|
||||
// should be deleted sometime soon
|
||||
@ -292,6 +309,10 @@ public class Account
|
||||
editor.remove(mUuid + ".signatureBeforeQuotedText");
|
||||
editor.remove(mUuid + ".expungePolicy");
|
||||
editor.remove(mUuid + ".maxPushFolders");
|
||||
for (String type : networkTypes)
|
||||
{
|
||||
editor.remove(mUuid + ".useCompression." + type);
|
||||
}
|
||||
deleteIdentities(preferences.getPreferences(), editor);
|
||||
editor.commit();
|
||||
}
|
||||
@ -364,6 +385,14 @@ public class Account
|
||||
editor.putBoolean(mUuid + ".signatureBeforeQuotedText", this.mIsSignatureBeforeQuotedText);
|
||||
editor.putString(mUuid + ".expungePolicy", mExpungePolicy);
|
||||
editor.putInt(mUuid + ".maxPushFolders", mMaxPushFolders);
|
||||
for (String type : networkTypes)
|
||||
{
|
||||
Boolean useCompression = compressionMap.get(type);
|
||||
if (useCompression != null)
|
||||
{
|
||||
editor.putBoolean(mUuid + ".useCompression." + type, useCompression);
|
||||
}
|
||||
}
|
||||
saveIdentities(preferences.getPreferences(), editor);
|
||||
|
||||
editor.commit();
|
||||
@ -810,6 +839,39 @@ public class Account
|
||||
return mDescription;
|
||||
}
|
||||
|
||||
public void setCompression(String networkType, boolean useCompression)
|
||||
{
|
||||
compressionMap.put(networkType, useCompression);
|
||||
}
|
||||
|
||||
public boolean useCompression(String networkType)
|
||||
{
|
||||
Boolean useCompression = compressionMap.get(networkType);
|
||||
if (useCompression == null)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
return useCompression;
|
||||
}
|
||||
}
|
||||
|
||||
public boolean useCompression(int type)
|
||||
{
|
||||
String networkType = TYPE_OTHER;
|
||||
switch (type)
|
||||
{
|
||||
case ConnectivityManager.TYPE_MOBILE:
|
||||
networkType = TYPE_MOBILE;
|
||||
break;
|
||||
case ConnectivityManager.TYPE_WIFI:
|
||||
networkType = TYPE_WIFI;
|
||||
break;
|
||||
}
|
||||
return useCompression(networkType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o)
|
||||
{
|
||||
|
@ -11,6 +11,7 @@ import android.util.Log;
|
||||
import android.view.View;
|
||||
import android.view.View.OnClickListener;
|
||||
import android.widget.*;
|
||||
|
||||
import com.fsck.k9.*;
|
||||
import com.fsck.k9.activity.ChooseFolder;
|
||||
import java.io.UnsupportedEncodingException;
|
||||
@ -79,6 +80,9 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
|
||||
private Button mNextButton;
|
||||
private Account mAccount;
|
||||
private boolean mMakeDefault;
|
||||
private CheckBox compressionMobile;
|
||||
private CheckBox compressionWifi;
|
||||
private CheckBox compressionOther;
|
||||
|
||||
public static void actionIncomingSettings(Activity context, Account account, boolean makeDefault)
|
||||
{
|
||||
@ -118,6 +122,9 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
|
||||
mWebdavAuthPathView = (EditText)findViewById(R.id.webdav_auth_path);
|
||||
mWebdavMailboxPathView = (EditText)findViewById(R.id.webdav_mailbox_path);
|
||||
mNextButton = (Button)findViewById(R.id.next);
|
||||
compressionMobile = (CheckBox)findViewById(R.id.compression_mobile);
|
||||
compressionWifi = (CheckBox)findViewById(R.id.compression_wifi);
|
||||
compressionOther = (CheckBox)findViewById(R.id.compression_other);
|
||||
|
||||
mImapFolderDrafts.setOnClickListener(this);
|
||||
mImapFolderSent.setOnClickListener(this);
|
||||
@ -279,6 +286,7 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
|
||||
findViewById(R.id.webdav_path_prefix_section).setVisibility(View.GONE);
|
||||
findViewById(R.id.webdav_path_debug_section).setVisibility(View.GONE);
|
||||
findViewById(R.id.account_auth_type).setVisibility(View.GONE);
|
||||
findViewById(R.id.compression_section).setVisibility(View.GONE);
|
||||
mAccount.setDeletePolicy(Account.DELETE_POLICY_NEVER);
|
||||
|
||||
|
||||
@ -312,6 +320,7 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
|
||||
/** Hide the unnecessary fields */
|
||||
findViewById(R.id.imap_path_prefix_section).setVisibility(View.GONE);
|
||||
findViewById(R.id.account_auth_type).setVisibility(View.GONE);
|
||||
findViewById(R.id.compression_section).setVisibility(View.GONE);
|
||||
if (uri.getPath() != null && uri.getPath().length() > 0)
|
||||
{
|
||||
String[] pathParts = uri.getPath().split("\\|");
|
||||
@ -358,7 +367,9 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
|
||||
SpinnerOption.setSpinnerOptionValue(mSecurityTypeView, i);
|
||||
}
|
||||
}
|
||||
|
||||
compressionMobile.setChecked(mAccount.useCompression(Account.TYPE_MOBILE));
|
||||
compressionWifi.setChecked(mAccount.useCompression(Account.TYPE_WIFI));
|
||||
compressionOther.setChecked(mAccount.useCompression(Account.TYPE_OTHER));
|
||||
if (uri.getHost() != null)
|
||||
{
|
||||
mServerView.setText(uri.getHost());
|
||||
@ -518,6 +529,9 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
|
||||
mAccount.setSentFolderName(mImapFolderSent.getText().toString());
|
||||
mAccount.setTrashFolderName(mImapFolderTrash.getText().toString());
|
||||
mAccount.setOutboxFolderName(mImapFolderOutbox.getText().toString());
|
||||
mAccount.setCompression(Account.TYPE_MOBILE, compressionMobile.isChecked());
|
||||
mAccount.setCompression(Account.TYPE_WIFI, compressionWifi.isChecked());
|
||||
mAccount.setCompression(Account.TYPE_OTHER, compressionOther.isChecked());
|
||||
AccountSetupCheckSettings.actionCheckSettings(this, mAccount, true, false);
|
||||
}
|
||||
catch (Exception e)
|
||||
|
@ -1,8 +1,10 @@
|
||||
|
||||
package com.fsck.k9.mail.store;
|
||||
|
||||
import android.content.Context;
|
||||
import android.net.ConnectivityManager;
|
||||
import android.net.NetworkInfo;
|
||||
import android.util.Log;
|
||||
|
||||
import com.fsck.k9.Account;
|
||||
import com.fsck.k9.K9;
|
||||
import com.fsck.k9.PeekableInputStream;
|
||||
@ -13,6 +15,9 @@ import com.fsck.k9.mail.store.ImapResponseParser.ImapList;
|
||||
import com.fsck.k9.mail.store.ImapResponseParser.ImapResponse;
|
||||
import com.fsck.k9.mail.transport.CountingOutputStream;
|
||||
import com.fsck.k9.mail.transport.EOLConvertingOutputStream;
|
||||
import com.jcraft.jzlib.JZlib;
|
||||
import com.jcraft.jzlib.ZInputStream;
|
||||
import com.jcraft.jzlib.ZOutputStream;
|
||||
import com.beetstra.jutf7.CharsetProvider;
|
||||
|
||||
import javax.net.ssl.SSLContext;
|
||||
@ -68,6 +73,9 @@ public class ImapStore extends Store
|
||||
private static final String CAPABILITY_CAPABILITY = "CAPABILITY";
|
||||
private static final String COMMAND_CAPABILITY = "CAPABILITY";
|
||||
|
||||
private static final String CAPABILITY_COMPRESS_DEFLATE = "COMPRESS=DEFLATE";
|
||||
private static final String COMMAND_COMPRESS_DEFLATE = "COMPRESS DEFLATE";
|
||||
|
||||
private String mHost;
|
||||
private int mPort;
|
||||
private String mUsername;
|
||||
@ -100,11 +108,12 @@ public class ImapStore extends Store
|
||||
* imap+tls+://auth:user:password@server:port CONNECTION_SECURITY_TLS_REQUIRED
|
||||
* imap+ssl+://auth:user:password@server:port CONNECTION_SECURITY_SSL_REQUIRED
|
||||
* imap+ssl://auth:user:password@server:port CONNECTION_SECURITY_SSL_OPTIONAL
|
||||
*
|
||||
* @param _uri
|
||||
*/
|
||||
public ImapStore(Account account) throws MessagingException
|
||||
{
|
||||
super(account);
|
||||
|
||||
URI uri;
|
||||
try
|
||||
{
|
||||
@ -1910,7 +1919,8 @@ public class ImapStore extends Store
|
||||
|
||||
if (hasCapability(CAPABILITY_CAPABILITY) == false)
|
||||
{
|
||||
Log.i(K9.LOG_TAG, "Did not get capabilities in banner, requesting CAPABILITY for " + getLogId());
|
||||
if (K9.DEBUG)
|
||||
Log.i(K9.LOG_TAG, "Did not get capabilities in banner, requesting CAPABILITY for " + getLogId());
|
||||
List<ImapResponse> responses = receiveCapabilities(executeSimpleCommand(COMMAND_CAPABILITY));
|
||||
if (responses.size() != 2)
|
||||
{
|
||||
@ -1954,10 +1964,11 @@ public class ImapStore extends Store
|
||||
if (mAuthType == AuthType.CRAM_MD5)
|
||||
{
|
||||
authCramMD5();
|
||||
// The authCramMD5 method on the previous line does not allow for handling updated capabilities
|
||||
// The authCramMD5 method called on the previous line does not allow for handling updated capabilities
|
||||
// sent by the server. So, to make sure we update to the post-authentication capability list
|
||||
// we fetch the capabilities here.
|
||||
Log.i(K9.LOG_TAG, "Updating capabilities after CRAM-MD5 authentication for " + getLogId());
|
||||
if (K9.DEBUG)
|
||||
Log.i(K9.LOG_TAG, "Updating capabilities after CRAM-MD5 authentication for " + getLogId());
|
||||
List<ImapResponse> responses = receiveCapabilities(executeSimpleCommand(COMMAND_CAPABILITY));
|
||||
if (responses.size() != 2)
|
||||
{
|
||||
@ -1980,6 +1991,51 @@ public class ImapStore extends Store
|
||||
{
|
||||
throw new AuthenticationFailedException(null, me);
|
||||
}
|
||||
if (K9.DEBUG)
|
||||
{
|
||||
Log.d(K9.LOG_TAG, CAPABILITY_COMPRESS_DEFLATE + " = " + hasCapability(CAPABILITY_COMPRESS_DEFLATE));
|
||||
}
|
||||
if (hasCapability(CAPABILITY_COMPRESS_DEFLATE))
|
||||
{
|
||||
ConnectivityManager connectivityManager = (ConnectivityManager)K9.app.getSystemService(Context.CONNECTIVITY_SERVICE);
|
||||
boolean useCompression = true;
|
||||
|
||||
NetworkInfo netInfo = connectivityManager.getActiveNetworkInfo();
|
||||
if (netInfo != null)
|
||||
{
|
||||
int type = netInfo.getType();
|
||||
if (K9.DEBUG)
|
||||
Log.d(K9.LOG_TAG, "On network type " + type);
|
||||
useCompression = mAccount.useCompression(type);
|
||||
|
||||
}
|
||||
if (K9.DEBUG)
|
||||
Log.d(K9.LOG_TAG, "useCompression " + useCompression);
|
||||
if (useCompression)
|
||||
{
|
||||
try
|
||||
{
|
||||
executeSimpleCommand(COMMAND_COMPRESS_DEFLATE);
|
||||
ZInputStream zInputStream = new ZInputStream(mSocket.getInputStream(), true);
|
||||
zInputStream.setFlushMode(JZlib.Z_PARTIAL_FLUSH);
|
||||
mIn = new PeekableInputStream(new BufferedInputStream(zInputStream, 1024));
|
||||
mParser = new ImapResponseParser(mIn);
|
||||
ZOutputStream zOutputStream = new ZOutputStream(mSocket.getOutputStream(), JZlib.Z_BEST_SPEED, true);
|
||||
mOut = new BufferedOutputStream(zOutputStream, 1024);
|
||||
zOutputStream.setFlushMode(JZlib.Z_PARTIAL_FLUSH);
|
||||
if (K9.DEBUG)
|
||||
{
|
||||
Log.i(K9.LOG_TAG, "Compression enabled for " + getLogId());
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
Log.e(K9.LOG_TAG, "Unable to negotiate compression", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (K9.DEBUG)
|
||||
Log.d(K9.LOG_TAG, "NAMESPACE = " + hasCapability(CAPABILITY_NAMESPACE)
|
||||
+ ", mPathPrefix = " + mPathPrefix);
|
||||
|
94
src/com/jcraft/jzlib/Adler32.java
Normal file
94
src/com/jcraft/jzlib/Adler32.java
Normal file
@ -0,0 +1,94 @@
|
||||
/* -*-mode:java; c-basic-offset:2; -*- */
|
||||
/*
|
||||
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in
|
||||
the documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. The names of the authors may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
||||
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
/*
|
||||
* This program is based on zlib-1.1.3, so all credit should go authors
|
||||
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
||||
* and contributors of zlib.
|
||||
*/
|
||||
|
||||
package com.jcraft.jzlib;
|
||||
|
||||
final class Adler32{
|
||||
|
||||
// largest prime smaller than 65536
|
||||
static final private int BASE=65521;
|
||||
// NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
|
||||
static final private int NMAX=5552;
|
||||
|
||||
long adler32(long adler, byte[] buf, int index, int len){
|
||||
if(buf == null){ return 1L; }
|
||||
|
||||
long s1=adler&0xffff;
|
||||
long s2=(adler>>16)&0xffff;
|
||||
int k;
|
||||
|
||||
while(len > 0) {
|
||||
k=len<NMAX?len:NMAX;
|
||||
len-=k;
|
||||
while(k>=16){
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
k-=16;
|
||||
}
|
||||
if(k!=0){
|
||||
do{
|
||||
s1+=buf[index++]&0xff; s2+=s1;
|
||||
}
|
||||
while(--k!=0);
|
||||
}
|
||||
s1%=BASE;
|
||||
s2%=BASE;
|
||||
}
|
||||
return (s2<<16)|s1;
|
||||
}
|
||||
|
||||
/*
|
||||
private java.util.zip.Adler32 adler=new java.util.zip.Adler32();
|
||||
long adler32(long value, byte[] buf, int index, int len){
|
||||
if(value==1) {adler.reset();}
|
||||
if(buf==null) {adler.reset();}
|
||||
else{adler.update(buf, index, len);}
|
||||
return adler.getValue();
|
||||
}
|
||||
*/
|
||||
}
|
1623
src/com/jcraft/jzlib/Deflate.java
Normal file
1623
src/com/jcraft/jzlib/Deflate.java
Normal file
File diff suppressed because it is too large
Load Diff
614
src/com/jcraft/jzlib/InfBlocks.java
Normal file
614
src/com/jcraft/jzlib/InfBlocks.java
Normal file
@ -0,0 +1,614 @@
|
||||
/* -*-mode:java; c-basic-offset:2; -*- */
|
||||
/*
|
||||
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in
|
||||
the documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. The names of the authors may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
||||
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
/*
|
||||
* This program is based on zlib-1.1.3, so all credit should go authors
|
||||
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
||||
* and contributors of zlib.
|
||||
*/
|
||||
|
||||
package com.jcraft.jzlib;
|
||||
|
||||
final class InfBlocks{
|
||||
static final private int MANY=1440;
|
||||
|
||||
// And'ing with mask[n] masks the lower n bits
|
||||
static final private int[] inflate_mask = {
|
||||
0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
|
||||
0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff, 0x000001ff,
|
||||
0x000003ff, 0x000007ff, 0x00000fff, 0x00001fff, 0x00003fff,
|
||||
0x00007fff, 0x0000ffff
|
||||
};
|
||||
|
||||
// Table for deflate from PKZIP's appnote.txt.
|
||||
static final int[] border = { // Order of the bit length code lengths
|
||||
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
|
||||
};
|
||||
|
||||
static final private int Z_OK=0;
|
||||
static final private int Z_STREAM_END=1;
|
||||
static final private int Z_NEED_DICT=2;
|
||||
static final private int Z_ERRNO=-1;
|
||||
static final private int Z_STREAM_ERROR=-2;
|
||||
static final private int Z_DATA_ERROR=-3;
|
||||
static final private int Z_MEM_ERROR=-4;
|
||||
static final private int Z_BUF_ERROR=-5;
|
||||
static final private int Z_VERSION_ERROR=-6;
|
||||
|
||||
static final private int TYPE=0; // get type bits (3, including end bit)
|
||||
static final private int LENS=1; // get lengths for stored
|
||||
static final private int STORED=2;// processing stored block
|
||||
static final private int TABLE=3; // get table lengths
|
||||
static final private int BTREE=4; // get bit lengths tree for a dynamic block
|
||||
static final private int DTREE=5; // get length, distance trees for a dynamic block
|
||||
static final private int CODES=6; // processing fixed or dynamic block
|
||||
static final private int DRY=7; // output remaining window bytes
|
||||
static final private int DONE=8; // finished last block, done
|
||||
static final private int BAD=9; // ot a data error--stuck here
|
||||
|
||||
int mode; // current inflate_block mode
|
||||
|
||||
int left; // if STORED, bytes left to copy
|
||||
|
||||
int table; // table lengths (14 bits)
|
||||
int index; // index into blens (or border)
|
||||
int[] blens; // bit lengths of codes
|
||||
int[] bb=new int[1]; // bit length tree depth
|
||||
int[] tb=new int[1]; // bit length decoding tree
|
||||
|
||||
InfCodes codes=new InfCodes(); // if CODES, current state
|
||||
|
||||
int last; // true if this block is the last block
|
||||
|
||||
// mode independent information
|
||||
int bitk; // bits in bit buffer
|
||||
int bitb; // bit buffer
|
||||
int[] hufts; // single malloc for tree space
|
||||
byte[] window; // sliding window
|
||||
int end; // one byte after sliding window
|
||||
int read; // window read pointer
|
||||
int write; // window write pointer
|
||||
Object checkfn; // check function
|
||||
long check; // check on output
|
||||
|
||||
InfTree inftree=new InfTree();
|
||||
|
||||
InfBlocks(ZStream z, Object checkfn, int w){
|
||||
hufts=new int[MANY*3];
|
||||
window=new byte[w];
|
||||
end=w;
|
||||
this.checkfn = checkfn;
|
||||
mode = TYPE;
|
||||
reset(z, null);
|
||||
}
|
||||
|
||||
void reset(ZStream z, long[] c){
|
||||
if(c!=null) c[0]=check;
|
||||
if(mode==BTREE || mode==DTREE){
|
||||
}
|
||||
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);
|
||||
}
|
||||
|
||||
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 (t >>> 1){
|
||||
case 0: // stored
|
||||
{b>>>=(3);k-=(3);}
|
||||
t = k & 7; // go to byte boundary
|
||||
|
||||
{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.init(bl[0], bd[0], tl[0], 0, td[0], 0, z);
|
||||
}
|
||||
|
||||
{b>>>=(3);k-=(3);}
|
||||
|
||||
mode = CODES;
|
||||
break;
|
||||
case 2: // dynamic
|
||||
|
||||
{b>>>=(3);k-=(3);}
|
||||
|
||||
mode = TABLE;
|
||||
break;
|
||||
case 3: // illegal
|
||||
|
||||
{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 ((((~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;
|
||||
System.arraycopy(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);
|
||||
if(blens==null || blens.length<t){
|
||||
blens=new int[t];
|
||||
}
|
||||
else{
|
||||
for(int i=0; i<t; i++){blens[i]=0;}
|
||||
}
|
||||
|
||||
{b>>>=(14);k-=(14);}
|
||||
|
||||
index = 0;
|
||||
mode = BTREE;
|
||||
case BTREE:
|
||||
while (index < 4 + (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>>>=(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;
|
||||
case DTREE:
|
||||
while (true){
|
||||
t = table;
|
||||
if(!(index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))){
|
||||
break;
|
||||
}
|
||||
|
||||
int[] h;
|
||||
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>>>=(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>>>=(t);k-=(t);
|
||||
|
||||
j += (b & inflate_mask[i]);
|
||||
|
||||
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.init(bl[0], bd[0], hufts, tl[0], hufts, td[0], z);
|
||||
}
|
||||
mode = 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;
|
||||
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;
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void free(ZStream z){
|
||||
reset(z, null);
|
||||
window=null;
|
||||
hufts=null;
|
||||
//ZFREE(z, s);
|
||||
}
|
||||
|
||||
void set_dictionary(byte[] d, int start, int n){
|
||||
System.arraycopy(d, start, window, 0, n);
|
||||
read = write = n;
|
||||
}
|
||||
|
||||
// Returns true if inflate is currently at the end of a block generated
|
||||
// by Z_SYNC_FLUSH or Z_FULL_FLUSH.
|
||||
int sync_point(){
|
||||
return mode == LENS ? 1 : 0;
|
||||
}
|
||||
|
||||
// copy as much as possible from the sliding window to the output area
|
||||
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
|
||||
System.arraycopy(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
|
||||
System.arraycopy(window, q, z.next_out, p, n);
|
||||
p += n;
|
||||
q += n;
|
||||
}
|
||||
|
||||
// update pointers
|
||||
z.next_out_index = p;
|
||||
read = q;
|
||||
|
||||
// done
|
||||
return r;
|
||||
}
|
||||
}
|
605
src/com/jcraft/jzlib/InfCodes.java
Normal file
605
src/com/jcraft/jzlib/InfCodes.java
Normal file
@ -0,0 +1,605 @@
|
||||
/* -*-mode:java; c-basic-offset:2; -*- */
|
||||
/*
|
||||
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in
|
||||
the documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. The names of the authors may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
||||
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
/*
|
||||
* This program is based on zlib-1.1.3, so all credit should go authors
|
||||
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
||||
* and contributors of zlib.
|
||||
*/
|
||||
|
||||
package com.jcraft.jzlib;
|
||||
|
||||
final class InfCodes{
|
||||
|
||||
static final private int[] inflate_mask = {
|
||||
0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
|
||||
0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff, 0x000001ff,
|
||||
0x000003ff, 0x000007ff, 0x00000fff, 0x00001fff, 0x00003fff,
|
||||
0x00007fff, 0x0000ffff
|
||||
};
|
||||
|
||||
static final private int Z_OK=0;
|
||||
static final private int Z_STREAM_END=1;
|
||||
static final private int Z_NEED_DICT=2;
|
||||
static final private int Z_ERRNO=-1;
|
||||
static final private int Z_STREAM_ERROR=-2;
|
||||
static final private int Z_DATA_ERROR=-3;
|
||||
static final private int Z_MEM_ERROR=-4;
|
||||
static final private int Z_BUF_ERROR=-5;
|
||||
static final private int Z_VERSION_ERROR=-6;
|
||||
|
||||
// waiting for "i:"=input,
|
||||
// "o:"=output,
|
||||
// "x:"=nothing
|
||||
static final private int START=0; // x: set up for LEN
|
||||
static final private int LEN=1; // i: get length/literal/eob next
|
||||
static final private int LENEXT=2; // i: getting length extra (have base)
|
||||
static final private int DIST=3; // i: get distance next
|
||||
static final private int DISTEXT=4;// i: getting distance extra
|
||||
static final private int COPY=5; // o: copying bytes in window, waiting for space
|
||||
static final private int LIT=6; // o: got literal, waiting for output space
|
||||
static final private int WASH=7; // o: got eob, possibly still output waiting
|
||||
static final private int END=8; // x: got eob and all data flushed
|
||||
static final private int BADCODE=9;// x: got error
|
||||
|
||||
int mode; // current inflate_codes mode
|
||||
|
||||
// mode dependent information
|
||||
int len;
|
||||
|
||||
int[] tree; // pointer into tree
|
||||
int tree_index=0;
|
||||
int need; // bits needed
|
||||
|
||||
int lit;
|
||||
|
||||
// if EXT or COPY, where and how much
|
||||
int get; // bits to get for extra
|
||||
int dist; // distance back to copy from
|
||||
|
||||
byte lbits; // ltree bits decoded per branch
|
||||
byte dbits; // dtree bits decoder per branch
|
||||
int[] ltree; // literal/length/eob tree
|
||||
int ltree_index; // literal/length/eob tree
|
||||
int[] dtree; // distance tree
|
||||
int dtree_index; // distance tree
|
||||
|
||||
InfCodes(){
|
||||
}
|
||||
void init(int bl, int bd,
|
||||
int[] tl, int tl_index,
|
||||
int[] td, int td_index, ZStream z){
|
||||
mode=START;
|
||||
lbits=(byte)bl;
|
||||
dbits=(byte)bd;
|
||||
ltree=tl;
|
||||
ltree_index=tl_index;
|
||||
dtree = td;
|
||||
dtree_index=td_index;
|
||||
tree=null;
|
||||
}
|
||||
|
||||
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;
|
||||
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>>>=(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 = 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;
|
||||
|
||||
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;
|
||||
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 = 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;
|
||||
|
||||
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;
|
||||
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;
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void free(ZStream z){
|
||||
// ZFREE(z, c);
|
||||
}
|
||||
|
||||
// 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.
|
||||
|
||||
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
|
||||
|
||||
int tp_index_t_3; // (tp_index+t)*3
|
||||
|
||||
// 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;
|
||||
tp_index_t_3=(tp_index+t)*3;
|
||||
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;
|
||||
tp_index_t_3=(tp_index+t)*3;
|
||||
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++]; // minimum count is three,
|
||||
s.window[q++]=s.window[r++]; // so unroll loop a little
|
||||
c-=2;
|
||||
}
|
||||
else{
|
||||
System.arraycopy(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{
|
||||
System.arraycopy(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{
|
||||
System.arraycopy(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]);
|
||||
tp_index_t_3=(tp_index+t)*3;
|
||||
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]);
|
||||
tp_index_t_3=(tp_index+t)*3;
|
||||
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;
|
||||
}
|
||||
}
|
520
src/com/jcraft/jzlib/InfTree.java
Normal file
520
src/com/jcraft/jzlib/InfTree.java
Normal file
@ -0,0 +1,520 @@
|
||||
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
|
||||
/*
|
||||
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in
|
||||
the documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. The names of the authors may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
||||
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
/*
|
||||
* This program is based on zlib-1.1.3, so all credit should go authors
|
||||
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
||||
* and contributors of zlib.
|
||||
*/
|
||||
|
||||
package com.jcraft.jzlib;
|
||||
|
||||
final class InfTree{
|
||||
|
||||
static final private int MANY=1440;
|
||||
|
||||
static final private int Z_OK=0;
|
||||
static final private int Z_STREAM_END=1;
|
||||
static final private int Z_NEED_DICT=2;
|
||||
static final private int Z_ERRNO=-1;
|
||||
static final private int Z_STREAM_ERROR=-2;
|
||||
static final private int Z_DATA_ERROR=-3;
|
||||
static final private int Z_MEM_ERROR=-4;
|
||||
static final private int Z_BUF_ERROR=-5;
|
||||
static final private int Z_VERSION_ERROR=-6;
|
||||
|
||||
static final int fixed_bl = 9;
|
||||
static final int fixed_bd = 5;
|
||||
|
||||
static final int[] fixed_tl = {
|
||||
96,7,256, 0,8,80, 0,8,16, 84,8,115,
|
||||
82,7,31, 0,8,112, 0,8,48, 0,9,192,
|
||||
80,7,10, 0,8,96, 0,8,32, 0,9,160,
|
||||
0,8,0, 0,8,128, 0,8,64, 0,9,224,
|
||||
80,7,6, 0,8,88, 0,8,24, 0,9,144,
|
||||
83,7,59, 0,8,120, 0,8,56, 0,9,208,
|
||||
81,7,17, 0,8,104, 0,8,40, 0,9,176,
|
||||
0,8,8, 0,8,136, 0,8,72, 0,9,240,
|
||||
80,7,4, 0,8,84, 0,8,20, 85,8,227,
|
||||
83,7,43, 0,8,116, 0,8,52, 0,9,200,
|
||||
81,7,13, 0,8,100, 0,8,36, 0,9,168,
|
||||
0,8,4, 0,8,132, 0,8,68, 0,9,232,
|
||||
80,7,8, 0,8,92, 0,8,28, 0,9,152,
|
||||
84,7,83, 0,8,124, 0,8,60, 0,9,216,
|
||||
82,7,23, 0,8,108, 0,8,44, 0,9,184,
|
||||
0,8,12, 0,8,140, 0,8,76, 0,9,248,
|
||||
80,7,3, 0,8,82, 0,8,18, 85,8,163,
|
||||
83,7,35, 0,8,114, 0,8,50, 0,9,196,
|
||||
81,7,11, 0,8,98, 0,8,34, 0,9,164,
|
||||
0,8,2, 0,8,130, 0,8,66, 0,9,228,
|
||||
80,7,7, 0,8,90, 0,8,26, 0,9,148,
|
||||
84,7,67, 0,8,122, 0,8,58, 0,9,212,
|
||||
82,7,19, 0,8,106, 0,8,42, 0,9,180,
|
||||
0,8,10, 0,8,138, 0,8,74, 0,9,244,
|
||||
80,7,5, 0,8,86, 0,8,22, 192,8,0,
|
||||
83,7,51, 0,8,118, 0,8,54, 0,9,204,
|
||||
81,7,15, 0,8,102, 0,8,38, 0,9,172,
|
||||
0,8,6, 0,8,134, 0,8,70, 0,9,236,
|
||||
80,7,9, 0,8,94, 0,8,30, 0,9,156,
|
||||
84,7,99, 0,8,126, 0,8,62, 0,9,220,
|
||||
82,7,27, 0,8,110, 0,8,46, 0,9,188,
|
||||
0,8,14, 0,8,142, 0,8,78, 0,9,252,
|
||||
96,7,256, 0,8,81, 0,8,17, 85,8,131,
|
||||
82,7,31, 0,8,113, 0,8,49, 0,9,194,
|
||||
80,7,10, 0,8,97, 0,8,33, 0,9,162,
|
||||
0,8,1, 0,8,129, 0,8,65, 0,9,226,
|
||||
80,7,6, 0,8,89, 0,8,25, 0,9,146,
|
||||
83,7,59, 0,8,121, 0,8,57, 0,9,210,
|
||||
81,7,17, 0,8,105, 0,8,41, 0,9,178,
|
||||
0,8,9, 0,8,137, 0,8,73, 0,9,242,
|
||||
80,7,4, 0,8,85, 0,8,21, 80,8,258,
|
||||
83,7,43, 0,8,117, 0,8,53, 0,9,202,
|
||||
81,7,13, 0,8,101, 0,8,37, 0,9,170,
|
||||
0,8,5, 0,8,133, 0,8,69, 0,9,234,
|
||||
80,7,8, 0,8,93, 0,8,29, 0,9,154,
|
||||
84,7,83, 0,8,125, 0,8,61, 0,9,218,
|
||||
82,7,23, 0,8,109, 0,8,45, 0,9,186,
|
||||
0,8,13, 0,8,141, 0,8,77, 0,9,250,
|
||||
80,7,3, 0,8,83, 0,8,19, 85,8,195,
|
||||
83,7,35, 0,8,115, 0,8,51, 0,9,198,
|
||||
81,7,11, 0,8,99, 0,8,35, 0,9,166,
|
||||
0,8,3, 0,8,131, 0,8,67, 0,9,230,
|
||||
80,7,7, 0,8,91, 0,8,27, 0,9,150,
|
||||
84,7,67, 0,8,123, 0,8,59, 0,9,214,
|
||||
82,7,19, 0,8,107, 0,8,43, 0,9,182,
|
||||
0,8,11, 0,8,139, 0,8,75, 0,9,246,
|
||||
80,7,5, 0,8,87, 0,8,23, 192,8,0,
|
||||
83,7,51, 0,8,119, 0,8,55, 0,9,206,
|
||||
81,7,15, 0,8,103, 0,8,39, 0,9,174,
|
||||
0,8,7, 0,8,135, 0,8,71, 0,9,238,
|
||||
80,7,9, 0,8,95, 0,8,31, 0,9,158,
|
||||
84,7,99, 0,8,127, 0,8,63, 0,9,222,
|
||||
82,7,27, 0,8,111, 0,8,47, 0,9,190,
|
||||
0,8,15, 0,8,143, 0,8,79, 0,9,254,
|
||||
96,7,256, 0,8,80, 0,8,16, 84,8,115,
|
||||
82,7,31, 0,8,112, 0,8,48, 0,9,193,
|
||||
|
||||
80,7,10, 0,8,96, 0,8,32, 0,9,161,
|
||||
0,8,0, 0,8,128, 0,8,64, 0,9,225,
|
||||
80,7,6, 0,8,88, 0,8,24, 0,9,145,
|
||||
83,7,59, 0,8,120, 0,8,56, 0,9,209,
|
||||
81,7,17, 0,8,104, 0,8,40, 0,9,177,
|
||||
0,8,8, 0,8,136, 0,8,72, 0,9,241,
|
||||
80,7,4, 0,8,84, 0,8,20, 85,8,227,
|
||||
83,7,43, 0,8,116, 0,8,52, 0,9,201,
|
||||
81,7,13, 0,8,100, 0,8,36, 0,9,169,
|
||||
0,8,4, 0,8,132, 0,8,68, 0,9,233,
|
||||
80,7,8, 0,8,92, 0,8,28, 0,9,153,
|
||||
84,7,83, 0,8,124, 0,8,60, 0,9,217,
|
||||
82,7,23, 0,8,108, 0,8,44, 0,9,185,
|
||||
0,8,12, 0,8,140, 0,8,76, 0,9,249,
|
||||
80,7,3, 0,8,82, 0,8,18, 85,8,163,
|
||||
83,7,35, 0,8,114, 0,8,50, 0,9,197,
|
||||
81,7,11, 0,8,98, 0,8,34, 0,9,165,
|
||||
0,8,2, 0,8,130, 0,8,66, 0,9,229,
|
||||
80,7,7, 0,8,90, 0,8,26, 0,9,149,
|
||||
84,7,67, 0,8,122, 0,8,58, 0,9,213,
|
||||
82,7,19, 0,8,106, 0,8,42, 0,9,181,
|
||||
0,8,10, 0,8,138, 0,8,74, 0,9,245,
|
||||
80,7,5, 0,8,86, 0,8,22, 192,8,0,
|
||||
83,7,51, 0,8,118, 0,8,54, 0,9,205,
|
||||
81,7,15, 0,8,102, 0,8,38, 0,9,173,
|
||||
0,8,6, 0,8,134, 0,8,70, 0,9,237,
|
||||
80,7,9, 0,8,94, 0,8,30, 0,9,157,
|
||||
84,7,99, 0,8,126, 0,8,62, 0,9,221,
|
||||
82,7,27, 0,8,110, 0,8,46, 0,9,189,
|
||||
0,8,14, 0,8,142, 0,8,78, 0,9,253,
|
||||
96,7,256, 0,8,81, 0,8,17, 85,8,131,
|
||||
82,7,31, 0,8,113, 0,8,49, 0,9,195,
|
||||
80,7,10, 0,8,97, 0,8,33, 0,9,163,
|
||||
0,8,1, 0,8,129, 0,8,65, 0,9,227,
|
||||
80,7,6, 0,8,89, 0,8,25, 0,9,147,
|
||||
83,7,59, 0,8,121, 0,8,57, 0,9,211,
|
||||
81,7,17, 0,8,105, 0,8,41, 0,9,179,
|
||||
0,8,9, 0,8,137, 0,8,73, 0,9,243,
|
||||
80,7,4, 0,8,85, 0,8,21, 80,8,258,
|
||||
83,7,43, 0,8,117, 0,8,53, 0,9,203,
|
||||
81,7,13, 0,8,101, 0,8,37, 0,9,171,
|
||||
0,8,5, 0,8,133, 0,8,69, 0,9,235,
|
||||
80,7,8, 0,8,93, 0,8,29, 0,9,155,
|
||||
84,7,83, 0,8,125, 0,8,61, 0,9,219,
|
||||
82,7,23, 0,8,109, 0,8,45, 0,9,187,
|
||||
0,8,13, 0,8,141, 0,8,77, 0,9,251,
|
||||
80,7,3, 0,8,83, 0,8,19, 85,8,195,
|
||||
83,7,35, 0,8,115, 0,8,51, 0,9,199,
|
||||
81,7,11, 0,8,99, 0,8,35, 0,9,167,
|
||||
0,8,3, 0,8,131, 0,8,67, 0,9,231,
|
||||
80,7,7, 0,8,91, 0,8,27, 0,9,151,
|
||||
84,7,67, 0,8,123, 0,8,59, 0,9,215,
|
||||
82,7,19, 0,8,107, 0,8,43, 0,9,183,
|
||||
0,8,11, 0,8,139, 0,8,75, 0,9,247,
|
||||
80,7,5, 0,8,87, 0,8,23, 192,8,0,
|
||||
83,7,51, 0,8,119, 0,8,55, 0,9,207,
|
||||
81,7,15, 0,8,103, 0,8,39, 0,9,175,
|
||||
0,8,7, 0,8,135, 0,8,71, 0,9,239,
|
||||
80,7,9, 0,8,95, 0,8,31, 0,9,159,
|
||||
84,7,99, 0,8,127, 0,8,63, 0,9,223,
|
||||
82,7,27, 0,8,111, 0,8,47, 0,9,191,
|
||||
0,8,15, 0,8,143, 0,8,79, 0,9,255
|
||||
};
|
||||
static final int[] fixed_td = {
|
||||
80,5,1, 87,5,257, 83,5,17, 91,5,4097,
|
||||
81,5,5, 89,5,1025, 85,5,65, 93,5,16385,
|
||||
80,5,3, 88,5,513, 84,5,33, 92,5,8193,
|
||||
82,5,9, 90,5,2049, 86,5,129, 192,5,24577,
|
||||
80,5,2, 87,5,385, 83,5,25, 91,5,6145,
|
||||
81,5,7, 89,5,1537, 85,5,97, 93,5,24577,
|
||||
80,5,4, 88,5,769, 84,5,49, 92,5,12289,
|
||||
82,5,13, 90,5,3073, 86,5,193, 192,5,24577
|
||||
};
|
||||
|
||||
// Tables for deflate from PKZIP's appnote.txt.
|
||||
static final int[] cplens = { // Copy lengths for literal codes 257..285
|
||||
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
|
||||
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
|
||||
};
|
||||
|
||||
// see note #13 above about 258
|
||||
static final int[] cplext = { // Extra bits for literal codes 257..285
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
|
||||
3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112 // 112==invalid
|
||||
};
|
||||
|
||||
static final int[] cpdist = { // Copy offsets for distance codes 0..29
|
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
|
||||
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
|
||||
8193, 12289, 16385, 24577
|
||||
};
|
||||
|
||||
static final int[] cpdext = { // Extra bits for distance codes
|
||||
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
|
||||
7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
|
||||
12, 12, 13, 13};
|
||||
|
||||
// If BMAX needs to be larger than 16, then h and x[] should be uLong.
|
||||
static final int BMAX=15; // maximum bit length of any code
|
||||
|
||||
int[] hn = null; // hufts used in space
|
||||
int[] v = null; // work area for huft_build
|
||||
int[] c = null; // bit length count table
|
||||
int[] r = null; // table entry for structure assignment
|
||||
int[] u = null; // table stack
|
||||
int[] x = null; // bit offsets, then code stack
|
||||
|
||||
private int huft_build(int[] b, // code lengths in bits (all assumed <= BMAX)
|
||||
int bindex,
|
||||
int n, // number of codes (assumed <= 288)
|
||||
int s, // number of simple-valued codes (0..s-1)
|
||||
int[] d, // list of base values for non-simple codes
|
||||
int[] e, // list of extra bits for non-simple codes
|
||||
int[] t, // result: starting table
|
||||
int[] m, // maximum lookup bits, returns actual
|
||||
int[] hp,// space for trees
|
||||
int[] hn,// hufts used in space
|
||||
int[] v // working area: values in order of bit length
|
||||
){
|
||||
// Given a list of code lengths and a maximum table size, make a set of
|
||||
// tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR
|
||||
// if the given code set is incomplete (the tables are still built in this
|
||||
// case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
|
||||
// lengths), or Z_MEM_ERROR if not enough memory.
|
||||
|
||||
int a; // counter for codes of length k
|
||||
int f; // i repeats in table every f entries
|
||||
int g; // maximum code length
|
||||
int h; // table level
|
||||
int i; // counter, current code
|
||||
int j; // counter
|
||||
int k; // number of bits in current code
|
||||
int l; // bits per table (returned in m)
|
||||
int mask; // (1 << w) - 1, to avoid cc -O bug on HP
|
||||
int p; // pointer into c[], b[], or v[]
|
||||
int q; // points to current table
|
||||
int w; // bits before this table == (l * h)
|
||||
int xp; // pointer into x
|
||||
int y; // number of dummy codes added
|
||||
int z; // number of entries in current table
|
||||
|
||||
// Generate counts for each bit length
|
||||
|
||||
p = 0; i = n;
|
||||
do {
|
||||
c[b[bindex+p]]++; p++; i--; // assume all entries <= BMAX
|
||||
}while(i!=0);
|
||||
|
||||
if(c[0] == n){ // null input--all zero length codes
|
||||
t[0] = -1;
|
||||
m[0] = 0;
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
// Find minimum and maximum length, bound *m by those
|
||||
l = m[0];
|
||||
for (j = 1; j <= BMAX; j++)
|
||||
if(c[j]!=0) break;
|
||||
k = j; // minimum code length
|
||||
if(l < j){
|
||||
l = j;
|
||||
}
|
||||
for (i = BMAX; i!=0; i--){
|
||||
if(c[i]!=0) break;
|
||||
}
|
||||
g = i; // maximum code length
|
||||
if(l > i){
|
||||
l = i;
|
||||
}
|
||||
m[0] = l;
|
||||
|
||||
// Adjust last length count to fill out codes, if needed
|
||||
for (y = 1 << j; j < i; j++, y <<= 1){
|
||||
if ((y -= c[j]) < 0){
|
||||
return Z_DATA_ERROR;
|
||||
}
|
||||
}
|
||||
if ((y -= c[i]) < 0){
|
||||
return Z_DATA_ERROR;
|
||||
}
|
||||
c[i] += y;
|
||||
|
||||
// Generate starting offsets into the value table for each length
|
||||
x[1] = j = 0;
|
||||
p = 1; xp = 2;
|
||||
while (--i!=0) { // note that i == g from above
|
||||
x[xp] = (j += c[p]);
|
||||
xp++;
|
||||
p++;
|
||||
}
|
||||
|
||||
// Make a table of values in order of bit lengths
|
||||
i = 0; p = 0;
|
||||
do {
|
||||
if ((j = b[bindex+p]) != 0){
|
||||
v[x[j]++] = i;
|
||||
}
|
||||
p++;
|
||||
}
|
||||
while (++i < n);
|
||||
n = x[g]; // set n to length of v
|
||||
|
||||
// Generate the Huffman codes and for each, make the table entries
|
||||
x[0] = i = 0; // first Huffman code is zero
|
||||
p = 0; // grab values in bit order
|
||||
h = -1; // no tables yet--level -1
|
||||
w = -l; // bits decoded == (l * h)
|
||||
u[0] = 0; // just to keep compilers happy
|
||||
q = 0; // ditto
|
||||
z = 0; // ditto
|
||||
|
||||
// go through the bit lengths (k already is bits in shortest code)
|
||||
for (; k <= g; k++){
|
||||
a = c[k];
|
||||
while (a--!=0){
|
||||
// here i is the Huffman code of length k bits for value *p
|
||||
// make tables up to required level
|
||||
while (k > w + l){
|
||||
h++;
|
||||
w += l; // previous table always l bits
|
||||
// compute minimum size table less than or equal to l bits
|
||||
z = g - w;
|
||||
z = (z > l) ? l : z; // table size upper limit
|
||||
if((f=1<<(j=k-w))>a+1){ // try a k-w bit table
|
||||
// too few codes for k-w bit table
|
||||
f -= a + 1; // deduct codes from patterns left
|
||||
xp = k;
|
||||
if(j < z){
|
||||
while (++j < z){ // try smaller tables up to z bits
|
||||
if((f <<= 1) <= c[++xp])
|
||||
break; // enough codes to use up j bits
|
||||
f -= c[xp]; // else deduct codes from patterns
|
||||
}
|
||||
}
|
||||
}
|
||||
z = 1 << j; // table entries for j-bit table
|
||||
|
||||
// allocate new table
|
||||
if (hn[0] + z > MANY){ // (note: doesn't matter for fixed)
|
||||
return Z_DATA_ERROR; // overflow of MANY
|
||||
}
|
||||
u[h] = q = /*hp+*/ hn[0]; // DEBUG
|
||||
hn[0] += z;
|
||||
|
||||
// connect to last table, if there is one
|
||||
if(h!=0){
|
||||
x[h]=i; // save pattern for backing up
|
||||
r[0]=(byte)j; // bits in this table
|
||||
r[1]=(byte)l; // bits to dump before this table
|
||||
j=i>>>(w - l);
|
||||
r[2] = (int)(q - u[h-1] - j); // offset to this table
|
||||
System.arraycopy(r, 0, hp, (u[h-1]+j)*3, 3); // connect to last table
|
||||
}
|
||||
else{
|
||||
t[0] = q; // first table is returned result
|
||||
}
|
||||
}
|
||||
|
||||
// set up table entry in r
|
||||
r[1] = (byte)(k - w);
|
||||
if (p >= n){
|
||||
r[0] = 128 + 64; // out of values--invalid code
|
||||
}
|
||||
else if (v[p] < s){
|
||||
r[0] = (byte)(v[p] < 256 ? 0 : 32 + 64); // 256 is end-of-block
|
||||
r[2] = v[p++]; // simple code is just the value
|
||||
}
|
||||
else{
|
||||
r[0]=(byte)(e[v[p]-s]+16+64); // non-simple--look up in lists
|
||||
r[2]=d[v[p++] - s];
|
||||
}
|
||||
|
||||
// fill code-like entries with r
|
||||
f=1<<(k-w);
|
||||
for (j=i>>>w;j<z;j+=f){
|
||||
System.arraycopy(r, 0, hp, (q+j)*3, 3);
|
||||
}
|
||||
|
||||
// backwards increment the k-bit code i
|
||||
for (j = 1 << (k - 1); (i & j)!=0; j >>>= 1){
|
||||
i ^= j;
|
||||
}
|
||||
i ^= j;
|
||||
|
||||
// backup over finished tables
|
||||
mask = (1 << w) - 1; // needed on HP, cc -O bug
|
||||
while ((i & mask) != x[h]){
|
||||
h--; // don't need to update q
|
||||
w -= l;
|
||||
mask = (1 << w) - 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Return Z_BUF_ERROR if we were given an incomplete table
|
||||
return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
|
||||
}
|
||||
|
||||
int inflate_trees_bits(int[] c, // 19 code lengths
|
||||
int[] bb, // bits tree desired/actual depth
|
||||
int[] tb, // bits tree result
|
||||
int[] hp, // space for trees
|
||||
ZStream z // for messages
|
||||
){
|
||||
int result;
|
||||
initWorkArea(19);
|
||||
hn[0]=0;
|
||||
result = huft_build(c, 0, 19, 19, null, null, tb, bb, hp, hn, v);
|
||||
|
||||
if(result == Z_DATA_ERROR){
|
||||
z.msg = "oversubscribed dynamic bit lengths tree";
|
||||
}
|
||||
else if(result == Z_BUF_ERROR || bb[0] == 0){
|
||||
z.msg = "incomplete dynamic bit lengths tree";
|
||||
result = Z_DATA_ERROR;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
int inflate_trees_dynamic(int nl, // number of literal/length codes
|
||||
int nd, // number of distance codes
|
||||
int[] c, // that many (total) code lengths
|
||||
int[] bl, // literal desired/actual bit depth
|
||||
int[] bd, // distance desired/actual bit depth
|
||||
int[] tl, // literal/length tree result
|
||||
int[] td, // distance tree result
|
||||
int[] hp, // space for trees
|
||||
ZStream z // for messages
|
||||
){
|
||||
int result;
|
||||
|
||||
// build literal/length tree
|
||||
initWorkArea(288);
|
||||
hn[0]=0;
|
||||
result = huft_build(c, 0, nl, 257, cplens, cplext, tl, bl, hp, hn, v);
|
||||
if (result != Z_OK || bl[0] == 0){
|
||||
if(result == Z_DATA_ERROR){
|
||||
z.msg = "oversubscribed literal/length tree";
|
||||
}
|
||||
else if (result != Z_MEM_ERROR){
|
||||
z.msg = "incomplete literal/length tree";
|
||||
result = Z_DATA_ERROR;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// build distance tree
|
||||
initWorkArea(288);
|
||||
result = huft_build(c, nl, nd, 0, cpdist, cpdext, td, bd, hp, hn, v);
|
||||
|
||||
if (result != Z_OK || (bd[0] == 0 && nl > 257)){
|
||||
if (result == Z_DATA_ERROR){
|
||||
z.msg = "oversubscribed distance tree";
|
||||
}
|
||||
else if (result == Z_BUF_ERROR) {
|
||||
z.msg = "incomplete distance tree";
|
||||
result = Z_DATA_ERROR;
|
||||
}
|
||||
else if (result != Z_MEM_ERROR){
|
||||
z.msg = "empty distance tree with lengths";
|
||||
result = Z_DATA_ERROR;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
static int inflate_trees_fixed(int[] bl, //literal desired/actual bit depth
|
||||
int[] bd, //distance desired/actual bit depth
|
||||
int[][] tl,//literal/length tree result
|
||||
int[][] td,//distance tree result
|
||||
ZStream z //for memory allocation
|
||||
){
|
||||
bl[0]=fixed_bl;
|
||||
bd[0]=fixed_bd;
|
||||
tl[0]=fixed_tl;
|
||||
td[0]=fixed_td;
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
private void initWorkArea(int vsize){
|
||||
if(hn==null){
|
||||
hn=new int[1];
|
||||
v=new int[vsize];
|
||||
c=new int[BMAX+1];
|
||||
r=new int[3];
|
||||
u=new int[BMAX];
|
||||
x=new int[BMAX+1];
|
||||
}
|
||||
if(v.length<vsize){ v=new int[vsize]; }
|
||||
for(int i=0; i<vsize; i++){v[i]=0;}
|
||||
for(int i=0; i<BMAX+1; i++){c[i]=0;}
|
||||
for(int i=0; i<3; i++){r[i]=0;}
|
||||
// for(int i=0; i<BMAX; i++){u[i]=0;}
|
||||
System.arraycopy(c, 0, u, 0, BMAX);
|
||||
// for(int i=0; i<BMAX+1; i++){x[i]=0;}
|
||||
System.arraycopy(c, 0, x, 0, BMAX+1);
|
||||
}
|
||||
}
|
374
src/com/jcraft/jzlib/Inflate.java
Normal file
374
src/com/jcraft/jzlib/Inflate.java
Normal file
@ -0,0 +1,374 @@
|
||||
/* -*-mode:java; c-basic-offset:2; -*- */
|
||||
/*
|
||||
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in
|
||||
the documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. The names of the authors may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
||||
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
/*
|
||||
* This program is based on zlib-1.1.3, so all credit should go authors
|
||||
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
||||
* and contributors of zlib.
|
||||
*/
|
||||
|
||||
package com.jcraft.jzlib;
|
||||
|
||||
final class Inflate{
|
||||
|
||||
static final private int MAX_WBITS=15; // 32K LZ77 window
|
||||
|
||||
// preset dictionary flag in zlib header
|
||||
static final private int PRESET_DICT=0x20;
|
||||
|
||||
static final int Z_NO_FLUSH=0;
|
||||
static final int Z_PARTIAL_FLUSH=1;
|
||||
static final int Z_SYNC_FLUSH=2;
|
||||
static final int Z_FULL_FLUSH=3;
|
||||
static final int Z_FINISH=4;
|
||||
|
||||
static final private int Z_DEFLATED=8;
|
||||
|
||||
static final private int Z_OK=0;
|
||||
static final private int Z_STREAM_END=1;
|
||||
static final private int Z_NEED_DICT=2;
|
||||
static final private int Z_ERRNO=-1;
|
||||
static final private int Z_STREAM_ERROR=-2;
|
||||
static final private int Z_DATA_ERROR=-3;
|
||||
static final private int Z_MEM_ERROR=-4;
|
||||
static final private int Z_BUF_ERROR=-5;
|
||||
static final private int Z_VERSION_ERROR=-6;
|
||||
|
||||
static final private int METHOD=0; // waiting for method byte
|
||||
static final private int FLAG=1; // waiting for flag byte
|
||||
static final private int DICT4=2; // four dictionary check bytes to go
|
||||
static final private int DICT3=3; // three dictionary check bytes to go
|
||||
static final private int DICT2=4; // two dictionary check bytes to go
|
||||
static final private int DICT1=5; // one dictionary check byte to go
|
||||
static final private int DICT0=6; // waiting for inflateSetDictionary
|
||||
static final private int BLOCKS=7; // decompressing blocks
|
||||
static final private int CHECK4=8; // four check bytes to go
|
||||
static final private int CHECK3=9; // three check bytes to go
|
||||
static final private int CHECK2=10; // two check bytes to go
|
||||
static final private int CHECK1=11; // one check byte to go
|
||||
static final private int DONE=12; // finished check, done
|
||||
static final private int BAD=13; // got an error--stay here
|
||||
|
||||
int mode; // current inflate mode
|
||||
|
||||
// mode dependent information
|
||||
int method; // if FLAGS, method byte
|
||||
|
||||
// if CHECK, check values to compare
|
||||
long[] was=new long[1] ; // computed check value
|
||||
long need; // stream check value
|
||||
|
||||
// if BAD, inflateSync's marker bytes count
|
||||
int marker;
|
||||
|
||||
// mode independent information
|
||||
int nowrap; // flag for no wrapper
|
||||
int wbits; // log2(window size) (8..15, defaults to 15)
|
||||
|
||||
InfBlocks blocks; // current inflate_blocks state
|
||||
|
||||
int inflateReset(ZStream z){
|
||||
if(z == null || z.istate == null) return Z_STREAM_ERROR;
|
||||
|
||||
z.total_in = z.total_out = 0;
|
||||
z.msg = null;
|
||||
z.istate.mode = z.istate.nowrap!=0 ? BLOCKS : METHOD;
|
||||
z.istate.blocks.reset(z, null);
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
int inflateEnd(ZStream z){
|
||||
if(blocks != null)
|
||||
blocks.free(z);
|
||||
blocks=null;
|
||||
// ZFREE(z, z->state);
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
int inflateInit(ZStream z, int w){
|
||||
z.msg = null;
|
||||
blocks = null;
|
||||
|
||||
// handle undocumented nowrap option (no zlib header or check)
|
||||
nowrap = 0;
|
||||
if(w < 0){
|
||||
w = - w;
|
||||
nowrap = 1;
|
||||
}
|
||||
|
||||
// set window size
|
||||
if(w<8 ||w>15){
|
||||
inflateEnd(z);
|
||||
return Z_STREAM_ERROR;
|
||||
}
|
||||
wbits=w;
|
||||
|
||||
z.istate.blocks=new InfBlocks(z,
|
||||
z.istate.nowrap!=0 ? null : this,
|
||||
1<<w);
|
||||
|
||||
// reset state
|
||||
inflateReset(z);
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
int inflate(ZStream z, int f){
|
||||
int r;
|
||||
int b;
|
||||
|
||||
if(z == null || z.istate == null || z.next_in == null)
|
||||
return Z_STREAM_ERROR;
|
||||
f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;
|
||||
r = Z_BUF_ERROR;
|
||||
while (true){
|
||||
//System.out.println("mode: "+z.istate.mode);
|
||||
switch (z.istate.mode){
|
||||
case METHOD:
|
||||
|
||||
if(z.avail_in==0)return r;r=f;
|
||||
|
||||
z.avail_in--; z.total_in++;
|
||||
if(((z.istate.method = z.next_in[z.next_in_index++])&0xf)!=Z_DEFLATED){
|
||||
z.istate.mode = BAD;
|
||||
z.msg="unknown compression method";
|
||||
z.istate.marker = 5; // can't try inflateSync
|
||||
break;
|
||||
}
|
||||
if((z.istate.method>>4)+8>z.istate.wbits){
|
||||
z.istate.mode = BAD;
|
||||
z.msg="invalid window size";
|
||||
z.istate.marker = 5; // can't try inflateSync
|
||||
break;
|
||||
}
|
||||
z.istate.mode=FLAG;
|
||||
case FLAG:
|
||||
|
||||
if(z.avail_in==0)return r;r=f;
|
||||
|
||||
z.avail_in--; z.total_in++;
|
||||
b = (z.next_in[z.next_in_index++])&0xff;
|
||||
|
||||
if((((z.istate.method << 8)+b) % 31)!=0){
|
||||
z.istate.mode = BAD;
|
||||
z.msg = "incorrect header check";
|
||||
z.istate.marker = 5; // can't try inflateSync
|
||||
break;
|
||||
}
|
||||
|
||||
if((b&PRESET_DICT)==0){
|
||||
z.istate.mode = BLOCKS;
|
||||
break;
|
||||
}
|
||||
z.istate.mode = DICT4;
|
||||
case DICT4:
|
||||
|
||||
if(z.avail_in==0)return r;r=f;
|
||||
|
||||
z.avail_in--; z.total_in++;
|
||||
z.istate.need=((z.next_in[z.next_in_index++]&0xff)<<24)&0xff000000L;
|
||||
z.istate.mode=DICT3;
|
||||
case DICT3:
|
||||
|
||||
if(z.avail_in==0)return r;r=f;
|
||||
|
||||
z.avail_in--; z.total_in++;
|
||||
z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<16)&0xff0000L;
|
||||
z.istate.mode=DICT2;
|
||||
case DICT2:
|
||||
|
||||
if(z.avail_in==0)return r;r=f;
|
||||
|
||||
z.avail_in--; z.total_in++;
|
||||
z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<8)&0xff00L;
|
||||
z.istate.mode=DICT1;
|
||||
case DICT1:
|
||||
|
||||
if(z.avail_in==0)return r;r=f;
|
||||
|
||||
z.avail_in--; z.total_in++;
|
||||
z.istate.need += (z.next_in[z.next_in_index++]&0xffL);
|
||||
z.adler = z.istate.need;
|
||||
z.istate.mode = DICT0;
|
||||
return Z_NEED_DICT;
|
||||
case DICT0:
|
||||
z.istate.mode = BAD;
|
||||
z.msg = "need dictionary";
|
||||
z.istate.marker = 0; // can try inflateSync
|
||||
return Z_STREAM_ERROR;
|
||||
case BLOCKS:
|
||||
|
||||
r = z.istate.blocks.proc(z, r);
|
||||
if(r == Z_DATA_ERROR){
|
||||
z.istate.mode = BAD;
|
||||
z.istate.marker = 0; // can try inflateSync
|
||||
break;
|
||||
}
|
||||
if(r == Z_OK){
|
||||
r = f;
|
||||
}
|
||||
if(r != Z_STREAM_END){
|
||||
return r;
|
||||
}
|
||||
r = f;
|
||||
z.istate.blocks.reset(z, z.istate.was);
|
||||
if(z.istate.nowrap!=0){
|
||||
z.istate.mode=DONE;
|
||||
break;
|
||||
}
|
||||
z.istate.mode=CHECK4;
|
||||
case CHECK4:
|
||||
|
||||
if(z.avail_in==0)return r;r=f;
|
||||
|
||||
z.avail_in--; z.total_in++;
|
||||
z.istate.need=((z.next_in[z.next_in_index++]&0xff)<<24)&0xff000000L;
|
||||
z.istate.mode=CHECK3;
|
||||
case CHECK3:
|
||||
|
||||
if(z.avail_in==0)return r;r=f;
|
||||
|
||||
z.avail_in--; z.total_in++;
|
||||
z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<16)&0xff0000L;
|
||||
z.istate.mode = CHECK2;
|
||||
case CHECK2:
|
||||
|
||||
if(z.avail_in==0)return r;r=f;
|
||||
|
||||
z.avail_in--; z.total_in++;
|
||||
z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<8)&0xff00L;
|
||||
z.istate.mode = CHECK1;
|
||||
case CHECK1:
|
||||
|
||||
if(z.avail_in==0)return r;r=f;
|
||||
|
||||
z.avail_in--; z.total_in++;
|
||||
z.istate.need+=(z.next_in[z.next_in_index++]&0xffL);
|
||||
|
||||
if(((int)(z.istate.was[0])) != ((int)(z.istate.need))){
|
||||
z.istate.mode = BAD;
|
||||
z.msg = "incorrect data check";
|
||||
z.istate.marker = 5; // can't try inflateSync
|
||||
break;
|
||||
}
|
||||
|
||||
z.istate.mode = DONE;
|
||||
case DONE:
|
||||
return Z_STREAM_END;
|
||||
case BAD:
|
||||
return Z_DATA_ERROR;
|
||||
default:
|
||||
return Z_STREAM_ERROR;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int inflateSetDictionary(ZStream z, byte[] dictionary, int dictLength){
|
||||
int index=0;
|
||||
int length = dictLength;
|
||||
if(z==null || z.istate == null|| z.istate.mode != DICT0)
|
||||
return Z_STREAM_ERROR;
|
||||
|
||||
if(z._adler.adler32(1L, dictionary, 0, dictLength)!=z.adler){
|
||||
return Z_DATA_ERROR;
|
||||
}
|
||||
|
||||
z.adler = z._adler.adler32(0, null, 0, 0);
|
||||
|
||||
if(length >= (1<<z.istate.wbits)){
|
||||
length = (1<<z.istate.wbits)-1;
|
||||
index=dictLength - length;
|
||||
}
|
||||
z.istate.blocks.set_dictionary(dictionary, index, length);
|
||||
z.istate.mode = BLOCKS;
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
static private byte[] mark = {(byte)0, (byte)0, (byte)0xff, (byte)0xff};
|
||||
|
||||
int inflateSync(ZStream z){
|
||||
int n; // number of bytes to look at
|
||||
int p; // pointer to bytes
|
||||
int m; // number of marker bytes found in a row
|
||||
long r, w; // temporaries to save total_in and total_out
|
||||
|
||||
// set up
|
||||
if(z == null || z.istate == null)
|
||||
return Z_STREAM_ERROR;
|
||||
if(z.istate.mode != BAD){
|
||||
z.istate.mode = BAD;
|
||||
z.istate.marker = 0;
|
||||
}
|
||||
if((n=z.avail_in)==0)
|
||||
return Z_BUF_ERROR;
|
||||
p=z.next_in_index;
|
||||
m=z.istate.marker;
|
||||
|
||||
// search
|
||||
while (n!=0 && m < 4){
|
||||
if(z.next_in[p] == mark[m]){
|
||||
m++;
|
||||
}
|
||||
else if(z.next_in[p]!=0){
|
||||
m = 0;
|
||||
}
|
||||
else{
|
||||
m = 4 - m;
|
||||
}
|
||||
p++; n--;
|
||||
}
|
||||
|
||||
// restore
|
||||
z.total_in += p-z.next_in_index;
|
||||
z.next_in_index = p;
|
||||
z.avail_in = n;
|
||||
z.istate.marker = m;
|
||||
|
||||
// return no joy or set up to restart on a new block
|
||||
if(m != 4){
|
||||
return Z_DATA_ERROR;
|
||||
}
|
||||
r=z.total_in; w=z.total_out;
|
||||
inflateReset(z);
|
||||
z.total_in=r; z.total_out = w;
|
||||
z.istate.mode = BLOCKS;
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
// Returns true if inflate is currently at the end of a block generated
|
||||
// by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
|
||||
// implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH
|
||||
// but removes the length bytes of the resulting empty stored block. When
|
||||
// decompressing, PPP checks that at the end of input packet, inflate is
|
||||
// waiting for these length bytes.
|
||||
int inflateSyncPoint(ZStream z){
|
||||
if(z == null || z.istate == null || z.istate.blocks == null)
|
||||
return Z_STREAM_ERROR;
|
||||
return z.istate.blocks.sync_point();
|
||||
}
|
||||
}
|
67
src/com/jcraft/jzlib/JZlib.java
Normal file
67
src/com/jcraft/jzlib/JZlib.java
Normal file
@ -0,0 +1,67 @@
|
||||
/* -*-mode:java; c-basic-offset:2; -*- */
|
||||
/*
|
||||
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in
|
||||
the documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. The names of the authors may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
||||
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
/*
|
||||
* This program is based on zlib-1.1.3, so all credit should go authors
|
||||
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
||||
* and contributors of zlib.
|
||||
*/
|
||||
|
||||
package com.jcraft.jzlib;
|
||||
|
||||
final public class JZlib{
|
||||
private static final String version="1.0.2";
|
||||
public static String version(){return version;}
|
||||
|
||||
// compression levels
|
||||
static final public int Z_NO_COMPRESSION=0;
|
||||
static final public int Z_BEST_SPEED=1;
|
||||
static final public int Z_BEST_COMPRESSION=9;
|
||||
static final public int Z_DEFAULT_COMPRESSION=(-1);
|
||||
|
||||
// compression strategy
|
||||
static final public int Z_FILTERED=1;
|
||||
static final public int Z_HUFFMAN_ONLY=2;
|
||||
static final public int Z_DEFAULT_STRATEGY=0;
|
||||
|
||||
static final public int Z_NO_FLUSH=0;
|
||||
static final public int Z_PARTIAL_FLUSH=1;
|
||||
static final public int Z_SYNC_FLUSH=2;
|
||||
static final public int Z_FULL_FLUSH=3;
|
||||
static final public int Z_FINISH=4;
|
||||
|
||||
static final public int Z_OK=0;
|
||||
static final public int Z_STREAM_END=1;
|
||||
static final public int Z_NEED_DICT=2;
|
||||
static final public int Z_ERRNO=-1;
|
||||
static final public int Z_STREAM_ERROR=-2;
|
||||
static final public int Z_DATA_ERROR=-3;
|
||||
static final public int Z_MEM_ERROR=-4;
|
||||
static final public int Z_BUF_ERROR=-5;
|
||||
static final public int Z_VERSION_ERROR=-6;
|
||||
}
|
149
src/com/jcraft/jzlib/StaticTree.java
Normal file
149
src/com/jcraft/jzlib/StaticTree.java
Normal file
@ -0,0 +1,149 @@
|
||||
/* -*-mode:java; c-basic-offset:2; -*- */
|
||||
/*
|
||||
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in
|
||||
the documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. The names of the authors may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
||||
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
/*
|
||||
* This program is based on zlib-1.1.3, so all credit should go authors
|
||||
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
||||
* and contributors of zlib.
|
||||
*/
|
||||
|
||||
package com.jcraft.jzlib;
|
||||
|
||||
final class StaticTree{
|
||||
static final private int MAX_BITS=15;
|
||||
|
||||
static final private int BL_CODES=19;
|
||||
static final private int D_CODES=30;
|
||||
static final private int LITERALS=256;
|
||||
static final private int LENGTH_CODES=29;
|
||||
static final private int L_CODES=(LITERALS+1+LENGTH_CODES);
|
||||
|
||||
// Bit length codes must not exceed MAX_BL_BITS bits
|
||||
static final int MAX_BL_BITS=7;
|
||||
|
||||
static final short[] static_ltree = {
|
||||
12, 8, 140, 8, 76, 8, 204, 8, 44, 8,
|
||||
172, 8, 108, 8, 236, 8, 28, 8, 156, 8,
|
||||
92, 8, 220, 8, 60, 8, 188, 8, 124, 8,
|
||||
252, 8, 2, 8, 130, 8, 66, 8, 194, 8,
|
||||
34, 8, 162, 8, 98, 8, 226, 8, 18, 8,
|
||||
146, 8, 82, 8, 210, 8, 50, 8, 178, 8,
|
||||
114, 8, 242, 8, 10, 8, 138, 8, 74, 8,
|
||||
202, 8, 42, 8, 170, 8, 106, 8, 234, 8,
|
||||
26, 8, 154, 8, 90, 8, 218, 8, 58, 8,
|
||||
186, 8, 122, 8, 250, 8, 6, 8, 134, 8,
|
||||
70, 8, 198, 8, 38, 8, 166, 8, 102, 8,
|
||||
230, 8, 22, 8, 150, 8, 86, 8, 214, 8,
|
||||
54, 8, 182, 8, 118, 8, 246, 8, 14, 8,
|
||||
142, 8, 78, 8, 206, 8, 46, 8, 174, 8,
|
||||
110, 8, 238, 8, 30, 8, 158, 8, 94, 8,
|
||||
222, 8, 62, 8, 190, 8, 126, 8, 254, 8,
|
||||
1, 8, 129, 8, 65, 8, 193, 8, 33, 8,
|
||||
161, 8, 97, 8, 225, 8, 17, 8, 145, 8,
|
||||
81, 8, 209, 8, 49, 8, 177, 8, 113, 8,
|
||||
241, 8, 9, 8, 137, 8, 73, 8, 201, 8,
|
||||
41, 8, 169, 8, 105, 8, 233, 8, 25, 8,
|
||||
153, 8, 89, 8, 217, 8, 57, 8, 185, 8,
|
||||
121, 8, 249, 8, 5, 8, 133, 8, 69, 8,
|
||||
197, 8, 37, 8, 165, 8, 101, 8, 229, 8,
|
||||
21, 8, 149, 8, 85, 8, 213, 8, 53, 8,
|
||||
181, 8, 117, 8, 245, 8, 13, 8, 141, 8,
|
||||
77, 8, 205, 8, 45, 8, 173, 8, 109, 8,
|
||||
237, 8, 29, 8, 157, 8, 93, 8, 221, 8,
|
||||
61, 8, 189, 8, 125, 8, 253, 8, 19, 9,
|
||||
275, 9, 147, 9, 403, 9, 83, 9, 339, 9,
|
||||
211, 9, 467, 9, 51, 9, 307, 9, 179, 9,
|
||||
435, 9, 115, 9, 371, 9, 243, 9, 499, 9,
|
||||
11, 9, 267, 9, 139, 9, 395, 9, 75, 9,
|
||||
331, 9, 203, 9, 459, 9, 43, 9, 299, 9,
|
||||
171, 9, 427, 9, 107, 9, 363, 9, 235, 9,
|
||||
491, 9, 27, 9, 283, 9, 155, 9, 411, 9,
|
||||
91, 9, 347, 9, 219, 9, 475, 9, 59, 9,
|
||||
315, 9, 187, 9, 443, 9, 123, 9, 379, 9,
|
||||
251, 9, 507, 9, 7, 9, 263, 9, 135, 9,
|
||||
391, 9, 71, 9, 327, 9, 199, 9, 455, 9,
|
||||
39, 9, 295, 9, 167, 9, 423, 9, 103, 9,
|
||||
359, 9, 231, 9, 487, 9, 23, 9, 279, 9,
|
||||
151, 9, 407, 9, 87, 9, 343, 9, 215, 9,
|
||||
471, 9, 55, 9, 311, 9, 183, 9, 439, 9,
|
||||
119, 9, 375, 9, 247, 9, 503, 9, 15, 9,
|
||||
271, 9, 143, 9, 399, 9, 79, 9, 335, 9,
|
||||
207, 9, 463, 9, 47, 9, 303, 9, 175, 9,
|
||||
431, 9, 111, 9, 367, 9, 239, 9, 495, 9,
|
||||
31, 9, 287, 9, 159, 9, 415, 9, 95, 9,
|
||||
351, 9, 223, 9, 479, 9, 63, 9, 319, 9,
|
||||
191, 9, 447, 9, 127, 9, 383, 9, 255, 9,
|
||||
511, 9, 0, 7, 64, 7, 32, 7, 96, 7,
|
||||
16, 7, 80, 7, 48, 7, 112, 7, 8, 7,
|
||||
72, 7, 40, 7, 104, 7, 24, 7, 88, 7,
|
||||
56, 7, 120, 7, 4, 7, 68, 7, 36, 7,
|
||||
100, 7, 20, 7, 84, 7, 52, 7, 116, 7,
|
||||
3, 8, 131, 8, 67, 8, 195, 8, 35, 8,
|
||||
163, 8, 99, 8, 227, 8
|
||||
};
|
||||
|
||||
static final short[] static_dtree = {
|
||||
0, 5, 16, 5, 8, 5, 24, 5, 4, 5,
|
||||
20, 5, 12, 5, 28, 5, 2, 5, 18, 5,
|
||||
10, 5, 26, 5, 6, 5, 22, 5, 14, 5,
|
||||
30, 5, 1, 5, 17, 5, 9, 5, 25, 5,
|
||||
5, 5, 21, 5, 13, 5, 29, 5, 3, 5,
|
||||
19, 5, 11, 5, 27, 5, 7, 5, 23, 5
|
||||
};
|
||||
|
||||
static StaticTree static_l_desc =
|
||||
new StaticTree(static_ltree, Tree.extra_lbits,
|
||||
LITERALS+1, L_CODES, MAX_BITS);
|
||||
|
||||
static StaticTree static_d_desc =
|
||||
new StaticTree(static_dtree, Tree.extra_dbits,
|
||||
0, D_CODES, MAX_BITS);
|
||||
|
||||
static StaticTree static_bl_desc =
|
||||
new StaticTree(null, Tree.extra_blbits,
|
||||
0, BL_CODES, MAX_BL_BITS);
|
||||
|
||||
short[] static_tree; // static tree or null
|
||||
int[] extra_bits; // extra bits for each code or null
|
||||
int extra_base; // base index for extra_bits
|
||||
int elems; // max number of elements in the tree
|
||||
int max_length; // max bit length for the codes
|
||||
|
||||
StaticTree(short[] static_tree,
|
||||
int[] extra_bits,
|
||||
int extra_base,
|
||||
int elems,
|
||||
int max_length
|
||||
){
|
||||
this.static_tree=static_tree;
|
||||
this.extra_bits=extra_bits;
|
||||
this.extra_base=extra_base;
|
||||
this.elems=elems;
|
||||
this.max_length=max_length;
|
||||
}
|
||||
}
|
365
src/com/jcraft/jzlib/Tree.java
Normal file
365
src/com/jcraft/jzlib/Tree.java
Normal file
@ -0,0 +1,365 @@
|
||||
/* -*-mode:java; c-basic-offset:2; -*- */
|
||||
/*
|
||||
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in
|
||||
the documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. The names of the authors may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
||||
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
/*
|
||||
* This program is based on zlib-1.1.3, so all credit should go authors
|
||||
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
||||
* and contributors of zlib.
|
||||
*/
|
||||
|
||||
package com.jcraft.jzlib;
|
||||
|
||||
final class Tree{
|
||||
static final private int MAX_BITS=15;
|
||||
static final private int BL_CODES=19;
|
||||
static final private int D_CODES=30;
|
||||
static final private int LITERALS=256;
|
||||
static final private int LENGTH_CODES=29;
|
||||
static final private int L_CODES=(LITERALS+1+LENGTH_CODES);
|
||||
static final private int HEAP_SIZE=(2*L_CODES+1);
|
||||
|
||||
// Bit length codes must not exceed MAX_BL_BITS bits
|
||||
static final int MAX_BL_BITS=7;
|
||||
|
||||
// end of block literal code
|
||||
static final int END_BLOCK=256;
|
||||
|
||||
// repeat previous bit length 3-6 times (2 bits of repeat count)
|
||||
static final int REP_3_6=16;
|
||||
|
||||
// repeat a zero length 3-10 times (3 bits of repeat count)
|
||||
static final int REPZ_3_10=17;
|
||||
|
||||
// repeat a zero length 11-138 times (7 bits of repeat count)
|
||||
static final int REPZ_11_138=18;
|
||||
|
||||
// extra bits for each length code
|
||||
static final int[] extra_lbits={
|
||||
0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0
|
||||
};
|
||||
|
||||
// extra bits for each distance code
|
||||
static final int[] extra_dbits={
|
||||
0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13
|
||||
};
|
||||
|
||||
// extra bits for each bit length code
|
||||
static final int[] extra_blbits={
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7
|
||||
};
|
||||
|
||||
static final byte[] bl_order={
|
||||
16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
|
||||
|
||||
|
||||
// The lengths of the bit length codes are sent in order of decreasing
|
||||
// probability, to avoid transmitting the lengths for unused bit
|
||||
// length codes.
|
||||
|
||||
static final int Buf_size=8*2;
|
||||
|
||||
// see definition of array dist_code below
|
||||
static final int DIST_CODE_LEN=512;
|
||||
|
||||
static final byte[] _dist_code = {
|
||||
0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8,
|
||||
8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10,
|
||||
10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
|
||||
11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
|
||||
12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
|
||||
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
|
||||
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
|
||||
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17,
|
||||
18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
|
||||
23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
|
||||
24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
|
||||
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
|
||||
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
|
||||
27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
|
||||
27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
|
||||
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
|
||||
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
|
||||
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
|
||||
};
|
||||
|
||||
static final byte[] _length_code={
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12,
|
||||
13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
|
||||
17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
|
||||
19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
|
||||
21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
|
||||
22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
|
||||
23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
|
||||
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
|
||||
25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
|
||||
25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
|
||||
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
|
||||
26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
|
||||
27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
|
||||
};
|
||||
|
||||
static final int[] base_length = {
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
|
||||
64, 80, 96, 112, 128, 160, 192, 224, 0
|
||||
};
|
||||
|
||||
static final int[] base_dist = {
|
||||
0, 1, 2, 3, 4, 6, 8, 12, 16, 24,
|
||||
32, 48, 64, 96, 128, 192, 256, 384, 512, 768,
|
||||
1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576
|
||||
};
|
||||
|
||||
// Mapping from a distance to a distance code. dist is the distance - 1 and
|
||||
// must not have side effects. _dist_code[256] and _dist_code[257] are never
|
||||
// used.
|
||||
static int d_code(int dist){
|
||||
return ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>>7)]);
|
||||
}
|
||||
|
||||
short[] dyn_tree; // the dynamic tree
|
||||
int max_code; // largest code with non zero frequency
|
||||
StaticTree stat_desc; // the corresponding static tree
|
||||
|
||||
// Compute the optimal bit lengths for a tree and update the total bit length
|
||||
// for the current block.
|
||||
// IN assertion: the fields freq and dad are set, heap[heap_max] and
|
||||
// above are the tree nodes sorted by increasing frequency.
|
||||
// OUT assertions: the field len is set to the optimal bit length, the
|
||||
// array bl_count contains the frequencies for each bit length.
|
||||
// The length opt_len is updated; static_len is also updated if stree is
|
||||
// not null.
|
||||
void gen_bitlen(Deflate s){
|
||||
short[] tree = dyn_tree;
|
||||
short[] stree = stat_desc.static_tree;
|
||||
int[] extra = stat_desc.extra_bits;
|
||||
int base = stat_desc.extra_base;
|
||||
int max_length = stat_desc.max_length;
|
||||
int h; // heap index
|
||||
int n, m; // iterate over the tree elements
|
||||
int bits; // bit length
|
||||
int xbits; // extra bits
|
||||
short f; // frequency
|
||||
int overflow = 0; // number of elements with bit length too large
|
||||
|
||||
for (bits = 0; bits <= MAX_BITS; bits++) s.bl_count[bits] = 0;
|
||||
|
||||
// In a first pass, compute the optimal bit lengths (which may
|
||||
// overflow in the case of the bit length tree).
|
||||
tree[s.heap[s.heap_max]*2+1] = 0; // root of the heap
|
||||
|
||||
for(h=s.heap_max+1; h<HEAP_SIZE; h++){
|
||||
n = s.heap[h];
|
||||
bits = tree[tree[n*2+1]*2+1] + 1;
|
||||
if (bits > max_length){ bits = max_length; overflow++; }
|
||||
tree[n*2+1] = (short)bits;
|
||||
// We overwrite tree[n*2+1] which is no longer needed
|
||||
|
||||
if (n > max_code) continue; // not a leaf node
|
||||
|
||||
s.bl_count[bits]++;
|
||||
xbits = 0;
|
||||
if (n >= base) xbits = extra[n-base];
|
||||
f = tree[n*2];
|
||||
s.opt_len += f * (bits + xbits);
|
||||
if (stree!=null) s.static_len += f * (stree[n*2+1] + xbits);
|
||||
}
|
||||
if (overflow == 0) return;
|
||||
|
||||
// This happens for example on obj2 and pic of the Calgary corpus
|
||||
// Find the first bit length which could increase:
|
||||
do {
|
||||
bits = max_length-1;
|
||||
while(s.bl_count[bits]==0) bits--;
|
||||
s.bl_count[bits]--; // move one leaf down the tree
|
||||
s.bl_count[bits+1]+=2; // move one overflow item as its brother
|
||||
s.bl_count[max_length]--;
|
||||
// The brother of the overflow item also moves one step up,
|
||||
// but this does not affect bl_count[max_length]
|
||||
overflow -= 2;
|
||||
}
|
||||
while (overflow > 0);
|
||||
|
||||
for (bits = max_length; bits != 0; bits--) {
|
||||
n = s.bl_count[bits];
|
||||
while (n != 0) {
|
||||
m = s.heap[--h];
|
||||
if (m > max_code) continue;
|
||||
if (tree[m*2+1] != bits) {
|
||||
s.opt_len += ((long)bits - (long)tree[m*2+1])*(long)tree[m*2];
|
||||
tree[m*2+1] = (short)bits;
|
||||
}
|
||||
n--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Construct one Huffman tree and assigns the code bit strings and lengths.
|
||||
// Update the total bit length for the current block.
|
||||
// IN assertion: the field freq is set for all tree elements.
|
||||
// OUT assertions: the fields len and code are set to the optimal bit length
|
||||
// and corresponding code. The length opt_len is updated; static_len is
|
||||
// also updated if stree is not null. The field max_code is set.
|
||||
void build_tree(Deflate s){
|
||||
short[] tree=dyn_tree;
|
||||
short[] stree=stat_desc.static_tree;
|
||||
int elems=stat_desc.elems;
|
||||
int n, m; // iterate over heap elements
|
||||
int max_code=-1; // largest code with non zero frequency
|
||||
int node; // new node being created
|
||||
|
||||
// Construct the initial heap, with least frequent element in
|
||||
// heap[1]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
|
||||
// heap[0] is not used.
|
||||
s.heap_len = 0;
|
||||
s.heap_max = HEAP_SIZE;
|
||||
|
||||
for(n=0; n<elems; n++) {
|
||||
if(tree[n*2] != 0) {
|
||||
s.heap[++s.heap_len] = max_code = n;
|
||||
s.depth[n] = 0;
|
||||
}
|
||||
else{
|
||||
tree[n*2+1] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// The pkzip format requires that at least one distance code exists,
|
||||
// and that at least one bit should be sent even if there is only one
|
||||
// possible code. So to avoid special checks later on we force at least
|
||||
// two codes of non zero frequency.
|
||||
while (s.heap_len < 2) {
|
||||
node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);
|
||||
tree[node*2] = 1;
|
||||
s.depth[node] = 0;
|
||||
s.opt_len--; if (stree!=null) s.static_len -= stree[node*2+1];
|
||||
// node is 0 or 1 so it does not have extra bits
|
||||
}
|
||||
this.max_code = max_code;
|
||||
|
||||
// The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
|
||||
// establish sub-heaps of increasing lengths:
|
||||
|
||||
for(n=s.heap_len/2;n>=1; n--)
|
||||
s.pqdownheap(tree, n);
|
||||
|
||||
// Construct the Huffman tree by repeatedly combining the least two
|
||||
// frequent nodes.
|
||||
|
||||
node=elems; // next internal node of the tree
|
||||
do{
|
||||
// n = node of least frequency
|
||||
n=s.heap[1];
|
||||
s.heap[1]=s.heap[s.heap_len--];
|
||||
s.pqdownheap(tree, 1);
|
||||
m=s.heap[1]; // m = node of next least frequency
|
||||
|
||||
s.heap[--s.heap_max] = n; // keep the nodes sorted by frequency
|
||||
s.heap[--s.heap_max] = m;
|
||||
|
||||
// Create a new node father of n and m
|
||||
tree[node*2] = (short)(tree[n*2] + tree[m*2]);
|
||||
s.depth[node] = (byte)(Math.max(s.depth[n],s.depth[m])+1);
|
||||
tree[n*2+1] = tree[m*2+1] = (short)node;
|
||||
|
||||
// and insert the new node in the heap
|
||||
s.heap[1] = node++;
|
||||
s.pqdownheap(tree, 1);
|
||||
}
|
||||
while(s.heap_len>=2);
|
||||
|
||||
s.heap[--s.heap_max] = s.heap[1];
|
||||
|
||||
// At this point, the fields freq and dad are set. We can now
|
||||
// generate the bit lengths.
|
||||
|
||||
gen_bitlen(s);
|
||||
|
||||
// The field len is now set, we can generate the bit codes
|
||||
gen_codes(tree, max_code, s.bl_count);
|
||||
}
|
||||
|
||||
// Generate the codes for a given tree and bit counts (which need not be
|
||||
// optimal).
|
||||
// IN assertion: the array bl_count contains the bit length statistics for
|
||||
// the given tree and the field len is set for all tree elements.
|
||||
// OUT assertion: the field code is set for all tree elements of non
|
||||
// zero code length.
|
||||
static void gen_codes(short[] tree, // the tree to decorate
|
||||
int max_code, // largest code with non zero frequency
|
||||
short[] bl_count // number of codes at each bit length
|
||||
){
|
||||
short[] next_code=new short[MAX_BITS+1]; // next code value for each bit length
|
||||
short code = 0; // running code value
|
||||
int bits; // bit index
|
||||
int n; // code index
|
||||
|
||||
// The distribution counts are first used to generate the code values
|
||||
// without bit reversal.
|
||||
for (bits = 1; bits <= MAX_BITS; bits++) {
|
||||
next_code[bits] = code = (short)((code + bl_count[bits-1]) << 1);
|
||||
}
|
||||
|
||||
// Check that the bit counts in bl_count are consistent. The last code
|
||||
// must be all ones.
|
||||
//Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
|
||||
// "inconsistent bit counts");
|
||||
//Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
|
||||
|
||||
for (n = 0; n <= max_code; n++) {
|
||||
int len = tree[n*2+1];
|
||||
if (len == 0) continue;
|
||||
// Now reverse the bits
|
||||
tree[n*2] = (short)(bi_reverse(next_code[len]++, len));
|
||||
}
|
||||
}
|
||||
|
||||
// Reverse the first len bits of a code, using straightforward code (a faster
|
||||
// method would use a table)
|
||||
// IN assertion: 1 <= len <= 15
|
||||
static int bi_reverse(int code, // the value to invert
|
||||
int len // its bit length
|
||||
){
|
||||
int res = 0;
|
||||
do{
|
||||
res|=code&1;
|
||||
code>>>=1;
|
||||
res<<=1;
|
||||
}
|
||||
while(--len>0);
|
||||
return res>>>1;
|
||||
}
|
||||
}
|
||||
|
149
src/com/jcraft/jzlib/ZInputStream.java
Normal file
149
src/com/jcraft/jzlib/ZInputStream.java
Normal file
@ -0,0 +1,149 @@
|
||||
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
|
||||
/*
|
||||
Copyright (c) 2001 Lapo Luchini.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in
|
||||
the documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. The names of the authors may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS
|
||||
OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
/*
|
||||
* This program is based on zlib-1.1.3, so all credit should go authors
|
||||
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
||||
* and contributors of zlib.
|
||||
*/
|
||||
|
||||
package com.jcraft.jzlib;
|
||||
import java.io.*;
|
||||
|
||||
public class ZInputStream extends FilterInputStream {
|
||||
|
||||
protected ZStream z=new ZStream();
|
||||
protected int bufsize=512;
|
||||
protected int flush=JZlib.Z_NO_FLUSH;
|
||||
protected byte[] buf=new byte[bufsize],
|
||||
buf1=new byte[1];
|
||||
protected boolean compress;
|
||||
|
||||
protected InputStream in=null;
|
||||
|
||||
public ZInputStream(InputStream in) {
|
||||
this(in, false);
|
||||
}
|
||||
public ZInputStream(InputStream in, boolean nowrap) {
|
||||
super(in);
|
||||
this.in=in;
|
||||
z.inflateInit(nowrap);
|
||||
compress=false;
|
||||
z.next_in=buf;
|
||||
z.next_in_index=0;
|
||||
z.avail_in=0;
|
||||
}
|
||||
|
||||
public ZInputStream(InputStream in, int level) {
|
||||
super(in);
|
||||
this.in=in;
|
||||
z.deflateInit(level);
|
||||
compress=true;
|
||||
z.next_in=buf;
|
||||
z.next_in_index=0;
|
||||
z.avail_in=0;
|
||||
}
|
||||
|
||||
/*public int available() throws IOException {
|
||||
return inf.finished() ? 0 : 1;
|
||||
}*/
|
||||
|
||||
public int read() throws IOException {
|
||||
if(read(buf1, 0, 1)==-1)
|
||||
return(-1);
|
||||
return(buf1[0]&0xFF);
|
||||
}
|
||||
|
||||
private boolean nomoreinput=false;
|
||||
|
||||
public int read(byte[] b, int off, int len) throws IOException {
|
||||
if(len==0)
|
||||
return(0);
|
||||
int err;
|
||||
z.next_out=b;
|
||||
z.next_out_index=off;
|
||||
z.avail_out=len;
|
||||
do {
|
||||
if((z.avail_in==0)&&(!nomoreinput)) { // if buffer is empty and more input is avaiable, refill it
|
||||
z.next_in_index=0;
|
||||
z.avail_in=in.read(buf, 0, bufsize);//(bufsize<z.avail_out ? bufsize : z.avail_out));
|
||||
if(z.avail_in==-1) {
|
||||
z.avail_in=0;
|
||||
nomoreinput=true;
|
||||
}
|
||||
}
|
||||
if(compress)
|
||||
err=z.deflate(flush);
|
||||
else
|
||||
err=z.inflate(flush);
|
||||
if(nomoreinput&&(err==JZlib.Z_BUF_ERROR))
|
||||
return(-1);
|
||||
if(err!=JZlib.Z_OK && err!=JZlib.Z_STREAM_END)
|
||||
throw new ZStreamException((compress ? "de" : "in")+"flating: "+z.msg);
|
||||
if((nomoreinput||err==JZlib.Z_STREAM_END)&&(z.avail_out==len))
|
||||
return(-1);
|
||||
}
|
||||
while(z.avail_out==len&&err==JZlib.Z_OK);
|
||||
//System.err.print("("+(len-z.avail_out)+")");
|
||||
return(len-z.avail_out);
|
||||
}
|
||||
|
||||
public long skip(long n) throws IOException {
|
||||
int len=512;
|
||||
if(n<len)
|
||||
len=(int)n;
|
||||
byte[] tmp=new byte[len];
|
||||
return((long)read(tmp));
|
||||
}
|
||||
|
||||
public int getFlushMode() {
|
||||
return(flush);
|
||||
}
|
||||
|
||||
public void setFlushMode(int flush) {
|
||||
this.flush=flush;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the total number of bytes input so far.
|
||||
*/
|
||||
public long getTotalIn() {
|
||||
return z.total_in;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the total number of bytes output so far.
|
||||
*/
|
||||
public long getTotalOut() {
|
||||
return z.total_out;
|
||||
}
|
||||
|
||||
public void close() throws IOException{
|
||||
in.close();
|
||||
}
|
||||
}
|
156
src/com/jcraft/jzlib/ZOutputStream.java
Normal file
156
src/com/jcraft/jzlib/ZOutputStream.java
Normal file
@ -0,0 +1,156 @@
|
||||
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
|
||||
/*
|
||||
Copyright (c) 2001 Lapo Luchini.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in
|
||||
the documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. The names of the authors may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS
|
||||
OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
/*
|
||||
* This program is based on zlib-1.1.3, so all credit should go authors
|
||||
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
||||
* and contributors of zlib.
|
||||
*/
|
||||
|
||||
package com.jcraft.jzlib;
|
||||
import java.io.*;
|
||||
|
||||
public class ZOutputStream extends OutputStream {
|
||||
|
||||
protected ZStream z=new ZStream();
|
||||
protected int bufsize=512;
|
||||
protected int flush=JZlib.Z_NO_FLUSH;
|
||||
protected byte[] buf=new byte[bufsize],
|
||||
buf1=new byte[1];
|
||||
protected boolean compress;
|
||||
|
||||
protected OutputStream out;
|
||||
|
||||
public ZOutputStream(OutputStream out) {
|
||||
super();
|
||||
this.out=out;
|
||||
z.inflateInit();
|
||||
compress=false;
|
||||
}
|
||||
|
||||
public ZOutputStream(OutputStream out, int level) {
|
||||
this(out, level, false);
|
||||
}
|
||||
public ZOutputStream(OutputStream out, int level, boolean nowrap) {
|
||||
super();
|
||||
this.out=out;
|
||||
z.deflateInit(level, nowrap);
|
||||
compress=true;
|
||||
}
|
||||
|
||||
public void write(int b) throws IOException {
|
||||
buf1[0]=(byte)b;
|
||||
write(buf1, 0, 1);
|
||||
}
|
||||
|
||||
public void write(byte b[], int off, int len) throws IOException {
|
||||
if(len==0)
|
||||
return;
|
||||
int err;
|
||||
z.next_in=b;
|
||||
z.next_in_index=off;
|
||||
z.avail_in=len;
|
||||
do{
|
||||
z.next_out=buf;
|
||||
z.next_out_index=0;
|
||||
z.avail_out=bufsize;
|
||||
if(compress)
|
||||
err=z.deflate(flush);
|
||||
else
|
||||
err=z.inflate(flush);
|
||||
if(err!=JZlib.Z_OK)
|
||||
throw new ZStreamException((compress?"de":"in")+"flating: "+z.msg);
|
||||
out.write(buf, 0, bufsize-z.avail_out);
|
||||
}
|
||||
while(z.avail_in>0 || z.avail_out==0);
|
||||
}
|
||||
|
||||
public int getFlushMode() {
|
||||
return(flush);
|
||||
}
|
||||
|
||||
public void setFlushMode(int flush) {
|
||||
this.flush=flush;
|
||||
}
|
||||
|
||||
public void finish() throws IOException {
|
||||
int err;
|
||||
do{
|
||||
z.next_out=buf;
|
||||
z.next_out_index=0;
|
||||
z.avail_out=bufsize;
|
||||
if(compress){ err=z.deflate(JZlib.Z_FINISH); }
|
||||
else{ err=z.inflate(JZlib.Z_FINISH); }
|
||||
if(err!=JZlib.Z_STREAM_END && err != JZlib.Z_OK)
|
||||
throw new ZStreamException((compress?"de":"in")+"flating: "+z.msg);
|
||||
if(bufsize-z.avail_out>0){
|
||||
out.write(buf, 0, bufsize-z.avail_out);
|
||||
}
|
||||
}
|
||||
while(z.avail_in>0 || z.avail_out==0);
|
||||
flush();
|
||||
}
|
||||
public void end() {
|
||||
if(z==null)
|
||||
return;
|
||||
if(compress){ z.deflateEnd(); }
|
||||
else{ z.inflateEnd(); }
|
||||
z.free();
|
||||
z=null;
|
||||
}
|
||||
public void close() throws IOException {
|
||||
try{
|
||||
try{finish();}
|
||||
catch (IOException ignored) {}
|
||||
}
|
||||
finally{
|
||||
end();
|
||||
out.close();
|
||||
out=null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the total number of bytes input so far.
|
||||
*/
|
||||
public long getTotalIn() {
|
||||
return z.total_in;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the total number of bytes output so far.
|
||||
*/
|
||||
public long getTotalOut() {
|
||||
return z.total_out;
|
||||
}
|
||||
|
||||
public void flush() throws IOException {
|
||||
out.flush();
|
||||
}
|
||||
|
||||
}
|
195
src/com/jcraft/jzlib/ZStream.java
Normal file
195
src/com/jcraft/jzlib/ZStream.java
Normal file
@ -0,0 +1,195 @@
|
||||
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
|
||||
/*
|
||||
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in
|
||||
the documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. The names of the authors may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
||||
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
/*
|
||||
* This program is based on zlib-1.1.3, so all credit should go authors
|
||||
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
||||
* and contributors of zlib.
|
||||
*/
|
||||
|
||||
package com.jcraft.jzlib;
|
||||
|
||||
final public class ZStream{
|
||||
|
||||
static final private int MAX_WBITS=15; // 32K LZ77 window
|
||||
static final private int DEF_WBITS=MAX_WBITS;
|
||||
|
||||
static final private int Z_STREAM_ERROR=-2;
|
||||
|
||||
public byte[] next_in; // next input byte
|
||||
public int next_in_index;
|
||||
public int avail_in; // number of bytes available at next_in
|
||||
public long total_in; // total nb of input bytes read so far
|
||||
|
||||
public byte[] next_out; // next output byte should be put there
|
||||
public int next_out_index;
|
||||
public int avail_out; // remaining free space at next_out
|
||||
public long total_out; // total nb of bytes output so far
|
||||
|
||||
public String msg;
|
||||
|
||||
Deflate dstate;
|
||||
Inflate istate;
|
||||
|
||||
int data_type; // best guess about the data type: ascii or binary
|
||||
|
||||
public long adler;
|
||||
Adler32 _adler=new Adler32();
|
||||
|
||||
public int inflateInit(){
|
||||
return inflateInit(DEF_WBITS);
|
||||
}
|
||||
public int inflateInit(boolean nowrap){
|
||||
return inflateInit(DEF_WBITS, nowrap);
|
||||
}
|
||||
public int inflateInit(int w){
|
||||
return inflateInit(w, false);
|
||||
}
|
||||
|
||||
public int inflateInit(int w, boolean nowrap){
|
||||
istate=new Inflate();
|
||||
return istate.inflateInit(this, nowrap?-w:w);
|
||||
}
|
||||
|
||||
public int inflate(int f){
|
||||
if(istate==null) return Z_STREAM_ERROR;
|
||||
return istate.inflate(this, f);
|
||||
}
|
||||
public int inflateEnd(){
|
||||
if(istate==null) return Z_STREAM_ERROR;
|
||||
int ret=istate.inflateEnd(this);
|
||||
istate = null;
|
||||
return ret;
|
||||
}
|
||||
public int inflateSync(){
|
||||
if(istate == null)
|
||||
return Z_STREAM_ERROR;
|
||||
return istate.inflateSync(this);
|
||||
}
|
||||
public int inflateSetDictionary(byte[] dictionary, int dictLength){
|
||||
if(istate == null)
|
||||
return Z_STREAM_ERROR;
|
||||
return istate.inflateSetDictionary(this, dictionary, dictLength);
|
||||
}
|
||||
|
||||
public int deflateInit(int level){
|
||||
return deflateInit(level, MAX_WBITS);
|
||||
}
|
||||
public int deflateInit(int level, boolean nowrap){
|
||||
return deflateInit(level, MAX_WBITS, nowrap);
|
||||
}
|
||||
public int deflateInit(int level, int bits){
|
||||
return deflateInit(level, bits, false);
|
||||
}
|
||||
public int deflateInit(int level, int bits, boolean nowrap){
|
||||
dstate=new Deflate();
|
||||
return dstate.deflateInit(this, level, nowrap?-bits:bits);
|
||||
}
|
||||
public int deflate(int flush){
|
||||
if(dstate==null){
|
||||
return Z_STREAM_ERROR;
|
||||
}
|
||||
return dstate.deflate(this, flush);
|
||||
}
|
||||
public int deflateEnd(){
|
||||
if(dstate==null) return Z_STREAM_ERROR;
|
||||
int ret=dstate.deflateEnd();
|
||||
dstate=null;
|
||||
return ret;
|
||||
}
|
||||
public int deflateParams(int level, int strategy){
|
||||
if(dstate==null) return Z_STREAM_ERROR;
|
||||
return dstate.deflateParams(this, level, strategy);
|
||||
}
|
||||
public int deflateSetDictionary (byte[] dictionary, int dictLength){
|
||||
if(dstate == null)
|
||||
return Z_STREAM_ERROR;
|
||||
return dstate.deflateSetDictionary(this, dictionary, dictLength);
|
||||
}
|
||||
|
||||
// Flush as much pending output as possible. All deflate() output goes
|
||||
// through this function so some applications may wish to modify it
|
||||
// to avoid allocating a large strm->next_out buffer and copying into it.
|
||||
// (See also read_buf()).
|
||||
void flush_pending(){
|
||||
int len=dstate.pending;
|
||||
|
||||
if(len>avail_out) len=avail_out;
|
||||
if(len==0) return;
|
||||
|
||||
if(dstate.pending_buf.length<=dstate.pending_out ||
|
||||
next_out.length<=next_out_index ||
|
||||
dstate.pending_buf.length<(dstate.pending_out+len) ||
|
||||
next_out.length<(next_out_index+len)){
|
||||
System.out.println(dstate.pending_buf.length+", "+dstate.pending_out+
|
||||
", "+next_out.length+", "+next_out_index+", "+len);
|
||||
System.out.println("avail_out="+avail_out);
|
||||
}
|
||||
|
||||
System.arraycopy(dstate.pending_buf, dstate.pending_out,
|
||||
next_out, next_out_index, len);
|
||||
|
||||
next_out_index+=len;
|
||||
dstate.pending_out+=len;
|
||||
total_out+=len;
|
||||
avail_out-=len;
|
||||
dstate.pending-=len;
|
||||
if(dstate.pending==0){
|
||||
dstate.pending_out=0;
|
||||
}
|
||||
}
|
||||
|
||||
// Read a new buffer from the current input stream, update the adler32
|
||||
// and total number of bytes read. All deflate() input goes through
|
||||
// this function so some applications may wish to modify it to avoid
|
||||
// allocating a large strm->next_in buffer and copying from it.
|
||||
// (See also flush_pending()).
|
||||
int read_buf(byte[] buf, int start, int size) {
|
||||
int len=avail_in;
|
||||
|
||||
if(len>size) len=size;
|
||||
if(len==0) return 0;
|
||||
|
||||
avail_in-=len;
|
||||
|
||||
if(dstate.noheader==0) {
|
||||
adler=_adler.adler32(adler, next_in, next_in_index, len);
|
||||
}
|
||||
System.arraycopy(next_in, next_in_index, buf, start, len);
|
||||
next_in_index += len;
|
||||
total_in += len;
|
||||
return len;
|
||||
}
|
||||
|
||||
public void free(){
|
||||
next_in=null;
|
||||
next_out=null;
|
||||
msg=null;
|
||||
_adler=null;
|
||||
}
|
||||
}
|
44
src/com/jcraft/jzlib/ZStreamException.java
Normal file
44
src/com/jcraft/jzlib/ZStreamException.java
Normal file
@ -0,0 +1,44 @@
|
||||
/* -*-mode:java; c-basic-offset:2; -*- */
|
||||
/*
|
||||
Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in
|
||||
the documentation and/or other materials provided with the distribution.
|
||||
|
||||
3. The names of the authors may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
||||
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
/*
|
||||
* This program is based on zlib-1.1.3, so all credit should go authors
|
||||
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
||||
* and contributors of zlib.
|
||||
*/
|
||||
|
||||
package com.jcraft.jzlib;
|
||||
|
||||
public class ZStreamException extends java.io.IOException {
|
||||
public ZStreamException() {
|
||||
super();
|
||||
}
|
||||
public ZStreamException(String s) {
|
||||
super(s);
|
||||
}
|
||||
}
|
Loading…
Reference in New Issue
Block a user