From fbb62ff1589086094980624b36d384b8c241319e Mon Sep 17 00:00:00 2001 From: Jesse Vincent Date: Mon, 31 Jan 2011 18:26:01 +0000 Subject: [PATCH] Replaced our local copy of jzlib with a clean jar built from jzlib 1.0.7 downloaded from jcraft: http://www.jcraft.com/jzlib/jzlib-1.0.7.tar.gz Built using the following build.xml (since jzlib doesn't include one) --- .classpath | 1 + libs/jzlib-1.0.7.jar | Bin 0 -> 37494 bytes src/com/jcraft/jzlib/Adler32.java | 94 -- src/com/jcraft/jzlib/Deflate.java | 1623 -------------------- src/com/jcraft/jzlib/InfBlocks.java | 614 -------- src/com/jcraft/jzlib/InfCodes.java | 605 -------- src/com/jcraft/jzlib/InfTree.java | 520 ------- src/com/jcraft/jzlib/Inflate.java | 374 ----- src/com/jcraft/jzlib/JZlib.java | 67 - src/com/jcraft/jzlib/StaticTree.java | 149 -- src/com/jcraft/jzlib/Tree.java | 365 ----- src/com/jcraft/jzlib/ZInputStream.java | 149 -- src/com/jcraft/jzlib/ZOutputStream.java | 156 -- src/com/jcraft/jzlib/ZStream.java | 195 --- src/com/jcraft/jzlib/ZStreamException.java | 44 - 15 files changed, 1 insertion(+), 4955 deletions(-) create mode 100644 libs/jzlib-1.0.7.jar delete mode 100644 src/com/jcraft/jzlib/Adler32.java delete mode 100644 src/com/jcraft/jzlib/Deflate.java delete mode 100644 src/com/jcraft/jzlib/InfBlocks.java delete mode 100644 src/com/jcraft/jzlib/InfCodes.java delete mode 100644 src/com/jcraft/jzlib/InfTree.java delete mode 100644 src/com/jcraft/jzlib/Inflate.java delete mode 100644 src/com/jcraft/jzlib/JZlib.java delete mode 100644 src/com/jcraft/jzlib/StaticTree.java delete mode 100644 src/com/jcraft/jzlib/Tree.java delete mode 100644 src/com/jcraft/jzlib/ZInputStream.java delete mode 100644 src/com/jcraft/jzlib/ZOutputStream.java delete mode 100644 src/com/jcraft/jzlib/ZStream.java delete mode 100644 src/com/jcraft/jzlib/ZStreamException.java diff --git a/.classpath b/.classpath index cabfc961e..0be97660a 100644 --- a/.classpath +++ b/.classpath @@ -6,6 +6,7 @@ + diff --git a/libs/jzlib-1.0.7.jar b/libs/jzlib-1.0.7.jar new file mode 100644 index 0000000000000000000000000000000000000000..fae8444360ec369827a2ea5e07e225d00af20f98 GIT binary patch literal 37494 zcmZ^~b984xv?dzcHak{Fzc}gGww-ir+qP}nwr$(CJ^kLjbKl%~Gqu+K=bUd;`qM+^Z&Q0kpDZ-+}+a5 z;J@Hd|L@9#p|0)Wz(7D^pg=$b|0g)Vk)^RcGZVd`rM`p1m4c)st~}be43mQ?)05r8 zarBTh7#npkGI#@3&@V@1Vkczez9nfUiT%{qR2ZwgB0bEYZ(waG=Y%9ZRd7se*e}c> zzFBL{DOVvmx5Ki}6{|klRF%I~O2F>&*Q|pXpvS_-jGHC0f@NzRNpD?_O`x9#`_1dL zvbA>Am*iI1sNF5ZS3rD#1hL4uYg_KGMy5|V1Bi9TwknK`|~OSL1xo!}c&moU!oj~l-4hi5W9!>3Dm`pjqslplm7|X|H+C%#wM2fj>f+PZLCeqO#j1} zPO%d*{eRGcfBXa_sW2Io(U36cYZ=Y<*IUansyExn1k;ku###K#6I<-(Qd@6ZJ<3t;-g`$H4M!8QbseM6e$OwZhq>PXreK0AxxNSHZA%tcQ~Ga_&v9O|{6r z2T0K6`{Z)Y3Lt-?1{1d}=XzL5PZee>wAacu%Qm+%l@~j%1_0N-f!6ra3P2^}3QvQ{r(? z%yh(A5UNZNIxz+bN)1}=`|pxM3rn=DxVUd~;~z6vx}rpZGt9*K`#FVm0n4?Ox0?+Y z7fu?#X1>P=6H^n@{}?%$GrB*o6k(@;DpoPsFzB3AxOj4MkVoJ+aCR75xLtnV10V_@ z8IVtqUO^xm2v@9KI-nS!PW0V5ARc;e~;L!%4l-whZ(~e8BlMz@I zgscWE38EZGSKwWj**iN*H{?~xUS8l^@z@-g@E!CX$jg_$50+j+u+*23US7~!b>A7_ zPvpxt?pi*GS5&wUMPCNJLCn1KnLpngy(vK7AiEPt-;%yHzMnLDy5O%Ca346mD|2^j zKs!LMn!Y^&qdNsJgh1cOyBVji7`=RcpU!fh4X+5bKEOA+jQbrxI|Io+gb-gqT|W@F zH%M>9?mvQV(|7kVK;NjlJwV?Z6yA7;b9{GUDPQ~Hx>`>W96hbam@8i-H!Gtx&^^U( zEHSbR;MkfYBM9(>7--jcxD!&A_~OzsCgkACm)1Ut1}-DlLaHO%(e(WJ32wApY0^=~ zFU2C!CayJtFJR2=H);BVbjxJBIF+zsW>^C z#Rb9NAW-nTy0&=c|EN~}`?zA_I%^|rFK@5t9BL=v)Ea^>XBt_pHFS-(Q&;V5%tdrD z)Ysg?tO-=6V!|<79b2xU-Z0n`?22a@qq(jpKEicWL|}IY*P;@I(P{H&x`@|z)i_xA zPu+w*3|n2?INLpsB~M>JZ+o{bKEE!@L~r!|F_3+!zRvdAqOCnT%^N(t6>p0nmwa;G z%=#cF-(Kz(7hmV?W#Bb&rME$g^mu8$ zvo;s~7XxAjk_rzf+Z;D1)(Zcgk~V-$Tev-0b!lm?tH8!I4%0BLS|+;WnSRz2VoVi} zL`~S2qMZx*1}|1;V-jxLens-#$k{+?b{;oo3@F5hoOOK9=GJbS;OKyWGag&=Ax;dB z+g&WS*(ZXiA&`tmg@o0cWn!2zd^921bKfl zUK$UFgOg)$6EaCe1OdU6f{ZCWy_0bCR?YpBKYNltG1uFO!~rh3j?_tte3XkDkfvws zm$!Hri{fA_S`@&g5fD8&drJ)9c0{7!VGLWC@+Oovh73U=O{*JFU&a^|f*w1_b$(~J zfs0``8=28j1{IVk$p;}lICv?+n-EY4shGo)#+QXdC<-2dsg$S{QJ|1*MRgNp8et-h zcAwS@k*y^T85voy_OZ2e{e6Jq_Xw>rY4@2<*P55td-wO2@S1BgdlpB0QZg4KDh~EEh{JOqgG+`wk|UVs zfoOenGEu&@>nyRSy?m>EzrB>nXYPVN9-cD zM1{jovNC9-EJE>cp@p3l41=uw?ddHP!=w}YMt^pB<{@gF9(a62srC6~qC05)NZb=4 z$GA%7Xn%9@mnI%?msv!j;LhPJJBfr%JP)zSP~RH<&OS9xqJ_!T$AR#b%%VreVk9?i z29u|&)Si0tMd0}ftFpbGZK{k+JA%IEesp{Im=r*seWcT9 z+i+ZJa+k`(mFJIUcqaU;`G%2R%6Xw3il}As+h?4@Bg|`70|9G$cXf+k9qo6@i}sCu zNI5uTAMIwgLIfqXtd|`a4fg+du`!5y* z^yw;<1DhoNJxK6VqtHRcxFBxF*ma&m!Km}+zux_^<)f~KDYOb6)?5G@3j5$e#^ zew4mE^nEQBOhn^oV3TH}=D@l{6_u3gEI-gHNjpSC$dH%5Rgy_alLli$`lA;@1-BhaX5SHVxY-uFq&6*KVtG08Z{CAGp@Qr|BPexQ4&bY08_lqn|`EJBe0a49!O;%Qw5PI|EBMe3NuzhZgro)A)c-1@PS>d1{*0tt7xV@_1B#*H(Ym zVEn+NE7Bte_;wi|_UW|z#*{owN&OZ|>y}ME`%p^j-l2PVxk;MsnRzUcJmu4SN0dCB z`Tezq^6nt@BM<%MR{YZ%_>Efp(-`;-vY<$FQ-(kW_WTFuwe7RR8p8oc5_Y ze)v-^^<6>ssLTA-#Poha_PF!=D+=Y^ChfbU{_FJv<()9~dj#b@L&~RuHv6Y6@Efr3 zqb1-Ia^^#o_mgyXlRUd)`2Iomh?x4_g7UtT_PxjLCQwA&Lvde4r&(=p^kFFcBhd6<`{Ryx}>A}*}0IfL3F~Ey5g|cdbgOy z&%@zZoQ_bJ@M5j>L(!jTPv@rQw<5jhPn5e8N9t_X23)IG^|qxz2^r}( z`FW1q&}~DHs|h8>!~zNHir1CJh3u|uX=F$qQSw*hnQcXZ$-^E~-F$PC#ZBila|b0= z0SyifB?0Kj3-Xu z9SN4KT1zADPTxmQJ7A9}TbTvuk@_6OA!l7eE$mVOJ_85~twJsSV+~bcf9s{4x2Qdm zEmtI4FikvC?iJF%rBF;xNonYzJU9#Wt z5Ao=1L|Te2#+nfP$!|frj#;ov9Ov*l{I~`>K%>eFM&{WbY?pZwdWg6Tc!VVb3Ux`n zGb$U-$6`X#n5-co8~dyprYd%3%Qxg%bR=6kP0KK*Skf#==q&Q-PR2@RVz1lO@)sSV ztdaX2C?vk7uEU4AI`@fQd~_|AGM?b8f=iZ6-!;Cvmwk<;$O)$R^HAjVLR0vbgxuq7ZlmThw@&UANcl9>`NP$;QwT#*Q^~wn>|t=9`>?NurU_ zi}SGfn~D_)5Yp&`bqRBAvvDX-QLT9IAUyRjJ_EoAsDBH`wbchw;hB8JOVBiqvfSgb zvqkQjy&9K4->^#(T_dhSsb|(qG5lYJ=O9Kty_tM1Wo=6V`6~6DVGoVW!y{QW|5+*&;r&EBHz)+UumMvC z7zd72%lM$GI~H11^>GjMnhdLT-w^PJnVG+kdAm=xq5c`bmLMHnX6HAVM%`7af!eso zHe+Bg4+gO3H4g$RB)Q<%)NL|Yg{!e8GNLoSU-DYYPxHZ)I|WX|au^>Y+udn2Uc&24 z_Z7p}pET73PMpP=?Psq(Jwz|T-FZk(qp?P&@MY46WAV*Lnb50Q?Sa4`9mPc6wbruo z6~{!}Oo=Vl<0wqb3h)`f5P|K;ZZyQ^A9EZ7CCOaE=*ip~nA{jmI{+R|mV#5oA*v4S zxyCmgFXPs8RS?|eBp&SR!{lsfCbV9D>!g{KYp+R6Zfy7`eKFi&n&D+h4UKEfj@Ss& zXCc2bgfk3^(~gq>Q@3AXd2w%~MNsb({az`dOk0YrC(mUdMiE!SSZhoEJHl3>dFt+< zmFh_>0pc7jWAdG@#Ect{cRU)Ip{&+MpVoIGPQ}Z2jBIkm}G00c_83h!2sMUq8s#c&J!Kab&Iy= zS5_sRo`1Uumxq(`oG=qE5eZC)t1|Bo-~L)B6{twQ zU4g%?uad2U-vPMDgN$`FJpeth`k+_N4o&2M$%r(SdmYhjbhmSo0dZ7n#oK|SCV@_= ziU+6yffUcS-={Q#_o$xDwpggy(%Dnl&7o&pqE3v;EmmU998Q*n=>+=TjlDaxZ#zdB z!5FbW)%X$agzbNL5pOcSh5p^eMcCr)vf!HS=Jtm=JPl;C-8gZfDp-r_;yhrF@#RFV zN*r!WI1D>ZI^^P~ZM8#ne$?C5pT`da9;QT#Y-^=`+_%S$6`ZiQ(LZ1uoJtMcvI?$1 zR$k4kvE4k=c?I_Jzxy8_l$Mnl@5twBl&s~`CXO>wWWTIS+@rIO&ne%3VIVINB+*q| zMGKjh6>6}EP0E9AG7>%0czKog>jVJLl^E9{8xvXt9bl#vbH7sf>nZ+#^ zXjS(efrso29OXOMm#^-HhA=EyuET-b@tv&a23Q`G7w421ccK~L@}dIE(CN$whwMgt zKzYJT#)^_o4+KqxlN zW811#Oke%wb$P=!hKZ*db3YgCocvz2YfftR9zQHt)#{e6-5&uGMq`P_#H=;^mhe>- zDdHtQ7X8S7)5Z*o~gs5EfP0|p!-JAcuGfk z?43(FbB7%wwwB(z(TwVQ(|7?X^b_b~vz~NFBf5dajGspR685EJ4*=$+?)5R3cv2Df z9r#hc7n}Q_M}g?=u(r-B{n7K|Ku~rUeQ-6!iwGfX=MM|3UudygVg~$-B7On(4YroJ zrwv}eOWwqyUM6~aRU?6zBtp*)LdzIDc$)JwTEElD+1B`TOI{DZte|AirUcm8j6RQf zHgNV|>Yu)SEoPQIf>?-`-(eLMt3UVXjgOH1Dv@^E!%D*x4rf1XjI9#>CeZ`7Bn=*uJ<2 z5IAw|J?BUx?OBXG+_>^fjz*24vK;2??^8P+`cfZrP9(y(Uc0)LL=IW_!Zwkr0B0a? zMc${!;9jCZC-o1HQ34uFa-tLPqH>5uMVFnUI>jYh@H)rR1J0%u9E&8a_ujnT=P9TM z1D8tQ&?f_xF5ATW9W~d%`zFVnwAS2HHcbMx=Vt<~_gFp5#jY3;$d!*;A2^T!*$z7O zM*_?%I`-tDbnJeHr$1!NH-oAw=ohMHCspsP=NNdm0ji}>Fx%ra?8mqyQ8gG(0YRmF z(`C*69DMt0Dg6icBAVnA>7lqPn1{w%L<_%Lmqv`dDhM+caQ?V7&Bj+za<&^L#~n5` z2W#aQu~zmw&#B)FcTuouVqtas!NRt95otk06XzpJyF!VDLR{5*3iclb2ZkdJ= zdT_1SZmXUdJiSXlE91suGNBU_+JrV#eD>+T=|VT^Wy^1E&VOAE-iC{D2%sH>AFSM6 z`?Pk>Lys(4(Bgu?mTlP!SONDAdeGblT8V>L_#EC3UA?9DmJzD#9bo7G%Ah6W! zD?Bp01G$%!Lo5~+QGSwa1rt`*)n^lx_L+QqaKq{@?G`8+A|^Abi~S@7B~oFPd}$*I z8H%OeTd55t^hr7ZvclkK=NlI;(8tN3`@)7f`&?XU&@ypNosZ4Z{ z-BZME0iBxi^Kf8^D-b{HGm$A#Kdj&aioT~Um?7foha_TGPDh-KT`}6hv#{=#LWBqm zVT+C81ujeQ4EqN8;Z?eSE6wJ1PLYyhVs3gH{0d6B72B)$_I~2fqmgx(Y@C@z3FEdE z`Hs3#YXUflT!+)`q5}Isx5^$GbsLYFHD9fNGN?kh;UrJcvTKC)s6WN+3KDqdl=_ zpp+8q)@$KLDDea@1RR)Gd_BiS6s`m~EK;tQUg1B6X6BB5Q=m;8=fw|ll- zrd`_hJ+}Gbaoo&(@mPvl6ik^J?^`#s(voM`_IXFt!A{(X#~Rp#qpK>z`V_~TE!SGG zHt*T1d-}H7z6mb#m)Xu;;ThjGSU~nL^;5ztWiRyB@5~;$^x-?v!asqAA&RmGq^=+t zqXO`v^R5)>h_`w5cfULrkt5bug%&&?Hu^wxM0;K_kd8!en6~WFX?fqfqTi&Ohn?N& zIVZGnjw*WlB_@)O-1Qj`Wm29v4KJ+JK~x<$-rM^5KMR-3Q!)`g3rbcv&eTnk$nIwl zUag0n&J0~=86chkdg#60&{!kbm^Hu%$!0L?l_{z=XC-}iGKx(NNIe>%MHdT=q~(H+ z$=kew6_$u9d`L%gjBoIGVUL+C<>UAF%y>DSJ*tl4a%TRxnd8|F*xjBz`7v&k!;zfZ zPTkcQhIK(WAR5}nrO%vuxVQToy2az~YP9|#Vnj$#*nP33*##1xG=4NnRc)szJ8$@{+<`2FIKDlLYLYW022Tqv3c(v_1;}6)R7jEj|#+cw6 z<}4lEcv)k8I>V13CkDlm9ny;T>?_WYziWD5sJuyE{b4*sBLrfVa`IR zyvq8@PS=foxnR8sfAO%`#=l`R-$uQ8S?XllzNv8|*|x!9y)itkaEs6DIsSqJrG3Wh zT6#N3%tb{0zNbI6dk6B0{rmy_?=?@TmXHlHI3OUze|1ly|5H_2+}cFI(#Fuj;XkUL zU1}b#ibvQ!veV)+^b}{}6Y{Wu&M;~yDtKZ@5;Syl4Ny_d=qdTdX7K_<(&i|EOezcm z+K$%kT{&6d;Ja{e-NTWiPHY%OgW8-yP#JRaFsYleQ8FWC+Pf|?h!G0i+TA6+{y z-ZxhsJue^K-LBVbn4y2kzNW-2P74rV=0~u&DHjA~;v=(TCLW|Nsw`QWpPAvor$}LYf@Y)8F|L{Ex={(mF?^7FZD_L{ZeIZel`fBZ`pxein9j@8HsC5#elKZ<9qDUBWy&Km8li=wf|&L?7|T zUbnEIql4yG@-1nsslAGeOKFD3%vt@qriUiQ$Mku9v$Ild)?CNB^*YNME3uriu92pw zi>zs>Mg0dW);ex?9_U|5QB}mtn=^PPmqu8lD=Vvw`M%^ZqIJDc88M>ui9qzhVL1;` zL{z}P^4;}sHseqWM5i-uXUCSNa~-Z(p2RQ;UxlzfZt{}?P^#EvBhKtqNI2>&!C#ON zK=(k)Sg&&pdXluvjRvZ;xcHMbt4(}KcxrQL1e>D)(zNvH0qkZ(X**U#+3gN9dIXAA z9>hEiDJv!L&A;aDYK>6ki7vJ+nGnD1Elo+9J$}>4Jtb?;aplt}%sob<=lN-esda}% z?dt#PH>ow4dRPM^pURml)QQv&xAJ1jnrwk`R330_?j{fmMPQX)S!%Pyjoc_58BLcy zM7b@u#(>^ndjNBh<;B_PV&&Yl2vo$GHZcI9OE)$+sh8oI=z$D{4rmwcRwu6|K)eha zOsMl@N{BWQMT!i*vdU_on%)%S#K4~ZwNR^OsWz-x+{p!@=wZ(VUSAVaG@0wGpCRyZ z1{~xp*C4=Erk=aLqOBhk-zb?op~J8Zb5(#GG*3${H~_OHV}U-tKoA7c`oxQ)e2TDM zG28VB9Hg+xHb^u=Bx!*R8PqLXV*KtWz*k5}^+@9IlN#dFzgr@;E$c$_$ei4h@!>7g zBX^qeNb^gY$xDJRJ$X`3f`1|>7mn9HF{e-&26ca;Fc z+zndzf`(u9=)Vpg!MVrKF{PZb<&gv}H-oVE&C%IEE9Cse2&w6^lw$4FVJyB05fQt005?@SXO!|GhJ{R)##TP zOZGkr`v8L3QJgYOh6##ZG;vk_QF51lL$>~^tBPVNSJrAu%&!IH29s5N4JL4yDNk}j z*7W)@GC64uc(;{fl7KNU=*v$U+-8@3)t?Nqv$$cDlgdAmIGl`rKPEe*`*PMJLB?PK zV~^3ru=%UZ@e>qC)S@gIQPG1;1FKTs!Pw`0aN6(Q72UHmv@X$Bi&^KMq$!QC6eFVZ zb9ujDME<G1DHa5M$) z!hU>0f5e#8q&cOZ&4YP|m}QfxEAa^D;ZeLitID+j>8kSY#(wmmKK*^#4dc#rs!4sS z$-kq*FZ$<2byogQqIh?iE&sgT<{&gG;<+7J^)lzSnZcql{te(wft-NJZv9YDdHL?j z#AkVs1GPZq0!vt9r1ZqoskbF(8&(oAcS)3l-cm^WyF~m}vLsWu9!utF>MZiA0VA}gg zLU+Hk-7Vr4Nwl4{dT_VLR4L-Ml+URfuk$Fn z(QS2RtJnOR?8*%a*A5gqfkI?s{hep~oO!E1PCjGKNe8~w(I##uEo4lnBW>|#UICIB@(+Qz+a=~#jRB(IPGz!6ir&J0x zdV>GXJV0V(7Y51VB}%4)A>^2F{Y6!AD`P2Ff7wD$M9{bjnlDH%950~r&SB9g6y`ni z)xYGE)^x)@ziry{fZAy#UqiTEY)DT!F^fkmGGUnzb_;n4S0xY-RQteCBEyMd7dycrhc`p@5;HF+Oa#~mF+2vBmdAY?^ z%gq30=(vL%kXsdgk|E!brRz5f$|1`!W6V){k=v^+f8rzRc4{PP<`o$68cCRu*NZ~L znlZ$L9gwvYjzGjaxnN8m(mh?Pug#(d9^lYTNO+@8*gRjgV|xd52xO98c8R!P z+bZmeM>!a;VbF)ECsi|yP)|CVIPfiKWql>fQRUqQhj(i)7gL4_*e#a^Ow%-KYR)~x zEj{4d@3IBepk2GTqE;_!+|kKK3T}3N?8*>cjjJ~) zD0_#R_?-w&2}>Zilh;Q~c*G~%fI+AJDEz>lZWnfKqF$9C=cjj!6 zl{vsBkFr&F{9|G$DJ0gpG(AK9M%1|FxjVyo!$3vV!8vT+xQ||njN-7r`cc8&W5v(b zE3}l?ffv15g%wZ&G$IYx%;eG^f3d#fh<;dc6@3pUV?$PcMe(;Bt1Q`Rc=n0+%V)wh z93!9yZuF}1m{?MCt!KN=Dqq{{=dAg|kXuxLw`^{O&`2+#Z4pj^hv@kgwmlM08Mh)s zwLcoqYo*Wg8D~Yuk9Wt&#~jBGn^_2(gO#glO(L)ks+@I9lMUgv!GUiFJVxhWDd|kwKK$@!ND>R-kI#{8vpuU zY}9i`LI^Kq)^tX0P+4YEhb_BhwH@NV|?Z`vQUf6l@e{ z4=_<&Iu|B0|5d_a{*9!~%ddS7W<|GWeAKB&4Y9NoLH<`WM+&lLM0MZd4GjbK9sHvG zC<6?5hbh;ItUSGX*n29O3MEhinyh}hv@7u9kwqPKQRjqR5Mz(EoJxM`F-+Ok+0F~P z=ElrHHRU!p6_6*?eO3t&vrD{%wt zEi7qBxE9Hz(I{@c@#V9UX)tYtK%cAih|5)}TBDGcPPIeWkpD~bzllBWSs4I719~P2uR-G3`d2_#`a;koqP=n&jU@T_%l+qqPI( z$w`Sdkq7)9_&RFI|Lsdr0pE(8)}>H`j57_w>zaWSF%t`DHljP4+1pdoC__Rm|E3W zPvu!O)B%>p#xE-+oa)Gr<&=V!eg}v;H6YMf$np5y6Hz~ zAfQnkARxm3ONb$8V`TiF5yqC9rUU94^0i?U3-i1f4tBKF8rCGfkzoQj#IniM`?xtK zk_B$SBzd#tmCKNvpC=|d<`}wwzPiF7`0KnNZ}2*Oo`wjv83=mzMT8l zkRV7i#g?d{$L%^%r?L_X=E9b44zJhyW7{KgPsZ1i4e&0c#OOyyRvlrYce(F-A7S)+K3n%22j`13n(w)1YWb_V206t{%Y zfA59;Y7{nBpggtxT1E%hHgBb0lR7V7BdIp@8* zO1?<`nka21FV{O+PJV6{^MK?>uM!#Ahh`BYn}=dLfCjTR_!@KMwnKJ06C#m;7=xRS z15=>N&ir#M1y9b5ntGy=cmTeZM%{W_c*&b-CyCo)q5Y9?W>k#bWxcU2xquWWR%le~ zrpfN9@X5u(0$8_o|H}=?G-LPTNW!x`y%1rmndU(Nr`PG$l_@ zc0t~j$tdJP#pQHhcW$Ntq)LQlIVlI<aqt=izxArMfGA*5HQ2WftC3s1{hLc54!A%uC7lsT`6oOG4GCcMu zhDs0$i?zENBznBw;$^+BO@=5%|o6zY*x%2!0^~Sh_OodjUSV z_lJe=Sm?q{fAU>*YWGYAAuV5p2k8Kt;jL4_8^|uJwiNpTfKQbDTKJwwG+8`!1Wq7- zLJT)B&S-y8TJOdE8ja40eOEPbK9f70iXXd*ufU)JkdE7dg=pl?U~;LS@(QZmYd=xBsoTYE(3(7=Cv0kko;*AFHgDX|!B&iveGc0K zygzHV!PkBVpg4cNGg#xpcXTS7QOE(oNt01W70^99hG*%0VLzZ&40|ucFA!>Dbg$Si zr`MXcCCM~yx6Agdh~1pmV*x6dU64guftWtb$szNc*V6$d$rf(6A+|=)d=%dFpGKc( zpNs45F?z}m6lsc2Xo*4PMH#uL_6V7rB8Q`C=mvw_mE_THPN*q%WdbNwBRpzWVp>P@ zR#=DGRC0Jz9IoF~6v~>aU&yx|>M>*Jjg$x1l^Itsz8qsq5jI#7D$4f99_%X6s@@1k zTID%-wpmPCnI_lA^k%u=PJ(;q+~K&%S~jCv-3Wbhz?_ih4|2%!+AK|Ln5~r;35vD6 zf&M;BKc(u%qg0jSb$3H!7qu8wl<=EJ5>pxQdL;JDFLQ+u_-4e~#k|Zu&|#NLNh(MB zQM?PC^`5(weWuA;j`D4>Tin3(+QpUjVe{f1)9c{jO|VMq;MG6H+O}_u9lMN@+W06F z0PUB-qHL8D73Zs;`EivE)n@m(@%>bUYJIUKyMYm}8~>b-Qw6Nwo*WN3r8Sub1lL^% zK4>qZyX1@WUyR@xc(UyZr7O}NwNpb{LNqugL1Ti17p=)lsYsscgd0lN$6OfU}LEio1Co{)`|?=_Vn##_gVvVn<4 zE`~*OL5}N{^Dweo;V~7w9sSY!m>k^@tE_*S@5)Y+^yPwyvG=7uHA?t=WdKnI2ZF90 z3HV9G`UVs`D9Nv*!z#yGhW-oIy%=zRb{duk+15#`BBz?Hw{tUICA8K#xW}%(lbk)R z+FSvi{(k{th506%IGNmuzsP%bE)`Izy*s z*KeVGc(Bs1AWi~EV@D6!Xwv*1=t@NOI1(w&DD|kBE#u^GyEPFhyIsY>;jIn5bYcJz+sZ493-w0D4U{ zN2-%n4DQ|u>ppA)y8=9Qw@C}l?=ZkQVIGiA8$tClGufplY7~%YQika?(on#>W4Vkxt5h%~TP7 z8#(EGn7rdHd4QYx*uapT5c3`IvM#&SE~vc4N&cN zPhmW!bkHv=V>3-kUOdDkIJ!?&nE@rQHTbeMxt)vHO(li>2Z8oNaxpRlisy&ZHoRB=f$Dma`&JTt&KLP z%iO-(TTsYl3QB_ZR##O;gOhU1bN-=Rm*T~>URMhRV;cGc!V(v%;$mG{iN!#2e~4Ar z>+D)r(JgTFq{iWmEE4g1PJ(Mxl>n;YA9+y2kelIyBZj(d-XD2i)c`cASQ zHmVjk$JNzzRTb?XhHNod4!L`u(NPx^)fcOq-R&;>?Gf(ns?u8B>>|xIImJ{9s%+Pr z-FaSKE|>SMj5XK2J~IkW=d@VOgOMhLw>v&Iy2Xa|mIucVCL%NlGQzDB;(cfl zJ-e{A(bU#uN^*dlovIHS{~hAX#H{=vz2F&Db7j|}V~MXFB-I4k@p4`x;#jq_*zvV= z9SYlVzzE~Tz&vuUUwo=>{&QtCxl!v5egEooh1n>3X|_{qV&J{hULC!ysvgl|b9SYX zlN$d#m9f#{V!7GK!zgWd+|xYO==RgsPxbXeidoFxNw93Aj!N<1n|zmX4R2ALCVpq4 zM94rxhbv{+IRUrS5sHm*F#x$JI{2;+dQNKSwdni4SLZ$G`yN-v>;A_}sxk&&&L;fH z4)pxM(5v6q-JwzzPcFyEeCiPRsledt6!^)|fG0cfwM}IP^s&{SKzFtbJWFL36{3-k zF?nGRw+k+p8HTeVw*iI|R|D^7zX+8%6OT_ik|VyfAl;f(T+u#a?5}bRB&PokG#U(ADL$!t+-~CN7A6p?+F>jki6-`*-DLh@` zZA!dI2=(;k^(9-(t4bjFm5p`opv>r|kreaRd~`k^`+hMw+E{HHIGwDuH6k6i<0Hr| zp+Uh|So5>jzvA7y!lD8wak6@QZBw(9q(3A}Y1g9j-jHDy_-X{ehe~H`uo#G1q4;>| z{@7SekJRnu4l+2W6FUXW5>;C2AdgT!;T8XS60EuUVeO{2$*wj(sPp7)o<5|WFW=UZ zW{Ggzv|j?K=BN}Ot(cM@(o$+eKFX2rBC^h}qab4kN`I}77Q zy!NfJX!#+=t7s!biunkgka6Jap3Ivc$4wtkvpClCYmf0W!&?bkL|8Mgb*t)xD$-R= zzjWQBC7i`Xz0K#Xq{Fbl9$&oiHk4b-aa)vWnGQ3jsR$bEM>g2ydg5{&EXI_Sa{$st zd-DY*rcG`(J|hGCAO)W)xDh+)qW^x9rJQQ5mN&c6YQ(TdCX!xic#|JN)ZFQQY z*?#i^J8k8=KW>PXlTXLA0krBs9P24Kq;RK|&9k1yZkZ}-SKmY2MH-?GurN#Z2TZ+gMWHjh&C|e6pEN%@rVjF>Ukk48) zhJ4Otq3c>tTn;0!vD6sfPE>M#B##=N=rG`upa%Uw9@T%N)yggY-yJSRX72s5V2*SC~;5^ukd|@`= z;Eyu-m4-E0AWxo0lQ5T5;3-cVvz%%;d#dK+OzU7Sxr5 zvExanP9Ju!)0jANI>=ckmXYAGRoh`!GZWRd`z(6Lf~)!4{`KGwmr8t`JQf_7%P!g# zR_2xX9dZ%g6dc=8Dyu8%4ZIQgxmJZ}uid9jddE85ZVe3R%VuNY!gk2r6}-Eck4ziy zjtm;tiNw`6ATPT(H}>|*I!V@H)6T)h&sD$P6O|g*oCB}PxLeWVNi23K{ELUBHw`4u zOuJRgX*w&@FEXqu{q?1J(v(@ZY22ZLmO_AQc7D}85i6ABoyPv6m+QRL6(S(uQ#fA0v2^)r*sh2PNcqVkIk&eXcYWeXg&yVG1N6h4@p14W zi#svQC4bTRH8J#P~TrFu+Au82MF06YH0>}c=NB{`tiCubd@+i*wH zi-m2wn>SFyXxD9ZLcR8GiT(*c9k)>lJs@5VCa0Ljzv4@fR&bQ8Gois8x4m+qZLktb6R|W`4M#AWW~)=}ern^or76!R%e%fcjwwFNAb9 z63g;KJi-Bvr9sI@7dGpb&jzt~$1`Pwkk4=uQ{ey;Kya*2L!DIA$ zeJi6;dRt6NO*p%nFor)zG?;^1qStTka8BsDn zn1QgKeUnjoI}+Bzp3IVCzdg|U05m#HD*dA@eP}og$BxeNCH%9hMK)J7gx@*hbgezJ zCfjZr3`Q*smS!Fjr{#Y9St>aqteu;Gy>yqR^+Y&2G1J*Qp?(k1$-=%FeKBA8i^}7I z+T+4v{Gu!TkzH?NOHaKU;!M-K<(@xzWz#Pi?<`!|XHEcM5)h4dHr;O|b1DT|So%fa z-!aUy=@+@)@^nGJ5qN80(McoxMZIT`=}PooHJm1uUruEti|qH#<#3Yc-Z-o=;6*M zDVFRU#qLphyiKInCu=>|uL2CU@*J|8crld!ODkr3Bkkg>T^n&o&FYzxBKJa11+0I{Ec~VoG2&x6B2qlOo;O zO@FH_rq_?0BLy$>tM};7{1m*2d5lNzWD75h14S@~I(47G7rfY*qxW;B#>6Av2*>3u z;5)bXiAZo(D%4Dr3IU&u@?6L}4@SLI^=rz;fAWr-kysvRWT!`e+``RNK$~ zk}PdOY+9ZzXd~;kOBFE(18Q4B^+fLsqbqZ#rnkMIi$JHw=pvfdT}3u)2W~6Ah&NJIQ)4@z zbfPK7RUDsUghqgECAy>_t@##y*XXF;0 zyxr$zhTjkFs7u1eP(*)F~IYFuF}L% z{Brx*Em`^710~1lmm{0GHNrvLrNJZA03nFmuNS3{?8(Y~M}@a|hB~=BhisR8?Ouu_ ztKXLHps63pEtjJ24&|ddhK$NwI6Awox{piCRw2$9j<>2WG-R&1#|Ku@FDkW#EKWs1 z*>+D{JyJW&UY;`#?IhJ;B(Dv#0muGZsX52KM`XyJk5Ap^DhU1Z($JNaP8<6jlUW9z6~N8O(G5K z)y!+MBsDhvntWcd9|#MR`5h7sv6;I2s&c*_)_oL?9@h?%oM6eDHei6&tM4EX3C0Jv zGk%npKFwAGB@6%sc~M{?T}UV%8OORvowjZD83RV(tsw`7Qk3IaMdD)r&@s7{$yaF# zFm5vpDDNzDy)}ih zqque`gU&)6pE+SV(8hS!(7&=Rj-5A8LOLRPFmxg;4k85IcOP=cYo&SiVKB?e<}Z4 z@!18h@+&56Rz+ug0POGWkzSk3LPL;%_GZqcd)yFVQr9`|7t{R3Z4O!Z&{$UTc%D2RUa}lvfo0 zYWU~x8muj45dZeO+}l4p{w;@yvdi~sfXo{+Px`Gl=I@%|RPeq^IC1eO;*fon^Au`{ zSg|WwiCBm~4zD%Qe>-KTN+Wq4i~nkW_}I8R5B}dfLjR|N1e9IJir;E|OWys#=x<JPKL{55Ns#VeME__`8u`3b z``du3=szj`rv2Ld`|m%P|9z@;;coET_&@Cab-Lrd-uD~N>)|&%`2U2tBUPjF+uQ#I z{wdt9+@Is~7yREN^)EJUG-(g7f&AM0f3km?DR zg#S|Xo7XGg|Bc_h@u>#YUxD-QZkE2<|3pkQRd}lZ*hxQGNa5`!8jHL?g(lPv@kcf0 zk1Btj^s5;CXMk$*@6!Tl*sJ~UKYBrWyGi^Z^HzwzKzadnl7eKTNIQj&A?&Oe2HZjaL5&LHuW2oFeSf{prs;1=s(Gn7`4WKsU($@6PaIjeWg5z7D`Y2kUR@IY_$> zua}2^8#L&@0{3^szWVSQb|!bj*2b5hnP{Ll3HNA=y+UTs$hpc)JYl~?+zw5x&$4c> zTB6p~sA3@RCx#vW?2}Q@9Nj{J*n(^bQ`iO3hg-srM>-nVKFF4bIpTgE_lK{mF~((( zPx#bJ4O{NHj2(>%=fgsyq!9a>n>Tgr_yiSN2 z|673M)y;hHof6vj{cj9X1YfNr1E_f=u& zQA&us`a9U#(|V`Me56)-Ss9%8I8L>yHnAoXB^W)C+ay z6NnTFGsmwd+^!ePP8RKcCX5+r(>dmk%3iXyd2-5Txp)kBP#rsTqnj40=x>+iiaaRj zGmKI!)af!AxG#WZoLf4CHGxS!$X-I3&&*(17$G0WU8^{}4%~&jA=5mJ9@R3b-9`1| z{y|qrVOWh*Qrl~>pey*pmuMZ%SBQ9`J5Ydtpw8p!7fh{>#%+d+htRxxdCAq=4%=-b zP1DvE&B!XN(k9xuk8#-M{O@3FRca(duot878_Q-3rG?>L_&ZpyQW=rp6 zEn^8L=A^p(oUI1!sP`{%1Z!Chztb6uEDCikNLlbC+H)1Et%Ff2mojV?=VPN^dRd5Z zcof1NCnx&)k*S_vfl4>&@C?65G9CGyBMI&-d=jw;;gM17&RMVG2vr)=Ybj1c(w%=z zz>{C4b&Bgqrpx_tGIYSDwtVY_$MX3fSq!`OCW{(hlch?c|M#z_f8>e$^XqA~)`KU; z0$NV8=5li9077#Vo9Y&Z?ngaL3sLw+&(p&* zgfl-;34sF^!(}O>iw|)%-uw7|$sM)Mp4lC>mp^z~AE-Syz|;J{xIH&6Ai95ap2=Ma z?RJi4on01awLZM{6fp}V8M-nhrZHpc>jHcxbgrwqb5eV3`t$-NKf?$I1^jsCFR6{ZkUCsWoWKzw-c$)1%G^N`gJ zL*_6xj66QaaF6^MO1FiPAmU0Yt;5)A-zvI^`EnPDYmF>(F{{@`V7hHIgKON26Eh;z z$0ucp1RivX+>dQW26XvpBk6oP42Qud{~EN+PH0T@+)OgrrK(hpR)04;KXRn|11b?GHi5Y9|_V5rls zTP9ma>TMv5=4vR{Sh)iI#^*7cqnM8sYpm~O&6P@LQ3e0 zCu`e$68#G&QSG&8ht^olF})+#HTQ|Uwek_%l=3<4ams%6JY@530jmM|kN?L3Olfq{u{76De@?MzXkvK>%OH}j~n;B-eDFIO-}U(#1n z2HB1u>Z(r6QH~!*kcEubZ}t>pGDFZPE7tGxhxkjUBDOGBE7$<+t=D|6x+QM0ehK;I zO_J=#!kaIxicIA~SLh!3TExx1Kk1y0n`gJg_lAYZcVn_<5R~b_Jj7Vb&ypPAYmhJH%PJD zp-F<*7D=TlMKVDUI-I7Q&Yh~O@JMs*j9Wo9;~UW*ua8}R5ToaX6wnA(*dFh)<(tju zD_KUTS|FCV2|M~gKi`XUQFJma(=>n?b@jUB_lNYT-lqw- zE*8MmwB#h<6owS`Nx=RN@Dq}o5JuRlFYHr?T`NJWWwKCL~aE7VGlrDH4rosa7UYe=l#7wi-ua zgCI=mc+SlCBIV$2!jF5^`GK@fv?lKZDUY&Khx|0uPz9%CL4#=h5Ev>156oX0jgon} z&l9h`HA#uT9m@(U6)_MUKi2kPl|MWha5U__?-dr~Z|<;gxxb?9wtI9~NTw2QRPeS`tA=r}V-BIG|omh?{=NCe6Gsn8*VAU#JHT6TH45&rdPX z+>wPp@6;Ve+xXcq{hs;5&g_=#3=saHfIgS~U|N6y#8VTuF z9?7M4ESm7#rP+3=cdp%=xda-t_cNvAp+}muwY8n&BrQf6OQ~N@u}kOfttA?@p#%<= zkdP<*O^|y;EDz!Y<-3p)1f>T~BvWIcY{UV}H7Rjz+w0 ztAbGB_s^t{Y)rFrf%dHdsotO4T}B8mAkJYU1Xa)a$Yzy(BIWgc zdSlG_RRY zPq%u=oA`a8Bs6%5ax^Y88?z2F$Ru>Y@UHS|7?0)g?K7oF1q~e#KXHh9g72Z5uY=~^ z<9>(X4QF0_80V}@p4lcVf_w0Bzp=M)78D$nDahzdDs9_Jzc1+fZ_}BZz z>%lWvID#Bjrm4ndqH#OD76qtTH8UhQXk|jS6*P~qI!#P*_UwL2$t0cki#HOH))lso znU9LFV(S!*s@0_}y<;6}OG1GuG^Ns3 zSUDglhP5ozK$pLZ-(Y8!DF&2uFQSH&nma?RiL*{UKfwVWa>JYB=-L7 z?C_eh`_ei~Pf&NvoYA2?rak=W3(>Md#tjEDQQI>46@{T#>V=gl_U0Mf2uo-$t8YYH z#cQTJQ&(`PcY{Xx^Tu}w!fzPC3SA!Bwxmf9iJrq{BG((C!~1<+UKLqhoT{ccaz}2Q z`(Yo#F#QJP_2`$D~z(p`bK*(Z1!aT zbP)>>%I_h&K+f(!-=OSHKJUmr??^oF$Sixw`EeUTBJ&vMrM%_0C5RX+5Z$l zYHlWO)~5fOa_F}R>y)H{GjMTPazecn=lU)`%rN1DnB%)H7)aWP_;CE0PsVWYZ_#|t zx^CA6!fDBGLSHLBXJ2ym1f7j{Gw-u5o+lhV8w6I?Jz4Zx?3c;O`^-E-q446F57^O1 zXc-IZqI%h}M|c_g+2~|bFWAZYSkY1yAZSc8K3mh5ShJ-Q%leLkpy$-&7=|e#xvZk)4BTyZj0Vem~RUc~e z*b|btMaMY=bWI}0*M7?Q>KEP0#<$);8P*Zxfy*IxIPYWb4zw80} z&7{OEwk9IYWW;{S^#qSXJebn=C$T({PZe`j+J4Ef$-u!Gt29{tuz)Um`m$;tB66W1 zJVq^isX3<>F`xRaHi_(}?cI$(^Z}zi)!_QEM+xN+SIb5((I}Cp6OHR0(Q5y!JM3P1 z$H~vrn*|{cC*_7NL2l0<3}(^W={^rF+#3vDeqA@{J|`MC$Tla&jtNhWEO|oTKlCUj z6zTY2IwX}jeS?vuCv1J6fN;qzBWL0;3?s`ls<=jK-SQyxBUytEzqU#a$wk#%1AibbMMJZn&006El#xwZA9gw8)Kw}jlQBIen0qN>$2F7G zNT;5t!oVI$xCO~2o@#JP>Gmtv!rsmM^?Elaw^?*Of%{cHpoKh+w3ZNXUNE-<`hH}3 zZHi(pB}e!M-X*xWr7%{huBmq7>9e5K!5MJDuo?SK9~T5a@@7!9y2(9mA}Gk$n9c=p zs<|2Y8lWA=!PrMc;nrPE;YW-Gf*!FN#3iyg(#{=(*0H4XNZNlt z9GT^oLh<#o&#@_5uJEtz;k|Fxwcxj~&aW;OoCzE?*8m8IWl|0wlW}m8Fo44kEZx2Xmf;W+`Q(fzYoM zz>I4Me3|?-K!N=>5P<(JUv4`o5c^6DOfCe~mex)Q@qD@`yr67Xb}-{7dpuON(0PA6xpfNWio;5 zm*^{xBD!9({thhgi}^mM_6&n$Q5y3p?op;p_(xe!N&gc6I-00wx#tp!_>FRrV*}|I%9m*k;KnR>2g(&m z>60N)jGTU``-2sGdVy=4`tZ1kav>XgO;DWM@VF^YVY-=EDw$4F_DHu>gY29j zvFRX8Bg+zt#Q3vWcM1ixx=DBzBrx!XPXabRNF2mS9=7jfM$5%0F}?|cd#EU&7*Zi~ ziJ>0cmosDJVwM>HSpP#9d*91NEIbQiNH!xvp`>In^Rp6F=@J@dw$eCUyel=Iyr-C4 z`4XASsYJ?B3s$!HI8wYTaa#kjs7LEHg_-j9 zD+@|HO`BGD)*NVk8M-{*=A`e_eEhWsNQwX``6@x3x-V7~uWN%6ek#trqyk|e#T^E0 z%UacnjDIS_y6Mhi7{V5aE2sp{z1mi;nSzXmENdcjA(kOFGt#{>2FIcDp-`dB;JWa- z2m4`6Q4AFxH%1UE5@V3>{Sn|8uL0h>?sz2urWBAUq)99d1_I~-88^~OrQ=^~p}naA zDcSv#4MVPCAi-2YWgLnnr=j}FYsR_kS5jbV0j@lr#Fkh641mlSDTmVerBpNn<#iKFWj9EGWq20B zP={Lp$iXJDYhzysWFeqhc$=Un2I`FMG-`;4ErUJbjS!X)wiB_Llm<$l_`N5gAXxwa zF=jO%*b81`eCZvgUxqKW#P}aE4hP8b?v2s;BgStCApO#P`whwd2y%m%KZ4u{;YtzA zB#@i$n0OWpynhXH59#$%;jh~qzsT<6pVGucs730OA%D@`r)yH=su?Yky?IJ_99CN0 zUjXskeA;gTdGe#(=ltr8N!pJEDc`KXJf%POuj5>4fq8^5@3VjPbw};zf{Z+fC10pp zLV)+N9I^>@QqR?ja?`Rh?8yZ}aq9Gnw^AR~^|542+1)HD6Xo_%DI;wPAIO)Iex)?KNHO&q;n`oJitJ$TQTa0n z3%la$l1|8LB_fB=tHlS@niC&U`!!vIkZ{AM0OS_e>?)>W&0hMbPr5C_A+l=Zc0H?V(WQu=CN%P_7FUjEmpZI{c|M}#x zJQr;pg7W6gJIXh22>z%0#(&*0MlZp7shK~(ob!wsp2%hmKFU9Qg1*=J`S>W9mCWnS;hE$>hkAV?U z@l;jj=%f}CJ_jUv1H`TshXCnHlTD-b=+s)w6tAXf&44rhC1=b++8Gy(*H{GdHi5v^ z`PJ8oS*S2)bv^~JyU~>S=Ju54!}eW1yi&w&(PlhuY9T?s0+-Ltk%R*RA8i{ts)*H+ zD+JBBC}_mCG`;U-L4A@+zSA;ReO;GaD|w z3c~3m5en;ih!nZ_whLxYYNS*p>`GXp?AIcY*9%}H;>Hnw=#FKkPm)Y;vu`+>9=lew zuSQPfDYqFZkYa|f)5u-XwnVEJJUy14Qf@!vGG^>&U`yR1BNdtAz|_S}ypZ6KnLV_x0?K-@m>nBC z0i|B9r#Or@a`P&*upx0+US+Pcb~woC^&DJgWF9^!#x*G-(Ji^h^?AYYG;uba?6Hm$ z3sn*ga1jc5;kz2Nd8=Q~qNv?i^V-<0RjC{JH83J8j5QYRtPOtyp$a|wN1>(Djk(*W zzZa@x6H)?a#2a#a@Tkh2nO#jIXfg7c+TNEvVzU;TD|*KtD(a`^?XjCSdaSuLuvQ39 zagO9*H6SBy(TIn^-WS!$KN*FXPVXAGkVVK|YPGG-!D^<&ArPX_u_PNqz>eT{anOE; zXdozOnm>?^Z)u%XT_+r@KeVq4TYw=>Vm%2Sf{t^)Jw>YaJ$HkX3eDx(BJ{DqeBH|veKuP>!@(J zEG(=&19hZ%#s!;0gaB8GGZRb!M;(NErI~!iJ~Kw$6drL1<&ku30vXw6-Dh@g>u2OA z1_Di7kwyc z_757$9R(a%SNThCW=`RH)^=!iG5s&%7xE09YXOC&9XP0q4hMjfx~B3o@;nNSuQ!+2IUca~tUh!z8jEu?BP zgC}m7xVT=Q4ZC#wZv9s_E>h}qQjLL%^|Fav*T^nWgC4*_$#L|!*G zKA2f8n0~^kIlc2GddQT~toh+r)BtkWuGUfxEt5F z-Z`pbOWCz>Gz|xT%{QbuaYzq}1>%o%eOGtv$kf7yG0#|D*BIEzN=h1mb#28rxX+?f zc-`e>7vKT83m9Zf4Y_Am_Fh_drw)eXJmNLb8fo1*_ssb2(V~!lW~cSNbkO};v2`=$ zy~1ovb@$M^Ir9>KOLVEJ`{W$0DdO@es99c6HY$OpaP&q7{3V|3k}wHU`QBR%RAG=c zoQ-5h@4DJzrpl!hqQ7<`JUG8S!Z%FZJT}E!WmdcHnPHWFGAHlYRo9}A<06h?wsX35 z^f=_IbamO*;9~UaAww`5Pv@!mX@#DKddzV1yW#-dt^Cti+yl2ErP=@uxAr{D3$Nw( zo#}?^jih2fHxHnX8<*y6`z~|2Z0lWJ07${hPI)2OLX@TZ68@=MzhuMH;A>IrNwz+l zY!BG(%o`(7euJVzsONgDKiab4-A5+@J9a>fBK7HA-=YIv#ADo&ORf|Cli$i5Us2-^ z_pKpuIsHr6^m8Y8FHuCEAf=fxSN?k~+9aG!@G81Vv~M&7(g+3G6zweSbhtN_U38k1e&Hg` zlw_eqVWm_#N87-U>eCg1ctRBM^Zoao_`)a4ubq*D@X1c7tKwq=F-e)^7bN3CQfipQ zq?me;5%C%z_&Lq$ux5M7RK?e-!(CUBDNo>MaJQqNqtCt|Dz3NRj|Y5i7QP4ym@-f#Ur-r$bO+ryaV4 z38fyu6p%nt_TaZ6@%KQ8qT<42*R#Gl&d4~GqUb2HZQ#ewVrC$^nU)z{Jwd&I3oIzc zYej&}Q|k2dDpnhTizkQ}NDRyY8UojW>}DipMrI;r0a+t&fkN>+z^*tfAe4(ENEqlB z4;dd67ZfiZ_ds?lP5cSPiq_@z*}(;>9vwjHLg|884-Y_f;dDWCVRRv6k06W{#09{) zK(L1hV(LT-A_92pVffJa-tpl9pujR__&Sj~8evt^+@u8YcpyxWI*8K@!-XGAYsTRM zQxDCD!G{3gbm6YYS_;hy5`+OTx-f%zL4u$Q;5`r{j)q)$Iw~#kS~omR4OkB1oL0h) zn;F70BjZcVk{qXw1oDCOU5NQ|8L4sNs6b*aXl-fwV$4+XL+mbiZCQ*oT5$|R8X%kc z&sCHQakfM5W>{@GtD+8+Jn@-BOdw4cg0}1`YR@<>GbSDBQ%cYHYmkErN?WQO>23VO z5G3gRJp{(HI59a&qBO7�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 aW}#IL0p6@^AdSL6m<=2e`wG;`zyJVWr;Eh^ literal 0 HcmV?d00001 diff --git a/src/com/jcraft/jzlib/Adler32.java b/src/com/jcraft/jzlib/Adler32.java deleted file mode 100644 index d8b6ef863..000000000 --- a/src/com/jcraft/jzlib/Adler32.java +++ /dev/null @@ -1,94 +0,0 @@ -/* -*-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=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(); - } - */ -} diff --git a/src/com/jcraft/jzlib/Deflate.java b/src/com/jcraft/jzlib/Deflate.java deleted file mode 100644 index 99788020b..000000000 --- a/src/com/jcraft/jzlib/Deflate.java +++ /dev/null @@ -1,1623 +0,0 @@ -/* -*-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 -final class Deflate{ - - static final private int MAX_MEM_LEVEL=9; - - static final private int Z_DEFAULT_COMPRESSION=-1; - - static final private int MAX_WBITS=15; // 32K LZ77 window - static final private int DEF_MEM_LEVEL=8; - - static class Config{ - int good_length; // reduce lazy search above this match length - int max_lazy; // do not perform lazy search above this match length - int nice_length; // quit search above this match length - int max_chain; - int func; - Config(int good_length, int max_lazy, - int nice_length, int max_chain, int func){ - this.good_length=good_length; - this.max_lazy=max_lazy; - this.nice_length=nice_length; - this.max_chain=max_chain; - this.func=func; - } - } - - static final private int STORED=0; - static final private int FAST=1; - static final private int SLOW=2; - static final private Config[] config_table; - static{ - config_table=new Config[10]; - // good lazy nice chain - config_table[0]=new Config(0, 0, 0, 0, STORED); - config_table[1]=new Config(4, 4, 8, 4, FAST); - config_table[2]=new Config(4, 5, 16, 8, FAST); - config_table[3]=new Config(4, 6, 32, 32, FAST); - - config_table[4]=new Config(4, 4, 16, 16, SLOW); - config_table[5]=new Config(8, 16, 32, 32, SLOW); - config_table[6]=new Config(8, 16, 128, 128, SLOW); - config_table[7]=new Config(8, 32, 128, 256, SLOW); - config_table[8]=new Config(32, 128, 258, 1024, SLOW); - config_table[9]=new Config(32, 258, 258, 4096, SLOW); - } - - static final private String[] z_errmsg = { - "need dictionary", // Z_NEED_DICT 2 - "stream end", // Z_STREAM_END 1 - "", // Z_OK 0 - "file error", // Z_ERRNO (-1) - "stream error", // Z_STREAM_ERROR (-2) - "data error", // Z_DATA_ERROR (-3) - "insufficient memory", // Z_MEM_ERROR (-4) - "buffer error", // Z_BUF_ERROR (-5) - "incompatible version",// Z_VERSION_ERROR (-6) - "" - }; - - // block not completed, need more input or more output - static final private int NeedMore=0; - - // block flush performed - static final private int BlockDone=1; - - // finish started, need only more output at next deflate - static final private int FinishStarted=2; - - // finish done, accept no more input or output - static final private int FinishDone=3; - - // preset dictionary flag in zlib header - static final private int PRESET_DICT=0x20; - - static final private int Z_FILTERED=1; - static final private int Z_HUFFMAN_ONLY=2; - static final private int Z_DEFAULT_STRATEGY=0; - - static final private int Z_NO_FLUSH=0; - static final private int Z_PARTIAL_FLUSH=1; - static final private int Z_SYNC_FLUSH=2; - static final private int Z_FULL_FLUSH=3; - static final private int Z_FINISH=4; - - 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 INIT_STATE=42; - static final private int BUSY_STATE=113; - static final private int FINISH_STATE=666; - - // The deflate compression method - static final private int Z_DEFLATED=8; - - static final private int STORED_BLOCK=0; - static final private int STATIC_TREES=1; - static final private int DYN_TREES=2; - - // The three kinds of block type - static final private int Z_BINARY=0; - static final private int Z_ASCII=1; - static final private int Z_UNKNOWN=2; - - static final private int Buf_size=8*2; - - // repeat previous bit length 3-6 times (2 bits of repeat count) - static final private int REP_3_6=16; - - // repeat a zero length 3-10 times (3 bits of repeat count) - static final private int REPZ_3_10=17; - - // repeat a zero length 11-138 times (7 bits of repeat count) - static final private int REPZ_11_138=18; - - static final private int MIN_MATCH=3; - static final private int MAX_MATCH=258; - static final private int MIN_LOOKAHEAD=(MAX_MATCH+MIN_MATCH+1); - - static final private int MAX_BITS=15; - static final private int D_CODES=30; - static final private int BL_CODES=19; - static final private int LENGTH_CODES=29; - static final private int LITERALS=256; - static final private int L_CODES=(LITERALS+1+LENGTH_CODES); - static final private int HEAP_SIZE=(2*L_CODES+1); - - static final private int END_BLOCK=256; - - ZStream strm; // pointer back to this zlib stream - int status; // as the name implies - byte[] pending_buf; // output still pending - int pending_buf_size; // size of pending_buf - int pending_out; // next pending byte to output to the stream - int pending; // nb of bytes in the pending buffer - int noheader; // suppress zlib header and adler32 - byte data_type; // UNKNOWN, BINARY or ASCII - byte method; // STORED (for zip only) or DEFLATED - int last_flush; // value of flush param for previous deflate call - - int w_size; // LZ77 window size (32K by default) - int w_bits; // log2(w_size) (8..16) - int w_mask; // w_size - 1 - - byte[] window; - // Sliding window. Input bytes are read into the second half of the window, - // and move to the first half later to keep a dictionary of at least wSize - // bytes. With this organization, matches are limited to a distance of - // wSize-MAX_MATCH bytes, but this ensures that IO is always - // performed with a length multiple of the block size. Also, it limits - // the window size to 64K, which is quite useful on MSDOS. - // To do: use the user input buffer as sliding window. - - int window_size; - // Actual size of window: 2*wSize, except when the user input buffer - // is directly used as sliding window. - - short[] prev; - // Link to older string with same hash index. To limit the size of this - // array to 64K, this link is maintained only for the last 32K strings. - // An index in this array is thus a window index modulo 32K. - - short[] head; // Heads of the hash chains or NIL. - - int ins_h; // hash index of string to be inserted - int hash_size; // number of elements in hash table - int hash_bits; // log2(hash_size) - int hash_mask; // hash_size-1 - - // Number of bits by which ins_h must be shifted at each input - // step. It must be such that after MIN_MATCH steps, the oldest - // byte no longer takes part in the hash key, that is: - // hash_shift * MIN_MATCH >= hash_bits - int hash_shift; - - // Window position at the beginning of the current output block. Gets - // negative when the window is moved backwards. - - int block_start; - - int match_length; // length of best match - int prev_match; // previous match - int match_available; // set if previous match exists - int strstart; // start of string to insert - int match_start; // start of matching string - int lookahead; // number of valid bytes ahead in window - - // Length of the best match at previous step. Matches not greater than this - // are discarded. This is used in the lazy match evaluation. - int prev_length; - - // To speed up deflation, hash chains are never searched beyond this - // length. A higher limit improves compression ratio but degrades the speed. - int max_chain_length; - - // Attempt to find a better match only when the current match is strictly - // smaller than this value. This mechanism is used only for compression - // levels >= 4. - int max_lazy_match; - - // Insert new strings in the hash table only if the match length is not - // greater than this length. This saves time but degrades compression. - // max_insert_length is used only for compression levels <= 3. - - int level; // compression level (1..9) - int strategy; // favor or force Huffman coding - - // Use a faster search when the previous match is longer than this - int good_match; - - // Stop searching when current match exceeds this - int nice_match; - - short[] dyn_ltree; // literal and length tree - short[] dyn_dtree; // distance tree - short[] bl_tree; // Huffman tree for bit lengths - - Tree l_desc=new Tree(); // desc for literal tree - Tree d_desc=new Tree(); // desc for distance tree - Tree bl_desc=new Tree(); // desc for bit length tree - - // number of codes at each bit length for an optimal tree - short[] bl_count=new short[MAX_BITS+1]; - - // heap used to build the Huffman trees - int[] heap=new int[2*L_CODES+1]; - - int heap_len; // number of elements in the heap - int heap_max; // element of largest frequency - // The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. - // The same heap array is used to build all trees. - - // Depth of each subtree used as tie breaker for trees of equal frequency - byte[] depth=new byte[2*L_CODES+1]; - - int l_buf; // index for literals or lengths */ - - // Size of match buffer for literals/lengths. There are 4 reasons for - // limiting lit_bufsize to 64K: - // - frequencies can be kept in 16 bit counters - // - if compression is not successful for the first block, all input - // data is still in the window so we can still emit a stored block even - // when input comes from standard input. (This can also be done for - // all blocks if lit_bufsize is not greater than 32K.) - // - if compression is not successful for a file smaller than 64K, we can - // even emit a stored file instead of a stored block (saving 5 bytes). - // This is applicable only for zip (not gzip or zlib). - // - creating new Huffman trees less frequently may not provide fast - // adaptation to changes in the input data statistics. (Take for - // example a binary file with poorly compressible code followed by - // a highly compressible string table.) Smaller buffer sizes give - // fast adaptation but have of course the overhead of transmitting - // trees more frequently. - // - I can't count above 4 - int lit_bufsize; - - int last_lit; // running index in l_buf - - // Buffer for distances. To simplify the code, d_buf and l_buf have - // the same number of elements. To use different lengths, an extra flag - // array would be necessary. - - int d_buf; // index of pendig_buf - - int opt_len; // bit length of current block with optimal trees - int static_len; // bit length of current block with static trees - int matches; // number of string matches in current block - int last_eob_len; // bit length of EOB code for last block - - // Output buffer. bits are inserted starting at the bottom (least - // significant bits). - short bi_buf; - - // Number of valid bits in bi_buf. All bits above the last valid bit - // are always zero. - int bi_valid; - - Deflate(){ - dyn_ltree=new short[HEAP_SIZE*2]; - dyn_dtree=new short[(2*D_CODES+1)*2]; // distance tree - bl_tree=new short[(2*BL_CODES+1)*2]; // Huffman tree for bit lengths - } - - void lm_init() { - window_size=2*w_size; - - head[hash_size-1]=0; - for(int i=0; i= 3; max_blindex--) { - if (bl_tree[Tree.bl_order[max_blindex]*2+1] != 0) break; - } - // Update opt_len to include the bit length tree and counts - opt_len += 3*(max_blindex+1) + 5+5+4; - - return max_blindex; - } - - - // Send the header for a block using dynamic Huffman trees: the counts, the - // lengths of the bit length codes, the literal tree and the distance tree. - // IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. - void send_all_trees(int lcodes, int dcodes, int blcodes){ - int rank; // index in bl_order - - send_bits(lcodes-257, 5); // not +255 as stated in appnote.txt - send_bits(dcodes-1, 5); - send_bits(blcodes-4, 4); // not -3 as stated in appnote.txt - for (rank = 0; rank < blcodes; rank++) { - send_bits(bl_tree[Tree.bl_order[rank]*2+1], 3); - } - send_tree(dyn_ltree, lcodes-1); // literal tree - send_tree(dyn_dtree, dcodes-1); // distance tree - } - - // Send a literal or distance tree in compressed form, using the codes in - // bl_tree. - void send_tree (short[] tree,// the tree to be sent - int max_code // and its largest code of non zero frequency - ){ - int n; // iterates over all tree elements - int prevlen = -1; // last emitted length - int curlen; // length of current code - int nextlen = tree[0*2+1]; // length of next code - int count = 0; // repeat count of the current code - int max_count = 7; // max repeat count - int min_count = 4; // min repeat count - - if (nextlen == 0){ max_count = 138; min_count = 3; } - - for (n = 0; n <= max_code; n++) { - curlen = nextlen; nextlen = tree[(n+1)*2+1]; - if(++count < max_count && curlen == nextlen) { - continue; - } - else if(count < min_count) { - do { send_code(curlen, bl_tree); } while (--count != 0); - } - else if(curlen != 0){ - if(curlen != prevlen){ - send_code(curlen, bl_tree); count--; - } - send_code(REP_3_6, bl_tree); - send_bits(count-3, 2); - } - else if(count <= 10){ - send_code(REPZ_3_10, bl_tree); - send_bits(count-3, 3); - } - else{ - send_code(REPZ_11_138, bl_tree); - send_bits(count-11, 7); - } - count = 0; prevlen = curlen; - if(nextlen == 0){ - max_count = 138; min_count = 3; - } - else if(curlen == nextlen){ - max_count = 6; min_count = 3; - } - else{ - max_count = 7; min_count = 4; - } - } - } - - // Output a byte on the stream. - // IN assertion: there is enough room in pending_buf. - final void put_byte(byte[] p, int start, int len){ - System.arraycopy(p, start, pending_buf, pending, len); - pending+=len; - } - - final void put_byte(byte c){ - pending_buf[pending++]=c; - } - final void put_short(int w) { - put_byte((byte)(w/*&0xff*/)); - put_byte((byte)(w>>>8)); - } - final void putShortMSB(int b){ - put_byte((byte)(b>>8)); - put_byte((byte)(b/*&0xff*/)); - } - - final void send_code(int c, short[] tree){ - int c2=c*2; - send_bits((tree[c2]&0xffff), (tree[c2+1]&0xffff)); - } - - void send_bits(int value, int length){ - int len = length; - if (bi_valid > (int)Buf_size - len) { - int val = value; -// bi_buf |= (val << bi_valid); - bi_buf |= ((val << bi_valid)&0xffff); - put_short(bi_buf); - bi_buf = (short)(val >>> (Buf_size - bi_valid)); - bi_valid += len - Buf_size; - } else { -// bi_buf |= (value) << bi_valid; - bi_buf |= (((value) << bi_valid)&0xffff); - bi_valid += len; - } - } - - // Send one empty static block to give enough lookahead for inflate. - // This takes 10 bits, of which 7 may remain in the bit buffer. - // The current inflate code requires 9 bits of lookahead. If the - // last two codes for the previous block (real code plus EOB) were coded - // on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode - // the last real code. In this case we send two empty static blocks instead - // of one. (There are no problems if the previous block is stored or fixed.) - // To simplify the code, we assume the worst case of last real code encoded - // on one bit only. - void _tr_align(){ - send_bits(STATIC_TREES<<1, 3); - send_code(END_BLOCK, StaticTree.static_ltree); - - bi_flush(); - - // Of the 10 bits for the empty block, we have already sent - // (10 - bi_valid) bits. The lookahead for the last real code (before - // the EOB of the previous block) was thus at least one plus the length - // of the EOB plus what we have just sent of the empty static block. - if (1 + last_eob_len + 10 - bi_valid < 9) { - send_bits(STATIC_TREES<<1, 3); - send_code(END_BLOCK, StaticTree.static_ltree); - bi_flush(); - } - last_eob_len = 7; - } - - - // Save the match info and tally the frequency counts. Return true if - // the current block must be flushed. - boolean _tr_tally (int dist, // distance of matched string - int lc // match length-MIN_MATCH or unmatched char (if dist==0) - ){ - - pending_buf[d_buf+last_lit*2] = (byte)(dist>>>8); - pending_buf[d_buf+last_lit*2+1] = (byte)dist; - - pending_buf[l_buf+last_lit] = (byte)lc; last_lit++; - - if (dist == 0) { - // lc is the unmatched char - dyn_ltree[lc*2]++; - } - else { - matches++; - // Here, lc is the match length - MIN_MATCH - dist--; // dist = match distance - 1 - dyn_ltree[(Tree._length_code[lc]+LITERALS+1)*2]++; - dyn_dtree[Tree.d_code(dist)*2]++; - } - - if ((last_lit & 0x1fff) == 0 && level > 2) { - // Compute an upper bound for the compressed length - int out_length = last_lit*8; - int in_length = strstart - block_start; - int dcode; - for (dcode = 0; dcode < D_CODES; dcode++) { - out_length += (int)dyn_dtree[dcode*2] * - (5L+Tree.extra_dbits[dcode]); - } - out_length >>>= 3; - if ((matches < (last_lit/2)) && out_length < in_length/2) return true; - } - - return (last_lit == lit_bufsize-1); - // We avoid equality with lit_bufsize because of wraparound at 64K - // on 16 bit machines and because stored blocks are restricted to - // 64K-1 bytes. - } - - // Send the block data compressed using the given Huffman trees - void compress_block(short[] ltree, short[] dtree){ - int dist; // distance of matched string - int lc; // match length or unmatched char (if dist == 0) - int lx = 0; // running index in l_buf - int code; // the code to send - int extra; // number of extra bits to send - - if (last_lit != 0){ - do{ - dist=((pending_buf[d_buf+lx*2]<<8)&0xff00)| - (pending_buf[d_buf+lx*2+1]&0xff); - lc=(pending_buf[l_buf+lx])&0xff; lx++; - - if(dist == 0){ - send_code(lc, ltree); // send a literal byte - } - else{ - // Here, lc is the match length - MIN_MATCH - code = Tree._length_code[lc]; - - send_code(code+LITERALS+1, ltree); // send the length code - extra = Tree.extra_lbits[code]; - if(extra != 0){ - lc -= Tree.base_length[code]; - send_bits(lc, extra); // send the extra length bits - } - dist--; // dist is now the match distance - 1 - code = Tree.d_code(dist); - - send_code(code, dtree); // send the distance code - extra = Tree.extra_dbits[code]; - if (extra != 0) { - dist -= Tree.base_dist[code]; - send_bits(dist, extra); // send the extra distance bits - } - } // literal or match pair ? - - // Check that the overlay between pending_buf and d_buf+l_buf is ok: - } - while (lx < last_lit); - } - - send_code(END_BLOCK, ltree); - last_eob_len = ltree[END_BLOCK*2+1]; - } - - // Set the data type to ASCII or BINARY, using a crude approximation: - // binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise. - // IN assertion: the fields freq of dyn_ltree are set and the total of all - // frequencies does not exceed 64K (to fit in an int on 16 bit machines). - void set_data_type(){ - int n = 0; - int ascii_freq = 0; - int bin_freq = 0; - while(n<7){ bin_freq += dyn_ltree[n*2]; n++;} - while(n<128){ ascii_freq += dyn_ltree[n*2]; n++;} - while(n (ascii_freq >>> 2) ? Z_BINARY : Z_ASCII); - } - - // Flush the bit buffer, keeping at most 7 bits in it. - void bi_flush(){ - if (bi_valid == 16) { - put_short(bi_buf); - bi_buf=0; - bi_valid=0; - } - else if (bi_valid >= 8) { - put_byte((byte)bi_buf); - bi_buf>>>=8; - bi_valid-=8; - } - } - - // Flush the bit buffer and align the output on a byte boundary - void bi_windup(){ - if (bi_valid > 8) { - put_short(bi_buf); - } else if (bi_valid > 0) { - put_byte((byte)bi_buf); - } - bi_buf = 0; - bi_valid = 0; - } - - // Copy a stored block, storing first the length and its - // one's complement if requested. - void copy_block(int buf, // the input data - int len, // its length - boolean header // true if block header must be written - ){ - int index=0; - bi_windup(); // align on byte boundary - last_eob_len = 8; // enough lookahead for inflate - - if (header) { - put_short((short)len); - put_short((short)~len); - } - - // while(len--!=0) { - // put_byte(window[buf+index]); - // index++; - // } - put_byte(window, buf, len); - } - - void flush_block_only(boolean eof){ - _tr_flush_block(block_start>=0 ? block_start : -1, - strstart-block_start, - eof); - block_start=strstart; - strm.flush_pending(); - } - - // Copy without compression as much as possible from the input stream, return - // the current block state. - // This function does not insert new strings in the dictionary since - // uncompressible data is probably not useful. This function is used - // only for the level=0 compression option. - // NOTE: this function should be optimized to avoid extra copying from - // window to pending_buf. - int deflate_stored(int flush){ - // Stored blocks are limited to 0xffff bytes, pending_buf is limited - // to pending_buf_size, and each stored block has a 5 byte header: - - int max_block_size = 0xffff; - int max_start; - - if(max_block_size > pending_buf_size - 5) { - max_block_size = pending_buf_size - 5; - } - - // Copy as much as possible from input to output: - while(true){ - // Fill the window as much as possible: - if(lookahead<=1){ - fill_window(); - if(lookahead==0 && flush==Z_NO_FLUSH) return NeedMore; - if(lookahead==0) break; // flush the current block - } - - strstart+=lookahead; - lookahead=0; - - // Emit a stored block if pending_buf will be full: - max_start=block_start+max_block_size; - if(strstart==0|| strstart>=max_start) { - // strstart == 0 is possible when wraparound on 16-bit machine - lookahead = (int)(strstart-max_start); - strstart = (int)max_start; - - flush_block_only(false); - if(strm.avail_out==0) return NeedMore; - - } - - // Flush if we may have to slide, otherwise block_start may become - // negative and the data will be gone: - if(strstart-block_start >= w_size-MIN_LOOKAHEAD) { - flush_block_only(false); - if(strm.avail_out==0) return NeedMore; - } - } - - flush_block_only(flush == Z_FINISH); - if(strm.avail_out==0) - return (flush == Z_FINISH) ? FinishStarted : NeedMore; - - return flush == Z_FINISH ? FinishDone : BlockDone; - } - - // Send a stored block - void _tr_stored_block(int buf, // input block - int stored_len, // length of input block - boolean eof // true if this is the last block for a file - ){ - send_bits((STORED_BLOCK<<1)+(eof?1:0), 3); // send block type - copy_block(buf, stored_len, true); // with header - } - - // Determine the best encoding for the current block: dynamic trees, static - // trees or store, and output the encoded block to the zip file. - void _tr_flush_block(int buf, // input block, or NULL if too old - int stored_len, // length of input block - boolean eof // true if this is the last block for a file - ) { - int opt_lenb, static_lenb;// opt_len and static_len in bytes - int max_blindex = 0; // index of last bit length code of non zero freq - - // Build the Huffman trees unless a stored block is forced - if(level > 0) { - // Check if the file is ascii or binary - if(data_type == Z_UNKNOWN) set_data_type(); - - // Construct the literal and distance trees - l_desc.build_tree(this); - - d_desc.build_tree(this); - - // At this point, opt_len and static_len are the total bit lengths of - // the compressed block data, excluding the tree representations. - - // Build the bit length tree for the above two trees, and get the index - // in bl_order of the last bit length code to send. - max_blindex=build_bl_tree(); - - // Determine the best encoding. Compute first the block length in bytes - opt_lenb=(opt_len+3+7)>>>3; - static_lenb=(static_len+3+7)>>>3; - - if(static_lenb<=opt_lenb) opt_lenb=static_lenb; - } - else { - opt_lenb=static_lenb=stored_len+5; // force a stored block - } - - if(stored_len+4<=opt_lenb && buf != -1){ - // 4: two words for the lengths - // The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. - // Otherwise we can't have processed more than WSIZE input bytes since - // the last block flush, because compression would have been - // successful. If LIT_BUFSIZE <= WSIZE, it is never too late to - // transform a block into a stored block. - _tr_stored_block(buf, stored_len, eof); - } - else if(static_lenb == opt_lenb){ - send_bits((STATIC_TREES<<1)+(eof?1:0), 3); - compress_block(StaticTree.static_ltree, StaticTree.static_dtree); - } - else{ - send_bits((DYN_TREES<<1)+(eof?1:0), 3); - send_all_trees(l_desc.max_code+1, d_desc.max_code+1, max_blindex+1); - compress_block(dyn_ltree, dyn_dtree); - } - - // The above check is made mod 2^32, for files larger than 512 MB - // and uLong implemented on 32 bits. - - init_block(); - - if(eof){ - bi_windup(); - } - } - - // Fill the window when the lookahead becomes insufficient. - // Updates strstart and lookahead. - // - // IN assertion: lookahead < MIN_LOOKAHEAD - // OUT assertions: strstart <= window_size-MIN_LOOKAHEAD - // At least one byte has been read, or avail_in == 0; reads are - // performed for at least two bytes (required for the zip translate_eol - // option -- not supported here). - void fill_window(){ - int n, m; - int p; - int more; // Amount of free space at the end of the window. - - do{ - more = (window_size-lookahead-strstart); - - // Deal with !@#$% 64K limit: - if(more==0 && strstart==0 && lookahead==0){ - more = w_size; - } - else if(more==-1) { - // Very unlikely, but possible on 16 bit machine if strstart == 0 - // and lookahead == 1 (input done one byte at time) - more--; - - // If the window is almost full and there is insufficient lookahead, - // move the upper half to the lower one to make room in the upper half. - } - else if(strstart >= w_size+ w_size-MIN_LOOKAHEAD) { - System.arraycopy(window, w_size, window, 0, w_size); - match_start-=w_size; - strstart-=w_size; // we now have strstart >= MAX_DIST - block_start-=w_size; - - // Slide the hash table (could be avoided with 32 bit values - // at the expense of memory usage). We slide even when level == 0 - // to keep the hash table consistent if we switch back to level > 0 - // later. (Using level 0 permanently is not an optimal usage of - // zlib, so we don't care about this pathological case.) - - n = hash_size; - p=n; - do { - m = (head[--p]&0xffff); - head[p]=(m>=w_size ? (short)(m-w_size) : 0); - } - while (--n != 0); - - n = w_size; - p = n; - do { - m = (prev[--p]&0xffff); - prev[p] = (m >= w_size ? (short)(m-w_size) : 0); - // If n is not on any hash chain, prev[n] is garbage but - // its value will never be used. - } - while (--n!=0); - more += w_size; - } - - if (strm.avail_in == 0) return; - - // If there was no sliding: - // strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && - // more == window_size - lookahead - strstart - // => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) - // => more >= window_size - 2*WSIZE + 2 - // In the BIG_MEM or MMAP case (not yet supported), - // window_size == input_size + MIN_LOOKAHEAD && - // strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. - // Otherwise, window_size == 2*WSIZE so more >= 2. - // If there was sliding, more >= WSIZE. So in all cases, more >= 2. - - n = strm.read_buf(window, strstart + lookahead, more); - lookahead += n; - - // Initialize the hash value now that we have some input: - if(lookahead >= MIN_MATCH) { - ins_h = window[strstart]&0xff; - ins_h=(((ins_h)<= MIN_MATCH){ - ins_h=(((ins_h)<=MIN_MATCH){ - // check_match(strstart, match_start, match_length); - - bflush=_tr_tally(strstart-match_start, match_length-MIN_MATCH); - - lookahead -= match_length; - - // Insert new strings in the hash table only if the match length - // is not too large. This saves time but degrades compression. - if(match_length <= max_lazy_match && - lookahead >= MIN_MATCH) { - match_length--; // string at strstart already in hash table - do{ - strstart++; - - ins_h=((ins_h<= MIN_MATCH) { - ins_h=(((ins_h)< 4096))) { - - // If prev_match is also MIN_MATCH, match_start is garbage - // but we will ignore the current match anyway. - match_length = MIN_MATCH-1; - } - } - - // If there was a match at the previous step and the current - // match is not better, output the previous match: - if(prev_length >= MIN_MATCH && match_length <= prev_length) { - int max_insert = strstart + lookahead - MIN_MATCH; - // Do not insert strings in hash table beyond this. - - // check_match(strstart-1, prev_match, prev_length); - - bflush=_tr_tally(strstart-1-prev_match, prev_length - MIN_MATCH); - - // Insert in hash table all strings up to the end of the match. - // strstart-1 and strstart are already inserted. If there is not - // enough lookahead, the last two strings are not inserted in - // the hash table. - lookahead -= prev_length-1; - prev_length -= 2; - do{ - if(++strstart <= max_insert) { - ins_h=(((ins_h)<(w_size-MIN_LOOKAHEAD) ? - strstart-(w_size-MIN_LOOKAHEAD) : 0; - int nice_match=this.nice_match; - - // Stop when cur_match becomes <= limit. To simplify the code, - // we prevent matches with the string of window index 0. - - int wmask = w_mask; - - int strend = strstart + MAX_MATCH; - byte scan_end1 = window[scan+best_len-1]; - byte scan_end = window[scan+best_len]; - - // The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. - // It is easy to get rid of this optimization if necessary. - - // Do not waste too much time if we already have a good match: - if (prev_length >= good_match) { - chain_length >>= 2; - } - - // Do not look for matches beyond the end of the input. This is necessary - // to make deflate deterministic. - if (nice_match > lookahead) nice_match = lookahead; - - do { - match = cur_match; - - // Skip to next match if the match length cannot increase - // or if the match length is less than 2: - if (window[match+best_len] != scan_end || - window[match+best_len-1] != scan_end1 || - window[match] != window[scan] || - window[++match] != window[scan+1]) continue; - - // The check at best_len-1 can be removed because it will be made - // again later. (This heuristic is not always a win.) - // It is not necessary to compare scan[2] and match[2] since they - // are always equal when the other bytes match, given that - // the hash keys are equal and that HASH_BITS >= 8. - scan += 2; match++; - - // We check for insufficient lookahead only every 8th comparison; - // the 256th check will be made at strstart+258. - do { - } while (window[++scan] == window[++match] && - window[++scan] == window[++match] && - window[++scan] == window[++match] && - window[++scan] == window[++match] && - window[++scan] == window[++match] && - window[++scan] == window[++match] && - window[++scan] == window[++match] && - window[++scan] == window[++match] && - scan < strend); - - len = MAX_MATCH - (int)(strend - scan); - scan = strend - MAX_MATCH; - - if(len>best_len) { - match_start = cur_match; - best_len = len; - if (len >= nice_match) break; - scan_end1 = window[scan+best_len-1]; - scan_end = window[scan+best_len]; - } - - } while ((cur_match = (prev[cur_match & wmask]&0xffff)) > limit - && --chain_length != 0); - - if (best_len <= lookahead) return best_len; - return lookahead; - } - - int deflateInit(ZStream strm, int level, int bits){ - return deflateInit2(strm, level, Z_DEFLATED, bits, DEF_MEM_LEVEL, - Z_DEFAULT_STRATEGY); - } - int deflateInit(ZStream strm, int level){ - return deflateInit(strm, level, MAX_WBITS); - } - int deflateInit2(ZStream strm, int level, int method, int windowBits, - int memLevel, int strategy){ - int noheader = 0; - // byte[] my_version=ZLIB_VERSION; - - // - // if (version == null || version[0] != my_version[0] - // || stream_size != sizeof(z_stream)) { - // return Z_VERSION_ERROR; - // } - - strm.msg = null; - - if (level == Z_DEFAULT_COMPRESSION) level = 6; - - if (windowBits < 0) { // undocumented feature: suppress zlib header - noheader = 1; - windowBits = -windowBits; - } - - if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || - method != Z_DEFLATED || - windowBits < 9 || windowBits > 15 || level < 0 || level > 9 || - strategy < 0 || strategy > Z_HUFFMAN_ONLY) { - return Z_STREAM_ERROR; - } - - strm.dstate = (Deflate)this; - - this.noheader = noheader; - w_bits = windowBits; - w_size = 1 << w_bits; - w_mask = w_size - 1; - - hash_bits = memLevel + 7; - hash_size = 1 << hash_bits; - hash_mask = hash_size - 1; - hash_shift = ((hash_bits+MIN_MATCH-1)/MIN_MATCH); - - window = new byte[w_size*2]; - prev = new short[w_size]; - head = new short[hash_size]; - - lit_bufsize = 1 << (memLevel + 6); // 16K elements by default - - // We overlay pending_buf and d_buf+l_buf. This works since the average - // output size for (length,distance) codes is <= 24 bits. - pending_buf = new byte[lit_bufsize*4]; - pending_buf_size = lit_bufsize*4; - - d_buf = lit_bufsize/2; - l_buf = (1+2)*lit_bufsize; - - this.level = level; - -//System.out.println("level="+level); - - this.strategy = strategy; - this.method = (byte)method; - - return deflateReset(strm); - } - - int deflateReset(ZStream strm){ - strm.total_in = strm.total_out = 0; - strm.msg = null; // - strm.data_type = Z_UNKNOWN; - - pending = 0; - pending_out = 0; - - if(noheader < 0) { - noheader = 0; // was set to -1 by deflate(..., Z_FINISH); - } - status = (noheader!=0) ? BUSY_STATE : INIT_STATE; - strm.adler=strm._adler.adler32(0, null, 0, 0); - - last_flush = Z_NO_FLUSH; - - tr_init(); - lm_init(); - return Z_OK; - } - - int deflateEnd(){ - if(status!=INIT_STATE && status!=BUSY_STATE && status!=FINISH_STATE){ - return Z_STREAM_ERROR; - } - // Deallocate in reverse order of allocations: - pending_buf=null; - head=null; - prev=null; - window=null; - // free - // dstate=null; - return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; - } - - int deflateParams(ZStream strm, int _level, int _strategy){ - int err=Z_OK; - - if(_level == Z_DEFAULT_COMPRESSION){ - _level = 6; - } - if(_level < 0 || _level > 9 || - _strategy < 0 || _strategy > Z_HUFFMAN_ONLY) { - return Z_STREAM_ERROR; - } - - if(config_table[level].func!=config_table[_level].func && - strm.total_in != 0) { - // Flush the last buffer: - err = strm.deflate(Z_PARTIAL_FLUSH); - } - - if(level != _level) { - level = _level; - max_lazy_match = config_table[level].max_lazy; - good_match = config_table[level].good_length; - nice_match = config_table[level].nice_length; - max_chain_length = config_table[level].max_chain; - } - strategy = _strategy; - return err; - } - - int deflateSetDictionary (ZStream strm, byte[] dictionary, int dictLength){ - int length = dictLength; - int index=0; - - if(dictionary == null || status != INIT_STATE) - return Z_STREAM_ERROR; - - strm.adler=strm._adler.adler32(strm.adler, dictionary, 0, dictLength); - - if(length < MIN_MATCH) return Z_OK; - if(length > w_size-MIN_LOOKAHEAD){ - length = w_size-MIN_LOOKAHEAD; - index=dictLength-length; // use the tail of the dictionary - } - System.arraycopy(dictionary, index, window, 0, length); - strstart = length; - block_start = length; - - // Insert all strings in the hash table (except for the last two bytes). - // s->lookahead stays null, so s->ins_h will be recomputed at the next - // call of fill_window. - - ins_h = window[0]&0xff; - ins_h=(((ins_h)<Z_FINISH || flush<0){ - return Z_STREAM_ERROR; - } - - if(strm.next_out == null || - (strm.next_in == null && strm.avail_in != 0) || - (status == FINISH_STATE && flush != Z_FINISH)) { - strm.msg=z_errmsg[Z_NEED_DICT-(Z_STREAM_ERROR)]; - return Z_STREAM_ERROR; - } - if(strm.avail_out == 0){ - strm.msg=z_errmsg[Z_NEED_DICT-(Z_BUF_ERROR)]; - return Z_BUF_ERROR; - } - - this.strm = strm; // just in case - old_flush = last_flush; - last_flush = flush; - - // Write the zlib header - if(status == INIT_STATE) { - int header = (Z_DEFLATED+((w_bits-8)<<4))<<8; - int level_flags=((level-1)&0xff)>>1; - - if(level_flags>3) level_flags=3; - header |= (level_flags<<6); - if(strstart!=0) header |= PRESET_DICT; - header+=31-(header % 31); - - status=BUSY_STATE; - putShortMSB(header); - - - // Save the adler32 of the preset dictionary: - if(strstart!=0){ - putShortMSB((int)(strm.adler>>>16)); - putShortMSB((int)(strm.adler&0xffff)); - } - strm.adler=strm._adler.adler32(0, null, 0, 0); - } - - // Flush as much pending output as possible - if(pending != 0) { - strm.flush_pending(); - if(strm.avail_out == 0) { - //System.out.println(" avail_out==0"); - // Since avail_out is 0, deflate will be called again with - // more output space, but possibly with both pending and - // avail_in equal to zero. There won't be anything to do, - // but this is not an error situation so make sure we - // return OK instead of BUF_ERROR at next call of deflate: - last_flush = -1; - return Z_OK; - } - - // Make sure there is something to do and avoid duplicate consecutive - // flushes. For repeated and useless calls with Z_FINISH, we keep - // returning Z_STREAM_END instead of Z_BUFF_ERROR. - } - else if(strm.avail_in==0 && flush <= old_flush && - flush != Z_FINISH) { - strm.msg=z_errmsg[Z_NEED_DICT-(Z_BUF_ERROR)]; - return Z_BUF_ERROR; - } - - // User must not provide more input after the first FINISH: - if(status == FINISH_STATE && strm.avail_in != 0) { - strm.msg=z_errmsg[Z_NEED_DICT-(Z_BUF_ERROR)]; - return Z_BUF_ERROR; - } - - // Start a new block or continue the current one. - if(strm.avail_in!=0 || lookahead!=0 || - (flush != Z_NO_FLUSH && status != FINISH_STATE)) { - int bstate=-1; - switch(config_table[level].func){ - case STORED: - bstate = deflate_stored(flush); - break; - case FAST: - bstate = deflate_fast(flush); - break; - case SLOW: - bstate = deflate_slow(flush); - break; - default: - } - - if (bstate==FinishStarted || bstate==FinishDone) { - status = FINISH_STATE; - } - if (bstate==NeedMore || bstate==FinishStarted) { - if(strm.avail_out == 0) { - last_flush = -1; // avoid BUF_ERROR next call, see above - } - return Z_OK; - // If flush != Z_NO_FLUSH && avail_out == 0, the next call - // of deflate should use the same flush parameter to make sure - // that the flush is complete. So we don't have to output an - // empty block here, this will be done at next call. This also - // ensures that for a very small output buffer, we emit at most - // one empty block. - } - - if (bstate==BlockDone) { - if(flush == Z_PARTIAL_FLUSH) { - _tr_align(); - } - else { // FULL_FLUSH or SYNC_FLUSH - _tr_stored_block(0, 0, false); - // For a full flush, this empty block will be recognized - // as a special marker by inflate_sync(). - if(flush == Z_FULL_FLUSH) { - //state.head[s.hash_size-1]=0; - for(int i=0; i>>16)); - putShortMSB((int)(strm.adler&0xffff)); - strm.flush_pending(); - - // If avail_out is zero, the application will call deflate again - // to flush the rest. - noheader = -1; // write the trailer only once! - return pending != 0 ? Z_OK : Z_STREAM_END; - } -} diff --git a/src/com/jcraft/jzlib/InfBlocks.java b/src/com/jcraft/jzlib/InfBlocks.java deleted file mode 100644 index f6997fc6b..000000000 --- a/src/com/jcraft/jzlib/InfBlocks.java +++ /dev/null @@ -1,614 +0,0 @@ -/* -*-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>> 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)<>> 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)(qn) 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)< 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>>=(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)<>>=(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)<>>=(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)<>>=(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 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; - } -} diff --git a/src/com/jcraft/jzlib/InfCodes.java b/src/com/jcraft/jzlib/InfCodes.java deleted file mode 100644 index c768fb1cb..000000000 --- a/src/com/jcraft/jzlib/InfCodes.java +++ /dev/null @@ -1,605 +0,0 @@ -/* -*-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= 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>>=(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)<>=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)<>=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)<>=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 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= 258 && n >= 10 - // get literal/length code - while(k<(20)){ // max bits for literal/length code - n--; - b|=(z.next_in[p++]&0xff)<>=(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)<>=(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)<>=(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)>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)>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)>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)>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; - } -} diff --git a/src/com/jcraft/jzlib/InfTree.java b/src/com/jcraft/jzlib/InfTree.java deleted file mode 100644 index cbca43667..000000000 --- a/src/com/jcraft/jzlib/InfTree.java +++ /dev/null @@ -1,520 +0,0 @@ -/* -*-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>>= 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.lengthstate); - 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<>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<>>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 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=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<>>=1; - res<<=1; - } - while(--len>0); - return res>>>1; - } -} - diff --git a/src/com/jcraft/jzlib/ZInputStream.java b/src/com/jcraft/jzlib/ZInputStream.java deleted file mode 100644 index 3f97c4483..000000000 --- a/src/com/jcraft/jzlib/ZInputStream.java +++ /dev/null @@ -1,149 +0,0 @@ -/* -*-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);//(bufsize0 || 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(); - } - -} diff --git a/src/com/jcraft/jzlib/ZStream.java b/src/com/jcraft/jzlib/ZStream.java deleted file mode 100644 index 4e208527e..000000000 --- a/src/com/jcraft/jzlib/ZStream.java +++ /dev/null @@ -1,195 +0,0 @@ -/* -*-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; - } -} diff --git a/src/com/jcraft/jzlib/ZStreamException.java b/src/com/jcraft/jzlib/ZStreamException.java deleted file mode 100644 index 308bb8a1e..000000000 --- a/src/com/jcraft/jzlib/ZStreamException.java +++ /dev/null @@ -1,44 +0,0 @@ -/* -*-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); - } -}