/src/lzo-2.10/src/lzo1x_9x.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* lzo1x_9x.c -- implementation of the LZO1X-999 compression algorithm |
2 | | |
3 | | This file is part of the LZO real-time data compression library. |
4 | | |
5 | | Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer |
6 | | All Rights Reserved. |
7 | | |
8 | | The LZO library is free software; you can redistribute it and/or |
9 | | modify it under the terms of the GNU General Public License as |
10 | | published by the Free Software Foundation; either version 2 of |
11 | | the License, or (at your option) any later version. |
12 | | |
13 | | The LZO library is distributed in the hope that it will be useful, |
14 | | but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 | | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
16 | | GNU General Public License for more details. |
17 | | |
18 | | You should have received a copy of the GNU General Public License |
19 | | along with the LZO library; see the file COPYING. |
20 | | If not, write to the Free Software Foundation, Inc., |
21 | | 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
22 | | |
23 | | Markus F.X.J. Oberhumer |
24 | | <markus@oberhumer.com> |
25 | | http://www.oberhumer.com/opensource/lzo/ |
26 | | */ |
27 | | |
28 | | |
29 | | #if !defined(LZO1X) && !defined(LZO1Y) && !defined(LZO1Z) |
30 | | # define LZO1X 1 |
31 | | #endif |
32 | | |
33 | | #if defined(LZO1X) |
34 | | # include "config1x.h" |
35 | | #elif defined(LZO1Y) |
36 | | # include "config1y.h" |
37 | | #elif defined(LZO1Z) |
38 | | # include "config1z.h" |
39 | | #else |
40 | | # error |
41 | | #endif |
42 | | |
43 | | |
44 | | /*********************************************************************** |
45 | | // |
46 | | ************************************************************************/ |
47 | | |
48 | 5.11k | #define SWD_N M4_MAX_OFFSET /* size of ring buffer */ |
49 | 58.6M | #define SWD_THRESHOLD 1 /* lower limit for match length */ |
50 | 25.5k | #define SWD_F 2048 /* upper limit for match length */ |
51 | | |
52 | 1.96G | #define SWD_BEST_OFF (LZO_MAX3( M2_MAX_LEN, M3_MAX_LEN, M4_MAX_LEN ) + 1) |
53 | | |
54 | | #if defined(LZO1X) |
55 | 3.20k | # define LZO_COMPRESS_T lzo1x_999_t |
56 | 1.60k | # define lzo_swd_t lzo1x_999_swd_t |
57 | | #elif defined(LZO1Y) |
58 | 3.20k | # define LZO_COMPRESS_T lzo1y_999_t |
59 | 1.60k | # define lzo_swd_t lzo1y_999_swd_t |
60 | 1.60k | # define lzo1x_999_compress_internal lzo1y_999_compress_internal |
61 | | # define lzo1x_999_compress_dict lzo1y_999_compress_dict |
62 | 1.60k | # define lzo1x_999_compress_level lzo1y_999_compress_level |
63 | | # define lzo1x_999_compress lzo1y_999_compress |
64 | | #elif defined(LZO1Z) |
65 | 3.82k | # define LZO_COMPRESS_T lzo1z_999_t |
66 | 1.91k | # define lzo_swd_t lzo1z_999_swd_t |
67 | 1.91k | # define lzo1x_999_compress_internal lzo1z_999_compress_internal |
68 | | # define lzo1x_999_compress_dict lzo1z_999_compress_dict |
69 | 1.91k | # define lzo1x_999_compress_level lzo1z_999_compress_level |
70 | | # define lzo1x_999_compress lzo1z_999_compress |
71 | | #else |
72 | | # error |
73 | | #endif |
74 | | |
75 | | #if 0 |
76 | | # define HEAD3(b,p) \ |
77 | | ((((((lzo_xint)b[p]<<3)^b[p+1])<<3)^b[p+2]) & (SWD_HSIZE-1)) |
78 | | #endif |
79 | | #if 0 && (LZO_OPT_UNALIGNED32) && (LZO_ABI_LITTLE_ENDIAN) |
80 | | # define HEAD3(b,p) \ |
81 | | (((* (lzo_uint32_tp) &b[p]) ^ ((* (lzo_uint32_tp) &b[p])>>10)) & (SWD_HSIZE-1)) |
82 | | #endif |
83 | | |
84 | | #include "lzo_mchw.ch" |
85 | | |
86 | | |
87 | | /* this is a public functions, but there is no prototype in a header file */ |
88 | | LZO_EXTERN(int) |
89 | | lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, |
90 | | lzo_bytep out, lzo_uintp out_len, |
91 | | lzo_voidp wrkmem, |
92 | | const lzo_bytep dict, lzo_uint dict_len, |
93 | | lzo_callback_p cb, |
94 | | int try_lazy_parm, |
95 | | lzo_uint good_length, |
96 | | lzo_uint max_lazy, |
97 | | lzo_uint nice_length, |
98 | | lzo_uint max_chain, |
99 | | lzo_uint32_t flags ); |
100 | | |
101 | | |
102 | | /*********************************************************************** |
103 | | // |
104 | | ************************************************************************/ |
105 | | |
106 | | static lzo_bytep |
107 | | code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) |
108 | 2.42M | { |
109 | 2.42M | lzo_uint x_len = m_len; |
110 | 2.42M | lzo_uint x_off = m_off; |
111 | | |
112 | 2.42M | c->match_bytes += m_len; |
113 | | |
114 | | #if 0 |
115 | | /* |
116 | | static lzo_uint last_m_len = 0, last_m_off = 0; |
117 | | static lzo_uint prev_m_off[4]; |
118 | | static unsigned prev_m_off_ptr = 0; |
119 | | unsigned i; |
120 | | |
121 | | //if (m_len >= 3 && m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) |
122 | | if (m_len >= 3 && m_len <= M2_MAX_LEN) |
123 | | { |
124 | | //if (m_len == last_m_len && m_off == last_m_off) |
125 | | //printf("last_m_len + last_m_off\n"); |
126 | | //else |
127 | | if (m_off == last_m_off) |
128 | | printf("last_m_off\n"); |
129 | | else |
130 | | { |
131 | | for (i = 0; i < 4; i++) |
132 | | if (m_off == prev_m_off[i]) |
133 | | printf("prev_m_off %u: %5ld\n",i,(long)m_off); |
134 | | } |
135 | | } |
136 | | last_m_len = m_len; |
137 | | last_m_off = prev_m_off[prev_m_off_ptr] = m_off; |
138 | | prev_m_off_ptr = (prev_m_off_ptr + 1) & 3; |
139 | | */ |
140 | | #endif |
141 | | |
142 | 2.42M | assert(op > c->out); |
143 | 2.42M | if (m_len == 2) |
144 | 799k | { |
145 | 799k | assert(m_off <= M1_MAX_OFFSET); |
146 | 799k | assert(c->r1_lit > 0); assert(c->r1_lit < 4); |
147 | 799k | m_off -= 1; |
148 | | #if defined(LZO1Z) |
149 | 317k | *op++ = LZO_BYTE(M1_MARKER | (m_off >> 6)); |
150 | 317k | *op++ = LZO_BYTE(m_off << 2); |
151 | | #else |
152 | 481k | *op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2)); |
153 | 481k | *op++ = LZO_BYTE(m_off >> 2); |
154 | | #endif |
155 | 799k | c->m1a_m++; |
156 | 799k | } |
157 | | #if defined(LZO1Z) |
158 | 650k | else if (m_len <= M2_MAX_LEN && (m_off <= M2_MAX_OFFSET || m_off == c->last_m_off)) |
159 | | #else |
160 | 974k | else if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) |
161 | 477k | #endif |
162 | 786k | { |
163 | 786k | assert(m_len >= 3); |
164 | | #if defined(LZO1X) |
165 | | m_off -= 1; |
166 | 243k | *op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2)); |
167 | 243k | *op++ = LZO_BYTE(m_off >> 3); |
168 | | assert(op[-2] >= M2_MARKER); |
169 | | #elif defined(LZO1Y) |
170 | | m_off -= 1; |
171 | 233k | *op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2)); |
172 | 233k | *op++ = LZO_BYTE(m_off >> 2); |
173 | | assert(op[-2] >= M2_MARKER); |
174 | | #elif defined(LZO1Z) |
175 | 309k | if (m_off == c->last_m_off) |
176 | 20.4k | *op++ = LZO_BYTE(((m_len - 1) << 5) | (0x700 >> 6)); |
177 | 289k | else |
178 | 289k | { |
179 | 289k | m_off -= 1; |
180 | 289k | *op++ = LZO_BYTE(((m_len - 1) << 5) | (m_off >> 6)); |
181 | 289k | *op++ = LZO_BYTE(m_off << 2); |
182 | 289k | } |
183 | | #endif |
184 | 786k | c->m2_m++; |
185 | 786k | } |
186 | 838k | else if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && c->r1_lit >= 4) |
187 | 21.2k | { |
188 | 21.2k | assert(m_len == 3); |
189 | 21.2k | assert(m_off > M2_MAX_OFFSET); |
190 | 21.2k | m_off -= 1 + M2_MAX_OFFSET; |
191 | | #if defined(LZO1Z) |
192 | 6.80k | *op++ = LZO_BYTE(M1_MARKER | (m_off >> 6)); |
193 | 6.80k | *op++ = LZO_BYTE(m_off << 2); |
194 | | #else |
195 | 14.4k | *op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2)); |
196 | 14.4k | *op++ = LZO_BYTE(m_off >> 2); |
197 | | #endif |
198 | 21.2k | c->m1b_m++; |
199 | 21.2k | } |
200 | 817k | else if (m_off <= M3_MAX_OFFSET) |
201 | 643k | { |
202 | 643k | assert(m_len >= 3); |
203 | 643k | m_off -= 1; |
204 | 643k | if (m_len <= M3_MAX_LEN) |
205 | 485k | *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); |
206 | 158k | else |
207 | 158k | { |
208 | 158k | m_len -= M3_MAX_LEN; |
209 | 158k | *op++ = M3_MARKER | 0; |
210 | 245k | while (m_len > 255) |
211 | 87.3k | { |
212 | 87.3k | m_len -= 255; |
213 | 87.3k | *op++ = 0; |
214 | 87.3k | } |
215 | 158k | assert(m_len > 0); |
216 | 158k | *op++ = LZO_BYTE(m_len); |
217 | 158k | } |
218 | | #if defined(LZO1Z) |
219 | 264k | *op++ = LZO_BYTE(m_off >> 6); |
220 | 264k | *op++ = LZO_BYTE(m_off << 2); |
221 | | #else |
222 | 379k | *op++ = LZO_BYTE(m_off << 2); |
223 | 379k | *op++ = LZO_BYTE(m_off >> 6); |
224 | | #endif |
225 | 643k | c->m3_m++; |
226 | 643k | } |
227 | 173k | else |
228 | 173k | { |
229 | 173k | lzo_uint k; |
230 | | |
231 | 173k | assert(m_len >= 3); |
232 | 173k | assert(m_off > 0x4000); assert(m_off <= 0xbfff); |
233 | 173k | m_off -= 0x4000; |
234 | 173k | k = (m_off & 0x4000) >> 11; |
235 | 173k | if (m_len <= M4_MAX_LEN) |
236 | 118k | *op++ = LZO_BYTE(M4_MARKER | k | (m_len - 2)); |
237 | 54.8k | else |
238 | 54.8k | { |
239 | 54.8k | m_len -= M4_MAX_LEN; |
240 | 54.8k | *op++ = LZO_BYTE(M4_MARKER | k | 0); |
241 | 75.7k | while (m_len > 255) |
242 | 20.9k | { |
243 | 20.9k | m_len -= 255; |
244 | 20.9k | *op++ = 0; |
245 | 20.9k | } |
246 | 54.8k | assert(m_len > 0); |
247 | 54.8k | *op++ = LZO_BYTE(m_len); |
248 | 54.8k | } |
249 | | #if defined(LZO1Z) |
250 | 69.8k | *op++ = LZO_BYTE(m_off >> 6); |
251 | 69.8k | *op++ = LZO_BYTE(m_off << 2); |
252 | | #else |
253 | 103k | *op++ = LZO_BYTE(m_off << 2); |
254 | 103k | *op++ = LZO_BYTE(m_off >> 6); |
255 | | #endif |
256 | 173k | c->m4_m++; |
257 | 173k | } |
258 | | |
259 | 2.42M | c->last_m_len = x_len; |
260 | 2.42M | c->last_m_off = x_off; |
261 | 2.42M | return op; |
262 | 2.42M | } Line | Count | Source | 108 | 778k | { | 109 | 778k | lzo_uint x_len = m_len; | 110 | 778k | lzo_uint x_off = m_off; | 111 | | | 112 | 778k | c->match_bytes += m_len; | 113 | | | 114 | | #if 0 | 115 | | /* | 116 | | static lzo_uint last_m_len = 0, last_m_off = 0; | 117 | | static lzo_uint prev_m_off[4]; | 118 | | static unsigned prev_m_off_ptr = 0; | 119 | | unsigned i; | 120 | | | 121 | | //if (m_len >= 3 && m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) | 122 | | if (m_len >= 3 && m_len <= M2_MAX_LEN) | 123 | | { | 124 | | //if (m_len == last_m_len && m_off == last_m_off) | 125 | | //printf("last_m_len + last_m_off\n"); | 126 | | //else | 127 | | if (m_off == last_m_off) | 128 | | printf("last_m_off\n"); | 129 | | else | 130 | | { | 131 | | for (i = 0; i < 4; i++) | 132 | | if (m_off == prev_m_off[i]) | 133 | | printf("prev_m_off %u: %5ld\n",i,(long)m_off); | 134 | | } | 135 | | } | 136 | | last_m_len = m_len; | 137 | | last_m_off = prev_m_off[prev_m_off_ptr] = m_off; | 138 | | prev_m_off_ptr = (prev_m_off_ptr + 1) & 3; | 139 | | */ | 140 | | #endif | 141 | | | 142 | 778k | assert(op > c->out); | 143 | 778k | if (m_len == 2) | 144 | 272k | { | 145 | 272k | assert(m_off <= M1_MAX_OFFSET); | 146 | 272k | assert(c->r1_lit > 0); assert(c->r1_lit < 4); | 147 | 272k | m_off -= 1; | 148 | | #if defined(LZO1Z) | 149 | | *op++ = LZO_BYTE(M1_MARKER | (m_off >> 6)); | 150 | | *op++ = LZO_BYTE(m_off << 2); | 151 | | #else | 152 | 272k | *op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2)); | 153 | 272k | *op++ = LZO_BYTE(m_off >> 2); | 154 | 272k | #endif | 155 | 272k | c->m1a_m++; | 156 | 272k | } | 157 | | #if defined(LZO1Z) | 158 | | else if (m_len <= M2_MAX_LEN && (m_off <= M2_MAX_OFFSET || m_off == c->last_m_off)) | 159 | | #else | 160 | 505k | else if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) | 161 | 243k | #endif | 162 | 243k | { | 163 | 243k | assert(m_len >= 3); | 164 | 243k | #if defined(LZO1X) | 165 | 243k | m_off -= 1; | 166 | 243k | *op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2)); | 167 | 243k | *op++ = LZO_BYTE(m_off >> 3); | 168 | 243k | assert(op[-2] >= M2_MARKER); | 169 | | #elif defined(LZO1Y) | 170 | | m_off -= 1; | 171 | | *op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2)); | 172 | | *op++ = LZO_BYTE(m_off >> 2); | 173 | | assert(op[-2] >= M2_MARKER); | 174 | | #elif defined(LZO1Z) | 175 | | if (m_off == c->last_m_off) | 176 | | *op++ = LZO_BYTE(((m_len - 1) << 5) | (0x700 >> 6)); | 177 | | else | 178 | | { | 179 | | m_off -= 1; | 180 | | *op++ = LZO_BYTE(((m_len - 1) << 5) | (m_off >> 6)); | 181 | | *op++ = LZO_BYTE(m_off << 2); | 182 | | } | 183 | | #endif | 184 | 243k | c->m2_m++; | 185 | 243k | } | 186 | 262k | else if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && c->r1_lit >= 4) | 187 | 6.01k | { | 188 | 6.01k | assert(m_len == 3); | 189 | 6.01k | assert(m_off > M2_MAX_OFFSET); | 190 | 6.01k | m_off -= 1 + M2_MAX_OFFSET; | 191 | | #if defined(LZO1Z) | 192 | | *op++ = LZO_BYTE(M1_MARKER | (m_off >> 6)); | 193 | | *op++ = LZO_BYTE(m_off << 2); | 194 | | #else | 195 | 6.01k | *op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2)); | 196 | 6.01k | *op++ = LZO_BYTE(m_off >> 2); | 197 | 6.01k | #endif | 198 | 6.01k | c->m1b_m++; | 199 | 6.01k | } | 200 | 256k | else if (m_off <= M3_MAX_OFFSET) | 201 | 200k | { | 202 | 200k | assert(m_len >= 3); | 203 | 200k | m_off -= 1; | 204 | 200k | if (m_len <= M3_MAX_LEN) | 205 | 156k | *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); | 206 | 44.2k | else | 207 | 44.2k | { | 208 | 44.2k | m_len -= M3_MAX_LEN; | 209 | 44.2k | *op++ = M3_MARKER | 0; | 210 | 70.5k | while (m_len > 255) | 211 | 26.3k | { | 212 | 26.3k | m_len -= 255; | 213 | 26.3k | *op++ = 0; | 214 | 26.3k | } | 215 | 44.2k | assert(m_len > 0); | 216 | 44.2k | *op++ = LZO_BYTE(m_len); | 217 | 44.2k | } | 218 | | #if defined(LZO1Z) | 219 | | *op++ = LZO_BYTE(m_off >> 6); | 220 | | *op++ = LZO_BYTE(m_off << 2); | 221 | | #else | 222 | 200k | *op++ = LZO_BYTE(m_off << 2); | 223 | 200k | *op++ = LZO_BYTE(m_off >> 6); | 224 | 200k | #endif | 225 | 200k | c->m3_m++; | 226 | 200k | } | 227 | 55.6k | else | 228 | 55.6k | { | 229 | 55.6k | lzo_uint k; | 230 | | | 231 | 55.6k | assert(m_len >= 3); | 232 | 55.6k | assert(m_off > 0x4000); assert(m_off <= 0xbfff); | 233 | 55.6k | m_off -= 0x4000; | 234 | 55.6k | k = (m_off & 0x4000) >> 11; | 235 | 55.6k | if (m_len <= M4_MAX_LEN) | 236 | 38.4k | *op++ = LZO_BYTE(M4_MARKER | k | (m_len - 2)); | 237 | 17.1k | else | 238 | 17.1k | { | 239 | 17.1k | m_len -= M4_MAX_LEN; | 240 | 17.1k | *op++ = LZO_BYTE(M4_MARKER | k | 0); | 241 | 24.2k | while (m_len > 255) | 242 | 7.02k | { | 243 | 7.02k | m_len -= 255; | 244 | 7.02k | *op++ = 0; | 245 | 7.02k | } | 246 | 17.1k | assert(m_len > 0); | 247 | 17.1k | *op++ = LZO_BYTE(m_len); | 248 | 17.1k | } | 249 | | #if defined(LZO1Z) | 250 | | *op++ = LZO_BYTE(m_off >> 6); | 251 | | *op++ = LZO_BYTE(m_off << 2); | 252 | | #else | 253 | 55.6k | *op++ = LZO_BYTE(m_off << 2); | 254 | 55.6k | *op++ = LZO_BYTE(m_off >> 6); | 255 | 55.6k | #endif | 256 | 55.6k | c->m4_m++; | 257 | 55.6k | } | 258 | | | 259 | 778k | c->last_m_len = x_len; | 260 | 778k | c->last_m_off = x_off; | 261 | 778k | return op; | 262 | 778k | } |
Line | Count | Source | 108 | 678k | { | 109 | 678k | lzo_uint x_len = m_len; | 110 | 678k | lzo_uint x_off = m_off; | 111 | | | 112 | 678k | c->match_bytes += m_len; | 113 | | | 114 | | #if 0 | 115 | | /* | 116 | | static lzo_uint last_m_len = 0, last_m_off = 0; | 117 | | static lzo_uint prev_m_off[4]; | 118 | | static unsigned prev_m_off_ptr = 0; | 119 | | unsigned i; | 120 | | | 121 | | //if (m_len >= 3 && m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) | 122 | | if (m_len >= 3 && m_len <= M2_MAX_LEN) | 123 | | { | 124 | | //if (m_len == last_m_len && m_off == last_m_off) | 125 | | //printf("last_m_len + last_m_off\n"); | 126 | | //else | 127 | | if (m_off == last_m_off) | 128 | | printf("last_m_off\n"); | 129 | | else | 130 | | { | 131 | | for (i = 0; i < 4; i++) | 132 | | if (m_off == prev_m_off[i]) | 133 | | printf("prev_m_off %u: %5ld\n",i,(long)m_off); | 134 | | } | 135 | | } | 136 | | last_m_len = m_len; | 137 | | last_m_off = prev_m_off[prev_m_off_ptr] = m_off; | 138 | | prev_m_off_ptr = (prev_m_off_ptr + 1) & 3; | 139 | | */ | 140 | | #endif | 141 | | | 142 | 678k | assert(op > c->out); | 143 | 678k | if (m_len == 2) | 144 | 209k | { | 145 | 209k | assert(m_off <= M1_MAX_OFFSET); | 146 | 209k | assert(c->r1_lit > 0); assert(c->r1_lit < 4); | 147 | 209k | m_off -= 1; | 148 | | #if defined(LZO1Z) | 149 | | *op++ = LZO_BYTE(M1_MARKER | (m_off >> 6)); | 150 | | *op++ = LZO_BYTE(m_off << 2); | 151 | | #else | 152 | 209k | *op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2)); | 153 | 209k | *op++ = LZO_BYTE(m_off >> 2); | 154 | 209k | #endif | 155 | 209k | c->m1a_m++; | 156 | 209k | } | 157 | | #if defined(LZO1Z) | 158 | | else if (m_len <= M2_MAX_LEN && (m_off <= M2_MAX_OFFSET || m_off == c->last_m_off)) | 159 | | #else | 160 | 468k | else if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) | 161 | 233k | #endif | 162 | 233k | { | 163 | 233k | assert(m_len >= 3); | 164 | | #if defined(LZO1X) | 165 | | m_off -= 1; | 166 | | *op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2)); | 167 | | *op++ = LZO_BYTE(m_off >> 3); | 168 | | assert(op[-2] >= M2_MARKER); | 169 | | #elif defined(LZO1Y) | 170 | | m_off -= 1; | 171 | 233k | *op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2)); | 172 | 233k | *op++ = LZO_BYTE(m_off >> 2); | 173 | 233k | assert(op[-2] >= M2_MARKER); | 174 | | #elif defined(LZO1Z) | 175 | | if (m_off == c->last_m_off) | 176 | | *op++ = LZO_BYTE(((m_len - 1) << 5) | (0x700 >> 6)); | 177 | | else | 178 | | { | 179 | | m_off -= 1; | 180 | | *op++ = LZO_BYTE(((m_len - 1) << 5) | (m_off >> 6)); | 181 | | *op++ = LZO_BYTE(m_off << 2); | 182 | | } | 183 | | #endif | 184 | 233k | c->m2_m++; | 185 | 233k | } | 186 | 235k | else if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && c->r1_lit >= 4) | 187 | 8.41k | { | 188 | 8.41k | assert(m_len == 3); | 189 | 8.41k | assert(m_off > M2_MAX_OFFSET); | 190 | 8.41k | m_off -= 1 + M2_MAX_OFFSET; | 191 | | #if defined(LZO1Z) | 192 | | *op++ = LZO_BYTE(M1_MARKER | (m_off >> 6)); | 193 | | *op++ = LZO_BYTE(m_off << 2); | 194 | | #else | 195 | 8.41k | *op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2)); | 196 | 8.41k | *op++ = LZO_BYTE(m_off >> 2); | 197 | 8.41k | #endif | 198 | 8.41k | c->m1b_m++; | 199 | 8.41k | } | 200 | 226k | else if (m_off <= M3_MAX_OFFSET) | 201 | 178k | { | 202 | 178k | assert(m_len >= 3); | 203 | 178k | m_off -= 1; | 204 | 178k | if (m_len <= M3_MAX_LEN) | 205 | 130k | *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); | 206 | 48.7k | else | 207 | 48.7k | { | 208 | 48.7k | m_len -= M3_MAX_LEN; | 209 | 48.7k | *op++ = M3_MARKER | 0; | 210 | 75.5k | while (m_len > 255) | 211 | 26.8k | { | 212 | 26.8k | m_len -= 255; | 213 | 26.8k | *op++ = 0; | 214 | 26.8k | } | 215 | 48.7k | assert(m_len > 0); | 216 | 48.7k | *op++ = LZO_BYTE(m_len); | 217 | 48.7k | } | 218 | | #if defined(LZO1Z) | 219 | | *op++ = LZO_BYTE(m_off >> 6); | 220 | | *op++ = LZO_BYTE(m_off << 2); | 221 | | #else | 222 | 178k | *op++ = LZO_BYTE(m_off << 2); | 223 | 178k | *op++ = LZO_BYTE(m_off >> 6); | 224 | 178k | #endif | 225 | 178k | c->m3_m++; | 226 | 178k | } | 227 | 48.0k | else | 228 | 48.0k | { | 229 | 48.0k | lzo_uint k; | 230 | | | 231 | 48.0k | assert(m_len >= 3); | 232 | 48.0k | assert(m_off > 0x4000); assert(m_off <= 0xbfff); | 233 | 48.0k | m_off -= 0x4000; | 234 | 48.0k | k = (m_off & 0x4000) >> 11; | 235 | 48.0k | if (m_len <= M4_MAX_LEN) | 236 | 33.4k | *op++ = LZO_BYTE(M4_MARKER | k | (m_len - 2)); | 237 | 14.6k | else | 238 | 14.6k | { | 239 | 14.6k | m_len -= M4_MAX_LEN; | 240 | 14.6k | *op++ = LZO_BYTE(M4_MARKER | k | 0); | 241 | 20.6k | while (m_len > 255) | 242 | 6.04k | { | 243 | 6.04k | m_len -= 255; | 244 | 6.04k | *op++ = 0; | 245 | 6.04k | } | 246 | 14.6k | assert(m_len > 0); | 247 | 14.6k | *op++ = LZO_BYTE(m_len); | 248 | 14.6k | } | 249 | | #if defined(LZO1Z) | 250 | | *op++ = LZO_BYTE(m_off >> 6); | 251 | | *op++ = LZO_BYTE(m_off << 2); | 252 | | #else | 253 | 48.0k | *op++ = LZO_BYTE(m_off << 2); | 254 | 48.0k | *op++ = LZO_BYTE(m_off >> 6); | 255 | 48.0k | #endif | 256 | 48.0k | c->m4_m++; | 257 | 48.0k | } | 258 | | | 259 | 678k | c->last_m_len = x_len; | 260 | 678k | c->last_m_off = x_off; | 261 | 678k | return op; | 262 | 678k | } |
Line | Count | Source | 108 | 968k | { | 109 | 968k | lzo_uint x_len = m_len; | 110 | 968k | lzo_uint x_off = m_off; | 111 | | | 112 | 968k | c->match_bytes += m_len; | 113 | | | 114 | | #if 0 | 115 | | /* | 116 | | static lzo_uint last_m_len = 0, last_m_off = 0; | 117 | | static lzo_uint prev_m_off[4]; | 118 | | static unsigned prev_m_off_ptr = 0; | 119 | | unsigned i; | 120 | | | 121 | | //if (m_len >= 3 && m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) | 122 | | if (m_len >= 3 && m_len <= M2_MAX_LEN) | 123 | | { | 124 | | //if (m_len == last_m_len && m_off == last_m_off) | 125 | | //printf("last_m_len + last_m_off\n"); | 126 | | //else | 127 | | if (m_off == last_m_off) | 128 | | printf("last_m_off\n"); | 129 | | else | 130 | | { | 131 | | for (i = 0; i < 4; i++) | 132 | | if (m_off == prev_m_off[i]) | 133 | | printf("prev_m_off %u: %5ld\n",i,(long)m_off); | 134 | | } | 135 | | } | 136 | | last_m_len = m_len; | 137 | | last_m_off = prev_m_off[prev_m_off_ptr] = m_off; | 138 | | prev_m_off_ptr = (prev_m_off_ptr + 1) & 3; | 139 | | */ | 140 | | #endif | 141 | | | 142 | 968k | assert(op > c->out); | 143 | 968k | if (m_len == 2) | 144 | 317k | { | 145 | 317k | assert(m_off <= M1_MAX_OFFSET); | 146 | 317k | assert(c->r1_lit > 0); assert(c->r1_lit < 4); | 147 | 317k | m_off -= 1; | 148 | 317k | #if defined(LZO1Z) | 149 | 317k | *op++ = LZO_BYTE(M1_MARKER | (m_off >> 6)); | 150 | 317k | *op++ = LZO_BYTE(m_off << 2); | 151 | | #else | 152 | | *op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2)); | 153 | | *op++ = LZO_BYTE(m_off >> 2); | 154 | | #endif | 155 | 317k | c->m1a_m++; | 156 | 317k | } | 157 | 650k | #if defined(LZO1Z) | 158 | 650k | else if (m_len <= M2_MAX_LEN && (m_off <= M2_MAX_OFFSET || m_off == c->last_m_off)) | 159 | | #else | 160 | | else if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) | 161 | | #endif | 162 | 309k | { | 163 | 309k | assert(m_len >= 3); | 164 | | #if defined(LZO1X) | 165 | | m_off -= 1; | 166 | | *op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2)); | 167 | | *op++ = LZO_BYTE(m_off >> 3); | 168 | | assert(op[-2] >= M2_MARKER); | 169 | | #elif defined(LZO1Y) | 170 | | m_off -= 1; | 171 | | *op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2)); | 172 | | *op++ = LZO_BYTE(m_off >> 2); | 173 | | assert(op[-2] >= M2_MARKER); | 174 | | #elif defined(LZO1Z) | 175 | 309k | if (m_off == c->last_m_off) | 176 | 20.4k | *op++ = LZO_BYTE(((m_len - 1) << 5) | (0x700 >> 6)); | 177 | 289k | else | 178 | 289k | { | 179 | 289k | m_off -= 1; | 180 | 289k | *op++ = LZO_BYTE(((m_len - 1) << 5) | (m_off >> 6)); | 181 | 289k | *op++ = LZO_BYTE(m_off << 2); | 182 | 289k | } | 183 | 309k | #endif | 184 | 309k | c->m2_m++; | 185 | 309k | } | 186 | 341k | else if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && c->r1_lit >= 4) | 187 | 6.80k | { | 188 | 6.80k | assert(m_len == 3); | 189 | 6.80k | assert(m_off > M2_MAX_OFFSET); | 190 | 6.80k | m_off -= 1 + M2_MAX_OFFSET; | 191 | 6.80k | #if defined(LZO1Z) | 192 | 6.80k | *op++ = LZO_BYTE(M1_MARKER | (m_off >> 6)); | 193 | 6.80k | *op++ = LZO_BYTE(m_off << 2); | 194 | | #else | 195 | | *op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2)); | 196 | | *op++ = LZO_BYTE(m_off >> 2); | 197 | | #endif | 198 | 6.80k | c->m1b_m++; | 199 | 6.80k | } | 200 | 334k | else if (m_off <= M3_MAX_OFFSET) | 201 | 264k | { | 202 | 264k | assert(m_len >= 3); | 203 | 264k | m_off -= 1; | 204 | 264k | if (m_len <= M3_MAX_LEN) | 205 | 199k | *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); | 206 | 65.0k | else | 207 | 65.0k | { | 208 | 65.0k | m_len -= M3_MAX_LEN; | 209 | 65.0k | *op++ = M3_MARKER | 0; | 210 | 99.1k | while (m_len > 255) | 211 | 34.1k | { | 212 | 34.1k | m_len -= 255; | 213 | 34.1k | *op++ = 0; | 214 | 34.1k | } | 215 | 65.0k | assert(m_len > 0); | 216 | 65.0k | *op++ = LZO_BYTE(m_len); | 217 | 65.0k | } | 218 | 264k | #if defined(LZO1Z) | 219 | 264k | *op++ = LZO_BYTE(m_off >> 6); | 220 | 264k | *op++ = LZO_BYTE(m_off << 2); | 221 | | #else | 222 | | *op++ = LZO_BYTE(m_off << 2); | 223 | | *op++ = LZO_BYTE(m_off >> 6); | 224 | | #endif | 225 | 264k | c->m3_m++; | 226 | 264k | } | 227 | 69.8k | else | 228 | 69.8k | { | 229 | 69.8k | lzo_uint k; | 230 | | | 231 | 69.8k | assert(m_len >= 3); | 232 | 69.8k | assert(m_off > 0x4000); assert(m_off <= 0xbfff); | 233 | 69.8k | m_off -= 0x4000; | 234 | 69.8k | k = (m_off & 0x4000) >> 11; | 235 | 69.8k | if (m_len <= M4_MAX_LEN) | 236 | 46.8k | *op++ = LZO_BYTE(M4_MARKER | k | (m_len - 2)); | 237 | 23.0k | else | 238 | 23.0k | { | 239 | 23.0k | m_len -= M4_MAX_LEN; | 240 | 23.0k | *op++ = LZO_BYTE(M4_MARKER | k | 0); | 241 | 30.9k | while (m_len > 255) | 242 | 7.90k | { | 243 | 7.90k | m_len -= 255; | 244 | 7.90k | *op++ = 0; | 245 | 7.90k | } | 246 | 23.0k | assert(m_len > 0); | 247 | 23.0k | *op++ = LZO_BYTE(m_len); | 248 | 23.0k | } | 249 | 69.8k | #if defined(LZO1Z) | 250 | 69.8k | *op++ = LZO_BYTE(m_off >> 6); | 251 | 69.8k | *op++ = LZO_BYTE(m_off << 2); | 252 | | #else | 253 | | *op++ = LZO_BYTE(m_off << 2); | 254 | | *op++ = LZO_BYTE(m_off >> 6); | 255 | | #endif | 256 | 69.8k | c->m4_m++; | 257 | 69.8k | } | 258 | | | 259 | 968k | c->last_m_len = x_len; | 260 | 968k | c->last_m_off = x_off; | 261 | 968k | return op; | 262 | 968k | } |
|
263 | | |
264 | | |
265 | | static lzo_bytep |
266 | | STORE_RUN ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii, lzo_uint t ) |
267 | 1.73M | { |
268 | 1.73M | c->lit_bytes += t; |
269 | | |
270 | 1.73M | if (op == c->out && t <= 238) |
271 | 4.91k | { |
272 | 4.91k | *op++ = LZO_BYTE(17 + t); |
273 | 4.91k | } |
274 | 1.72M | else if (t <= 3) |
275 | 1.52M | { |
276 | | #if defined(LZO1Z) |
277 | 610k | op[-1] = LZO_BYTE(op[-1] | t); |
278 | | #else |
279 | 918k | op[-2] = LZO_BYTE(op[-2] | t); |
280 | | #endif |
281 | 1.52M | c->lit1_r++; |
282 | 1.52M | } |
283 | 198k | else if (t <= 18) |
284 | 104k | { |
285 | 104k | *op++ = LZO_BYTE(t - 3); |
286 | 104k | c->lit2_r++; |
287 | 104k | } |
288 | 93.4k | else |
289 | 93.4k | { |
290 | 93.4k | lzo_uint tt = t - 18; |
291 | | |
292 | 93.4k | *op++ = 0; |
293 | 266k | while (tt > 255) |
294 | 173k | { |
295 | 173k | tt -= 255; |
296 | 173k | *op++ = 0; |
297 | 173k | } |
298 | 93.4k | assert(tt > 0); |
299 | 93.4k | *op++ = LZO_BYTE(tt); |
300 | 93.4k | c->lit3_r++; |
301 | 93.4k | } |
302 | 53.0M | do *op++ = *ii++; while (--t > 0); |
303 | | |
304 | 1.73M | return op; |
305 | 1.73M | } Line | Count | Source | 267 | 566k | { | 268 | 566k | c->lit_bytes += t; | 269 | | | 270 | 566k | if (op == c->out && t <= 238) | 271 | 1.53k | { | 272 | 1.53k | *op++ = LZO_BYTE(17 + t); | 273 | 1.53k | } | 274 | 564k | else if (t <= 3) | 275 | 500k | { | 276 | | #if defined(LZO1Z) | 277 | | op[-1] = LZO_BYTE(op[-1] | t); | 278 | | #else | 279 | 500k | op[-2] = LZO_BYTE(op[-2] | t); | 280 | 500k | #endif | 281 | 500k | c->lit1_r++; | 282 | 500k | } | 283 | 64.2k | else if (t <= 18) | 284 | 34.6k | { | 285 | 34.6k | *op++ = LZO_BYTE(t - 3); | 286 | 34.6k | c->lit2_r++; | 287 | 34.6k | } | 288 | 29.5k | else | 289 | 29.5k | { | 290 | 29.5k | lzo_uint tt = t - 18; | 291 | | | 292 | 29.5k | *op++ = 0; | 293 | 90.3k | while (tt > 255) | 294 | 60.7k | { | 295 | 60.7k | tt -= 255; | 296 | 60.7k | *op++ = 0; | 297 | 60.7k | } | 298 | 29.5k | assert(tt > 0); | 299 | 29.5k | *op++ = LZO_BYTE(tt); | 300 | 29.5k | c->lit3_r++; | 301 | 29.5k | } | 302 | 18.2M | do *op++ = *ii++; while (--t > 0); | 303 | | | 304 | 566k | return op; | 305 | 566k | } |
Line | Count | Source | 267 | 483k | { | 268 | 483k | c->lit_bytes += t; | 269 | | | 270 | 483k | if (op == c->out && t <= 238) | 271 | 1.54k | { | 272 | 1.54k | *op++ = LZO_BYTE(17 + t); | 273 | 1.54k | } | 274 | 481k | else if (t <= 3) | 275 | 418k | { | 276 | | #if defined(LZO1Z) | 277 | | op[-1] = LZO_BYTE(op[-1] | t); | 278 | | #else | 279 | 418k | op[-2] = LZO_BYTE(op[-2] | t); | 280 | 418k | #endif | 281 | 418k | c->lit1_r++; | 282 | 418k | } | 283 | 63.1k | else if (t <= 18) | 284 | 31.2k | { | 285 | 31.2k | *op++ = LZO_BYTE(t - 3); | 286 | 31.2k | c->lit2_r++; | 287 | 31.2k | } | 288 | 31.9k | else | 289 | 31.9k | { | 290 | 31.9k | lzo_uint tt = t - 18; | 291 | | | 292 | 31.9k | *op++ = 0; | 293 | 87.8k | while (tt > 255) | 294 | 55.9k | { | 295 | 55.9k | tt -= 255; | 296 | 55.9k | *op++ = 0; | 297 | 55.9k | } | 298 | 31.9k | assert(tt > 0); | 299 | 31.9k | *op++ = LZO_BYTE(tt); | 300 | 31.9k | c->lit3_r++; | 301 | 31.9k | } | 302 | 17.1M | do *op++ = *ii++; while (--t > 0); | 303 | | | 304 | 483k | return op; | 305 | 483k | } |
Line | Count | Source | 267 | 683k | { | 268 | 683k | c->lit_bytes += t; | 269 | | | 270 | 683k | if (op == c->out && t <= 238) | 271 | 1.82k | { | 272 | 1.82k | *op++ = LZO_BYTE(17 + t); | 273 | 1.82k | } | 274 | 681k | else if (t <= 3) | 275 | 610k | { | 276 | 610k | #if defined(LZO1Z) | 277 | 610k | op[-1] = LZO_BYTE(op[-1] | t); | 278 | | #else | 279 | | op[-2] = LZO_BYTE(op[-2] | t); | 280 | | #endif | 281 | 610k | c->lit1_r++; | 282 | 610k | } | 283 | 70.7k | else if (t <= 18) | 284 | 38.8k | { | 285 | 38.8k | *op++ = LZO_BYTE(t - 3); | 286 | 38.8k | c->lit2_r++; | 287 | 38.8k | } | 288 | 31.9k | else | 289 | 31.9k | { | 290 | 31.9k | lzo_uint tt = t - 18; | 291 | | | 292 | 31.9k | *op++ = 0; | 293 | 88.5k | while (tt > 255) | 294 | 56.6k | { | 295 | 56.6k | tt -= 255; | 296 | 56.6k | *op++ = 0; | 297 | 56.6k | } | 298 | 31.9k | assert(tt > 0); | 299 | 31.9k | *op++ = LZO_BYTE(tt); | 300 | 31.9k | c->lit3_r++; | 301 | 31.9k | } | 302 | 17.6M | do *op++ = *ii++; while (--t > 0); | 303 | | | 304 | 683k | return op; | 305 | 683k | } |
|
306 | | |
307 | | |
308 | | static lzo_bytep |
309 | | code_run ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii, |
310 | | lzo_uint lit, lzo_uint m_len ) |
311 | 2.42M | { |
312 | 2.42M | if (lit > 0) |
313 | 1.72M | { |
314 | 1.72M | assert(m_len >= 2); |
315 | 1.72M | op = STORE_RUN(c,op,ii,lit); |
316 | 1.72M | c->r1_m_len = m_len; |
317 | 1.72M | c->r1_lit = lit; |
318 | 1.72M | } |
319 | 695k | else |
320 | 695k | { |
321 | 695k | assert(m_len >= 3); |
322 | 695k | c->r1_m_len = 0; |
323 | 695k | c->r1_lit = 0; |
324 | 695k | } |
325 | | |
326 | 2.42M | return op; |
327 | 2.42M | } Line | Count | Source | 311 | 778k | { | 312 | 778k | if (lit > 0) | 313 | 565k | { | 314 | 565k | assert(m_len >= 2); | 315 | 565k | op = STORE_RUN(c,op,ii,lit); | 316 | 565k | c->r1_m_len = m_len; | 317 | 565k | c->r1_lit = lit; | 318 | 565k | } | 319 | 212k | else | 320 | 212k | { | 321 | 212k | assert(m_len >= 3); | 322 | 212k | c->r1_m_len = 0; | 323 | 212k | c->r1_lit = 0; | 324 | 212k | } | 325 | | | 326 | 778k | return op; | 327 | 778k | } |
Line | Count | Source | 311 | 678k | { | 312 | 678k | if (lit > 0) | 313 | 482k | { | 314 | 482k | assert(m_len >= 2); | 315 | 482k | op = STORE_RUN(c,op,ii,lit); | 316 | 482k | c->r1_m_len = m_len; | 317 | 482k | c->r1_lit = lit; | 318 | 482k | } | 319 | 195k | else | 320 | 195k | { | 321 | 195k | assert(m_len >= 3); | 322 | 195k | c->r1_m_len = 0; | 323 | 195k | c->r1_lit = 0; | 324 | 195k | } | 325 | | | 326 | 678k | return op; | 327 | 678k | } |
Line | Count | Source | 311 | 968k | { | 312 | 968k | if (lit > 0) | 313 | 682k | { | 314 | 682k | assert(m_len >= 2); | 315 | 682k | op = STORE_RUN(c,op,ii,lit); | 316 | 682k | c->r1_m_len = m_len; | 317 | 682k | c->r1_lit = lit; | 318 | 682k | } | 319 | 286k | else | 320 | 286k | { | 321 | 286k | assert(m_len >= 3); | 322 | 286k | c->r1_m_len = 0; | 323 | 286k | c->r1_lit = 0; | 324 | 286k | } | 325 | | | 326 | 968k | return op; | 327 | 968k | } |
|
328 | | |
329 | | |
330 | | /*********************************************************************** |
331 | | // |
332 | | ************************************************************************/ |
333 | | |
334 | | static lzo_uint |
335 | | len_of_coded_match ( lzo_uint m_len, lzo_uint m_off, lzo_uint lit ) |
336 | 4.83M | { |
337 | 4.83M | lzo_uint n = 4; |
338 | | |
339 | 4.83M | if (m_len < 2) |
340 | 890k | return 0; |
341 | 3.94M | if (m_len == 2) |
342 | 1.35M | return (m_off <= M1_MAX_OFFSET && lit > 0 && lit < 4) ? 2 : 0; |
343 | 2.59M | if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) |
344 | 1.13M | return 2; |
345 | 1.45M | if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && lit >= 4) |
346 | 23.3k | return 2; |
347 | 1.43M | if (m_off <= M3_MAX_OFFSET) |
348 | 1.13M | { |
349 | 1.13M | if (m_len <= M3_MAX_LEN) |
350 | 915k | return 3; |
351 | 216k | m_len -= M3_MAX_LEN; |
352 | 221k | while (m_len > 255) |
353 | 5.07k | { |
354 | 5.07k | m_len -= 255; |
355 | 5.07k | n++; |
356 | 5.07k | } |
357 | 216k | return n; |
358 | 1.13M | } |
359 | 298k | if (m_off <= M4_MAX_OFFSET) |
360 | 298k | { |
361 | 298k | if (m_len <= M4_MAX_LEN) |
362 | 210k | return 3; |
363 | 88.2k | m_len -= M4_MAX_LEN; |
364 | 90.6k | while (m_len > 255) |
365 | 2.39k | { |
366 | 2.39k | m_len -= 255; |
367 | 2.39k | n++; |
368 | 2.39k | } |
369 | 88.2k | return n; |
370 | 298k | } |
371 | 0 | return 0; |
372 | 298k | } lzo1x_9x.c:len_of_coded_match Line | Count | Source | 336 | 1.55M | { | 337 | 1.55M | lzo_uint n = 4; | 338 | | | 339 | 1.55M | if (m_len < 2) | 340 | 292k | return 0; | 341 | 1.26M | if (m_len == 2) | 342 | 458k | return (m_off <= M1_MAX_OFFSET && lit > 0 && lit < 4) ? 2 : 0; | 343 | 807k | if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) | 344 | 355k | return 2; | 345 | 451k | if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && lit >= 4) | 346 | 6.63k | return 2; | 347 | 445k | if (m_off <= M3_MAX_OFFSET) | 348 | 348k | { | 349 | 348k | if (m_len <= M3_MAX_LEN) | 350 | 290k | return 3; | 351 | 57.3k | m_len -= M3_MAX_LEN; | 352 | 58.8k | while (m_len > 255) | 353 | 1.57k | { | 354 | 1.57k | m_len -= 255; | 355 | 1.57k | n++; | 356 | 1.57k | } | 357 | 57.3k | return n; | 358 | 348k | } | 359 | 97.0k | if (m_off <= M4_MAX_OFFSET) | 360 | 97.0k | { | 361 | 97.0k | if (m_len <= M4_MAX_LEN) | 362 | 70.2k | return 3; | 363 | 26.8k | m_len -= M4_MAX_LEN; | 364 | 27.5k | while (m_len > 255) | 365 | 795 | { | 366 | 795 | m_len -= 255; | 367 | 795 | n++; | 368 | 795 | } | 369 | 26.8k | return n; | 370 | 97.0k | } | 371 | 0 | return 0; | 372 | 97.0k | } |
lzo1y_9x.c:len_of_coded_match Line | Count | Source | 336 | 1.31M | { | 337 | 1.31M | lzo_uint n = 4; | 338 | | | 339 | 1.31M | if (m_len < 2) | 340 | 228k | return 0; | 341 | 1.08M | if (m_len == 2) | 342 | 342k | return (m_off <= M1_MAX_OFFSET && lit > 0 && lit < 4) ? 2 : 0; | 343 | 744k | if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) | 344 | 333k | return 2; | 345 | 410k | if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && lit >= 4) | 346 | 9.21k | return 2; | 347 | 401k | if (m_off <= M3_MAX_OFFSET) | 348 | 322k | { | 349 | 322k | if (m_len <= M3_MAX_LEN) | 350 | 252k | return 3; | 351 | 69.7k | m_len -= M3_MAX_LEN; | 352 | 71.0k | while (m_len > 255) | 353 | 1.39k | { | 354 | 1.39k | m_len -= 255; | 355 | 1.39k | n++; | 356 | 1.39k | } | 357 | 69.7k | return n; | 358 | 322k | } | 359 | 79.1k | if (m_off <= M4_MAX_OFFSET) | 360 | 79.1k | { | 361 | 79.1k | if (m_len <= M4_MAX_LEN) | 362 | 56.1k | return 3; | 363 | 22.9k | m_len -= M4_MAX_LEN; | 364 | 23.6k | while (m_len > 255) | 365 | 685 | { | 366 | 685 | m_len -= 255; | 367 | 685 | n++; | 368 | 685 | } | 369 | 22.9k | return n; | 370 | 79.1k | } | 371 | 0 | return 0; | 372 | 79.1k | } |
lzo1z_9x.c:len_of_coded_match Line | Count | Source | 336 | 1.95M | { | 337 | 1.95M | lzo_uint n = 4; | 338 | | | 339 | 1.95M | if (m_len < 2) | 340 | 369k | return 0; | 341 | 1.59M | if (m_len == 2) | 342 | 549k | return (m_off <= M1_MAX_OFFSET && lit > 0 && lit < 4) ? 2 : 0; | 343 | 1.04M | if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) | 344 | 449k | return 2; | 345 | 591k | if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && lit >= 4) | 346 | 7.46k | return 2; | 347 | 584k | if (m_off <= M3_MAX_OFFSET) | 348 | 461k | { | 349 | 461k | if (m_len <= M3_MAX_LEN) | 350 | 371k | return 3; | 351 | 89.5k | m_len -= M3_MAX_LEN; | 352 | 91.6k | while (m_len > 255) | 353 | 2.10k | { | 354 | 2.10k | m_len -= 255; | 355 | 2.10k | n++; | 356 | 2.10k | } | 357 | 89.5k | return n; | 358 | 461k | } | 359 | 122k | if (m_off <= M4_MAX_OFFSET) | 360 | 122k | { | 361 | 122k | if (m_len <= M4_MAX_LEN) | 362 | 84.1k | return 3; | 363 | 38.5k | m_len -= M4_MAX_LEN; | 364 | 39.4k | while (m_len > 255) | 365 | 918 | { | 366 | 918 | m_len -= 255; | 367 | 918 | n++; | 368 | 918 | } | 369 | 38.5k | return n; | 370 | 122k | } | 371 | 0 | return 0; | 372 | 122k | } |
|
373 | | |
374 | | |
375 | | static lzo_uint |
376 | | min_gain(lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, lzo_uint l1, lzo_uint l2, lzo_uint l3) |
377 | 1.02M | { |
378 | 1.02M | lzo_uint lazy_match_min_gain; |
379 | | |
380 | 1.02M | assert (ahead >= 1); |
381 | 1.02M | lazy_match_min_gain = ahead; |
382 | | |
383 | | #if 0 |
384 | | if (l3) |
385 | | lit2 -= ahead; |
386 | | #endif |
387 | | |
388 | 1.02M | if (lit1 <= 3) |
389 | 1.00M | lazy_match_min_gain += (lit2 <= 3) ? 0 : 2; |
390 | 21.5k | else if (lit1 <= 18) |
391 | 12.7k | lazy_match_min_gain += (lit2 <= 18) ? 0 : 1; |
392 | | |
393 | 1.02M | lazy_match_min_gain += (l2 - l1) * 2; |
394 | 1.02M | if (l3) |
395 | 4.93k | lazy_match_min_gain -= (ahead - l3) * 2; |
396 | | |
397 | 1.02M | if ((lzo_int) lazy_match_min_gain < 0) |
398 | 50.2k | lazy_match_min_gain = 0; |
399 | | |
400 | | #if 0 |
401 | | if (l1 == 2) |
402 | | if (lazy_match_min_gain == 0) |
403 | | lazy_match_min_gain = 1; |
404 | | #endif |
405 | | |
406 | 1.02M | return lazy_match_min_gain; |
407 | 1.02M | } Line | Count | Source | 377 | 334k | { | 378 | 334k | lzo_uint lazy_match_min_gain; | 379 | | | 380 | 334k | assert (ahead >= 1); | 381 | 334k | lazy_match_min_gain = ahead; | 382 | | | 383 | | #if 0 | 384 | | if (l3) | 385 | | lit2 -= ahead; | 386 | | #endif | 387 | | | 388 | 334k | if (lit1 <= 3) | 389 | 327k | lazy_match_min_gain += (lit2 <= 3) ? 0 : 2; | 390 | 7.15k | else if (lit1 <= 18) | 391 | 4.28k | lazy_match_min_gain += (lit2 <= 18) ? 0 : 1; | 392 | | | 393 | 334k | lazy_match_min_gain += (l2 - l1) * 2; | 394 | 334k | if (l3) | 395 | 1.60k | lazy_match_min_gain -= (ahead - l3) * 2; | 396 | | | 397 | 334k | if ((lzo_int) lazy_match_min_gain < 0) | 398 | 13.9k | lazy_match_min_gain = 0; | 399 | | | 400 | | #if 0 | 401 | | if (l1 == 2) | 402 | | if (lazy_match_min_gain == 0) | 403 | | lazy_match_min_gain = 1; | 404 | | #endif | 405 | | | 406 | 334k | return lazy_match_min_gain; | 407 | 334k | } |
Line | Count | Source | 377 | 268k | { | 378 | 268k | lzo_uint lazy_match_min_gain; | 379 | | | 380 | 268k | assert (ahead >= 1); | 381 | 268k | lazy_match_min_gain = ahead; | 382 | | | 383 | | #if 0 | 384 | | if (l3) | 385 | | lit2 -= ahead; | 386 | | #endif | 387 | | | 388 | 268k | if (lit1 <= 3) | 389 | 261k | lazy_match_min_gain += (lit2 <= 3) ? 0 : 2; | 390 | 6.48k | else if (lit1 <= 18) | 391 | 3.59k | lazy_match_min_gain += (lit2 <= 18) ? 0 : 1; | 392 | | | 393 | 268k | lazy_match_min_gain += (l2 - l1) * 2; | 394 | 268k | if (l3) | 395 | 1.50k | lazy_match_min_gain -= (ahead - l3) * 2; | 396 | | | 397 | 268k | if ((lzo_int) lazy_match_min_gain < 0) | 398 | 14.6k | lazy_match_min_gain = 0; | 399 | | | 400 | | #if 0 | 401 | | if (l1 == 2) | 402 | | if (lazy_match_min_gain == 0) | 403 | | lazy_match_min_gain = 1; | 404 | | #endif | 405 | | | 406 | 268k | return lazy_match_min_gain; | 407 | 268k | } |
Line | Count | Source | 377 | 421k | { | 378 | 421k | lzo_uint lazy_match_min_gain; | 379 | | | 380 | 421k | assert (ahead >= 1); | 381 | 421k | lazy_match_min_gain = ahead; | 382 | | | 383 | | #if 0 | 384 | | if (l3) | 385 | | lit2 -= ahead; | 386 | | #endif | 387 | | | 388 | 421k | if (lit1 <= 3) | 389 | 413k | lazy_match_min_gain += (lit2 <= 3) ? 0 : 2; | 390 | 7.86k | else if (lit1 <= 18) | 391 | 4.83k | lazy_match_min_gain += (lit2 <= 18) ? 0 : 1; | 392 | | | 393 | 421k | lazy_match_min_gain += (l2 - l1) * 2; | 394 | 421k | if (l3) | 395 | 1.82k | lazy_match_min_gain -= (ahead - l3) * 2; | 396 | | | 397 | 421k | if ((lzo_int) lazy_match_min_gain < 0) | 398 | 21.6k | lazy_match_min_gain = 0; | 399 | | | 400 | | #if 0 | 401 | | if (l1 == 2) | 402 | | if (lazy_match_min_gain == 0) | 403 | | lazy_match_min_gain = 1; | 404 | | #endif | 405 | | | 406 | 421k | return lazy_match_min_gain; | 407 | 421k | } |
|
408 | | |
409 | | |
410 | | /*********************************************************************** |
411 | | // |
412 | | ************************************************************************/ |
413 | | |
414 | | #if !defined(NDEBUG) |
415 | | static |
416 | | void assert_match( const lzo_swd_p swd, lzo_uint m_len, lzo_uint m_off ) |
417 | | { |
418 | | const LZO_COMPRESS_T *c = swd->c; |
419 | | lzo_uint d_off; |
420 | | |
421 | | assert(m_len >= 2); |
422 | | if (m_off <= (lzo_uint) (c->bp - c->in)) |
423 | | { |
424 | | assert(c->bp - m_off + m_len < c->ip); |
425 | | assert(lzo_memcmp(c->bp, c->bp - m_off, m_len) == 0); |
426 | | } |
427 | | else |
428 | | { |
429 | | assert(swd->dict != NULL); |
430 | | d_off = m_off - (lzo_uint) (c->bp - c->in); |
431 | | assert(d_off <= swd->dict_len); |
432 | | if (m_len > d_off) |
433 | | { |
434 | | assert(lzo_memcmp(c->bp, swd->dict_end - d_off, d_off) == 0); |
435 | | assert(c->in + m_len - d_off < c->ip); |
436 | | assert(lzo_memcmp(c->bp + d_off, c->in, m_len - d_off) == 0); |
437 | | } |
438 | | else |
439 | | { |
440 | | assert(lzo_memcmp(c->bp, swd->dict_end - d_off, m_len) == 0); |
441 | | } |
442 | | } |
443 | | } |
444 | | #else |
445 | 3.24M | # define assert_match(a,b,c) ((void)0) |
446 | | #endif |
447 | | |
448 | | |
449 | | #if defined(SWD_BEST_OFF) |
450 | | |
451 | | static void |
452 | | better_match ( const lzo_swd_p swd, lzo_uint *m_len, lzo_uint *m_off ) |
453 | 3.86M | { |
454 | | #if defined(LZO1Z) |
455 | | const LZO_COMPRESS_T *c = swd->c; |
456 | | #endif |
457 | | |
458 | 3.86M | if (*m_len <= M2_MIN_LEN) |
459 | 1.87M | return; |
460 | | #if defined(LZO1Z) |
461 | 795k | if (*m_off == c->last_m_off && *m_len <= M2_MAX_LEN) |
462 | 13.9k | return; |
463 | 781k | #if 1 |
464 | 781k | if (*m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 && |
465 | 781k | c->last_m_off && swd->best_off[*m_len-1] == c->last_m_off) |
466 | 1.62k | { |
467 | 1.62k | *m_len = *m_len - 1; |
468 | 1.62k | *m_off = swd->best_off[*m_len]; |
469 | 1.62k | return; |
470 | 1.62k | } |
471 | 779k | #endif |
472 | 779k | #endif |
473 | | |
474 | 1.97M | if (*m_off <= M2_MAX_OFFSET) |
475 | 1.13M | return; |
476 | | |
477 | 840k | #if 1 |
478 | | /* M3/M4 -> M2 */ |
479 | 840k | if (*m_off > M2_MAX_OFFSET && |
480 | 840k | *m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 && |
481 | 840k | swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M2_MAX_OFFSET) |
482 | 59.5k | { |
483 | 59.5k | *m_len = *m_len - 1; |
484 | 59.5k | *m_off = swd->best_off[*m_len]; |
485 | 59.5k | return; |
486 | 59.5k | } |
487 | 781k | #endif |
488 | | |
489 | 781k | #if 1 |
490 | | /* M4 -> M2 */ |
491 | 781k | if (*m_off > M3_MAX_OFFSET && |
492 | 781k | *m_len >= M4_MAX_LEN + 1 && *m_len <= M2_MAX_LEN + 2 && |
493 | 781k | swd->best_off[*m_len-2] && swd->best_off[*m_len-2] <= M2_MAX_OFFSET) |
494 | 3.12k | { |
495 | 3.12k | *m_len = *m_len - 2; |
496 | 3.12k | *m_off = swd->best_off[*m_len]; |
497 | 3.12k | return; |
498 | 3.12k | } |
499 | 778k | #endif |
500 | | |
501 | 778k | #if 1 |
502 | | /* M4 -> M3 */ |
503 | 778k | if (*m_off > M3_MAX_OFFSET && |
504 | 778k | *m_len >= M4_MAX_LEN + 1 && *m_len <= M3_MAX_LEN + 1 && |
505 | 778k | swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M3_MAX_OFFSET) |
506 | 5.99k | { |
507 | 5.99k | *m_len = *m_len - 1; |
508 | 5.99k | *m_off = swd->best_off[*m_len]; |
509 | 5.99k | } |
510 | 778k | #endif |
511 | 778k | } Line | Count | Source | 453 | 1.24M | { | 454 | | #if defined(LZO1Z) | 455 | | const LZO_COMPRESS_T *c = swd->c; | 456 | | #endif | 457 | | | 458 | 1.24M | if (*m_len <= M2_MIN_LEN) | 459 | 618k | return; | 460 | | #if defined(LZO1Z) | 461 | | if (*m_off == c->last_m_off && *m_len <= M2_MAX_LEN) | 462 | | return; | 463 | | #if 1 | 464 | | if (*m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 && | 465 | | c->last_m_off && swd->best_off[*m_len-1] == c->last_m_off) | 466 | | { | 467 | | *m_len = *m_len - 1; | 468 | | *m_off = swd->best_off[*m_len]; | 469 | | return; | 470 | | } | 471 | | #endif | 472 | | #endif | 473 | | | 474 | 622k | if (*m_off <= M2_MAX_OFFSET) | 475 | 367k | return; | 476 | | | 477 | 255k | #if 1 | 478 | | /* M3/M4 -> M2 */ | 479 | 255k | if (*m_off > M2_MAX_OFFSET && | 480 | 255k | *m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 && | 481 | 255k | swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M2_MAX_OFFSET) | 482 | 18.2k | { | 483 | 18.2k | *m_len = *m_len - 1; | 484 | 18.2k | *m_off = swd->best_off[*m_len]; | 485 | 18.2k | return; | 486 | 18.2k | } | 487 | 237k | #endif | 488 | | | 489 | 237k | #if 1 | 490 | | /* M4 -> M2 */ | 491 | 237k | if (*m_off > M3_MAX_OFFSET && | 492 | 237k | *m_len >= M4_MAX_LEN + 1 && *m_len <= M2_MAX_LEN + 2 && | 493 | 237k | swd->best_off[*m_len-2] && swd->best_off[*m_len-2] <= M2_MAX_OFFSET) | 494 | 1.31k | { | 495 | 1.31k | *m_len = *m_len - 2; | 496 | 1.31k | *m_off = swd->best_off[*m_len]; | 497 | 1.31k | return; | 498 | 1.31k | } | 499 | 235k | #endif | 500 | | | 501 | 235k | #if 1 | 502 | | /* M4 -> M3 */ | 503 | 235k | if (*m_off > M3_MAX_OFFSET && | 504 | 235k | *m_len >= M4_MAX_LEN + 1 && *m_len <= M3_MAX_LEN + 1 && | 505 | 235k | swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M3_MAX_OFFSET) | 506 | 1.74k | { | 507 | 1.74k | *m_len = *m_len - 1; | 508 | 1.74k | *m_off = swd->best_off[*m_len]; | 509 | 1.74k | } | 510 | 235k | #endif | 511 | 235k | } |
Line | Count | Source | 453 | 1.06M | { | 454 | | #if defined(LZO1Z) | 455 | | const LZO_COMPRESS_T *c = swd->c; | 456 | | #endif | 457 | | | 458 | 1.06M | if (*m_len <= M2_MIN_LEN) | 459 | 489k | return; | 460 | | #if defined(LZO1Z) | 461 | | if (*m_off == c->last_m_off && *m_len <= M2_MAX_LEN) | 462 | | return; | 463 | | #if 1 | 464 | | if (*m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 && | 465 | | c->last_m_off && swd->best_off[*m_len-1] == c->last_m_off) | 466 | | { | 467 | | *m_len = *m_len - 1; | 468 | | *m_off = swd->best_off[*m_len]; | 469 | | return; | 470 | | } | 471 | | #endif | 472 | | #endif | 473 | | | 474 | 573k | if (*m_off <= M2_MAX_OFFSET) | 475 | 313k | return; | 476 | | | 477 | 259k | #if 1 | 478 | | /* M3/M4 -> M2 */ | 479 | 259k | if (*m_off > M2_MAX_OFFSET && | 480 | 259k | *m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 && | 481 | 259k | swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M2_MAX_OFFSET) | 482 | 17.2k | { | 483 | 17.2k | *m_len = *m_len - 1; | 484 | 17.2k | *m_off = swd->best_off[*m_len]; | 485 | 17.2k | return; | 486 | 17.2k | } | 487 | 242k | #endif | 488 | | | 489 | 242k | #if 1 | 490 | | /* M4 -> M2 */ | 491 | 242k | if (*m_off > M3_MAX_OFFSET && | 492 | 242k | *m_len >= M4_MAX_LEN + 1 && *m_len <= M2_MAX_LEN + 2 && | 493 | 242k | swd->best_off[*m_len-2] && swd->best_off[*m_len-2] <= M2_MAX_OFFSET) | 494 | 979 | { | 495 | 979 | *m_len = *m_len - 2; | 496 | 979 | *m_off = swd->best_off[*m_len]; | 497 | 979 | return; | 498 | 979 | } | 499 | 241k | #endif | 500 | | | 501 | 241k | #if 1 | 502 | | /* M4 -> M3 */ | 503 | 241k | if (*m_off > M3_MAX_OFFSET && | 504 | 241k | *m_len >= M4_MAX_LEN + 1 && *m_len <= M3_MAX_LEN + 1 && | 505 | 241k | swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M3_MAX_OFFSET) | 506 | 1.62k | { | 507 | 1.62k | *m_len = *m_len - 1; | 508 | 1.62k | *m_off = swd->best_off[*m_len]; | 509 | 1.62k | } | 510 | 241k | #endif | 511 | 241k | } |
Line | Count | Source | 453 | 1.55M | { | 454 | 1.55M | #if defined(LZO1Z) | 455 | 1.55M | const LZO_COMPRESS_T *c = swd->c; | 456 | 1.55M | #endif | 457 | | | 458 | 1.55M | if (*m_len <= M2_MIN_LEN) | 459 | 764k | return; | 460 | 795k | #if defined(LZO1Z) | 461 | 795k | if (*m_off == c->last_m_off && *m_len <= M2_MAX_LEN) | 462 | 13.9k | return; | 463 | 781k | #if 1 | 464 | 781k | if (*m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 && | 465 | 781k | c->last_m_off && swd->best_off[*m_len-1] == c->last_m_off) | 466 | 1.62k | { | 467 | 1.62k | *m_len = *m_len - 1; | 468 | 1.62k | *m_off = swd->best_off[*m_len]; | 469 | 1.62k | return; | 470 | 1.62k | } | 471 | 779k | #endif | 472 | 779k | #endif | 473 | | | 474 | 779k | if (*m_off <= M2_MAX_OFFSET) | 475 | 454k | return; | 476 | | | 477 | 325k | #if 1 | 478 | | /* M3/M4 -> M2 */ | 479 | 325k | if (*m_off > M2_MAX_OFFSET && | 480 | 325k | *m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 && | 481 | 325k | swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M2_MAX_OFFSET) | 482 | 24.0k | { | 483 | 24.0k | *m_len = *m_len - 1; | 484 | 24.0k | *m_off = swd->best_off[*m_len]; | 485 | 24.0k | return; | 486 | 24.0k | } | 487 | 301k | #endif | 488 | | | 489 | 301k | #if 1 | 490 | | /* M4 -> M2 */ | 491 | 301k | if (*m_off > M3_MAX_OFFSET && | 492 | 301k | *m_len >= M4_MAX_LEN + 1 && *m_len <= M2_MAX_LEN + 2 && | 493 | 301k | swd->best_off[*m_len-2] && swd->best_off[*m_len-2] <= M2_MAX_OFFSET) | 494 | 828 | { | 495 | 828 | *m_len = *m_len - 2; | 496 | 828 | *m_off = swd->best_off[*m_len]; | 497 | 828 | return; | 498 | 828 | } | 499 | 300k | #endif | 500 | | | 501 | 300k | #if 1 | 502 | | /* M4 -> M3 */ | 503 | 300k | if (*m_off > M3_MAX_OFFSET && | 504 | 300k | *m_len >= M4_MAX_LEN + 1 && *m_len <= M3_MAX_LEN + 1 && | 505 | 300k | swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M3_MAX_OFFSET) | 506 | 2.62k | { | 507 | 2.62k | *m_len = *m_len - 1; | 508 | 2.62k | *m_off = swd->best_off[*m_len]; | 509 | 2.62k | } | 510 | 300k | #endif | 511 | 300k | } |
|
512 | | |
513 | | #endif |
514 | | |
515 | | |
516 | | /*********************************************************************** |
517 | | // |
518 | | ************************************************************************/ |
519 | | |
520 | | LZO_PUBLIC(int) |
521 | | lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, |
522 | | lzo_bytep out, lzo_uintp out_len, |
523 | | lzo_voidp wrkmem, |
524 | | const lzo_bytep dict, lzo_uint dict_len, |
525 | | lzo_callback_p cb, |
526 | | int try_lazy_parm, |
527 | | lzo_uint good_length, |
528 | | lzo_uint max_lazy, |
529 | | lzo_uint nice_length, |
530 | | lzo_uint max_chain, |
531 | | lzo_uint32_t flags ) |
532 | 5.11k | { |
533 | 5.11k | lzo_bytep op; |
534 | 5.11k | const lzo_bytep ii; |
535 | 5.11k | lzo_uint lit; |
536 | 5.11k | lzo_uint m_len, m_off; |
537 | 5.11k | LZO_COMPRESS_T cc; |
538 | 5.11k | LZO_COMPRESS_T * const c = &cc; |
539 | 5.11k | lzo_swd_p const swd = (lzo_swd_p) wrkmem; |
540 | 5.11k | lzo_uint try_lazy; |
541 | 5.11k | int r; |
542 | | |
543 | | /* sanity check */ |
544 | | #if defined(LZO1X) |
545 | 1.60k | LZO_COMPILE_TIME_ASSERT(LZO1X_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) |
546 | | #elif defined(LZO1Y) |
547 | 1.60k | LZO_COMPILE_TIME_ASSERT(LZO1Y_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) |
548 | | #elif defined(LZO1Z) |
549 | 1.91k | LZO_COMPILE_TIME_ASSERT(LZO1Z_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) |
550 | | #else |
551 | | # error |
552 | | #endif |
553 | | |
554 | | /* setup parameter defaults */ |
555 | | /* number of lazy match tries */ |
556 | 5.11k | try_lazy = (lzo_uint) try_lazy_parm; |
557 | 5.11k | if (try_lazy_parm < 0) |
558 | 0 | try_lazy = 1; |
559 | | /* reduce lazy match search if we already have a match with this length */ |
560 | 5.11k | if (good_length == 0) |
561 | 0 | good_length = 32; |
562 | | /* do not try a lazy match if we already have a match with this length */ |
563 | 5.11k | if (max_lazy == 0) |
564 | 0 | max_lazy = 32; |
565 | | /* stop searching for longer matches than this one */ |
566 | 5.11k | if (nice_length == 0) |
567 | 5.11k | nice_length = 0; |
568 | | /* don't search more positions than this */ |
569 | 5.11k | if (max_chain == 0) |
570 | 0 | max_chain = SWD_MAX_CHAIN; |
571 | | |
572 | 5.11k | c->init = 0; |
573 | 5.11k | c->ip = c->in = in; |
574 | 5.11k | c->in_end = in + in_len; |
575 | 5.11k | c->out = out; |
576 | 5.11k | c->cb = cb; |
577 | 5.11k | c->m1a_m = c->m1b_m = c->m2_m = c->m3_m = c->m4_m = 0; |
578 | 5.11k | c->lit1_r = c->lit2_r = c->lit3_r = 0; |
579 | | |
580 | 5.11k | op = out; |
581 | 5.11k | ii = c->ip; /* point to start of literal run */ |
582 | 5.11k | lit = 0; |
583 | 5.11k | c->r1_lit = c->r1_m_len = 0; |
584 | | |
585 | 5.11k | r = init_match(c,swd,dict,dict_len,flags); |
586 | 5.11k | if (r != 0) |
587 | 0 | return r; |
588 | 5.11k | if (max_chain > 0) |
589 | 5.11k | swd->max_chain = max_chain; |
590 | 5.11k | if (nice_length > 0) |
591 | 0 | swd->nice_length = nice_length; |
592 | | |
593 | 5.11k | r = find_match(c,swd,0,0); |
594 | 5.11k | if (r != 0) |
595 | 0 | return r; |
596 | 55.4M | while (c->look > 0) |
597 | 55.4M | { |
598 | 55.4M | lzo_uint ahead; |
599 | 55.4M | lzo_uint max_ahead; |
600 | 55.4M | lzo_uint l1, l2, l3; |
601 | | |
602 | 55.4M | c->codesize = pd(op, out); |
603 | | |
604 | 55.4M | m_len = c->m_len; |
605 | 55.4M | m_off = c->m_off; |
606 | | |
607 | 55.4M | assert(c->bp == c->ip - c->look); |
608 | 55.4M | assert(c->bp >= in); |
609 | 55.4M | if (lit == 0) |
610 | 2.42M | ii = c->bp; |
611 | 55.4M | assert(ii + lit == c->bp); |
612 | 55.4M | assert(swd->b_char == *(c->bp)); |
613 | | |
614 | 55.4M | if ( m_len < 2 || |
615 | 55.4M | (m_len == 2 && (m_off > M1_MAX_OFFSET || lit == 0 || lit >= 4)) || |
616 | 55.4M | #if 1 |
617 | | /* Do not accept this match for compressed-data compatibility |
618 | | * with LZO v1.01 and before |
619 | | * [ might be a problem for decompress() and optimize() ] |
620 | | */ |
621 | 55.4M | (m_len == 2 && op == out) || |
622 | 55.4M | #endif |
623 | 55.4M | (op == out && lit == 0)) |
624 | 52.1M | { |
625 | | /* a literal */ |
626 | 52.1M | m_len = 0; |
627 | 52.1M | } |
628 | 3.23M | else if (m_len == M2_MIN_LEN) |
629 | 947k | { |
630 | | /* compression ratio improves if we code a literal in some cases */ |
631 | 947k | if (m_off > MX_MAX_OFFSET && lit >= 4) |
632 | 401k | m_len = 0; |
633 | 947k | } |
634 | | |
635 | 55.4M | if (m_len == 0) |
636 | 52.5M | { |
637 | | /* a literal */ |
638 | 52.5M | lit++; |
639 | 52.5M | swd->max_chain = max_chain; |
640 | 52.5M | r = find_match(c,swd,1,0); |
641 | 52.5M | assert(r == 0); LZO_UNUSED(r); |
642 | 52.5M | continue; |
643 | 52.5M | } |
644 | | |
645 | | /* a match */ |
646 | 2.83M | #if defined(SWD_BEST_OFF) |
647 | 2.83M | if (swd->use_best_off) |
648 | 2.83M | better_match(swd,&m_len,&m_off); |
649 | 2.83M | #endif |
650 | 2.83M | assert_match(swd,m_len,m_off); |
651 | | |
652 | | |
653 | | /* shall we try a lazy match ? */ |
654 | 2.83M | ahead = 0; |
655 | 2.83M | if (try_lazy == 0 || m_len >= max_lazy) |
656 | 53.8k | { |
657 | | /* no */ |
658 | 53.8k | l1 = 0; |
659 | 53.8k | max_ahead = 0; |
660 | 53.8k | } |
661 | 2.77M | else |
662 | 2.77M | { |
663 | | /* yes, try a lazy match */ |
664 | 2.77M | l1 = len_of_coded_match(m_len,m_off,lit); |
665 | 2.77M | assert(l1 > 0); |
666 | 2.77M | #if 1 |
667 | 2.77M | max_ahead = LZO_MIN(try_lazy, l1 - 1); |
668 | | #else |
669 | | max_ahead = LZO_MIN3(try_lazy, l1, m_len - 1); |
670 | | #endif |
671 | 2.77M | } |
672 | | |
673 | | |
674 | 6.03M | while (ahead < max_ahead && c->look > m_len) |
675 | 3.60M | { |
676 | 3.60M | lzo_uint lazy_match_min_gain; |
677 | | |
678 | 3.60M | if (m_len >= good_length) |
679 | 309k | swd->max_chain = max_chain >> 2; |
680 | 3.29M | else |
681 | 3.29M | swd->max_chain = max_chain; |
682 | 3.60M | r = find_match(c,swd,1,0); |
683 | 3.60M | ahead++; |
684 | | |
685 | 3.60M | assert(r == 0); LZO_UNUSED(r); |
686 | 3.60M | assert(c->look > 0); |
687 | 3.60M | assert(ii + lit + ahead == c->bp); |
688 | | |
689 | | #if defined(LZO1Z) |
690 | 1.45M | if (m_off == c->last_m_off && c->m_off != c->last_m_off) |
691 | 253k | if (m_len >= M2_MIN_LEN && m_len <= M2_MAX_LEN) |
692 | 5.53k | c->m_len = 0; |
693 | | #endif |
694 | 3.60M | if (c->m_len < m_len) |
695 | 2.32M | continue; |
696 | 1.28M | #if 1 |
697 | 1.28M | if (c->m_len == m_len && c->m_off >= m_off) |
698 | 255k | continue; |
699 | 1.03M | #endif |
700 | 1.03M | #if defined(SWD_BEST_OFF) |
701 | 1.03M | if (swd->use_best_off) |
702 | 1.03M | better_match(swd,&c->m_len,&c->m_off); |
703 | 1.03M | #endif |
704 | 1.03M | l2 = len_of_coded_match(c->m_len,c->m_off,lit+ahead); |
705 | 1.03M | if (l2 == 0) |
706 | 6.91k | continue; |
707 | | #if 0 |
708 | | if (c->m_len == m_len && l2 >= l1) |
709 | | continue; |
710 | | #endif |
711 | | |
712 | | |
713 | 1.02M | #if 1 |
714 | | /* compressed-data compatibility [see above] */ |
715 | 1.02M | l3 = (op == out) ? 0 : len_of_coded_match(ahead,m_off,lit); |
716 | | #else |
717 | | l3 = len_of_coded_match(ahead,m_off,lit); |
718 | | #endif |
719 | | |
720 | 1.02M | lazy_match_min_gain = min_gain(ahead,lit,lit+ahead,l1,l2,l3); |
721 | 1.02M | if (c->m_len >= m_len + lazy_match_min_gain) |
722 | 410k | { |
723 | 410k | c->lazy++; |
724 | 410k | assert_match(swd,c->m_len,c->m_off); |
725 | | |
726 | 410k | if (l3) |
727 | 2.93k | { |
728 | | /* code previous run */ |
729 | 2.93k | op = code_run(c,op,ii,lit,ahead); |
730 | 2.93k | lit = 0; |
731 | | /* code shortened match */ |
732 | 2.93k | op = code_match(c,op,ahead,m_off); |
733 | 2.93k | } |
734 | 407k | else |
735 | 407k | { |
736 | 407k | lit += ahead; |
737 | 407k | assert(ii + lit == c->bp); |
738 | 407k | } |
739 | 410k | goto lazy_match_done; |
740 | 410k | } |
741 | 1.02M | } |
742 | | |
743 | | |
744 | 2.42M | assert(ii + lit + ahead == c->bp); |
745 | | |
746 | | /* 1 - code run */ |
747 | 2.42M | op = code_run(c,op,ii,lit,m_len); |
748 | 2.42M | lit = 0; |
749 | | |
750 | | /* 2 - code match */ |
751 | 2.42M | op = code_match(c,op,m_len,m_off); |
752 | 2.42M | swd->max_chain = max_chain; |
753 | 2.42M | r = find_match(c,swd,m_len,1+ahead); |
754 | 2.42M | assert(r == 0); LZO_UNUSED(r); |
755 | | |
756 | 2.83M | lazy_match_done: ; |
757 | 2.83M | } |
758 | | |
759 | | |
760 | | /* store final run */ |
761 | 5.11k | if (lit > 0) |
762 | 2.94k | op = STORE_RUN(c,op,ii,lit); |
763 | | |
764 | 5.11k | #if defined(LZO_EOF_CODE) |
765 | 5.11k | *op++ = M4_MARKER | 1; |
766 | 5.11k | *op++ = 0; |
767 | 5.11k | *op++ = 0; |
768 | 5.11k | #endif |
769 | | |
770 | 5.11k | c->codesize = pd(op, out); |
771 | 5.11k | assert(c->textsize == in_len); |
772 | | |
773 | 5.11k | *out_len = pd(op, out); |
774 | | |
775 | 5.11k | if (c->cb && c->cb->nprogress) |
776 | 0 | (*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0); |
777 | | |
778 | | #if 0 |
779 | | printf("%ld %ld -> %ld %ld: %ld %ld %ld %ld %ld %ld: %ld %ld %ld %ld\n", |
780 | | (long) c->textsize, (long) in_len, (long) c->codesize, |
781 | | c->match_bytes, c->m1a_m, c->m1b_m, c->m2_m, c->m3_m, c->m4_m, |
782 | | c->lit_bytes, c->lit1_r, c->lit2_r, c->lit3_r, c->lazy); |
783 | | #endif |
784 | 5.11k | assert(c->lit_bytes + c->match_bytes == in_len); |
785 | | |
786 | 5.11k | return LZO_E_OK; |
787 | 5.11k | } lzo1x_999_compress_internal Line | Count | Source | 532 | 1.60k | { | 533 | 1.60k | lzo_bytep op; | 534 | 1.60k | const lzo_bytep ii; | 535 | 1.60k | lzo_uint lit; | 536 | 1.60k | lzo_uint m_len, m_off; | 537 | 1.60k | LZO_COMPRESS_T cc; | 538 | 1.60k | LZO_COMPRESS_T * const c = &cc; | 539 | 1.60k | lzo_swd_p const swd = (lzo_swd_p) wrkmem; | 540 | 1.60k | lzo_uint try_lazy; | 541 | 1.60k | int r; | 542 | | | 543 | | /* sanity check */ | 544 | 1.60k | #if defined(LZO1X) | 545 | 1.60k | LZO_COMPILE_TIME_ASSERT(LZO1X_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) | 546 | | #elif defined(LZO1Y) | 547 | | LZO_COMPILE_TIME_ASSERT(LZO1Y_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) | 548 | | #elif defined(LZO1Z) | 549 | | LZO_COMPILE_TIME_ASSERT(LZO1Z_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) | 550 | | #else | 551 | | # error | 552 | | #endif | 553 | | | 554 | | /* setup parameter defaults */ | 555 | | /* number of lazy match tries */ | 556 | 1.60k | try_lazy = (lzo_uint) try_lazy_parm; | 557 | 1.60k | if (try_lazy_parm < 0) | 558 | 0 | try_lazy = 1; | 559 | | /* reduce lazy match search if we already have a match with this length */ | 560 | 1.60k | if (good_length == 0) | 561 | 0 | good_length = 32; | 562 | | /* do not try a lazy match if we already have a match with this length */ | 563 | 1.60k | if (max_lazy == 0) | 564 | 0 | max_lazy = 32; | 565 | | /* stop searching for longer matches than this one */ | 566 | 1.60k | if (nice_length == 0) | 567 | 1.60k | nice_length = 0; | 568 | | /* don't search more positions than this */ | 569 | 1.60k | if (max_chain == 0) | 570 | 0 | max_chain = SWD_MAX_CHAIN; | 571 | | | 572 | 1.60k | c->init = 0; | 573 | 1.60k | c->ip = c->in = in; | 574 | 1.60k | c->in_end = in + in_len; | 575 | 1.60k | c->out = out; | 576 | 1.60k | c->cb = cb; | 577 | 1.60k | c->m1a_m = c->m1b_m = c->m2_m = c->m3_m = c->m4_m = 0; | 578 | 1.60k | c->lit1_r = c->lit2_r = c->lit3_r = 0; | 579 | | | 580 | 1.60k | op = out; | 581 | 1.60k | ii = c->ip; /* point to start of literal run */ | 582 | 1.60k | lit = 0; | 583 | 1.60k | c->r1_lit = c->r1_m_len = 0; | 584 | | | 585 | 1.60k | r = init_match(c,swd,dict,dict_len,flags); | 586 | 1.60k | if (r != 0) | 587 | 0 | return r; | 588 | 1.60k | if (max_chain > 0) | 589 | 1.60k | swd->max_chain = max_chain; | 590 | 1.60k | if (nice_length > 0) | 591 | 0 | swd->nice_length = nice_length; | 592 | | | 593 | 1.60k | r = find_match(c,swd,0,0); | 594 | 1.60k | if (r != 0) | 595 | 0 | return r; | 596 | 18.9M | while (c->look > 0) | 597 | 18.9M | { | 598 | 18.9M | lzo_uint ahead; | 599 | 18.9M | lzo_uint max_ahead; | 600 | 18.9M | lzo_uint l1, l2, l3; | 601 | | | 602 | 18.9M | c->codesize = pd(op, out); | 603 | | | 604 | 18.9M | m_len = c->m_len; | 605 | 18.9M | m_off = c->m_off; | 606 | | | 607 | 18.9M | assert(c->bp == c->ip - c->look); | 608 | 18.9M | assert(c->bp >= in); | 609 | 18.9M | if (lit == 0) | 610 | 778k | ii = c->bp; | 611 | 18.9M | assert(ii + lit == c->bp); | 612 | 18.9M | assert(swd->b_char == *(c->bp)); | 613 | | | 614 | 18.9M | if ( m_len < 2 || | 615 | 18.9M | (m_len == 2 && (m_off > M1_MAX_OFFSET || lit == 0 || lit >= 4)) || | 616 | 18.9M | #if 1 | 617 | | /* Do not accept this match for compressed-data compatibility | 618 | | * with LZO v1.01 and before | 619 | | * [ might be a problem for decompress() and optimize() ] | 620 | | */ | 621 | 18.9M | (m_len == 2 && op == out) || | 622 | 18.9M | #endif | 623 | 18.9M | (op == out && lit == 0)) | 624 | 17.9M | { | 625 | | /* a literal */ | 626 | 17.9M | m_len = 0; | 627 | 17.9M | } | 628 | 1.02M | else if (m_len == M2_MIN_LEN) | 629 | 287k | { | 630 | | /* compression ratio improves if we code a literal in some cases */ | 631 | 287k | if (m_off > MX_MAX_OFFSET && lit >= 4) | 632 | 118k | m_len = 0; | 633 | 287k | } | 634 | | | 635 | 18.9M | if (m_len == 0) | 636 | 18.0M | { | 637 | | /* a literal */ | 638 | 18.0M | lit++; | 639 | 18.0M | swd->max_chain = max_chain; | 640 | 18.0M | r = find_match(c,swd,1,0); | 641 | 18.0M | assert(r == 0); LZO_UNUSED(r); | 642 | 18.0M | continue; | 643 | 18.0M | } | 644 | | | 645 | | /* a match */ | 646 | 904k | #if defined(SWD_BEST_OFF) | 647 | 904k | if (swd->use_best_off) | 648 | 904k | better_match(swd,&m_len,&m_off); | 649 | 904k | #endif | 650 | 904k | assert_match(swd,m_len,m_off); | 651 | | | 652 | | | 653 | | /* shall we try a lazy match ? */ | 654 | 904k | ahead = 0; | 655 | 904k | if (try_lazy == 0 || m_len >= max_lazy) | 656 | 16.3k | { | 657 | | /* no */ | 658 | 16.3k | l1 = 0; | 659 | 16.3k | max_ahead = 0; | 660 | 16.3k | } | 661 | 888k | else | 662 | 888k | { | 663 | | /* yes, try a lazy match */ | 664 | 888k | l1 = len_of_coded_match(m_len,m_off,lit); | 665 | 888k | assert(l1 > 0); | 666 | 888k | #if 1 | 667 | 888k | max_ahead = LZO_MIN(try_lazy, l1 - 1); | 668 | | #else | 669 | | max_ahead = LZO_MIN3(try_lazy, l1, m_len - 1); | 670 | | #endif | 671 | 888k | } | 672 | | | 673 | | | 674 | 1.92M | while (ahead < max_ahead && c->look > m_len) | 675 | 1.14M | { | 676 | 1.14M | lzo_uint lazy_match_min_gain; | 677 | | | 678 | 1.14M | if (m_len >= good_length) | 679 | 83.7k | swd->max_chain = max_chain >> 2; | 680 | 1.06M | else | 681 | 1.06M | swd->max_chain = max_chain; | 682 | 1.14M | r = find_match(c,swd,1,0); | 683 | 1.14M | ahead++; | 684 | | | 685 | 1.14M | assert(r == 0); LZO_UNUSED(r); | 686 | 1.14M | assert(c->look > 0); | 687 | 1.14M | assert(ii + lit + ahead == c->bp); | 688 | | | 689 | | #if defined(LZO1Z) | 690 | | if (m_off == c->last_m_off && c->m_off != c->last_m_off) | 691 | | if (m_len >= M2_MIN_LEN && m_len <= M2_MAX_LEN) | 692 | | c->m_len = 0; | 693 | | #endif | 694 | 1.14M | if (c->m_len < m_len) | 695 | 731k | continue; | 696 | 416k | #if 1 | 697 | 416k | if (c->m_len == m_len && c->m_off >= m_off) | 698 | 79.9k | continue; | 699 | 336k | #endif | 700 | 336k | #if defined(SWD_BEST_OFF) | 701 | 336k | if (swd->use_best_off) | 702 | 336k | better_match(swd,&c->m_len,&c->m_off); | 703 | 336k | #endif | 704 | 336k | l2 = len_of_coded_match(c->m_len,c->m_off,lit+ahead); | 705 | 336k | if (l2 == 0) | 706 | 2.27k | continue; | 707 | | #if 0 | 708 | | if (c->m_len == m_len && l2 >= l1) | 709 | | continue; | 710 | | #endif | 711 | | | 712 | | | 713 | 334k | #if 1 | 714 | | /* compressed-data compatibility [see above] */ | 715 | 334k | l3 = (op == out) ? 0 : len_of_coded_match(ahead,m_off,lit); | 716 | | #else | 717 | | l3 = len_of_coded_match(ahead,m_off,lit); | 718 | | #endif | 719 | | | 720 | 334k | lazy_match_min_gain = min_gain(ahead,lit,lit+ahead,l1,l2,l3); | 721 | 334k | if (c->m_len >= m_len + lazy_match_min_gain) | 722 | 127k | { | 723 | 127k | c->lazy++; | 724 | 127k | assert_match(swd,c->m_len,c->m_off); | 725 | | | 726 | 127k | if (l3) | 727 | 896 | { | 728 | | /* code previous run */ | 729 | 896 | op = code_run(c,op,ii,lit,ahead); | 730 | 896 | lit = 0; | 731 | | /* code shortened match */ | 732 | 896 | op = code_match(c,op,ahead,m_off); | 733 | 896 | } | 734 | 126k | else | 735 | 126k | { | 736 | 126k | lit += ahead; | 737 | 126k | assert(ii + lit == c->bp); | 738 | 126k | } | 739 | 127k | goto lazy_match_done; | 740 | 127k | } | 741 | 334k | } | 742 | | | 743 | | | 744 | 777k | assert(ii + lit + ahead == c->bp); | 745 | | | 746 | | /* 1 - code run */ | 747 | 777k | op = code_run(c,op,ii,lit,m_len); | 748 | 777k | lit = 0; | 749 | | | 750 | | /* 2 - code match */ | 751 | 777k | op = code_match(c,op,m_len,m_off); | 752 | 777k | swd->max_chain = max_chain; | 753 | 777k | r = find_match(c,swd,m_len,1+ahead); | 754 | 777k | assert(r == 0); LZO_UNUSED(r); | 755 | | | 756 | 904k | lazy_match_done: ; | 757 | 904k | } | 758 | | | 759 | | | 760 | | /* store final run */ | 761 | 1.60k | if (lit > 0) | 762 | 893 | op = STORE_RUN(c,op,ii,lit); | 763 | | | 764 | 1.60k | #if defined(LZO_EOF_CODE) | 765 | 1.60k | *op++ = M4_MARKER | 1; | 766 | 1.60k | *op++ = 0; | 767 | 1.60k | *op++ = 0; | 768 | 1.60k | #endif | 769 | | | 770 | 1.60k | c->codesize = pd(op, out); | 771 | 1.60k | assert(c->textsize == in_len); | 772 | | | 773 | 1.60k | *out_len = pd(op, out); | 774 | | | 775 | 1.60k | if (c->cb && c->cb->nprogress) | 776 | 0 | (*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0); | 777 | | | 778 | | #if 0 | 779 | | printf("%ld %ld -> %ld %ld: %ld %ld %ld %ld %ld %ld: %ld %ld %ld %ld\n", | 780 | | (long) c->textsize, (long) in_len, (long) c->codesize, | 781 | | c->match_bytes, c->m1a_m, c->m1b_m, c->m2_m, c->m3_m, c->m4_m, | 782 | | c->lit_bytes, c->lit1_r, c->lit2_r, c->lit3_r, c->lazy); | 783 | | #endif | 784 | 1.60k | assert(c->lit_bytes + c->match_bytes == in_len); | 785 | | | 786 | 1.60k | return LZO_E_OK; | 787 | 1.60k | } |
lzo1y_999_compress_internal Line | Count | Source | 532 | 1.60k | { | 533 | 1.60k | lzo_bytep op; | 534 | 1.60k | const lzo_bytep ii; | 535 | 1.60k | lzo_uint lit; | 536 | 1.60k | lzo_uint m_len, m_off; | 537 | 1.60k | LZO_COMPRESS_T cc; | 538 | 1.60k | LZO_COMPRESS_T * const c = &cc; | 539 | 1.60k | lzo_swd_p const swd = (lzo_swd_p) wrkmem; | 540 | 1.60k | lzo_uint try_lazy; | 541 | 1.60k | int r; | 542 | | | 543 | | /* sanity check */ | 544 | | #if defined(LZO1X) | 545 | | LZO_COMPILE_TIME_ASSERT(LZO1X_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) | 546 | | #elif defined(LZO1Y) | 547 | 1.60k | LZO_COMPILE_TIME_ASSERT(LZO1Y_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) | 548 | | #elif defined(LZO1Z) | 549 | | LZO_COMPILE_TIME_ASSERT(LZO1Z_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) | 550 | | #else | 551 | | # error | 552 | | #endif | 553 | | | 554 | | /* setup parameter defaults */ | 555 | | /* number of lazy match tries */ | 556 | 1.60k | try_lazy = (lzo_uint) try_lazy_parm; | 557 | 1.60k | if (try_lazy_parm < 0) | 558 | 0 | try_lazy = 1; | 559 | | /* reduce lazy match search if we already have a match with this length */ | 560 | 1.60k | if (good_length == 0) | 561 | 0 | good_length = 32; | 562 | | /* do not try a lazy match if we already have a match with this length */ | 563 | 1.60k | if (max_lazy == 0) | 564 | 0 | max_lazy = 32; | 565 | | /* stop searching for longer matches than this one */ | 566 | 1.60k | if (nice_length == 0) | 567 | 1.60k | nice_length = 0; | 568 | | /* don't search more positions than this */ | 569 | 1.60k | if (max_chain == 0) | 570 | 0 | max_chain = SWD_MAX_CHAIN; | 571 | | | 572 | 1.60k | c->init = 0; | 573 | 1.60k | c->ip = c->in = in; | 574 | 1.60k | c->in_end = in + in_len; | 575 | 1.60k | c->out = out; | 576 | 1.60k | c->cb = cb; | 577 | 1.60k | c->m1a_m = c->m1b_m = c->m2_m = c->m3_m = c->m4_m = 0; | 578 | 1.60k | c->lit1_r = c->lit2_r = c->lit3_r = 0; | 579 | | | 580 | 1.60k | op = out; | 581 | 1.60k | ii = c->ip; /* point to start of literal run */ | 582 | 1.60k | lit = 0; | 583 | 1.60k | c->r1_lit = c->r1_m_len = 0; | 584 | | | 585 | 1.60k | r = init_match(c,swd,dict,dict_len,flags); | 586 | 1.60k | if (r != 0) | 587 | 0 | return r; | 588 | 1.60k | if (max_chain > 0) | 589 | 1.60k | swd->max_chain = max_chain; | 590 | 1.60k | if (nice_length > 0) | 591 | 0 | swd->nice_length = nice_length; | 592 | | | 593 | 1.60k | r = find_match(c,swd,0,0); | 594 | 1.60k | if (r != 0) | 595 | 0 | return r; | 596 | 17.8M | while (c->look > 0) | 597 | 17.8M | { | 598 | 17.8M | lzo_uint ahead; | 599 | 17.8M | lzo_uint max_ahead; | 600 | 17.8M | lzo_uint l1, l2, l3; | 601 | | | 602 | 17.8M | c->codesize = pd(op, out); | 603 | | | 604 | 17.8M | m_len = c->m_len; | 605 | 17.8M | m_off = c->m_off; | 606 | | | 607 | 17.8M | assert(c->bp == c->ip - c->look); | 608 | 17.8M | assert(c->bp >= in); | 609 | 17.8M | if (lit == 0) | 610 | 679k | ii = c->bp; | 611 | 17.8M | assert(ii + lit == c->bp); | 612 | 17.8M | assert(swd->b_char == *(c->bp)); | 613 | | | 614 | 17.8M | if ( m_len < 2 || | 615 | 17.8M | (m_len == 2 && (m_off > M1_MAX_OFFSET || lit == 0 || lit >= 4)) || | 616 | 17.8M | #if 1 | 617 | | /* Do not accept this match for compressed-data compatibility | 618 | | * with LZO v1.01 and before | 619 | | * [ might be a problem for decompress() and optimize() ] | 620 | | */ | 621 | 17.8M | (m_len == 2 && op == out) || | 622 | 17.8M | #endif | 623 | 17.8M | (op == out && lit == 0)) | 624 | 16.9M | { | 625 | | /* a literal */ | 626 | 16.9M | m_len = 0; | 627 | 16.9M | } | 628 | 940k | else if (m_len == M2_MIN_LEN) | 629 | 303k | { | 630 | | /* compression ratio improves if we code a literal in some cases */ | 631 | 303k | if (m_off > MX_MAX_OFFSET && lit >= 4) | 632 | 147k | m_len = 0; | 633 | 303k | } | 634 | | | 635 | 17.8M | if (m_len == 0) | 636 | 17.0M | { | 637 | | /* a literal */ | 638 | 17.0M | lit++; | 639 | 17.0M | swd->max_chain = max_chain; | 640 | 17.0M | r = find_match(c,swd,1,0); | 641 | 17.0M | assert(r == 0); LZO_UNUSED(r); | 642 | 17.0M | continue; | 643 | 17.0M | } | 644 | | | 645 | | /* a match */ | 646 | 792k | #if defined(SWD_BEST_OFF) | 647 | 792k | if (swd->use_best_off) | 648 | 792k | better_match(swd,&m_len,&m_off); | 649 | 792k | #endif | 650 | 792k | assert_match(swd,m_len,m_off); | 651 | | | 652 | | | 653 | | /* shall we try a lazy match ? */ | 654 | 792k | ahead = 0; | 655 | 792k | if (try_lazy == 0 || m_len >= max_lazy) | 656 | 15.7k | { | 657 | | /* no */ | 658 | 15.7k | l1 = 0; | 659 | 15.7k | max_ahead = 0; | 660 | 15.7k | } | 661 | 777k | else | 662 | 777k | { | 663 | | /* yes, try a lazy match */ | 664 | 777k | l1 = len_of_coded_match(m_len,m_off,lit); | 665 | 777k | assert(l1 > 0); | 666 | 777k | #if 1 | 667 | 777k | max_ahead = LZO_MIN(try_lazy, l1 - 1); | 668 | | #else | 669 | | max_ahead = LZO_MIN3(try_lazy, l1, m_len - 1); | 670 | | #endif | 671 | 777k | } | 672 | | | 673 | | | 674 | 1.68M | while (ahead < max_ahead && c->look > m_len) | 675 | 1.00M | { | 676 | 1.00M | lzo_uint lazy_match_min_gain; | 677 | | | 678 | 1.00M | if (m_len >= good_length) | 679 | 96.7k | swd->max_chain = max_chain >> 2; | 680 | 910k | else | 681 | 910k | swd->max_chain = max_chain; | 682 | 1.00M | r = find_match(c,swd,1,0); | 683 | 1.00M | ahead++; | 684 | | | 685 | 1.00M | assert(r == 0); LZO_UNUSED(r); | 686 | 1.00M | assert(c->look > 0); | 687 | 1.00M | assert(ii + lit + ahead == c->bp); | 688 | | | 689 | | #if defined(LZO1Z) | 690 | | if (m_off == c->last_m_off && c->m_off != c->last_m_off) | 691 | | if (m_len >= M2_MIN_LEN && m_len <= M2_MAX_LEN) | 692 | | c->m_len = 0; | 693 | | #endif | 694 | 1.00M | if (c->m_len < m_len) | 695 | 659k | continue; | 696 | 347k | #if 1 | 697 | 347k | if (c->m_len == m_len && c->m_off >= m_off) | 698 | 77.6k | continue; | 699 | 270k | #endif | 700 | 270k | #if defined(SWD_BEST_OFF) | 701 | 270k | if (swd->use_best_off) | 702 | 270k | better_match(swd,&c->m_len,&c->m_off); | 703 | 270k | #endif | 704 | 270k | l2 = len_of_coded_match(c->m_len,c->m_off,lit+ahead); | 705 | 270k | if (l2 == 0) | 706 | 2.09k | continue; | 707 | | #if 0 | 708 | | if (c->m_len == m_len && l2 >= l1) | 709 | | continue; | 710 | | #endif | 711 | | | 712 | | | 713 | 268k | #if 1 | 714 | | /* compressed-data compatibility [see above] */ | 715 | 268k | l3 = (op == out) ? 0 : len_of_coded_match(ahead,m_off,lit); | 716 | | #else | 717 | | l3 = len_of_coded_match(ahead,m_off,lit); | 718 | | #endif | 719 | | | 720 | 268k | lazy_match_min_gain = min_gain(ahead,lit,lit+ahead,l1,l2,l3); | 721 | 268k | if (c->m_len >= m_len + lazy_match_min_gain) | 722 | 115k | { | 723 | 115k | c->lazy++; | 724 | 115k | assert_match(swd,c->m_len,c->m_off); | 725 | | | 726 | 115k | if (l3) | 727 | 952 | { | 728 | | /* code previous run */ | 729 | 952 | op = code_run(c,op,ii,lit,ahead); | 730 | 952 | lit = 0; | 731 | | /* code shortened match */ | 732 | 952 | op = code_match(c,op,ahead,m_off); | 733 | 952 | } | 734 | 114k | else | 735 | 114k | { | 736 | 114k | lit += ahead; | 737 | 114k | assert(ii + lit == c->bp); | 738 | 114k | } | 739 | 115k | goto lazy_match_done; | 740 | 115k | } | 741 | 268k | } | 742 | | | 743 | | | 744 | 677k | assert(ii + lit + ahead == c->bp); | 745 | | | 746 | | /* 1 - code run */ | 747 | 677k | op = code_run(c,op,ii,lit,m_len); | 748 | 677k | lit = 0; | 749 | | | 750 | | /* 2 - code match */ | 751 | 677k | op = code_match(c,op,m_len,m_off); | 752 | 677k | swd->max_chain = max_chain; | 753 | 677k | r = find_match(c,swd,m_len,1+ahead); | 754 | 677k | assert(r == 0); LZO_UNUSED(r); | 755 | | | 756 | 792k | lazy_match_done: ; | 757 | 792k | } | 758 | | | 759 | | | 760 | | /* store final run */ | 761 | 1.60k | if (lit > 0) | 762 | 888 | op = STORE_RUN(c,op,ii,lit); | 763 | | | 764 | 1.60k | #if defined(LZO_EOF_CODE) | 765 | 1.60k | *op++ = M4_MARKER | 1; | 766 | 1.60k | *op++ = 0; | 767 | 1.60k | *op++ = 0; | 768 | 1.60k | #endif | 769 | | | 770 | 1.60k | c->codesize = pd(op, out); | 771 | 1.60k | assert(c->textsize == in_len); | 772 | | | 773 | 1.60k | *out_len = pd(op, out); | 774 | | | 775 | 1.60k | if (c->cb && c->cb->nprogress) | 776 | 0 | (*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0); | 777 | | | 778 | | #if 0 | 779 | | printf("%ld %ld -> %ld %ld: %ld %ld %ld %ld %ld %ld: %ld %ld %ld %ld\n", | 780 | | (long) c->textsize, (long) in_len, (long) c->codesize, | 781 | | c->match_bytes, c->m1a_m, c->m1b_m, c->m2_m, c->m3_m, c->m4_m, | 782 | | c->lit_bytes, c->lit1_r, c->lit2_r, c->lit3_r, c->lazy); | 783 | | #endif | 784 | 1.60k | assert(c->lit_bytes + c->match_bytes == in_len); | 785 | | | 786 | 1.60k | return LZO_E_OK; | 787 | 1.60k | } |
lzo1z_999_compress_internal Line | Count | Source | 532 | 1.91k | { | 533 | 1.91k | lzo_bytep op; | 534 | 1.91k | const lzo_bytep ii; | 535 | 1.91k | lzo_uint lit; | 536 | 1.91k | lzo_uint m_len, m_off; | 537 | 1.91k | LZO_COMPRESS_T cc; | 538 | 1.91k | LZO_COMPRESS_T * const c = &cc; | 539 | 1.91k | lzo_swd_p const swd = (lzo_swd_p) wrkmem; | 540 | 1.91k | lzo_uint try_lazy; | 541 | 1.91k | int r; | 542 | | | 543 | | /* sanity check */ | 544 | | #if defined(LZO1X) | 545 | | LZO_COMPILE_TIME_ASSERT(LZO1X_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) | 546 | | #elif defined(LZO1Y) | 547 | | LZO_COMPILE_TIME_ASSERT(LZO1Y_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) | 548 | | #elif defined(LZO1Z) | 549 | 1.91k | LZO_COMPILE_TIME_ASSERT(LZO1Z_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) | 550 | | #else | 551 | | # error | 552 | | #endif | 553 | | | 554 | | /* setup parameter defaults */ | 555 | | /* number of lazy match tries */ | 556 | 1.91k | try_lazy = (lzo_uint) try_lazy_parm; | 557 | 1.91k | if (try_lazy_parm < 0) | 558 | 0 | try_lazy = 1; | 559 | | /* reduce lazy match search if we already have a match with this length */ | 560 | 1.91k | if (good_length == 0) | 561 | 0 | good_length = 32; | 562 | | /* do not try a lazy match if we already have a match with this length */ | 563 | 1.91k | if (max_lazy == 0) | 564 | 0 | max_lazy = 32; | 565 | | /* stop searching for longer matches than this one */ | 566 | 1.91k | if (nice_length == 0) | 567 | 1.91k | nice_length = 0; | 568 | | /* don't search more positions than this */ | 569 | 1.91k | if (max_chain == 0) | 570 | 0 | max_chain = SWD_MAX_CHAIN; | 571 | | | 572 | 1.91k | c->init = 0; | 573 | 1.91k | c->ip = c->in = in; | 574 | 1.91k | c->in_end = in + in_len; | 575 | 1.91k | c->out = out; | 576 | 1.91k | c->cb = cb; | 577 | 1.91k | c->m1a_m = c->m1b_m = c->m2_m = c->m3_m = c->m4_m = 0; | 578 | 1.91k | c->lit1_r = c->lit2_r = c->lit3_r = 0; | 579 | | | 580 | 1.91k | op = out; | 581 | 1.91k | ii = c->ip; /* point to start of literal run */ | 582 | 1.91k | lit = 0; | 583 | 1.91k | c->r1_lit = c->r1_m_len = 0; | 584 | | | 585 | 1.91k | r = init_match(c,swd,dict,dict_len,flags); | 586 | 1.91k | if (r != 0) | 587 | 0 | return r; | 588 | 1.91k | if (max_chain > 0) | 589 | 1.91k | swd->max_chain = max_chain; | 590 | 1.91k | if (nice_length > 0) | 591 | 0 | swd->nice_length = nice_length; | 592 | | | 593 | 1.91k | r = find_match(c,swd,0,0); | 594 | 1.91k | if (r != 0) | 595 | 0 | return r; | 596 | 18.5M | while (c->look > 0) | 597 | 18.5M | { | 598 | 18.5M | lzo_uint ahead; | 599 | 18.5M | lzo_uint max_ahead; | 600 | 18.5M | lzo_uint l1, l2, l3; | 601 | | | 602 | 18.5M | c->codesize = pd(op, out); | 603 | | | 604 | 18.5M | m_len = c->m_len; | 605 | 18.5M | m_off = c->m_off; | 606 | | | 607 | 18.5M | assert(c->bp == c->ip - c->look); | 608 | 18.5M | assert(c->bp >= in); | 609 | 18.5M | if (lit == 0) | 610 | 969k | ii = c->bp; | 611 | 18.5M | assert(ii + lit == c->bp); | 612 | 18.5M | assert(swd->b_char == *(c->bp)); | 613 | | | 614 | 18.5M | if ( m_len < 2 || | 615 | 18.5M | (m_len == 2 && (m_off > M1_MAX_OFFSET || lit == 0 || lit >= 4)) || | 616 | 18.5M | #if 1 | 617 | | /* Do not accept this match for compressed-data compatibility | 618 | | * with LZO v1.01 and before | 619 | | * [ might be a problem for decompress() and optimize() ] | 620 | | */ | 621 | 18.5M | (m_len == 2 && op == out) || | 622 | 18.5M | #endif | 623 | 18.5M | (op == out && lit == 0)) | 624 | 17.2M | { | 625 | | /* a literal */ | 626 | 17.2M | m_len = 0; | 627 | 17.2M | } | 628 | 1.27M | else if (m_len == M2_MIN_LEN) | 629 | 356k | { | 630 | | /* compression ratio improves if we code a literal in some cases */ | 631 | 356k | if (m_off > MX_MAX_OFFSET && lit >= 4) | 632 | 135k | m_len = 0; | 633 | 356k | } | 634 | | | 635 | 18.5M | if (m_len == 0) | 636 | 17.4M | { | 637 | | /* a literal */ | 638 | 17.4M | lit++; | 639 | 17.4M | swd->max_chain = max_chain; | 640 | 17.4M | r = find_match(c,swd,1,0); | 641 | 17.4M | assert(r == 0); LZO_UNUSED(r); | 642 | 17.4M | continue; | 643 | 17.4M | } | 644 | | | 645 | | /* a match */ | 646 | 1.13M | #if defined(SWD_BEST_OFF) | 647 | 1.13M | if (swd->use_best_off) | 648 | 1.13M | better_match(swd,&m_len,&m_off); | 649 | 1.13M | #endif | 650 | 1.13M | assert_match(swd,m_len,m_off); | 651 | | | 652 | | | 653 | | /* shall we try a lazy match ? */ | 654 | 1.13M | ahead = 0; | 655 | 1.13M | if (try_lazy == 0 || m_len >= max_lazy) | 656 | 21.8k | { | 657 | | /* no */ | 658 | 21.8k | l1 = 0; | 659 | 21.8k | max_ahead = 0; | 660 | 21.8k | } | 661 | 1.11M | else | 662 | 1.11M | { | 663 | | /* yes, try a lazy match */ | 664 | 1.11M | l1 = len_of_coded_match(m_len,m_off,lit); | 665 | 1.11M | assert(l1 > 0); | 666 | 1.11M | #if 1 | 667 | 1.11M | max_ahead = LZO_MIN(try_lazy, l1 - 1); | 668 | | #else | 669 | | max_ahead = LZO_MIN3(try_lazy, l1, m_len - 1); | 670 | | #endif | 671 | 1.11M | } | 672 | | | 673 | | | 674 | 2.42M | while (ahead < max_ahead && c->look > m_len) | 675 | 1.45M | { | 676 | 1.45M | lzo_uint lazy_match_min_gain; | 677 | | | 678 | 1.45M | if (m_len >= good_length) | 679 | 128k | swd->max_chain = max_chain >> 2; | 680 | 1.32M | else | 681 | 1.32M | swd->max_chain = max_chain; | 682 | 1.45M | r = find_match(c,swd,1,0); | 683 | 1.45M | ahead++; | 684 | | | 685 | 1.45M | assert(r == 0); LZO_UNUSED(r); | 686 | 1.45M | assert(c->look > 0); | 687 | 1.45M | assert(ii + lit + ahead == c->bp); | 688 | | | 689 | 1.45M | #if defined(LZO1Z) | 690 | 1.45M | if (m_off == c->last_m_off && c->m_off != c->last_m_off) | 691 | 253k | if (m_len >= M2_MIN_LEN && m_len <= M2_MAX_LEN) | 692 | 5.53k | c->m_len = 0; | 693 | 1.45M | #endif | 694 | 1.45M | if (c->m_len < m_len) | 695 | 931k | continue; | 696 | 521k | #if 1 | 697 | 521k | if (c->m_len == m_len && c->m_off >= m_off) | 698 | 97.7k | continue; | 699 | 424k | #endif | 700 | 424k | #if defined(SWD_BEST_OFF) | 701 | 424k | if (swd->use_best_off) | 702 | 424k | better_match(swd,&c->m_len,&c->m_off); | 703 | 424k | #endif | 704 | 424k | l2 = len_of_coded_match(c->m_len,c->m_off,lit+ahead); | 705 | 424k | if (l2 == 0) | 706 | 2.55k | continue; | 707 | | #if 0 | 708 | | if (c->m_len == m_len && l2 >= l1) | 709 | | continue; | 710 | | #endif | 711 | | | 712 | | | 713 | 421k | #if 1 | 714 | | /* compressed-data compatibility [see above] */ | 715 | 421k | l3 = (op == out) ? 0 : len_of_coded_match(ahead,m_off,lit); | 716 | | #else | 717 | | l3 = len_of_coded_match(ahead,m_off,lit); | 718 | | #endif | 719 | | | 720 | 421k | lazy_match_min_gain = min_gain(ahead,lit,lit+ahead,l1,l2,l3); | 721 | 421k | if (c->m_len >= m_len + lazy_match_min_gain) | 722 | 167k | { | 723 | 167k | c->lazy++; | 724 | 167k | assert_match(swd,c->m_len,c->m_off); | 725 | | | 726 | 167k | if (l3) | 727 | 1.08k | { | 728 | | /* code previous run */ | 729 | 1.08k | op = code_run(c,op,ii,lit,ahead); | 730 | 1.08k | lit = 0; | 731 | | /* code shortened match */ | 732 | 1.08k | op = code_match(c,op,ahead,m_off); | 733 | 1.08k | } | 734 | 166k | else | 735 | 166k | { | 736 | 166k | lit += ahead; | 737 | 166k | assert(ii + lit == c->bp); | 738 | 166k | } | 739 | 167k | goto lazy_match_done; | 740 | 167k | } | 741 | 421k | } | 742 | | | 743 | | | 744 | 967k | assert(ii + lit + ahead == c->bp); | 745 | | | 746 | | /* 1 - code run */ | 747 | 967k | op = code_run(c,op,ii,lit,m_len); | 748 | 967k | lit = 0; | 749 | | | 750 | | /* 2 - code match */ | 751 | 967k | op = code_match(c,op,m_len,m_off); | 752 | 967k | swd->max_chain = max_chain; | 753 | 967k | r = find_match(c,swd,m_len,1+ahead); | 754 | 967k | assert(r == 0); LZO_UNUSED(r); | 755 | | | 756 | 1.13M | lazy_match_done: ; | 757 | 1.13M | } | 758 | | | 759 | | | 760 | | /* store final run */ | 761 | 1.91k | if (lit > 0) | 762 | 1.15k | op = STORE_RUN(c,op,ii,lit); | 763 | | | 764 | 1.91k | #if defined(LZO_EOF_CODE) | 765 | 1.91k | *op++ = M4_MARKER | 1; | 766 | 1.91k | *op++ = 0; | 767 | 1.91k | *op++ = 0; | 768 | 1.91k | #endif | 769 | | | 770 | 1.91k | c->codesize = pd(op, out); | 771 | 1.91k | assert(c->textsize == in_len); | 772 | | | 773 | 1.91k | *out_len = pd(op, out); | 774 | | | 775 | 1.91k | if (c->cb && c->cb->nprogress) | 776 | 0 | (*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0); | 777 | | | 778 | | #if 0 | 779 | | printf("%ld %ld -> %ld %ld: %ld %ld %ld %ld %ld %ld: %ld %ld %ld %ld\n", | 780 | | (long) c->textsize, (long) in_len, (long) c->codesize, | 781 | | c->match_bytes, c->m1a_m, c->m1b_m, c->m2_m, c->m3_m, c->m4_m, | 782 | | c->lit_bytes, c->lit1_r, c->lit2_r, c->lit3_r, c->lazy); | 783 | | #endif | 784 | 1.91k | assert(c->lit_bytes + c->match_bytes == in_len); | 785 | | | 786 | 1.91k | return LZO_E_OK; | 787 | 1.91k | } |
|
788 | | |
789 | | |
790 | | /*********************************************************************** |
791 | | // |
792 | | ************************************************************************/ |
793 | | |
794 | | LZO_PUBLIC(int) |
795 | | lzo1x_999_compress_level ( const lzo_bytep in , lzo_uint in_len, |
796 | | lzo_bytep out, lzo_uintp out_len, |
797 | | lzo_voidp wrkmem, |
798 | | const lzo_bytep dict, lzo_uint dict_len, |
799 | | lzo_callback_p cb, |
800 | | int compression_level ) |
801 | 5.11k | { |
802 | 5.11k | static const struct |
803 | 5.11k | { |
804 | 5.11k | int try_lazy_parm; |
805 | 5.11k | lzo_uint good_length; |
806 | 5.11k | lzo_uint max_lazy; |
807 | 5.11k | lzo_uint nice_length; |
808 | 5.11k | lzo_uint max_chain; |
809 | 5.11k | lzo_uint32_t flags; |
810 | 5.11k | } c[9] = { |
811 | | /* faster compression */ |
812 | 5.11k | { 0, 0, 0, 8, 4, 0 }, |
813 | 5.11k | { 0, 0, 0, 16, 8, 0 }, |
814 | 5.11k | { 0, 0, 0, 32, 16, 0 }, |
815 | 5.11k | { 1, 4, 4, 16, 16, 0 }, |
816 | 5.11k | { 1, 8, 16, 32, 32, 0 }, |
817 | 5.11k | { 1, 8, 16, 128, 128, 0 }, |
818 | 5.11k | { 2, 8, 32, 128, 256, 0 }, |
819 | 5.11k | { 2, 32, 128, SWD_F, 2048, 1 }, |
820 | 5.11k | { 2, SWD_F, SWD_F, SWD_F, 4096, 1 } |
821 | | /* max. compression */ |
822 | 5.11k | }; |
823 | | |
824 | 5.11k | if (compression_level < 1 || compression_level > 9) |
825 | 0 | return LZO_E_ERROR; |
826 | | |
827 | 5.11k | compression_level -= 1; |
828 | 5.11k | return lzo1x_999_compress_internal(in, in_len, out, out_len, wrkmem, |
829 | 5.11k | dict, dict_len, cb, |
830 | 5.11k | c[compression_level].try_lazy_parm, |
831 | 5.11k | c[compression_level].good_length, |
832 | 5.11k | c[compression_level].max_lazy, |
833 | | #if 0 |
834 | | c[compression_level].nice_length, |
835 | | #else |
836 | 5.11k | 0, |
837 | 5.11k | #endif |
838 | 5.11k | c[compression_level].max_chain, |
839 | 5.11k | c[compression_level].flags); |
840 | 5.11k | } Line | Count | Source | 801 | 1.60k | { | 802 | 1.60k | static const struct | 803 | 1.60k | { | 804 | 1.60k | int try_lazy_parm; | 805 | 1.60k | lzo_uint good_length; | 806 | 1.60k | lzo_uint max_lazy; | 807 | 1.60k | lzo_uint nice_length; | 808 | 1.60k | lzo_uint max_chain; | 809 | 1.60k | lzo_uint32_t flags; | 810 | 1.60k | } c[9] = { | 811 | | /* faster compression */ | 812 | 1.60k | { 0, 0, 0, 8, 4, 0 }, | 813 | 1.60k | { 0, 0, 0, 16, 8, 0 }, | 814 | 1.60k | { 0, 0, 0, 32, 16, 0 }, | 815 | 1.60k | { 1, 4, 4, 16, 16, 0 }, | 816 | 1.60k | { 1, 8, 16, 32, 32, 0 }, | 817 | 1.60k | { 1, 8, 16, 128, 128, 0 }, | 818 | 1.60k | { 2, 8, 32, 128, 256, 0 }, | 819 | 1.60k | { 2, 32, 128, SWD_F, 2048, 1 }, | 820 | 1.60k | { 2, SWD_F, SWD_F, SWD_F, 4096, 1 } | 821 | | /* max. compression */ | 822 | 1.60k | }; | 823 | | | 824 | 1.60k | if (compression_level < 1 || compression_level > 9) | 825 | 0 | return LZO_E_ERROR; | 826 | | | 827 | 1.60k | compression_level -= 1; | 828 | 1.60k | return lzo1x_999_compress_internal(in, in_len, out, out_len, wrkmem, | 829 | 1.60k | dict, dict_len, cb, | 830 | 1.60k | c[compression_level].try_lazy_parm, | 831 | 1.60k | c[compression_level].good_length, | 832 | 1.60k | c[compression_level].max_lazy, | 833 | | #if 0 | 834 | | c[compression_level].nice_length, | 835 | | #else | 836 | 1.60k | 0, | 837 | 1.60k | #endif | 838 | 1.60k | c[compression_level].max_chain, | 839 | 1.60k | c[compression_level].flags); | 840 | 1.60k | } |
Line | Count | Source | 801 | 1.60k | { | 802 | 1.60k | static const struct | 803 | 1.60k | { | 804 | 1.60k | int try_lazy_parm; | 805 | 1.60k | lzo_uint good_length; | 806 | 1.60k | lzo_uint max_lazy; | 807 | 1.60k | lzo_uint nice_length; | 808 | 1.60k | lzo_uint max_chain; | 809 | 1.60k | lzo_uint32_t flags; | 810 | 1.60k | } c[9] = { | 811 | | /* faster compression */ | 812 | 1.60k | { 0, 0, 0, 8, 4, 0 }, | 813 | 1.60k | { 0, 0, 0, 16, 8, 0 }, | 814 | 1.60k | { 0, 0, 0, 32, 16, 0 }, | 815 | 1.60k | { 1, 4, 4, 16, 16, 0 }, | 816 | 1.60k | { 1, 8, 16, 32, 32, 0 }, | 817 | 1.60k | { 1, 8, 16, 128, 128, 0 }, | 818 | 1.60k | { 2, 8, 32, 128, 256, 0 }, | 819 | 1.60k | { 2, 32, 128, SWD_F, 2048, 1 }, | 820 | 1.60k | { 2, SWD_F, SWD_F, SWD_F, 4096, 1 } | 821 | | /* max. compression */ | 822 | 1.60k | }; | 823 | | | 824 | 1.60k | if (compression_level < 1 || compression_level > 9) | 825 | 0 | return LZO_E_ERROR; | 826 | | | 827 | 1.60k | compression_level -= 1; | 828 | 1.60k | return lzo1x_999_compress_internal(in, in_len, out, out_len, wrkmem, | 829 | 1.60k | dict, dict_len, cb, | 830 | 1.60k | c[compression_level].try_lazy_parm, | 831 | 1.60k | c[compression_level].good_length, | 832 | 1.60k | c[compression_level].max_lazy, | 833 | | #if 0 | 834 | | c[compression_level].nice_length, | 835 | | #else | 836 | 1.60k | 0, | 837 | 1.60k | #endif | 838 | 1.60k | c[compression_level].max_chain, | 839 | 1.60k | c[compression_level].flags); | 840 | 1.60k | } |
Line | Count | Source | 801 | 1.91k | { | 802 | 1.91k | static const struct | 803 | 1.91k | { | 804 | 1.91k | int try_lazy_parm; | 805 | 1.91k | lzo_uint good_length; | 806 | 1.91k | lzo_uint max_lazy; | 807 | 1.91k | lzo_uint nice_length; | 808 | 1.91k | lzo_uint max_chain; | 809 | 1.91k | lzo_uint32_t flags; | 810 | 1.91k | } c[9] = { | 811 | | /* faster compression */ | 812 | 1.91k | { 0, 0, 0, 8, 4, 0 }, | 813 | 1.91k | { 0, 0, 0, 16, 8, 0 }, | 814 | 1.91k | { 0, 0, 0, 32, 16, 0 }, | 815 | 1.91k | { 1, 4, 4, 16, 16, 0 }, | 816 | 1.91k | { 1, 8, 16, 32, 32, 0 }, | 817 | 1.91k | { 1, 8, 16, 128, 128, 0 }, | 818 | 1.91k | { 2, 8, 32, 128, 256, 0 }, | 819 | 1.91k | { 2, 32, 128, SWD_F, 2048, 1 }, | 820 | 1.91k | { 2, SWD_F, SWD_F, SWD_F, 4096, 1 } | 821 | | /* max. compression */ | 822 | 1.91k | }; | 823 | | | 824 | 1.91k | if (compression_level < 1 || compression_level > 9) | 825 | 0 | return LZO_E_ERROR; | 826 | | | 827 | 1.91k | compression_level -= 1; | 828 | 1.91k | return lzo1x_999_compress_internal(in, in_len, out, out_len, wrkmem, | 829 | 1.91k | dict, dict_len, cb, | 830 | 1.91k | c[compression_level].try_lazy_parm, | 831 | 1.91k | c[compression_level].good_length, | 832 | 1.91k | c[compression_level].max_lazy, | 833 | | #if 0 | 834 | | c[compression_level].nice_length, | 835 | | #else | 836 | 1.91k | 0, | 837 | 1.91k | #endif | 838 | 1.91k | c[compression_level].max_chain, | 839 | 1.91k | c[compression_level].flags); | 840 | 1.91k | } |
|
841 | | |
842 | | |
843 | | /*********************************************************************** |
844 | | // |
845 | | ************************************************************************/ |
846 | | |
847 | | LZO_PUBLIC(int) |
848 | | lzo1x_999_compress_dict ( const lzo_bytep in , lzo_uint in_len, |
849 | | lzo_bytep out, lzo_uintp out_len, |
850 | | lzo_voidp wrkmem, |
851 | | const lzo_bytep dict, lzo_uint dict_len ) |
852 | 0 | { |
853 | 0 | return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem, |
854 | 0 | dict, dict_len, 0, 8); |
855 | 0 | } Unexecuted instantiation: lzo1x_999_compress_dict Unexecuted instantiation: lzo1y_999_compress_dict Unexecuted instantiation: lzo1z_999_compress_dict |
856 | | |
857 | | LZO_PUBLIC(int) |
858 | | lzo1x_999_compress ( const lzo_bytep in , lzo_uint in_len, |
859 | | lzo_bytep out, lzo_uintp out_len, |
860 | | lzo_voidp wrkmem ) |
861 | 5.11k | { |
862 | 5.11k | return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem, |
863 | 5.11k | NULL, 0, (lzo_callback_p) 0, 8); |
864 | 5.11k | } Line | Count | Source | 861 | 1.60k | { | 862 | 1.60k | return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem, | 863 | 1.60k | NULL, 0, (lzo_callback_p) 0, 8); | 864 | 1.60k | } |
Line | Count | Source | 861 | 1.60k | { | 862 | 1.60k | return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem, | 863 | 1.60k | NULL, 0, (lzo_callback_p) 0, 8); | 864 | 1.60k | } |
Line | Count | Source | 861 | 1.91k | { | 862 | 1.91k | return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem, | 863 | 1.91k | NULL, 0, (lzo_callback_p) 0, 8); | 864 | 1.91k | } |
|
865 | | |
866 | | |
867 | | /* vim:set ts=4 sw=4 et: */ |