Subversion Repositories Kolibri OS

Rev

Rev 6847 | Rev 6863 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. ; deflate.asm -- compress data using the deflation algorithm
  2. ; Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
  3. ; For conditions of distribution and use, see copyright notice in zlib.inc
  4.  
  5. ;  ALGORITHM
  6.  
  7. ;      The "deflation" process depends on being able to identify portions
  8. ;      of the input text which are identical to earlier input (within a
  9. ;      sliding window trailing behind the input currently being processed).
  10.  
  11. ;      The most straightforward technique turns out to be the fastest for
  12. ;      most input files: try all possible matches and select the longest.
  13. ;      The key feature of this algorithm is that insertions into the string
  14. ;      dictionary are very simple and thus fast, and deletions are avoided
  15. ;      completely. Insertions are performed at each input character, whereas
  16. ;      string matches are performed only when the previous match ends. So it
  17. ;      is preferable to spend more time in matches to allow very fast string
  18. ;      insertions and avoid deletions. The matching algorithm for small
  19. ;      strings is inspired from that of Rabin & Karp. A brute force approach
  20. ;      is used to find longer strings when a small match has been found.
  21. ;      A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
  22. ;      (by Leonid Broukhis).
  23. ;         A previous version of this file used a more sophisticated algorithm
  24. ;      (by Fiala and Greene) which is guaranteed to run in linear amortized
  25. ;      time, but has a larger average cost, uses more memory and is patented.
  26. ;      However the F&G algorithm may be faster for some highly redundant
  27. ;      files if the parameter max_chain_length (described below) is too large.
  28.  
  29. ;  ACKNOWLEDGEMENTS
  30.  
  31. ;      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
  32. ;      I found it in 'freeze' written by Leonid Broukhis.
  33. ;      Thanks to many people for bug reports and testing.
  34.  
  35. ;  REFERENCES
  36.  
  37. ;      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
  38. ;      Available in http://tools.ietf.org/html/rfc1951
  39.  
  40. ;      A description of the Rabin and Karp algorithm is given in the book
  41. ;         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
  42.  
  43. ;      Fiala,E.R., and Greene,D.H.
  44. ;         Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
  45.  
  46.  
  47. deflate_copyright db ' deflate 1.2.8 Copyright 1995-2013 Jean-loup Gailly and Mark Adler ',0
  48.  
  49. ;  If you use the zlib library in a product, an acknowledgment is welcome
  50. ;  in the documentation of your product. If for some reason you cannot
  51. ;  include such an acknowledgment, I would appreciate that you keep this
  52. ;  copyright string in the executable of your product.
  53.  
  54. ; ===========================================================================
  55. ;  Function prototypes.
  56.  
  57. ;enum block_state
  58. need_more   equ 0 ;block not completed, need more input or more output
  59. block_done equ 1 ;block flush performed
  60. finish_started equ 2 ;finish started, need only more output at next deflate
  61. finish_done equ 3 ;finish done, accept no more input or output
  62.  
  63. ; ===========================================================================
  64. ; Local data
  65.  
  66. NIL equ 0
  67. ; Tail of hash chains
  68.  
  69. TOO_FAR equ 4096
  70. ; Matches of length 3 are discarded if their distance exceeds TOO_FAR
  71.  
  72. ; Values for max_lazy_match, good_match and max_chain_length, depending on
  73. ; the desired pack level (0..9). The values given below have been tuned to
  74. ; exclude worst case performance for pathological files. Better values may be
  75. ; found for specific files.
  76.  
  77. struct config_s ;config
  78.         good_length dw ? ;uint_16 ;reduce lazy search above this match length
  79.         max_lazy    dw ? ;uint_16 ;do not perform lazy search above this match length
  80.         nice_length dw ? ;uint_16 ;quit search above this match length
  81.         max_chain   dw ? ;uint_16
  82.         co_func     dd ? ;compress_func
  83. ends
  84.  
  85. align 16
  86. configuration_table:
  87.         config_s  0,   0,   0,    0, deflate_stored  ;store only
  88.         config_s  4,   4,   8,    4, deflate_fast ;max speed, no lazy matches
  89. if FASTEST eq 0
  90.         config_s  4,   5,  16,    8, deflate_fast
  91.         config_s  4,   6,  32,   32, deflate_fast
  92.         config_s  4,   4,  16,   16, deflate_slow ;lazy matches
  93.         config_s  8,  16,  32,   32, deflate_slow
  94.         config_s  8,  16, 128,  128, deflate_slow
  95.         config_s  8,  32, 128,  256, deflate_slow
  96.         config_s 32, 128, 258, 1024, deflate_slow
  97.         config_s 32, 258, 258, 4096, deflate_slow ;max compression
  98. end if
  99.  
  100. ; Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
  101. ; For deflate_fast() (levels <= 3) good is ignored and lazy has a different
  102. ; meaning.
  103.  
  104.  
  105. EQUAL equ 0
  106. ; result of memcmp for equal strings
  107.  
  108. ; rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH
  109. macro RANK f, reg
  110. {
  111. local .end0
  112.         xor reg,reg
  113.         cmp f,4
  114.         jle .end0
  115.                 sub reg,9
  116.         .end0:
  117.         add reg,f
  118.         add reg,f
  119. }
  120.  
  121. ; ===========================================================================
  122. ; Update a hash value with the given input byte
  123. ; IN  assertion: all calls to to UPDATE_HASH are made with consecutive
  124. ;    input characters, so that a running hash key can be computed from the
  125. ;    previous key instead of complete recalculation each time.
  126.  
  127. macro UPDATE_HASH s,h,c
  128. {
  129. push ebx ecx
  130.         mov ebx,h
  131.         mov ecx,[s+deflate_state.hash_shift]
  132.         shl ebx,cl
  133.         xor ebx,c
  134.         and ebx,[s+deflate_state.hash_mask]
  135.         mov h,ebx
  136. pop ecx ebx
  137. }
  138.  
  139. ; ===========================================================================
  140. ; Insert string str in the dictionary and set match_head to the previous head
  141. ; of the hash chain (the most recent string with same hash key). Return
  142. ; the previous length of the hash chain.
  143. ; If this file is compiled with -DFASTEST, the compression level is forced
  144. ; to 1, and no hash chains are maintained.
  145. ; IN  assertion: all calls to to INSERT_STRING are made with consecutive
  146. ;    input characters and the first MIN_MATCH bytes of str are valid
  147. ;    (except for the last MIN_MATCH-1 bytes of the input file).
  148.  
  149. macro INSERT_STRING s, str, match_head
  150. {
  151.         mov eax,[s+deflate_state.window]
  152.         add eax,str
  153.         add eax,MIN_MATCH-1
  154.         movzx eax,byte[eax]
  155.         UPDATE_HASH s, [s+deflate_state.ins_h], eax
  156.         mov eax,[s+deflate_state.ins_h]
  157.         shl eax,1
  158.         add eax,[s+deflate_state.head]
  159.         movzx eax,word[eax]
  160.         mov match_head,eax
  161. push ebx
  162. if FASTEST eq 0
  163.         mov ebx,[s+deflate_state.w_mask]
  164.         and ebx,str
  165.         shl ebx,1
  166.         add ebx,[s+deflate_state.prev]
  167.         mov [ebx],ax
  168.  
  169. end if
  170.         mov eax,[s+deflate_state.ins_h]
  171.         shl eax,1
  172.         add eax,[s+deflate_state.head]
  173.         mov ebx,str
  174.         mov [eax],bx
  175. pop ebx
  176. }
  177.  
  178. ; ===========================================================================
  179. ; Initialize the hash table (avoiding 64K overflow for 16 bit systems).
  180. ; prev[] will be initialized on the fly.
  181.  
  182. macro CLEAR_HASH s
  183. {
  184.         ;mov eax,[s+deflate_state.hash_size]
  185.         ;dec eax
  186.         ;shl eax,1
  187.         ;add eax,[s+deflate_state.head]
  188.         ;mov word[eax],NIL
  189.         mov eax,[s+deflate_state.hash_size]
  190.         ;dec eax
  191.         shl eax,1 ;sizeof(*s.head)
  192.         stdcall zmemzero, [s+deflate_state.head], eax
  193. }
  194.  
  195. align 4
  196. proc deflateInit, strm:dword, level:dword
  197.         stdcall deflateInit_, [strm], [level], ZLIB_VERSION, sizeof.z_stream
  198.         ret
  199. endp
  200.  
  201. ; =========================================================================
  202. ;int (strm, level, version, stream_size)
  203. ;    z_streamp strm
  204. ;    int level
  205. ;    const char *version
  206. ;    int stream_size
  207. align 4
  208. proc deflateInit_, strm:dword, level:dword, version:dword, stream_size:dword
  209.         stdcall deflateInit2_, [strm], [level], Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,\
  210.                         Z_DEFAULT_STRATEGY, [version], [stream_size]
  211.         ; To do: ignore strm->next_in if we use it as window
  212.         ret
  213. endp
  214.  
  215. align 4
  216. proc deflateInit2, strm:dword, level:dword, method:dword, windowBits:dword, memLevel:dword, strategy:dword
  217.         stdcall deflateInit2_, [strm],[level],[method],[windowBits],[memLevel],\
  218.                 [strategy], ZLIB_VERSION, sizeof.z_stream
  219.         ret
  220. endp
  221.  
  222. ; =========================================================================
  223. ;int (strm, level, method, windowBits, memLevel, strategy,
  224. ;                  version, stream_size)
  225. ;    z_streamp strm
  226. ;    int  level
  227. ;    int  method
  228. ;    int  windowBits
  229. ;    int  memLevel
  230. ;    int  strategy
  231. ;    const char *version
  232. ;    int stream_size
  233. align 4
  234. proc deflateInit2_ uses ebx ecx edx edi, strm:dword, level:dword, method:dword,\
  235.         windowBits:dword, memLevel:dword, strategy:dword, version:dword, stream_size:dword
  236. locals
  237.         wrap dd 1 ;int
  238.         overlay dd ? ;uint_16p
  239. endl
  240.         ; We overlay pending_buf and d_buf+l_buf. This works since the average
  241.         ; output size for (length,distance) codes is <= 24 bits.
  242.  
  243.         mov eax,[version]
  244.         cmp eax,Z_NULL
  245.         je @f
  246.         mov ebx,dword[ZLIB_VERSION]
  247.         cmp dword[eax],ebx
  248.         jne @f
  249.         cmp dword[stream_size],sizeof.z_stream
  250.         je .end0
  251.         @@: ;if (..==0 || ..[0]!=..[0] || ..!=..)
  252.                 mov eax,Z_VERSION_ERROR
  253.                 jmp .end_f
  254.         .end0:
  255.         mov ebx,[strm]
  256.         cmp ebx,Z_NULL
  257.         jne @f ;if (..==0) return ..
  258.                 mov eax,Z_STREAM_ERROR
  259.                 jmp .end_f
  260.         @@:
  261.  
  262.         mov dword[ebx+z_stream.msg],Z_NULL
  263.         cmp dword[ebx+z_stream.zalloc],0
  264.         jne @f ;if (..==0)
  265. if Z_SOLO eq 1
  266.                 mov eax,Z_STREAM_ERROR
  267.                 jmp .end_f
  268. else
  269.                 mov dword[ebx+z_stream.zalloc],zcalloc
  270.                 mov dword[ebx+z_stream.opaque],0
  271. end if
  272.         @@:
  273.         cmp dword[ebx+z_stream.zfree],0
  274.         jne @f ;if (..==0)
  275. if Z_SOLO eq 1
  276.                 mov eax,Z_STREAM_ERROR
  277.                 jmp .end_f
  278. else
  279.                 mov dword[ebx+z_stream.zfree],zcfree
  280. end if
  281.         @@:
  282.  
  283. if FASTEST eq 1
  284.         cmp dword[level],0
  285.         je @f ;if (..!=0)
  286.                 mov dword[level],1
  287.         @@:
  288. else
  289.         cmp dword[level],Z_DEFAULT_COMPRESSION
  290.         jne @f ;if (..==0)
  291.                 mov dword[level],6
  292.         @@:
  293. end if
  294.  
  295.         cmp dword[windowBits],0
  296.         jge @f ;if (..<0) ;suppress zlib wrapper
  297.                 mov dword[wrap],0
  298.                 neg dword[windowBits]
  299.                 inc dword[windowBits]
  300.                 jmp .end1
  301.         @@:
  302. if GZIP eq 1
  303.         cmp dword[windowBits],15
  304.         jle .end1 ;else if (..>15)
  305.                 mov dword[wrap],2 ;write gzip wrapper instead
  306.                 sub dword[windowBits],16
  307. end if
  308.         .end1:
  309.         cmp dword[memLevel],1
  310.         jl .end2
  311.         cmp dword[memLevel],MAX_MEM_LEVEL
  312.         jg .end2
  313.         cmp dword[method],Z_DEFLATED
  314.         jne .end2
  315.         cmp dword[windowBits],8
  316.         jl .end2
  317.         cmp dword[windowBits],15
  318.         jg .end2
  319.         cmp dword[level],0
  320.         jl .end2
  321.         cmp dword[level],9
  322.         jg .end2
  323.         cmp dword[strategy],0
  324.         jl .end2
  325.         cmp dword[strategy],Z_FIXED
  326.         jle @f
  327.         .end2: ;if (..<.. || ..>.. || ..!=.. || ..<.. || ..>.. || ..<0 || ..>.. || ..<0 || ..>..)
  328.                 mov eax,Z_STREAM_ERROR
  329.                 jmp .end_f
  330.         @@:
  331.         cmp dword[windowBits],8
  332.         jne @f ;if (..==..)
  333.                 inc dword[windowBits] ;until 256-byte window bug fixed
  334.         @@:
  335.         ZALLOC ebx, 1, sizeof.deflate_state
  336.         ;eax = s
  337.         cmp eax,Z_NULL
  338.         jne @f ;if (..==0)
  339.                 mov eax,Z_MEM_ERROR
  340.                 jmp .end_f
  341.         @@:
  342.         mov edi,eax ;edi = s
  343.         mov [ebx+z_stream.state],edi
  344.         mov [edi+deflate_state.strm],ebx
  345.  
  346.         mov eax,[wrap]
  347.         mov [edi+deflate_state.wrap],eax
  348.         mov [edi+deflate_state.gzhead],Z_NULL
  349.         mov ecx,[windowBits]
  350.         mov [edi+deflate_state.w_bits],ecx
  351.         xor eax,eax
  352.         inc eax
  353.         shl eax,cl
  354.         mov [edi+deflate_state.w_size],eax
  355.         dec eax
  356.         mov [edi+deflate_state.w_mask],eax
  357.  
  358.         mov ecx,[memLevel]
  359.         add ecx,7
  360.         mov [edi+deflate_state.hash_bits],ecx
  361.         xor eax,eax
  362.         inc eax
  363.         shl eax,cl
  364.         mov [edi+deflate_state.hash_size],eax
  365.         dec eax
  366.         mov [edi+deflate_state.hash_mask],eax
  367.         add ecx,MIN_MATCH-1
  368.         xor edx,edx
  369.         mov eax,ecx
  370.         mov ecx,MIN_MATCH
  371.         div ecx
  372.         mov [edi+deflate_state.hash_shift],eax
  373.  
  374.         ZALLOC ebx, [edi+deflate_state.w_size], 2 ;2*sizeof(Byte)
  375.         mov [edi+deflate_state.window],eax
  376.         ZALLOC ebx, [edi+deflate_state.w_size], 2 ;sizeof(Pos)
  377.         mov [edi+deflate_state.prev],eax
  378.         ZALLOC ebx, [edi+deflate_state.hash_size], 2 ;sizeof(Pos)
  379.         mov [edi+deflate_state.head],eax
  380.  
  381.         mov dword[edi+deflate_state.high_water],0 ;nothing written to s->window yet
  382.  
  383.         mov ecx,[memLevel]
  384.         add ecx,6
  385.         xor eax,eax
  386.         inc eax
  387.         shl eax,cl
  388.         mov [edi+deflate_state.lit_bufsize],eax ;16K elements by default
  389.  
  390.         ZALLOC ebx, eax, 4 ;sizeof(uint_16)+2
  391.         mov [overlay],eax
  392.         mov [edi+deflate_state.pending_buf],eax
  393.         mov eax,[edi+deflate_state.lit_bufsize]
  394.         imul eax,4 ;sizeof(uint_16)+2
  395.         mov [edi+deflate_state.pending_buf_size],eax
  396.  
  397.         cmp dword[edi+deflate_state.window],Z_NULL
  398.         je .end3
  399.         cmp dword[edi+deflate_state.prev],Z_NULL
  400.         je .end3
  401.         cmp dword[edi+deflate_state.head],Z_NULL
  402.         je .end3
  403.         cmp dword[edi+deflate_state.pending_buf],Z_NULL
  404.         jne @f
  405.         .end3: ;if (..==0 || ..==0 || ..==0 || ..==0)
  406.                 mov dword[edi+deflate_state.status],FINISH_STATE
  407.                 ERR_MSG Z_MEM_ERROR
  408.                 mov [ebx+z_stream.msg],eax
  409.                 stdcall deflateEnd, ebx
  410.                 mov eax,Z_MEM_ERROR
  411.                 jmp .end_f
  412.         @@:
  413.         mov eax,[edi+deflate_state.lit_bufsize]
  414.         shr eax,1 ;/=sizeof(uint_16)
  415.         add eax,[overlay]
  416.         mov [edi+deflate_state.d_buf],eax
  417.         mov eax,[edi+deflate_state.lit_bufsize]
  418.         imul eax,3 ;1+sizeof(uint_16)
  419.         add eax,[edi+deflate_state.pending_buf]
  420.         mov [edi+deflate_state.l_buf],eax
  421.  
  422.         mov eax,[level]
  423.         mov [edi+deflate_state.level],ax
  424.         mov eax,[strategy]
  425.         mov [edi+deflate_state.strategy],ax
  426.         mov eax,[method]
  427.         mov [edi+deflate_state.method],al
  428.  
  429.         stdcall deflateReset, ebx
  430. .end_f:
  431. zlib_debug 'deflateInit2_ strategy = %d',[strategy]
  432.         ret
  433. endp
  434.  
  435. ; =========================================================================
  436. ;int (strm, dictionary, dictLength)
  437. ;    z_streamp strm
  438. ;    const Bytef *dictionary
  439. ;    uInt  dictLength
  440. align 4
  441. proc deflateSetDictionary uses ebx ecx edx edi esi, strm:dword, dictionary:dword, dictLength:dword
  442. locals
  443.         wrap  dd ? ;int
  444.         avail dd ? ;unsigned
  445.         next  dd ? ;unsigned char*
  446. endl
  447.         mov ebx,[strm]
  448.         cmp ebx,Z_NULL
  449.         je @f
  450.         mov edi,[ebx+z_stream.state]
  451.         cmp edi,Z_NULL
  452.         je @f
  453.         cmp dword[dictionary],Z_NULL
  454.         jne .end0 ;if (..==0 || ..==0 || ..==0)
  455.         @@:
  456.                 mov eax,Z_STREAM_ERROR
  457.                 jmp .end_f
  458.         .end0:
  459.        
  460.         mov eax,[edi+deflate_state.wrap]
  461.         mov [wrap],eax
  462.         cmp dword[wrap],2
  463.         je .end1
  464.         cmp dword[edi+deflate_state.lookahead],0
  465.         jne .end1
  466.         cmp dword[wrap],1
  467.         jne @f
  468.         cmp dword[edi+deflate_state.status],INIT_STATE
  469.         je @f
  470.         .end1: ;if (..==.. || .. || (..==.. && ..!=..)) return ..
  471.                 mov eax,Z_STREAM_ERROR
  472.                 jmp .end_f
  473.         @@:
  474.  
  475.         ; when using zlib wrappers, compute Adler-32 for provided dictionary
  476.         cmp dword[wrap],1
  477.         jne @f ;if (..==..)
  478.                 stdcall adler32, [ebx+z_stream.adler], [dictionary], [dictLength]
  479.                 mov [ebx+z_stream.adler],eax
  480.         @@:
  481.         mov dword[edi+deflate_state.wrap],0 ;avoid computing Adler-32 in read_buf
  482.  
  483.         ; if dictionary would fill window, just replace the history
  484.         mov eax,[edi+deflate_state.w_size]
  485.         cmp [dictLength],eax
  486.         jl .end2 ;if (..>=..)
  487.                 cmp dword[wrap],0
  488.                 jne @f ;if (..==0) ;already empty otherwise
  489.                         CLEAR_HASH edi
  490.                         mov dword[edi+deflate_state.strstart],0
  491.                         mov dword[edi+deflate_state.block_start],0
  492.                         mov dword[edi+deflate_state.insert],0
  493.                 @@:
  494.                 mov eax,[dictLength]
  495.                 sub eax,[edi+deflate_state.w_size]
  496.                 add [dictionary],eax ;use the tail
  497.                 mov eax,[edi+deflate_state.w_size]
  498.                 mov [dictLength],eax
  499.         .end2:
  500.  
  501.         ; insert dictionary into window and hash
  502.         mov eax,[ebx+z_stream.avail_in]
  503.         mov [avail],eax
  504.         mov eax,[ebx+z_stream.next_in]
  505.         mov [next],eax
  506.         mov eax,[dictLength]
  507.         mov [ebx+z_stream.avail_in],eax
  508.         mov eax,[dictionary]
  509.         mov [ebx+z_stream.next_in],eax
  510.         stdcall fill_window, edi
  511.         .cycle0: ;while (..>=..)
  512.                 mov ecx,[edi+deflate_state.lookahead]
  513.                 cmp ecx,MIN_MATCH
  514.                 jl .cycle0end
  515.                 mov esi,[edi+deflate_state.strstart]
  516.                 ;esi = str
  517.                 sub ecx,MIN_MATCH-1
  518.                 .cycle1: ;do
  519.                         mov eax,[edi+deflate_state.window]
  520.                         add eax,esi
  521.                         add eax,MIN_MATCH-1
  522.                         movzx eax,byte[eax]
  523.                         UPDATE_HASH edi, [edi+deflate_state.ins_h], eax
  524. if FASTEST eq 0
  525.                         mov edx,[edi+deflate_state.ins_h]
  526.                         shl edx,1
  527.                         add edx,[edi+deflate_state.head]
  528.                         movzx edx,word[edx] ;edx = s.head[s.ins_h]
  529.                         mov eax,esi
  530.                         and eax,[edi+deflate_state.w_mask]
  531.                         shl eax,1
  532.                         add eax,[edi+deflate_state.prev]
  533.                         mov [eax],dx
  534. end if
  535.                         mov edx,[edi+deflate_state.ins_h]
  536.                         shl edx,1
  537.                         add edx,[edi+deflate_state.head]
  538.                         mov [edx],si ;s.head[s.ins_h] = str
  539.                         inc esi
  540.                         dec ecx
  541.                         jnz .cycle1 ;while (--..)
  542.                 mov [edi+deflate_state.strstart],esi
  543.                 mov [edi+deflate_state.lookahead],MIN_MATCH-1
  544.                 stdcall fill_window, edi
  545.                 jmp .cycle0
  546. align 4
  547.         .cycle0end:
  548.         mov eax,[edi+deflate_state.strstart]
  549.         add eax,[edi+deflate_state.lookahead]
  550.         mov [edi+deflate_state.strstart],eax
  551.         mov [edi+deflate_state.block_start],eax
  552.         mov eax,[edi+deflate_state.lookahead]
  553.         mov [edi+deflate_state.insert],eax
  554.         mov dword[edi+deflate_state.lookahead],0
  555.         mov eax,MIN_MATCH-1
  556.         mov [edi+deflate_state.prev_length],eax
  557.         mov [edi+deflate_state.match_length],eax
  558.         mov dword[edi+deflate_state.match_available],0
  559.         mov eax,[next]
  560.         mov [ebx+z_stream.next_in],eax
  561.         mov eax,[avail]
  562.         mov [ebx+z_stream.avail_in],eax
  563.         mov eax,[wrap]
  564.         mov [edi+deflate_state.wrap],eax
  565.         mov eax,Z_OK
  566. .end_f:
  567.         ret
  568. endp
  569.  
  570. ; =========================================================================
  571. ;int (strm)
  572. ;    z_streamp strm
  573. align 4
  574. proc deflateResetKeep uses ebx edi, strm:dword
  575.         mov ebx,[strm]
  576.         cmp ebx,Z_NULL
  577.         je @f
  578.         mov edi,[ebx+z_stream.state]
  579.         cmp edi,Z_NULL
  580.         je @f
  581.         cmp dword[ebx+z_stream.zalloc],0
  582.         je @f
  583.         cmp dword[ebx+z_stream.zfree],0
  584.         jne .end0 ;if (..==0 || ..==0 || ..==0 || ..==0)
  585.         @@:
  586.                 mov eax,Z_STREAM_ERROR
  587.                 jmp .end_f
  588.         .end0:
  589.  
  590.         mov dword[ebx+z_stream.total_out],0
  591.         mov dword[ebx+z_stream.total_in],0
  592.         mov dword[ebx+z_stream.msg],Z_NULL ;use zfree if we ever allocate msg dynamically
  593.         mov dword[ebx+z_stream.data_type],Z_UNKNOWN
  594.  
  595.         mov dword[edi+deflate_state.pending],0
  596.         mov eax,[edi+deflate_state.pending_buf]
  597.         mov [edi+deflate_state.pending_out],eax
  598.  
  599.         cmp dword[edi+deflate_state.wrap],0
  600.         jge @f ;if (..<0)
  601.                 neg dword[edi+deflate_state.wrap] ;was made negative by deflate(..., Z_FINISH)
  602.         @@:
  603.         mov eax,BUSY_STATE
  604.         cmp dword[edi+deflate_state.wrap],0
  605.         je @f
  606.                 mov eax,INIT_STATE
  607.         @@:
  608.         mov dword[edi+deflate_state.status],eax
  609.         stdcall adler32, 0, Z_NULL, 0
  610. if GZIP eq 1
  611.         cmp dword[edi+deflate_state.wrap],2
  612.         jne @f
  613.                 xor eax,eax ;stdcall calc_crc32, 0, Z_NULL, 0
  614.         @@:
  615. end if
  616.         mov dword[ebx+z_stream.adler],eax
  617.         mov dword[edi+deflate_state.last_flush],Z_NO_FLUSH
  618.         stdcall _tr_init, edi
  619.  
  620.         mov eax,Z_OK
  621. .end_f:
  622.         ret
  623. endp
  624.  
  625. ; =========================================================================
  626. ;int (strm)
  627. ;    z_streamp strm
  628. align 4
  629. proc deflateReset uses ebx, strm:dword
  630.         mov ebx,[strm]
  631.         zlib_debug 'deflateReset'
  632.         stdcall deflateResetKeep, ebx
  633.         cmp eax,Z_OK
  634.         jne @f ;if (..==Z_OK)
  635.                 stdcall lm_init, [ebx+z_stream.state]
  636.         @@:
  637.         ret
  638. endp
  639.  
  640. ; =========================================================================
  641. ;int (strm, head)
  642. ;    z_streamp strm
  643. ;    gz_headerp head
  644. align 4
  645. proc deflateSetHeader uses ebx, strm:dword, head:dword
  646.         mov ebx,[strm]
  647.         cmp ebx,Z_NULL
  648.         je @f
  649.         mov ebx,[ebx+z_stream.state]
  650.         cmp ebx,Z_NULL
  651.         jne .end0
  652.         @@: ;if (..==0 || ..==0) return ..
  653.                 mov eax,Z_STREAM_ERROR
  654.                 jmp .end_f
  655.         .end0:
  656.         cmp dword[ebx+deflate_state.wrap],2
  657.         je @f ;if (..!=..) return ..
  658.                 mov eax,Z_STREAM_ERROR
  659.                 jmp .end_f
  660.         @@:
  661.         mov eax,[head]
  662.         mov [ebx+deflate_state.gzhead],eax
  663.         mov eax,Z_OK
  664. .end_f:
  665.         ret
  666. endp
  667.  
  668. ; =========================================================================
  669. ;int (strm, pending, bits)
  670. ;    unsigned *pending
  671. ;    int *bits
  672. ;    z_streamp strm
  673. align 4
  674. proc deflatePending uses ebx edi, strm:dword, pending:dword, bits:dword
  675.         mov ebx,[strm]
  676.         cmp ebx,Z_NULL
  677.         je @f
  678.         mov edi,[ebx+z_stream.state]
  679.         cmp edi,Z_NULL
  680.         jne .end0
  681.         @@: ;if (..==0 || ..==0) return ..
  682.                 mov eax,Z_STREAM_ERROR
  683.                 jmp .end_f
  684.         .end0:
  685.         cmp dword[pending],Z_NULL
  686.         je @f ;if (..!=..)
  687.                 mov eax,[pending]
  688.                 mov ebx,[edi+deflate_state.pending]
  689.                 mov [eax],ebx
  690.         @@:
  691.         cmp dword[bits],Z_NULL
  692.         je @f ;if (..!=..)
  693.                 mov eax,[bits]
  694.                 mov ebx,[edi+deflate_state.bi_valid]
  695.                 mov [eax],ebx
  696.         @@:
  697.         mov eax,Z_OK
  698. .end_f:
  699.         ret
  700. endp
  701.  
  702. ; =========================================================================
  703. ;int (strm, bits, value)
  704. ;    z_streamp strm
  705. ;    int bits
  706. ;    int value
  707. align 4
  708. proc deflatePrime uses ebx edi, strm:dword, bits:dword, value:dword
  709. ;    int put;
  710.  
  711.         mov ebx,[strm]
  712.         cmp ebx,Z_NULL
  713.         je @f
  714.         mov edi,[ebx+z_stream.state] ;s = strm.state
  715.         cmp edi,Z_NULL
  716.         jne .end0
  717.         @@: ;if (..==0 || ..==0) return ..
  718.                 mov eax,Z_STREAM_ERROR
  719.                 jmp .end_f
  720.         .end0:
  721. ;    if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
  722. ;        return Z_BUF_ERROR;
  723. ;    do {
  724. ;        put = Buf_size - s->bi_valid;
  725. ;        if (put > bits)
  726. ;            put = bits;
  727. ;        s->bi_buf |= (uint_16)((value & ((1 << put) - 1)) << s->bi_valid);
  728. ;        s->bi_valid += put;
  729. ;        _tr_flush_bits(s);
  730. ;        value >>= put;
  731. ;        bits -= put;
  732. ;    } while (bits);
  733.         mov eax,Z_OK
  734. .end_f:
  735.         ret
  736. endp
  737.  
  738. ; =========================================================================
  739. ;int (strm, level, strategy)
  740. ;    z_streamp strm
  741. ;    int level
  742. ;    int strategy
  743. align 4
  744. proc deflateParams uses ebx edi, strm:dword, level:dword, strategy:dword
  745. locals
  746.         co_func dd ?
  747.         err dd Z_OK
  748. endl
  749.  
  750.         mov ebx,[strm]
  751.         cmp ebx,Z_NULL
  752.         je @f
  753.         mov edi,[ebx+z_stream.state] ;s = strm.state
  754.         cmp edi,Z_NULL
  755.         jne .end0
  756.         @@: ;if (..==0 || ..==0) return ..
  757.                 mov eax,Z_STREAM_ERROR
  758.                 jmp .end_f
  759.         .end0:
  760.  
  761. if FASTEST eq 1
  762.         cmp dword[level],0
  763.         je @f ;if (..!=0)
  764.                 mov dword[level],1
  765.         @@:
  766. else
  767.         cmp dword[level],Z_DEFAULT_COMPRESSION
  768.         jne @f ;if (..==0)
  769.                 mov dword[level],6
  770.         @@:
  771. end if
  772.         cmp dword[level],0
  773.         jl @f
  774.         cmp dword[level],9
  775.         jg @f
  776.         cmp dword[strategy],0
  777.         jl @f
  778.         cmp dword[strategy],Z_FIXED
  779.         jle .end1
  780.         @@: ;if (..<0 || ..>9 || ..<0 || ..>..)
  781.                 mov eax,Z_STREAM_ERROR
  782.                 jmp .end_f
  783.         .end1:
  784.         movzx eax,word[edi+deflate_state.level]
  785.         imul eax,sizeof.config_s
  786.         add eax,configuration_table+config_s.co_func
  787.         mov [co_func],eax
  788.  
  789. ;    if ((strategy != s->strategy || co_func != configuration_table[level].func) &&
  790. ;        strm->total_in != 0) {
  791.                 ; Flush the last buffer:
  792. ;        err = deflate(strm, Z_BLOCK);
  793. ;        if (err == Z_BUF_ERROR && s->pending == 0)
  794. ;            err = Z_OK;
  795. ;    }
  796. ;    if (s->level != level) {
  797. ;        s->level = level;
  798. ;        s->max_lazy_match   = configuration_table[level].max_lazy;
  799. ;        s->good_match       = configuration_table[level].good_length;
  800. ;        s->nice_match       = configuration_table[level].nice_length;
  801. ;        s->max_chain_length = configuration_table[level].max_chain;
  802. ;    }
  803.         mov eax,[strategy]
  804.         mov [edi+deflate_state.strategy],ax
  805.         mov eax,[err]
  806. .end_f:
  807.         ret
  808. endp
  809.  
  810. ; =========================================================================
  811. ;int (strm, good_length, max_lazy, nice_length, max_chain)
  812. ;    z_streamp strm
  813. ;    int good_length
  814. ;    int max_lazy
  815. ;    int nice_length
  816. ;    int max_chain
  817. align 4
  818. proc deflateTune uses ebx, strm:dword, good_length:dword, max_lazy:dword,\
  819.                         nice_length:dword, max_chain:dword
  820.         mov ebx,[strm]
  821.         cmp ebx,Z_NULL
  822.         je @f
  823.         cmp dword[ebx+z_stream.state],Z_NULL
  824.         jne .end0
  825.         @@: ;if (..==0 || ..==0) return ..
  826.                 mov eax,Z_STREAM_ERROR
  827.                 jmp .end_f
  828.         .end0:
  829.         mov ebx,[ebx+z_stream.state] ;s = strm.state
  830.         mov eax,[good_length]
  831.         mov [ebx+deflate_state.good_match],eax
  832.         mov eax,[max_lazy]
  833.         mov [ebx+deflate_state.max_lazy_match],eax
  834.         mov eax,[nice_length]
  835.         mov [ebx+deflate_state.nice_match],eax
  836.         mov eax,[max_chain]
  837.         mov [ebx+deflate_state.max_chain_length],eax
  838.         mov eax,Z_OK
  839. .end_f:
  840.         ret
  841. endp
  842.  
  843. ; =========================================================================
  844. ; For the default windowBits of 15 and memLevel of 8, this function returns
  845. ; a close to exact, as well as small, upper bound on the compressed size.
  846. ; They are coded as constants here for a reason--if the #define's are
  847. ; changed, then this function needs to be changed as well.  The return
  848. ; value for 15 and 8 only works for those exact settings.
  849.  
  850. ; For any setting other than those defaults for windowBits and memLevel,
  851. ; the value returned is a conservative worst case for the maximum expansion
  852. ; resulting from using fixed blocks instead of stored blocks, which deflate
  853. ; can emit on compressed data for some combinations of the parameters.
  854.  
  855. ; This function could be more sophisticated to provide closer upper bounds for
  856. ; every combination of windowBits and memLevel.  But even the conservative
  857. ; upper bound of about 14% expansion does not seem onerous for output buffer
  858. ; allocation.
  859.  
  860. ;uLong (strm, sourceLen)
  861. ;    z_streamp strm
  862. ;    uLong sourceLen
  863. align 4
  864. proc deflateBound, strm:dword, sourceLen:dword
  865. ;    deflate_state *s;
  866. ;    uLong complen, wraplen;
  867. ;    Bytef *str;
  868.         zlib_debug 'deflateBound'
  869.  
  870.         ; conservative upper bound for compressed data
  871. ;    complen = sourceLen +
  872. ;              ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
  873.  
  874.         ; if can't get parameters, return conservative bound plus zlib wrapper
  875. ;    if (strm == Z_NULL || strm->state == Z_NULL)
  876. ;        return complen + 6;
  877.  
  878.         ; compute wrapper length
  879. ;    s = strm->state;
  880. ;    switch (s->wrap) {
  881. ;    case 0:                                 /* raw deflate */
  882. ;        wraplen = 0;
  883. ;        break;
  884. ;    case 1:                                 /* zlib wrapper */
  885. ;        wraplen = 6 + (s->strstart ? 4 : 0);
  886. ;        break;
  887. ;    case 2:                                 /* gzip wrapper */
  888. ;        wraplen = 18;
  889. ;        if (s->gzhead != Z_NULL) {          /* user-supplied gzip header */
  890. ;            if (s->gzhead->extra != Z_NULL)
  891. ;                wraplen += 2 + s->gzhead->extra_len;
  892. ;            str = s->gzhead->name;
  893. ;            if (str != Z_NULL)
  894. ;                do {
  895. ;                    wraplen++;
  896. ;                } while (*str++);
  897. ;            str = s->gzhead->comment;
  898. ;            if (str != Z_NULL)
  899. ;                do {
  900. ;                    wraplen++;
  901. ;                } while (*str++);
  902. ;            if (s->gzhead->hcrc)
  903. ;                wraplen += 2;
  904. ;        }
  905. ;        break;
  906. ;    default:                                /* for compiler happiness */
  907. ;        wraplen = 6;
  908. ;    }
  909.  
  910.         ; if not default parameters, return conservative bound
  911. ;    if (s->w_bits != 15 || s->hash_bits != 8 + 7)
  912. ;        return complen + wraplen;
  913.  
  914.         ; default settings: return tight bound for that case
  915. ;    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
  916. ;           (sourceLen >> 25) + 13 - 6 + wraplen;
  917. .end_f:
  918.         ret
  919. endp
  920.  
  921. ; =========================================================================
  922. ; Put a short in the pending buffer. The 16-bit value is put in MSB order.
  923. ; IN assertion: the stream state is correct and there is enough room in
  924. ; pending_buf.
  925.  
  926. ;void (s, b)
  927. ;    deflate_state *s
  928. ;    uInt b
  929. align 4
  930. proc putShortMSB uses ebx ecx, s:dword, b:dword
  931.         mov ebx,[s]
  932.         mov ecx,[b]
  933.         put_byte ebx, ch
  934.         put_byte ebx, cl
  935.         ret
  936. endp
  937.  
  938. ; =========================================================================
  939. ; Flush as much pending output as possible. All deflate() output goes
  940. ; through this function so some applications may wish to modify it
  941. ; to avoid allocating a large strm->next_out buffer and copying into it.
  942. ; (See also read_buf()).
  943.  
  944. ;void (z_streamp strm)
  945. align 16
  946. proc flush_pending uses eax ebx ecx edx, strm:dword
  947. ;ecx - len
  948. ;edx - deflate_state *s
  949. ;ebx - strm
  950.         mov ebx,[strm]
  951.         mov edx,[ebx+z_stream.state]
  952.  
  953.         stdcall _tr_flush_bits, edx
  954.         mov ecx,[edx+deflate_state.pending]
  955.         mov eax,[ebx+z_stream.avail_out]
  956.         cmp ecx,eax
  957.         jle @f ;if (..>..)
  958.                 mov ecx,eax
  959.         @@:
  960.         test ecx,ecx
  961.         jz @f
  962.  
  963.         stdcall zmemcpy, [ebx+z_stream.next_out], [edx+deflate_state.pending_out], ecx
  964.         add [ebx+z_stream.next_out],ecx
  965.         add [edx+deflate_state.pending_out],ecx
  966.         add [ebx+z_stream.total_out],ecx
  967.         sub [ebx+z_stream.avail_out],ecx
  968.         sub [edx+deflate_state.pending],ecx
  969.         cmp dword[edx+deflate_state.pending],0
  970.         jne @f ;if (..==0)
  971.                 mov eax,[edx+deflate_state.pending_buf]
  972.                 mov [edx+deflate_state.pending_out],eax
  973.         @@:
  974.         ret
  975. endp
  976.  
  977. ; =========================================================================
  978. ;int (strm, flush)
  979. ;    z_streamp strm
  980. ;    int flush
  981. align 16
  982. proc deflate uses ebx ecx edx edi esi, strm:dword, flush:dword
  983. locals
  984.         old_flush dd ? ;int ;value of flush param for previous deflate call
  985.         val dd ?
  986. endl
  987.         mov ebx,[strm]
  988.         cmp ebx,Z_NULL
  989.         je @f
  990.         mov edi,[ebx+z_stream.state] ;s = strm.state
  991.         cmp edi,Z_NULL
  992.         je @f
  993.         cmp dword[flush],Z_BLOCK
  994.         jg @f
  995.         cmp dword[flush],0
  996.         jge .end10 ;if (..==0 || ..==0 || ..>.. || ..<0)
  997.         @@:
  998.                 mov eax,Z_STREAM_ERROR
  999.                 jmp .end_f
  1000.         .end10:
  1001.         cmp dword[ebx+z_stream.next_out],Z_NULL
  1002.         je .beg0
  1003.         cmp dword[ebx+z_stream.next_in],Z_NULL
  1004.         jne @f
  1005.         cmp dword[ebx+z_stream.avail_in],0
  1006.         jne .beg0
  1007.         @@:
  1008.         cmp dword[edi+deflate_state.status],FINISH_STATE
  1009.         jne .end0
  1010.         cmp dword[flush],Z_FINISH
  1011.         je .end0
  1012.         .beg0: ;if (..==0 || (..==0 && ..!=0) || (..==.. && ..!=..))
  1013.                 ERR_RETURN ebx, Z_STREAM_ERROR
  1014.                 jmp .end_f
  1015.         .end0:
  1016.         cmp dword[ebx+z_stream.avail_out],0
  1017.         jne @f ;if (..==0)
  1018.                 ERR_RETURN ebx, Z_BUF_ERROR
  1019.                 jmp .end_f
  1020.         @@:
  1021.  
  1022.         mov dword[edi+deflate_state.strm],ebx ;just in case
  1023.         mov eax,[edi+deflate_state.last_flush]
  1024.         mov [old_flush],eax
  1025.         mov eax,[flush]
  1026.         mov [edi+deflate_state.last_flush],eax
  1027.  
  1028.         ; Write the header
  1029.         cmp dword[edi+deflate_state.status],INIT_STATE
  1030.         jne .end2 ;if (..==..)
  1031. if GZIP eq 1
  1032.                 cmp dword[edi+deflate_state.wrap],2
  1033.                 jne .end1 ;if (..==..)
  1034.                         xor eax,eax ;stdcall calc_crc32, 0, Z_NULL, 0
  1035.                         mov [ebx+z_stream.adler],eax
  1036.                         put_byte edi, 31
  1037.                         put_byte edi, 139
  1038.                         put_byte edi, 8
  1039.                         cmp dword[edi+deflate_state.gzhead],Z_NULL
  1040.                         jne .end3 ;if (..==0)
  1041.                                 put_byte edi, 0
  1042.                                 put_dword edi, 0
  1043.                                 xor cl,cl
  1044.                                 cmp word[edi+deflate_state.level],2
  1045.                                 jge @f
  1046.                                         mov cl,4
  1047.                                 @@:
  1048.                                 cmp word[edi+deflate_state.strategy],Z_HUFFMAN_ONLY
  1049.                                 jl @f
  1050.                                         mov cl,4
  1051.                                 @@:
  1052.                                 cmp word[edi+deflate_state.level],9
  1053.                                 jne @f
  1054.                                         mov cl,2
  1055.                                 @@: ;..==.. ? 2 : (..>=.. || ..<.. ? 4 : 0)
  1056.                                 put_byte edi, cl
  1057.                                 put_byte edi, OS_CODE
  1058.                                 mov dword[edi+deflate_state.status],BUSY_STATE
  1059.                                 jmp .end2
  1060.                         .end3: ;else
  1061.                                 mov edx,[edi+deflate_state.gzhead]
  1062.                                 xor cl,cl
  1063.                                 cmp [edx+gz_header.text],0
  1064.                                 je @f
  1065.                                         inc cl
  1066.                                 @@:
  1067.                                 cmp [edx+gz_header.hcrc],0
  1068.                                 je @f
  1069.                                         add cl,2
  1070.                                 @@:
  1071.                                 cmp [edx+gz_header.extra],Z_NULL
  1072.                                 je @f
  1073.                                         add cl,4
  1074.                                 @@:
  1075.                                 cmp [edx+gz_header.name],Z_NULL
  1076.                                 je @f
  1077.                                         add cl,8
  1078.                                 @@:
  1079.                                 cmp [edx+gz_header.comment],Z_NULL
  1080.                                 je @f
  1081.                                         add cl,16
  1082.                                 @@:
  1083.                                 put_byte edi, cl
  1084.                                 mov ecx,[edx+gz_header.time]
  1085.                                 put_dword edi, ecx
  1086.                                 xor cl,cl
  1087.                                 cmp word[edi+deflate_state.level],2
  1088.                                 jge @f
  1089.                                         mov cl,4
  1090.                                 @@:
  1091.                                 cmp word[edi+deflate_state.strategy],Z_HUFFMAN_ONLY
  1092.                                 jl @f
  1093.                                         mov cl,4
  1094.                                 @@:
  1095.                                 cmp word[edi+deflate_state.level],9
  1096.                                 jne @f
  1097.                                         mov cl,2
  1098.                                 @@: ;..==.. ? 2 : (..>=.. || ..<.. ? 4 : 0)
  1099.                                 put_byte edi, cl
  1100.                                 mov ecx,[edx+gz_header.os]
  1101.                                 put_byte edi, cl
  1102.                                 cmp dword[edx+gz_header.extra],Z_NULL
  1103.                                 je @f ;if (..!=0)
  1104.                                         mov ecx,[edx+gz_header.extra_len]
  1105.                                         put_byte edi, cl
  1106.                                         put_byte edi, ch
  1107.                                 @@:
  1108.                                 cmp dword[edx+gz_header.hcrc],0
  1109.                                 je @f ;if (..)
  1110.                                         stdcall calc_crc32, [ebx+z_stream.adler],\
  1111.                                                 [edi+deflate_state.pending_buf], [edi+deflate_state.pending]
  1112.                                         mov [ebx+z_stream.adler],eax
  1113.                                 @@:
  1114.                                 mov dword[edi+deflate_state.gzindex],0
  1115.                                 mov dword[edi+deflate_state.status],EXTRA_STATE
  1116.                         jmp .end2
  1117.                 .end1: ;else
  1118. end if
  1119.                         mov edx,[edi+deflate_state.w_bits]
  1120.                         sub edx,8
  1121.                         shl edx,4
  1122.                         add edx,Z_DEFLATED
  1123.                         shl edx,8 ;edx = header
  1124.                         ;esi = level_flags
  1125.  
  1126.                         mov esi,3
  1127.                         cmp word[edi+deflate_state.strategy],Z_HUFFMAN_ONLY
  1128.                         jge @f
  1129.                         cmp word[edi+deflate_state.level],2
  1130.                         jge .end30 ;if (..>=.. || ..<..)
  1131.                         @@:
  1132.                                 xor esi,esi
  1133.                                 jmp .end4
  1134.                         .end30:
  1135.                         cmp word[edi+deflate_state.level],6
  1136.                         jge @f ;else if (..<..)
  1137.                                 mov esi,1
  1138.                                 jmp .end4
  1139.                         @@:
  1140.                         ;;cmp word[edi+deflate_state.level],6
  1141.                         jne .end4 ;else if (..==..)
  1142.                                 mov esi,2
  1143.                         .end4:
  1144.                         shl esi,6
  1145.                         or edx,esi
  1146.                         cmp dword[edi+deflate_state.strstart],0
  1147.                         je @f ;if (..!=0)
  1148.                                 or edx,PRESET_DICT
  1149.                         @@:
  1150.                         mov esi,edx
  1151.                         mov eax,edx
  1152.                         xor edx,edx
  1153.                         mov ecx,31
  1154.                         div ecx
  1155.                         add esi,31
  1156.                         sub esi,edx ;esi = header
  1157.  
  1158.                         mov dword[edi+deflate_state.status],BUSY_STATE
  1159.                         stdcall putShortMSB, edi, esi
  1160.  
  1161.                         ; Save the adler32 of the preset dictionary:
  1162.                         cmp dword[edi+deflate_state.strstart],0
  1163.                         je @f ;if (..!=0)
  1164.                                 mov ecx,[ebx+z_stream.adler]
  1165.                                 bswap ecx
  1166.                                 put_dword edi, ecx
  1167.                         @@:
  1168.                         xor eax,eax ;stdcall calc_crc32, 0, Z_NULL, 0
  1169.                         mov [ebx+z_stream.adler],eax
  1170.         .end2:
  1171. if GZIP eq 1
  1172.         mov edx,[edi+deflate_state.gzhead]
  1173.         cmp dword[edi+deflate_state.status],EXTRA_STATE
  1174.         jne .end5 ;if (..==..)
  1175.                 cmp dword[edx+gz_header.extra],Z_NULL
  1176.                 je .end21 ;if (..!=..)
  1177.                         mov esi,[edi+deflate_state.pending]
  1178.                         ;esi = beg ;start of bytes to update crc
  1179.  
  1180.                         movzx ecx,word[edx+gz_header.extra_len]
  1181. align 4
  1182.                         .cycle0: ;while (..<..)
  1183.                         cmp dword[edi+deflate_state.gzindex],ecx
  1184.                         jge .cycle0end
  1185.                                 mov eax,[edi+deflate_state.pending]
  1186.                                 cmp eax,[edi+deflate_state.pending_buf_size]
  1187.                                 jne .end24 ;if (..==..)
  1188.                                         mov dword[edx+gz_header.hcrc],0
  1189.                                         je @f
  1190.                                         cmp [edi+deflate_state.pending],esi
  1191.                                         jle @f ;if (.. && ..>..)
  1192.                                                 mov ecx,[edi+deflate_state.pending]
  1193.                                                 sub ecx,esi
  1194.                                                 mov eax,[edi+deflate_state.pending_buf]
  1195.                                                 add eax,esi
  1196.                                                 stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
  1197.                                                 mov [ebx+z_stream.adler],eax
  1198.                                         @@:
  1199.                                         stdcall flush_pending, ebx
  1200.                                         mov esi,[edi+deflate_state.pending]
  1201.                                         cmp esi,[edi+deflate_state.pending_buf_size]
  1202.                                         je .cycle0end ;if (..==..) break
  1203.                                 .end24:
  1204.                                 push ebx
  1205.                                         mov ebx,[edi+deflate_state.gzindex]
  1206.                                         add ebx,[edx+gz_header.extra]
  1207.                                         mov bl,[ebx]
  1208.                                         put_byte edi, bl
  1209.                                 pop ebx
  1210.                                 inc dword[edi+deflate_state.gzindex]
  1211.                                 jmp .cycle0
  1212.                         .cycle0end:
  1213.                         mov dword[edx+gz_header.hcrc],0
  1214.                         je @f
  1215.                         cmp [edi+deflate_state.pending],esi
  1216.                         jle @f ;if (.. && ..>..)
  1217.                                 mov ecx,[edi+deflate_state.pending]
  1218.                                 sub ecx,esi
  1219.                                 mov eax,[edi+deflate_state.pending_buf]
  1220.                                 add eax,esi
  1221.                                 stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
  1222.                                 mov [ebx+z_stream.adler],eax
  1223.                         @@:
  1224.                         mov eax,[edx+gz_header.extra_len]
  1225.                         cmp dword[edi+deflate_state.gzindex],eax
  1226.                         jne .end5 ;if (..==..)
  1227.                                 mov dword[edi+deflate_state.gzindex],0
  1228.                                 mov dword[edi+deflate_state.status],NAME_STATE
  1229.                         jmp .end5
  1230.                 .end21: ;else
  1231.                         mov dword[edi+deflate_state.status],NAME_STATE
  1232.         .end5:
  1233.         cmp dword[edi+deflate_state.status],NAME_STATE
  1234.         jne .end6 ;if (..==..)
  1235.                 cmp dword[edx+gz_header.name],Z_NULL
  1236.                 je .end22 ;if (..!=..)
  1237.                         mov esi,[edi+deflate_state.pending]
  1238.                         ;esi = beg ;start of bytes to update crc
  1239.  
  1240.                         .cycle1: ;do
  1241.                                 mov eax,[edi+deflate_state.pending]
  1242.                                 cmp eax,[edi+deflate_state.pending_buf_size]
  1243.                                 jne .end25 ;if (..==..)
  1244.                                         mov dword[edx+gz_header.hcrc],0
  1245.                                         je @f
  1246.                                         cmp [edi+deflate_state.pending],esi
  1247.                                         jle @f ;if (.. && ..>..)
  1248.                                                 mov ecx,[edi+deflate_state.pending]
  1249.                                                 sub ecx,esi
  1250.                                                 mov eax,[edi+deflate_state.pending_buf]
  1251.                                                 add eax,esi
  1252.                                                 stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
  1253.                                                 mov [ebx+z_stream.adler],eax
  1254.                                         @@:
  1255.                                         stdcall flush_pending, ebx
  1256.                                         mov esi,[edi+deflate_state.pending]
  1257.                                         cmp esi,[edi+deflate_state.pending_buf_size]
  1258.                                         jne .end25 ;if (..==..)
  1259.                                                 mov dword[val],1
  1260.                                                 jmp .cycle1end
  1261.                                 .end25:
  1262.                                 push ebx
  1263.                                         mov ebx,[edi+deflate_state.gzindex]
  1264.                                         add ebx,[edx+gz_header.name]
  1265.                                         movzx ebx,byte[ebx]
  1266.                                         mov [val],ebx
  1267.                                         inc dword[edi+deflate_state.gzindex]
  1268.                                         put_byte edi, bl
  1269.                                 pop ebx
  1270.                                 cmp dword[val],0
  1271.                                 jne .cycle1 ;while (val != 0)
  1272.                         .cycle1end:
  1273.                         mov dword[edx+gz_header.hcrc],0
  1274.                         je @f
  1275.                         cmp [edi+deflate_state.pending],esi
  1276.                         jle @f ;if (.. && ..>..)
  1277.                                 mov ecx,[edi+deflate_state.pending]
  1278.                                 sub ecx,esi
  1279.                                 mov eax,[edi+deflate_state.pending_buf]
  1280.                                 add eax,esi
  1281.                                 stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
  1282.                                 mov [ebx+z_stream.adler],eax
  1283.                         @@:
  1284.                         cmp dword[val],0
  1285.                         jne .end6 ;if (val == 0)
  1286.                                 mov dword[edi+deflate_state.gzindex],0
  1287.                                 mov dword[edi+deflate_state.status],COMMENT_STATE
  1288.                         jmp .end6
  1289.                 .end22: ;else
  1290.                         mov dword[edi+deflate_state.status],COMMENT_STATE
  1291.         .end6:
  1292.         cmp dword[edi+deflate_state.status],COMMENT_STATE
  1293.         jne .end7 ;if (..==..)
  1294.                 cmp dword[edx+gz_header.comment],Z_NULL
  1295.                 je .end23 ;if (..!=..)
  1296.                         mov esi,[edi+deflate_state.pending]
  1297.                         ;esi = beg ;start of bytes to update crc
  1298.  
  1299.                         .cycle2: ;do
  1300.                                 mov eax,[edi+deflate_state.pending]
  1301.                                 cmp eax,[edi+deflate_state.pending_buf_size]
  1302.                                 jne .end26 ;if (..==..)
  1303.                                         mov dword[edx+gz_header.hcrc],0
  1304.                                         je @f
  1305.                                         cmp [edi+deflate_state.pending],esi
  1306.                                         jle @f ;if (.. && ..>..)
  1307.                                                 mov ecx,[edi+deflate_state.pending]
  1308.                                                 sub ecx,esi
  1309.                                                 mov eax,[edi+deflate_state.pending_buf]
  1310.                                                 add eax,esi
  1311.                                                 stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
  1312.                                                 mov [ebx+z_stream.adler],eax
  1313.                                         @@:
  1314.                                         stdcall flush_pending, ebx
  1315.                                         mov esi,[edi+deflate_state.pending]
  1316.                                         cmp esi,[edi+deflate_state.pending_buf_size]
  1317.                                         jne .end26 ;if (..==..)
  1318.                                                 mov dword[val],1
  1319.                                                 jmp .cycle2end
  1320.                                 .end26:
  1321.                                 push ebx
  1322.                                         mov ebx,[edi+deflate_state.gzindex]
  1323.                                         add ebx,[edx+gz_header.comment]
  1324.                                         movzx ebx,byte[ebx]
  1325.                                         mov [val],ebx
  1326.                                         inc dword[edi+deflate_state.gzindex]
  1327.                                         put_byte edi, bl
  1328.                                 pop ebx
  1329.                                 cmp dword[val],0
  1330.                                 jne .cycle2 ;while (val != 0)
  1331.                         .cycle2end:
  1332.                         mov dword[edx+gz_header.hcrc],0
  1333.                         je @f
  1334.                         cmp [edi+deflate_state.pending],esi
  1335.                         jle @f ;if (.. && ..>..)
  1336.                                 mov ecx,[edi+deflate_state.pending]
  1337.                                 sub ecx,esi
  1338.                                 mov eax,[edi+deflate_state.pending_buf]
  1339.                                 add eax,esi
  1340.                                 stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
  1341.                                 mov [ebx+z_stream.adler],eax
  1342.                         @@:
  1343.                         cmp dword[val],0
  1344.                         jne .end7 ;if (val == 0)
  1345.                                 mov dword[edi+deflate_state.status],HCRC_STATE
  1346.                         jmp .end7
  1347.                 .end23: ;else
  1348.                         mov dword[edi+deflate_state.status],HCRC_STATE
  1349.         .end7:
  1350.         cmp dword[edi+deflate_state.status],HCRC_STATE
  1351.         jne .end8 ;if (..==..)
  1352.                 cmp dword[edx+gz_header.hcrc],0
  1353.                 je .end9 ;if (..)
  1354.                         mov ecx,[edi+deflate_state.pending]
  1355.                         add ecx,2
  1356.                         cmp ecx,[edi+deflate_state.pending_buf_size]
  1357.                         jbe @f ;if (..>..)
  1358.                                 stdcall flush_pending, ebx
  1359.                         @@:
  1360.                         mov ecx,[edi+deflate_state.pending]
  1361.                         add ecx,2
  1362.                         cmp ecx,[edi+deflate_state.pending_buf_size]
  1363.                         ja .end8 ;if (..<=..)
  1364.                                 mov ecx,[ebx+z_stream.adler]
  1365.                                 put_byte edi, cl
  1366.                                 put_byte edi, ch
  1367.                                 xor eax,eax ;stdcall calc_crc32, 0, Z_NULL, 0
  1368.                                 mov [ebx+z_stream.adler],eax
  1369.                                 mov dword[edi+deflate_state.status],BUSY_STATE
  1370.                         jmp .end8
  1371.                 .end9: ;else
  1372.                         mov dword[edi+deflate_state.status],BUSY_STATE
  1373.         .end8:
  1374. end if
  1375.  
  1376.         ; Flush as much pending output as possible
  1377.         cmp dword[edi+deflate_state.pending],0
  1378.         je .end13 ;if (..!=0)
  1379.                 stdcall flush_pending, ebx
  1380.                 cmp dword[ebx+z_stream.avail_out],0
  1381.                 jne @f ;if (..==0)
  1382.                         ; Since avail_out is 0, deflate will be called again with
  1383.                         ; more output space, but possibly with both pending and
  1384.                         ; avail_in equal to zero. There won't be anything to do,
  1385.                         ; but this is not an error situation so make sure we
  1386.                         ; return OK instead of BUF_ERROR at next call of deflate:
  1387.  
  1388.                         mov dword[edi+deflate_state.last_flush],-1
  1389.                         mov eax,Z_OK
  1390.                         jmp .end_f
  1391.                 ; Make sure there is something to do and avoid duplicate consecutive
  1392.                 ; flushes. For repeated and useless calls with Z_FINISH, we keep
  1393.                 ; returning Z_STREAM_END instead of Z_BUF_ERROR.
  1394. align 4
  1395.         .end13:
  1396.         cmp dword[ebx+z_stream.avail_in],0
  1397.         jne @f
  1398.         RANK dword[old_flush],esi
  1399.         RANK dword[flush],eax
  1400.         cmp eax,esi
  1401.         jg @f
  1402.         cmp dword[flush],Z_FINISH
  1403.         je @f ;else if (..==0 && ..<=.. && ..!=..)
  1404.                 ERR_RETURN ebx, Z_BUF_ERROR
  1405.                 jmp .end_f
  1406.         @@:
  1407.  
  1408.         ; User must not provide more input after the first FINISH:
  1409.         cmp dword[edi+deflate_state.status],FINISH_STATE
  1410.         jne @f
  1411.         cmp dword[ebx+z_stream.avail_in],0
  1412.         je @f ;if (..==.. && ..!=0)
  1413.                 ERR_RETURN ebx, Z_BUF_ERROR
  1414.                 jmp .end_f
  1415.         @@:
  1416.  
  1417.         ; Start a new block or continue the current one.
  1418.  
  1419.         cmp dword[ebx+z_stream.avail_in],0
  1420.         jne @f
  1421.         cmp dword[edi+deflate_state.lookahead],0
  1422.         jne @f
  1423.         cmp dword[flush],Z_NO_FLUSH
  1424.         je .end11
  1425.         cmp dword[edi+deflate_state.status],FINISH_STATE
  1426.         je .end11
  1427.         @@: ;if (..!=0 || ..!=0 || (..!=.. && ..!=..))
  1428.                 ;edx = bstate
  1429.                 cmp word[edi+deflate_state.strategy],Z_HUFFMAN_ONLY
  1430.                 jne @f
  1431.                         stdcall deflate_huff, edi, [flush]
  1432.                         jmp .end20
  1433.                 @@:
  1434.                 cmp word[edi+deflate_state.strategy],Z_RLE
  1435.                 jne @f
  1436.                         stdcall deflate_rle, edi, [flush]
  1437.                         jmp .end20
  1438.                 @@:
  1439.                 movzx eax,word[edi+deflate_state.level]
  1440.                 imul eax,sizeof.config_s
  1441.                 add eax,configuration_table+config_s.co_func
  1442.                 stdcall dword[eax], edi, [flush]
  1443.                 .end20:
  1444.                 mov edx,eax
  1445.  
  1446.                 cmp edx,finish_started
  1447.                 je @f
  1448.                 cmp edx,finish_done
  1449.                 jne .end18
  1450.                 @@: ;if (..==.. || ..==..)
  1451.                         mov dword[edi+deflate_state.status],FINISH_STATE
  1452.                 .end18:
  1453.                 cmp edx,need_more
  1454.                 je @f
  1455.                 cmp edx,finish_started
  1456.                 jne .end19
  1457.                 @@: ;if (..==.. || ..==..)
  1458.                         cmp dword[ebx+z_stream.avail_out],0
  1459.                         jne @f ;if (..==0)
  1460.                                 mov dword[edi+deflate_state.last_flush],-1 ;avoid BUF_ERROR next call, see above
  1461.                         @@:
  1462.                         mov eax,Z_OK
  1463.                         jmp .end_f
  1464.                         ; If flush != Z_NO_FLUSH && avail_out == 0, the next call
  1465.                         ; of deflate should use the same flush parameter to make sure
  1466.                         ; that the flush is complete. So we don't have to output an
  1467.                         ; empty block here, this will be done at next call. This also
  1468.                         ; ensures that for a very small output buffer, we emit at most
  1469.                         ; one empty block.
  1470.  
  1471.                 .end19:
  1472.                 cmp edx,block_done
  1473.                 jne .end11 ;if (..==..)
  1474.                         cmp dword[flush],Z_PARTIAL_FLUSH
  1475.                         jne @f ;if (..==..)
  1476.                                 stdcall _tr_align, edi
  1477.                                 jmp .end16
  1478.                         @@:
  1479.                         cmp dword[flush],Z_BLOCK
  1480.                         je .end16 ;else if (..!=..) ;FULL_FLUSH or SYNC_FLUSH
  1481.                                 stdcall _tr_stored_block, edi, 0, 0, 0
  1482.                                 ; For a full flush, this empty block will be recognized
  1483.                                 ; as a special marker by inflate_sync().
  1484.  
  1485.                         cmp dword[flush],Z_FULL_FLUSH
  1486.                         jne .end16 ;if (..==..)
  1487.                                 CLEAR_HASH edi ;forget history
  1488.                                 cmp dword[edi+deflate_state.lookahead],0
  1489.                                 jne .end16 ;if (..==0)
  1490.                                         mov dword[edi+deflate_state.strstart],0
  1491.                                         mov dword[edi+deflate_state.block_start],0
  1492.                                         mov dword[edi+deflate_state.insert],0
  1493.                 .end16:
  1494.                 stdcall flush_pending, ebx
  1495.                 cmp dword[ebx+z_stream.avail_out],0
  1496.                 jne .end11 ;if (..==0)
  1497.                         mov dword[edi+deflate_state.last_flush],-1 ;avoid BUF_ERROR at next call, see above
  1498.                         mov eax,Z_OK
  1499.                         jmp .end_f
  1500.         .end11:
  1501.         cmp dword[ebx+z_stream.avail_out],0
  1502.         jg @f
  1503.                 zlib_assert 'bug2' ;Assert(..>0)
  1504.         @@:
  1505.  
  1506.         cmp dword[flush],Z_FINISH
  1507.         je @f ;if (..!=0)
  1508.                 mov eax,Z_OK
  1509.                 jmp .end_f
  1510.         @@:
  1511.         cmp dword[edi+deflate_state.wrap],0
  1512.         jg @f ;if (..<=0)
  1513.                 mov eax,Z_STREAM_END
  1514.                 jmp .end_f
  1515.         @@:
  1516.  
  1517.         ; Write the trailer
  1518. if GZIP eq 1
  1519.         cmp dword[edi+deflate_state.wrap],2
  1520.         jne @f ;if (..==..)
  1521.                 mov ecx,[ebx+z_stream.adler]
  1522.                 put_dword edi, ecx
  1523.                 mov ecx,[ebx+z_stream.total_in]
  1524.                 put_dword edi, ecx
  1525.                 jmp .end17
  1526.         @@: ;else
  1527. end if
  1528.                 mov ecx,[ebx+z_stream.adler]
  1529.                 bswap ecx
  1530.                 put_dword edi, ecx
  1531.         .end17:
  1532.         stdcall flush_pending, ebx
  1533.         ; If avail_out is zero, the application will call deflate again
  1534.         ; to flush the rest.
  1535.  
  1536.         cmp dword[edi+deflate_state.wrap],0
  1537.         jle @f ;if (..>0) ;write the trailer only once!
  1538.                 neg dword[edi+deflate_state.wrap]
  1539.         @@:
  1540.         mov eax,Z_OK
  1541.         cmp dword[edi+deflate_state.pending],0
  1542.         jne .end_f
  1543.                 mov eax,Z_STREAM_END
  1544. .end_f:
  1545.         ret
  1546. endp
  1547.  
  1548. ; =========================================================================
  1549. ;int (strm)
  1550. ;    z_streamp strm
  1551. align 4
  1552. proc deflateEnd uses ebx ecx edx, strm:dword
  1553.         mov ebx,[strm]
  1554.         cmp ebx,Z_NULL
  1555.         je @f
  1556.         mov edx,[ebx+z_stream.state]
  1557.         cmp edx,Z_NULL
  1558.         jne .end0
  1559.         @@: ;if (..==0 || ..==0) return ..
  1560.                 mov eax,Z_STREAM_ERROR
  1561.                 jmp .end_f
  1562.         .end0:
  1563.  
  1564.         mov ecx,[edx+deflate_state.status]
  1565.         cmp ecx,INIT_STATE
  1566.         je @f
  1567.         cmp ecx,EXTRA_STATE
  1568.         je @f
  1569.         cmp ecx,NAME_STATE
  1570.         je @f
  1571.         cmp ecx,COMMENT_STATE
  1572.         je @f
  1573.         cmp ecx,HCRC_STATE
  1574.         je @f
  1575.         cmp ecx,BUSY_STATE
  1576.         je @f
  1577.         cmp ecx,FINISH_STATE
  1578.         je @f ;if (..!=.. && ..!=.. && ..!=.. && ..!=.. && ..!=.. && ..!=.. && ..!=..)
  1579.                 mov eax,Z_STREAM_ERROR
  1580.                 jmp .end_f
  1581.         @@:
  1582.  
  1583.         ; Deallocate in reverse order of allocations:
  1584.         TRY_FREE ebx, dword[edx+deflate_state.pending_buf]
  1585.         TRY_FREE ebx, dword[edx+deflate_state.head]
  1586.         TRY_FREE ebx, dword[edx+deflate_state.prev]
  1587.         TRY_FREE ebx, dword[edx+deflate_state.window]
  1588.  
  1589.         ZFREE ebx, dword[ebx+z_stream.state]
  1590.         mov dword[ebx+z_stream.state],Z_NULL
  1591.  
  1592.         mov eax,Z_DATA_ERROR
  1593.         cmp ecx,BUSY_STATE
  1594.         je .end_f
  1595.                 mov eax,Z_OK
  1596. .end_f:
  1597.         ret
  1598. endp
  1599.  
  1600. ; =========================================================================
  1601. ; Copy the source state to the destination state.
  1602. ; To simplify the source, this is not supported for 16-bit MSDOS (which
  1603. ; doesn't have enough memory anyway to duplicate compression states).
  1604.  
  1605. ;int (dest, source)
  1606. ;    z_streamp dest
  1607. ;    z_streamp source
  1608. align 4
  1609. proc deflateCopy uses ebx edx edi esi, dest:dword, source:dword
  1610. ;ebx = overlay ;uint_16p
  1611. ;edi = ds ;deflate_state*
  1612. ;esi = ss ;deflate_state*
  1613.  
  1614.         mov esi,[source]
  1615.         cmp esi,Z_NULL
  1616.         je @f
  1617.         mov edx,[dest]
  1618.         cmp edx,Z_NULL
  1619.         je @f
  1620.         mov esi,[esi+z_stream.state]
  1621.         cmp esi,Z_NULL
  1622.         jne .end0
  1623.         @@: ;if (..==0 || ..==0 || ..==0)
  1624.                 mov eax,Z_STREAM_ERROR
  1625.                 jmp .end_f
  1626.         .end0:
  1627.  
  1628.         stdcall zmemcpy, edx, [source], sizeof.z_stream
  1629.  
  1630.         ZALLOC edx, 1, sizeof.deflate_state
  1631.         cmp eax,0
  1632.         jne @f ;if (..==0) return ..
  1633.                 mov eax,Z_MEM_ERROR
  1634.                 jmp .end_f
  1635.         @@:
  1636.         mov edi,eax
  1637.         mov [edx+z_stream.state],eax
  1638.         stdcall zmemcpy, edi, esi, sizeof.deflate_state
  1639.         mov dword[edi+deflate_state.strm],edx
  1640.  
  1641.         ZALLOC edx, [edi+deflate_state.w_size], 2 ;2*sizeof.db
  1642.         mov dword[edi+deflate_state.window],eax
  1643.         ZALLOC edx, [edi+deflate_state.w_size], 2 ;sizeof.dw
  1644.         mov dword[edi+deflate_state.prev],eax
  1645.         ZALLOC edx, [edi+deflate_state.hash_size], 2 ;sizeof.dw
  1646.         mov dword[edi+deflate_state.head],eax
  1647.         ZALLOC edx, [edi+deflate_state.lit_bufsize], 4 ;sizeof.dw+2
  1648.         mov ebx,eax
  1649.         mov dword[edi+deflate_state.pending_buf],eax
  1650.  
  1651.         cmp dword[edi+deflate_state.window],Z_NULL
  1652.         je @f
  1653.         cmp dword[edi+deflate_state.prev],Z_NULL
  1654.         je @f
  1655.         cmp dword[edi+deflate_state.head],Z_NULL
  1656.         je @f
  1657.         cmp dword[edi+deflate_state.pending_buf],Z_NULL
  1658.         jne .end1
  1659.         @@: ;if (..==0 || ..==0 || ..==0 || ..==0)
  1660.                 stdcall deflateEnd, edx
  1661.                 mov eax,Z_MEM_ERROR
  1662.                 jmp .end_f
  1663.         .end1:
  1664.  
  1665.         ; following zmemcpy do not work for 16-bit MSDOS
  1666.         mov eax,[edi+deflate_state.w_size]
  1667.         shl eax,1 ;*= 2*sizeof.db
  1668.         stdcall zmemcpy, [edi+deflate_state.window], [esi+deflate_state.window], eax
  1669.         mov eax,[edi+deflate_state.w_size]
  1670.         shl eax,1 ;*= sizeof.dw
  1671.         stdcall zmemcpy, [edi+deflate_state.prev], [esi+deflate_state.prev], eax
  1672.         mov eax,[edi+deflate_state.hash_size]
  1673.         shl eax,1 ;*= sizeof.dw
  1674.         stdcall zmemcpy, [edi+deflate_state.head], [esi+deflate_state.head], eax
  1675.         stdcall zmemcpy, [edi+deflate_state.pending_buf], [esi+deflate_state.pending_buf], [edi+deflate_state.pending_buf_size]
  1676.  
  1677.         mov eax,[edi+deflate_state.pending_buf]
  1678.         add eax,[esi+deflate_state.pending_out]
  1679.         sub eax,[esi+deflate_state.pending_buf]
  1680.         mov [edi+deflate_state.pending_out],eax
  1681.         mov eax,[edi+deflate_state.lit_bufsize]
  1682.         shr eax,1 ;/=sizeof.uint_16
  1683.         add eax,ebx
  1684.         mov [edi+deflate_state.d_buf],eax
  1685.         mov eax,[edi+deflate_state.lit_bufsize]
  1686.         imul eax,3 ;*=1+sizeof.uint_16
  1687.         add eax,[edi+deflate_state.pending_buf]
  1688.         mov [edi+deflate_state.l_buf],eax
  1689.  
  1690.         mov eax,edi
  1691.         add eax,deflate_state.dyn_ltree
  1692.         mov [edi+deflate_state.l_desc.dyn_tree],eax
  1693.         add eax,deflate_state.dyn_dtree-deflate_state.dyn_ltree
  1694.         mov [edi+deflate_state.d_desc.dyn_tree],eax
  1695.         add eax,deflate_state.bl_tree-deflate_state.dyn_dtree
  1696.         mov [edi+deflate_state.bl_desc.dyn_tree],eax
  1697.  
  1698.         mov eax,Z_OK
  1699. .end_f:
  1700.         ret
  1701. endp
  1702.  
  1703. ; ===========================================================================
  1704. ; Read a new buffer from the current input stream, update the adler32
  1705. ; and total number of bytes read.  All deflate() input goes through
  1706. ; this function so some applications may wish to modify it to avoid
  1707. ; allocating a large strm->next_in buffer and copying from it.
  1708. ; (See also flush_pending()).
  1709.  
  1710. ;int (strm, buf, size)
  1711. ;    z_streamp strm
  1712. ;    Bytef *buf
  1713. ;    unsigned size
  1714. align 16
  1715. proc read_buf uses ebx ecx, strm:dword, buf:dword, size:dword
  1716.         mov ebx,[strm]
  1717.         mov eax,[ebx+z_stream.avail_in]
  1718.  
  1719.         cmp eax,[size]
  1720.         jle @f ;if (..>..)
  1721.                 mov eax,[size]
  1722.         @@:
  1723.         cmp eax,0
  1724.         jg @f
  1725.                 xor eax,eax
  1726.                 jmp .end_f ;if (..==0) return 0
  1727.         @@:
  1728.  
  1729.         sub [ebx+z_stream.avail_in],eax
  1730.  
  1731.         stdcall zmemcpy, [buf],[ebx+z_stream.next_in],eax
  1732.         mov ecx,[ebx+z_stream.state]
  1733.         cmp dword[ecx+deflate_state.wrap],1
  1734.         jne @f ;if (..==..)
  1735.                 push eax
  1736.                 stdcall adler32, [ebx+z_stream.adler], [buf], eax
  1737.                 mov [ebx+z_stream.adler],eax
  1738.                 pop eax
  1739. if GZIP eq 1
  1740.                 jmp .end0
  1741. end if
  1742.         @@:
  1743. if GZIP eq 1
  1744.         cmp dword[ecx+deflate_state.wrap],2
  1745.         jne .end0 ;else if (..==..)
  1746.                 push eax
  1747.                 stdcall calc_crc32, [ebx+z_stream.adler], [buf], eax
  1748.                 mov [ebx+z_stream.adler],eax
  1749.                 pop eax
  1750.         .end0:
  1751. end if
  1752.         add [ebx+z_stream.next_in],eax
  1753.         add [ebx+z_stream.total_in],eax
  1754.  
  1755. .end_f:
  1756.         ret
  1757. endp
  1758.  
  1759. ; ===========================================================================
  1760. ; Initialize the "longest match" routines for a new zlib stream
  1761.  
  1762. ;void (deflate_state *s)
  1763. align 16
  1764. proc lm_init uses eax ebx edi, s:dword
  1765.         mov edi,[s]
  1766.         mov eax,[edi+deflate_state.w_size]
  1767.         shl eax,1
  1768.         mov [edi+deflate_state.window_size],eax
  1769.  
  1770.         CLEAR_HASH edi
  1771.  
  1772.         ; Set the default configuration parameters:
  1773.  
  1774.         movzx eax,word[edi+deflate_state.level]
  1775.         imul eax,sizeof.config_s
  1776.         add eax,configuration_table
  1777.         movzx ebx,word[eax+config_s.max_lazy]
  1778.         mov [edi+deflate_state.max_lazy_match],ebx
  1779.         movzx ebx,word[eax+config_s.good_length]
  1780.         mov [edi+deflate_state.good_match],ebx
  1781.         movzx ebx,word[eax+config_s.nice_length]
  1782.         mov [edi+deflate_state.nice_match],ebx
  1783.         movzx ebx,word[eax+config_s.max_chain]
  1784.         mov [edi+deflate_state.max_chain_length],ebx
  1785.  
  1786.         mov dword[edi+deflate_state.strstart],0
  1787.         mov dword[edi+deflate_state.block_start],0
  1788.         mov dword[edi+deflate_state.lookahead],0
  1789.         mov dword[edi+deflate_state.insert],0
  1790.         mov dword[edi+deflate_state.prev_length],MIN_MATCH-1
  1791.         mov dword[edi+deflate_state.match_length],MIN_MATCH-1
  1792.         mov dword[edi+deflate_state.match_available],0
  1793.         mov dword[edi+deflate_state.ins_h],0
  1794. if FASTEST eq 0
  1795. ;if ASMV
  1796. ;    call match_init ;initialize the asm code
  1797. ;end if
  1798. end if
  1799.         ret
  1800. endp
  1801.  
  1802. ;uInt (s, cur_match)
  1803. ;    deflate_state *s
  1804. ;    IPos cur_match ;current match
  1805. align 16
  1806. proc longest_match uses ebx ecx edx edi esi, s:dword, cur_match:dword
  1807. if FASTEST eq 0
  1808. ; ===========================================================================
  1809. ; Set match_start to the longest match starting at the given string and
  1810. ; return its length. Matches shorter or equal to prev_length are discarded,
  1811. ; in which case the result is equal to prev_length and match_start is
  1812. ; garbage.
  1813. ; IN assertions: cur_match is the head of the hash chain for the current
  1814. ;   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
  1815. ; OUT assertion: the match length is not greater than s->lookahead.
  1816.  
  1817. ;#ifndef ASMV
  1818. ; For 80x86 and 680x0, an optimized version will be provided in match.asm or
  1819. ; match.S. The code will be functionally equivalent.
  1820. locals
  1821.         chain_length dd ? ;unsigned ;max hash chain length
  1822.         len        dd ? ;int ;length of current match
  1823.         strend     dd ? ;Bytef *
  1824.         best_len   dd ? ;int ;best match length so far
  1825.         nice_match dd ? ;int ;stop if match long enough
  1826.         limit      dd NIL ;IPos
  1827.         prev       dd ? ;Posf *
  1828.         wmask      dd ? ;uInt
  1829. endl
  1830.         mov edx,[s]
  1831.         mov eax,[edx+deflate_state.max_chain_length]
  1832.         mov [chain_length],eax
  1833.         mov edi,[edx+deflate_state.window]
  1834.         add edi,[edx+deflate_state.strstart]
  1835.         ;edi - Bytef *scan ;current string
  1836.         ;esi - Bytef *match ;matched string
  1837.         mov eax,[edx+deflate_state.prev_length]
  1838.         mov [best_len],eax
  1839.         mov eax,[edx+deflate_state.nice_match]
  1840.         mov [nice_match],eax
  1841.  
  1842.         MAX_DIST edx
  1843.         cmp [edx+deflate_state.strstart],eax
  1844.         jle @f
  1845.                 mov ecx,[edx+deflate_state.strstart]
  1846.                 sub ecx,eax
  1847.                 mov [limit],ecx
  1848.         @@:
  1849.         ; Stop when cur_match becomes <= limit. To simplify the code,
  1850.         ; we prevent matches with the string of window index 0.
  1851.         mov eax,[edx+deflate_state.prev]
  1852.         mov [prev],eax
  1853.         mov eax,[edx+deflate_state.w_mask]
  1854.         mov [wmask],eax
  1855.         mov eax,edi
  1856.         add eax,MAX_MATCH ;-1 ???
  1857.         mov [strend],eax
  1858.         mov eax,[best_len]
  1859.         dec eax
  1860.         mov bx,[edi+eax]
  1861.         ;bl - Byte scan_end1
  1862.         ;bh - Byte scan_end
  1863.  
  1864.         ; The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
  1865.         ; It is easy to get rid of this optimization if necessary.
  1866.  
  1867. if MAX_MATCH <> 258
  1868.         cmp dword[edx+deflate_state.hash_bits],8
  1869.         jge @f
  1870.                 zlib_assert 'Code too clever' ;Assert(..>=.. && ..==..)
  1871.         @@:
  1872. end if
  1873.  
  1874.         ; Do not waste too much time if we already have a good match:
  1875.         mov eax,[edx+deflate_state.good_match]
  1876.         cmp [edx+deflate_state.prev_length],eax
  1877.         jl @f ;if (..>=..)
  1878.                 shr dword[chain_length],2
  1879.         @@:
  1880.         ; Do not look for matches beyond the end of the input. This is necessary
  1881.         ; to make deflate deterministic.
  1882.  
  1883.         mov eax,[edx+deflate_state.lookahead]
  1884.         cmp dword[nice_match],eax
  1885.         jle @f ;if (..>..)
  1886.                 mov [nice_match],eax
  1887.         @@:
  1888.  
  1889.         mov eax,[edx+deflate_state.window_size]
  1890.         sub eax,MIN_LOOKAHEAD
  1891.         cmp [edx+deflate_state.strstart],eax
  1892.         jle .cycle0
  1893.                 zlib_assert 'need lookahead' ;Assert(..<=..)
  1894.  
  1895. align 4
  1896.         .cycle0: ;do
  1897.                 mov eax,[edx+deflate_state.strstart]
  1898.                 cmp [cur_match],eax
  1899.                 jl @f
  1900.                         zlib_assert 'no future' ;Assert(..<..)
  1901.                 @@:
  1902.                 mov esi,[edx+deflate_state.window]
  1903.                 add esi,[cur_match]
  1904.  
  1905.                 ; Skip to next match if the match length cannot increase
  1906.                 ; or if the match length is less than 2.  Note that the checks below
  1907.                 ; for insufficient lookahead only occur occasionally for performance
  1908.                 ; reasons.  Therefore uninitialized memory will be accessed, and
  1909.                 ; conditional jumps will be made that depend on those values.
  1910.                 ; However the length of the match is limited to the lookahead, so
  1911.                 ; the output of deflate is not affected by the uninitialized values.
  1912.  
  1913.                 mov eax,[best_len]
  1914.                 dec eax
  1915.                 cmp word[esi+eax],bx
  1916.                 jne .cycle0cont
  1917.                 mov al,byte[esi]
  1918.                 cmp al,byte[edi]
  1919.                 jne .cycle0cont
  1920.                 inc esi
  1921.                 mov al,byte[esi]
  1922.                 cmp al,[edi+1]
  1923.                 jne .cycle0cont ;if (..!=.. || ..!=.. || ..!=.. || ..!=..) continue
  1924.  
  1925.                 ; The check at best_len-1 can be removed because it will be made
  1926.                 ; again later. (This heuristic is not always a win.)
  1927.                 ; It is not necessary to compare scan[2] and match[2] since they
  1928.                 ; are always equal when the other bytes match, given that
  1929.                 ; the hash keys are equal and that HASH_BITS >= 8.
  1930.  
  1931.                 add edi,2
  1932.                 inc esi
  1933.                 mov al,byte[edi]
  1934.                 cmp al,byte[esi]
  1935.                 je @f
  1936.                         zlib_assert 'match[2]?' ;Assert(..==..)
  1937.                 @@:
  1938.  
  1939.                 ; We check for insufficient lookahead only every 8th comparison;
  1940.                 ; the 256th check will be made at strstart+258.
  1941.  
  1942.                 inc edi
  1943.                 inc esi
  1944.                 mov ecx,[strend]
  1945.                 sub ecx,edi
  1946.                 jz @f
  1947.                         repe cmpsb
  1948.                         dec edi
  1949.                         dec esi
  1950.                 @@:
  1951.  
  1952.                 mov eax,[edx+deflate_state.window_size]
  1953.                 dec eax
  1954.                 add eax,[edx+deflate_state.window]
  1955.                 cmp edi,eax
  1956.                 jle @f
  1957.                         zlib_assert 'wild scan' ;Assert(..<=..)
  1958.                 @@:
  1959.  
  1960.                 mov eax,MAX_MATCH
  1961.                 add eax,edi
  1962.                 sub eax,[strend]
  1963.                 mov [len],eax
  1964.                 mov edi,[strend]
  1965.                 sub edi,MAX_MATCH
  1966.  
  1967.                 mov eax,[best_len]
  1968.                 cmp [len],eax
  1969.                 jle .cycle0cont ;if (..>..)
  1970.                         mov eax,[cur_match]
  1971.                         mov [edx+deflate_state.match_start],eax
  1972.                         mov eax,[len]
  1973.                         mov [best_len],eax
  1974.                         mov eax,[nice_match]
  1975.                         cmp [len],eax
  1976.                         jge .cycle0end ;if (..>=..) break
  1977.                         mov eax,[best_len]
  1978.                         dec eax
  1979.                         mov bx,[edi+eax]
  1980.  
  1981.                 .cycle0cont:
  1982.                 mov eax,[cur_match]
  1983.                 and eax,[wmask]
  1984.                 shl eax,1
  1985.                 add eax,[prev]
  1986.                 movzx eax,word[eax] ;eax = prev[cur_match & wmask]
  1987.                 mov [cur_match],eax
  1988.                 cmp eax,[limit]
  1989.                 jle .cycle0end
  1990.                 dec dword[chain_length]
  1991.                 jnz .cycle0
  1992. align 4
  1993.         .cycle0end: ;while (..>.. && ..!=0)
  1994.  
  1995.         mov eax,[edx+deflate_state.lookahead]
  1996.         cmp [best_len],eax
  1997.         jg @f ;if (..<=..)
  1998.                 mov eax,[best_len]
  1999.         @@:    
  2000. ;end if ;ASMV
  2001.  
  2002. else ;FASTEST
  2003.  
  2004. ; ---------------------------------------------------------------------------
  2005. ; Optimized version for FASTEST only
  2006.         mov edx,[s]
  2007.         zlib_debug 'longest_match'
  2008.  
  2009.         ; The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
  2010.         ; It is easy to get rid of this optimization if necessary.
  2011.  
  2012. if MAX_MATCH <> 258
  2013.         cmp dword[edx+deflate_state.hash_bits],8
  2014.         jge @f
  2015.                 zlib_assert 'Code too clever' ;Assert(..>=.. && ..==..)
  2016.         @@:
  2017. end if
  2018.         mov eax,[edx+deflate_state.window_size]
  2019.         sub eax,MIN_LOOKAHEAD
  2020.         cmp [edx+deflate_state.strstart],eax
  2021.         jle @f
  2022.                 zlib_assert 'need lookahead' ;Assert(..<=..)
  2023.         @@:
  2024.         mov eax,[edx+deflate_state.strstart]
  2025.         cmp [cur_match],eax
  2026.         jl @f
  2027.                 zlib_assert 'no future' ;Assert(..<..)
  2028.         @@:
  2029.  
  2030.         mov esi,[edx+deflate_state.window]
  2031.         mov edi,esi
  2032.         add esi,[cur_match]
  2033.         add edi,[edx+deflate_state.strstart]
  2034.         ;edi = scan
  2035.         ;esi = match
  2036.  
  2037.         ; Return failure if the match length is less than 2:
  2038.  
  2039.         lodsw
  2040.         cmp ax,word[edi]
  2041.         je @f ;if (word[edi] != word[esi]) return
  2042.                 mov eax,MIN_MATCH-1
  2043.                 jmp .end_f
  2044.         @@:
  2045.  
  2046.         ; The check at best_len-1 can be removed because it will be made
  2047.         ; again later. (This heuristic is not always a win.)
  2048.         ; It is not necessary to compare scan[2] and match[2] since they
  2049.         ; are always equal when the other bytes match, given that
  2050.         ; the hash keys are equal and that HASH_BITS >= 8.
  2051.  
  2052.         add edi,2
  2053.         mov al,byte[edi]
  2054.         cmp al,byte[esi]
  2055.         je @f
  2056.                 zlib_assert 'match[2]?' ;Assert(..==..)
  2057.         @@:
  2058.  
  2059.         ; We check for insufficient lookahead only every 8th comparison;
  2060.         ; the 256th check will be made at strstart+258.
  2061.  
  2062.         mov ebx,edi
  2063.         mov ecx,MAX_MATCH
  2064. align 4
  2065.         @@:
  2066.                 lodsb
  2067.                 scasb
  2068.                 loope @b
  2069.  
  2070.         mov eax,[edx+deflate_state.window_size]
  2071.         dec eax
  2072.         add eax,[edx+deflate_state.window]
  2073.         cmp edi,eax
  2074.         jle @f
  2075.                 zlib_assert 'wild scan' ;Assert(..<=..)
  2076.         @@:
  2077.         sub edi,ebx
  2078.         ;edi = len
  2079.  
  2080.         cmp edi,MIN_MATCH
  2081.         jge @f ;if (..<..)
  2082.                 mov eax,MIN_MATCH-1
  2083.                 jmp .end_f
  2084.         @@:
  2085.         mov eax,[cur_match]
  2086.         mov [edx+deflate_state.match_start],eax
  2087.         mov eax,[edx+deflate_state.lookahead]
  2088.         cmp edi,eax
  2089.         jg @f ;if (len <= s.lookahead) ? len : s.lookahead
  2090.                 mov eax,edi
  2091.         @@:
  2092. end if ;FASTEST
  2093. .end_f:
  2094.         ret
  2095. endp
  2096.  
  2097. ; ===========================================================================
  2098. ; Check that the match at match_start is indeed a match.
  2099.  
  2100. ;void (s, start, match, length)
  2101. ;    deflate_state *s
  2102. ;    IPos start, match
  2103. ;    int length
  2104. align 4
  2105. proc check_match, s:dword, start:dword, p3match:dword, length:dword
  2106. if DEBUG eq 1
  2107.         ; check that the match is indeed a match
  2108. ;    if (zmemcmp(s->window + match,
  2109. ;                s->window + start, length) != EQUAL) {
  2110. ;        fprintf(stderr, " start %u, match %u, length %d\n",
  2111. ;                start, match, length);
  2112. ;        do {
  2113. ;            fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
  2114. ;        } while (--length != 0);
  2115. ;        z_error("invalid match");
  2116. ;    }
  2117. ;    if (z_verbose > 1) {
  2118. ;        fprintf(stderr,"\\[%d,%d]", start-match, length);
  2119. ;        do { putc(s->window[start++], stderr); } while (--length != 0);
  2120. ;    }
  2121. end if ;DEBUG
  2122.         ret
  2123. endp
  2124.  
  2125. ; ===========================================================================
  2126. ; Fill the window when the lookahead becomes insufficient.
  2127. ; Updates strstart and lookahead.
  2128.  
  2129. ; IN assertion: lookahead < MIN_LOOKAHEAD
  2130. ; OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
  2131. ;    At least one byte has been read, or avail_in == 0; reads are
  2132. ;    performed for at least two bytes (required for the zip translate_eol
  2133. ;    option -- not supported here).
  2134.  
  2135. ;void (deflate_state *s)
  2136. align 16
  2137. proc fill_window, s:dword
  2138. pushad
  2139. ;esi = p, str, curr
  2140. ;ebx = more ;Amount of free space at the end of the window.
  2141.         ;Объем свободного пространства в конце окна.
  2142. ;ecx = wsize ;uInt
  2143. ;edx = s.strm
  2144.         mov edi,[s]
  2145.         cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
  2146.         jl @f
  2147.                 zlib_assert 'already enough lookahead' ;Assert(..<..)
  2148.         @@:
  2149.  
  2150.         mov ecx,[edi+deflate_state.w_size]
  2151.         mov edx,[edi+deflate_state.strm]
  2152.         .cycle0: ;do
  2153.                 mov ebx,[edi+deflate_state.window_size]
  2154.                 sub ebx,[edi+deflate_state.lookahead]
  2155.                 sub ebx,[edi+deflate_state.strstart]
  2156.  
  2157.                 ; If the window is almost full and there is insufficient lookahead,
  2158.                 ; move the upper half to the lower one to make room in the upper half.
  2159.  
  2160.                 ;;MAX_DIST edi
  2161.                 ;;add eax,ecx
  2162.                 mov eax,[edi+deflate_state.w_size]
  2163.                 lea eax,[ecx+eax-MIN_LOOKAHEAD]
  2164.                 cmp [edi+deflate_state.strstart],eax
  2165.                 jb .end0 ;if (..>=..)
  2166.                         push ecx
  2167.                         mov eax,[edi+deflate_state.window]
  2168.                         add eax,ecx
  2169.                         stdcall zmemcpy, [edi+deflate_state.window], eax
  2170.                         sub [edi+deflate_state.match_start],ecx
  2171.                         sub [edi+deflate_state.strstart],ecx ;we now have strstart >= MAX_DIST
  2172.                         sub [edi+deflate_state.block_start],ecx
  2173.                         ; Slide the hash table (could be avoided with 32 bit values
  2174.                         ; at the expense of memory usage). We slide even when level == 0
  2175.                         ; to keep the hash table consistent if we switch back to level > 0
  2176.                         ; later. (Using level 0 permanently is not an optimal usage of
  2177.                         ; zlib, so we don't care about this pathological case.)
  2178.  
  2179.                         push ebx ecx
  2180.                         ;ebx = wsize
  2181.                         ;ecx = n
  2182.                         mov ebx,ecx
  2183.                         mov ecx,[edi+deflate_state.hash_size]
  2184.                         mov esi,ecx
  2185.                         shl esi,1
  2186.                         add esi,[edi+deflate_state.head]
  2187.                         .cycle1: ;do
  2188.                                 sub esi,2
  2189.                                 movzx eax,word[esi]
  2190.                                 mov word[esi],NIL
  2191.                                 cmp eax,ebx
  2192.                                 jl @f
  2193.                                         sub eax,ebx
  2194.                                         mov [esi],ax
  2195.                                 @@:
  2196.                         loop .cycle1 ;while (..)
  2197. if FASTEST eq 0
  2198.                         mov ecx,ebx
  2199.                         mov esi,ecx
  2200.                         shl esi,1
  2201.                         add esi,[edi+deflate_state.prev]
  2202.                         .cycle2: ;do
  2203.                                 sub esi,2
  2204.                                 movzx eax,word[esi]
  2205.                                 mov word[esi],NIL
  2206.                                 cmp eax,ebx
  2207.                                 jl @f
  2208.                                         sub eax,ebx
  2209.                                         mov [esi],ax
  2210.                                 @@:
  2211.                                 ; If n is not on any hash chain, prev[n] is garbage but
  2212.                                 ; its value will never be used.
  2213.  
  2214.                         loop .cycle2 ;while (..)
  2215. end if
  2216.                         pop ecx ebx
  2217.                         add ebx,ecx
  2218.                 .end0:
  2219.                 cmp dword[edx+z_stream.avail_in],0
  2220.                 je .cycle0end ;if (..==0) break
  2221.  
  2222.                 ; If there was no sliding:
  2223.                 ;    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
  2224.                 ;    more == window_size - lookahead - strstart
  2225.                 ; => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
  2226.                 ; => more >= window_size - 2*WSIZE + 2
  2227.                 ; In the BIG_MEM or MMAP case (not yet supported),
  2228.                 ;   window_size == input_size + MIN_LOOKAHEAD  &&
  2229.                 ;   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
  2230.                 ; Otherwise, window_size == 2*WSIZE so more >= 2.
  2231.                 ; If there was sliding, more >= WSIZE. So in all cases, more >= 2.
  2232.  
  2233.                 cmp ebx,2
  2234.                 jge @f
  2235.                         zlib_assert 'more < 2' ;Assert(..>=..)
  2236.                 @@:
  2237.                 mov eax,[edi+deflate_state.window]
  2238.                 add eax,[edi+deflate_state.strstart]
  2239.                 add eax,[edi+deflate_state.lookahead]
  2240.                 stdcall read_buf, edx, eax, ebx
  2241.                 add [edi+deflate_state.lookahead],eax
  2242.  
  2243.                 ; Initialize the hash value now that we have some input:
  2244.                 mov eax,[edi+deflate_state.lookahead]
  2245.                 add eax,[edi+deflate_state.insert]
  2246.                 cmp eax,MIN_MATCH
  2247.                 jl .end1 ;if (..>=..)
  2248.                         mov esi,[edi+deflate_state.strstart]
  2249.                         sub esi,[edi+deflate_state.insert]
  2250.                         ;esi = str
  2251.                         mov eax,[edi+deflate_state.window]
  2252.                         add eax,esi
  2253.                         mov [edi+deflate_state.ins_h],eax
  2254.                         inc eax
  2255.                         movzx eax,byte[eax]
  2256.             UPDATE_HASH edi, [edi+deflate_state.ins_h], eax
  2257. if MIN_MATCH <> 3
  2258. ;            Call UPDATE_HASH() MIN_MATCH-3 more times
  2259. end if
  2260.                         .cycle3: ;while (..)
  2261.                         cmp dword[edi+deflate_state.insert],0
  2262.                         je .end1
  2263.                                 mov eax,esi
  2264.                                 add eax,MIN_MATCH-1
  2265.                                 add eax,[edi+deflate_state.window]
  2266.                                 movzx eax,byte[eax]
  2267.                                 UPDATE_HASH edi, [edi+deflate_state.ins_h], eax
  2268. if FASTEST eq 0
  2269.                                 mov eax,[edi+deflate_state.ins_h]
  2270.                                 shl eax,1
  2271.                                 add eax,[edi+deflate_state.head]
  2272.                                 push ebx
  2273.                                 mov ebx,[edi+deflate_state.w_mask]
  2274.                                 and ebx,esi
  2275.                                 shl ebx,1
  2276.                                 add ebx,[edi+deflate_state.prev]
  2277.                                 mov ax,[eax]
  2278.                                 mov [ebx],ax
  2279.                                 pop ebx
  2280. end if
  2281.                                 mov eax,[edi+deflate_state.ins_h]
  2282.                                 shl eax,1
  2283.                                 add eax,[edi+deflate_state.head]
  2284.                                 mov [eax],si
  2285.                                 inc esi
  2286.                                 dec dword[edi+deflate_state.insert]
  2287.                                 mov eax,[edi+deflate_state.lookahead]
  2288.                                 add eax,[edi+deflate_state.insert]
  2289.                                 cmp eax,MIN_MATCH
  2290.                                 jb .end1 ;if (..<..) break
  2291.                         jmp .cycle3
  2292.                 .end1:
  2293.                 ; If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
  2294.                 ; but this is not important since only literal bytes will be emitted.
  2295.  
  2296.                 cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
  2297.                 jae .cycle0end
  2298.                 cmp dword[edx+z_stream.avail_in],0
  2299.                 jne .cycle0
  2300. align 4
  2301.         .cycle0end: ;while (..<.. && ..!=..)
  2302.  
  2303.         ; If the WIN_INIT bytes after the end of the current data have never been
  2304.         ; written, then zero those bytes in order to avoid memory check reports of
  2305.         ; the use of uninitialized (or uninitialised as Julian writes) bytes by
  2306.         ; the longest match routines.  Update the high water mark for the next
  2307.         ; time through here.  WIN_INIT is set to MAX_MATCH since the longest match
  2308.         ; routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
  2309.  
  2310.         mov eax,[edi+deflate_state.window_size]
  2311.         cmp [edi+deflate_state.high_water],eax
  2312.         jae .end2 ;if (..<..)
  2313.                 mov esi,[edi+deflate_state.lookahead]
  2314.                 add esi,[edi+deflate_state.strstart]
  2315.                 ;esi = curr
  2316.  
  2317.                 cmp [edi+deflate_state.high_water],esi
  2318.                 jae .end3 ;if (..<..)
  2319.                         ; Previous high water mark below current data -- zero WIN_INIT
  2320.                         ; bytes or up to end of window, whichever is less.
  2321.  
  2322.                         mov eax,[edi+deflate_state.window_size]
  2323.                         sub eax,esi
  2324.                         cmp eax,WIN_INIT
  2325.                         jbe @f ;if (..>..)
  2326.                                 mov eax,WIN_INIT
  2327.                         @@:
  2328.                         mov edx,[edi+deflate_state.window]
  2329.                         add edx,esi
  2330.                         stdcall zmemzero, edx, eax
  2331.                         add eax,esi
  2332.                         mov [edi+deflate_state.high_water],eax
  2333.                         jmp .end2
  2334.                 .end3: ;else if (..<..)
  2335.                 mov eax,esi
  2336.                 add eax,WIN_INIT
  2337.                 cmp [edi+deflate_state.high_water],eax
  2338.                 jae .end2
  2339.                         ; High water mark at or above current data, but below current data
  2340.                         ; plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
  2341.                         ; to end of window, whichever is less.
  2342.  
  2343.                         ;eax = esi+WIN_INIT
  2344.                         sub eax,[edi+deflate_state.high_water]
  2345.                         mov edx,[edi+deflate_state.window_size]
  2346.                         sub edx,[edi+deflate_state.high_water]
  2347.                         cmp eax,edx ;if (..>..)
  2348.                         jbe @f
  2349.                                 mov eax,edx
  2350.                         @@:
  2351.                         mov edx,[edi+deflate_state.window]
  2352.                         add edx,[edi+deflate_state.high_water]
  2353.                         stdcall zmemzero, edx, eax
  2354.                         add [edi+deflate_state.high_water],eax
  2355.         .end2:
  2356.  
  2357.         mov eax,[edi+deflate_state.window_size]
  2358.         sub eax,MIN_LOOKAHEAD
  2359.         cmp [edi+deflate_state.strstart],eax
  2360.         jle @f
  2361.                 zlib_assert 'not enough room for search' ;Assert(..<=..)
  2362.         @@:
  2363. popad
  2364.         ret
  2365. endp
  2366.  
  2367. ; ===========================================================================
  2368. ; Flush the current block, with given end-of-file flag.
  2369. ; IN assertion: strstart is set to the end of the current match.
  2370.  
  2371. macro FLUSH_BLOCK_ONLY s, last
  2372. {
  2373. local .end0
  2374.         push dword last
  2375.         mov eax,[s+deflate_state.strstart]
  2376.         sub eax,[s+deflate_state.block_start]
  2377.         push eax
  2378.         xor eax,eax
  2379.         cmp [s+deflate_state.block_start],eax
  2380.         jl .end0
  2381.                 mov eax,[s+deflate_state.block_start]
  2382.                 add eax,[s+deflate_state.window]
  2383.         .end0:
  2384.         stdcall _tr_flush_block, s, eax
  2385.         mov eax,[s+deflate_state.strstart]
  2386.         mov [s+deflate_state.block_start],eax
  2387.         stdcall flush_pending, [s+deflate_state.strm]
  2388. ;   Tracev((stderr,"[FLUSH]"));
  2389. }
  2390.  
  2391. ; Same but force premature exit if necessary.
  2392. macro FLUSH_BLOCK s, last
  2393. {
  2394. local .end0
  2395.         FLUSH_BLOCK_ONLY s, last
  2396.         mov eax,[s+deflate_state.strm]
  2397.         cmp dword[eax+z_stream.avail_out],0
  2398.         jne .end0 ;if (..==0)
  2399. if last eq 1
  2400.                 mov eax,finish_started
  2401. else
  2402.                 mov eax,need_more
  2403. end if
  2404.                 jmp .end_f
  2405.         .end0:
  2406. }
  2407.  
  2408. ; ===========================================================================
  2409. ; Copy without compression as much as possible from the input stream, return
  2410. ; the current block state.
  2411. ; This function does not insert new strings in the dictionary since
  2412. ; uncompressible data is probably not useful. This function is used
  2413. ; only for the level=0 compression option.
  2414. ; NOTE: this function should be optimized to avoid extra copying from
  2415. ; window to pending_buf.
  2416.  
  2417. ;block_state (s, flush)
  2418. ;    deflate_state *s
  2419. ;    int flush
  2420. align 4
  2421. proc deflate_stored uses ebx ecx edi, s:dword, flush:dword
  2422. ; Stored blocks are limited to 0xffff bytes, pending_buf is limited
  2423. ; to pending_buf_size, and each stored block has a 5 byte header:
  2424.         mov edi,[s]
  2425.  
  2426.         mov ecx,0xffff
  2427.         mov eax,[edi+deflate_state.pending_buf_size]
  2428.         sub eax,5
  2429.         cmp ecx,eax
  2430.         jle .cycle0 ;if (..>..)
  2431.                 mov ecx,eax
  2432.         ;ecx = max_block_size
  2433.  
  2434.         ; Copy as much as possible from input to output:
  2435. align 4
  2436.         .cycle0: ;for (;;)
  2437.                 ; Fill the window as much as possible:
  2438.                 cmp dword[edi+deflate_state.lookahead],1
  2439.                 jg .end0 ;if (..<=..)
  2440. ;            Assert(s->strstart < s->w_size+MAX_DIST(s) ||
  2441. ;                   s->block_start >= (long)s->w_size, "slide too late");
  2442.  
  2443.                         stdcall fill_window, edi
  2444.                         cmp dword[edi+deflate_state.lookahead],0
  2445.                         jne @f
  2446.                         cmp dword[flush],Z_NO_FLUSH
  2447.                         jne @f ;if (..==0 && ..==..)
  2448.                                 mov eax,need_more
  2449.                                 jmp .end_f
  2450.                         @@:
  2451.                         cmp dword[edi+deflate_state.lookahead],0
  2452.                         je .cycle0end