Coverage Report

Created: 2024-05-21 06:11

/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
}
lzo1x_9x.c:code_match
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
}
lzo1y_9x.c:code_match
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
}
lzo1z_9x.c:code_match
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
}
lzo1x_9x.c:STORE_RUN
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
}
lzo1y_9x.c:STORE_RUN
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
}
lzo1z_9x.c:STORE_RUN
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
}
lzo1x_9x.c:code_run
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
}
lzo1y_9x.c:code_run
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
}
lzo1z_9x.c:code_run
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
}
lzo1x_9x.c:min_gain
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
}
lzo1y_9x.c:min_gain
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
}
lzo1z_9x.c:min_gain
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
}
lzo1x_9x.c:better_match
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
}
lzo1y_9x.c:better_match
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
}
lzo1z_9x.c:better_match
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
}
lzo1x_999_compress_level
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
}
lzo1y_999_compress_level
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
}
lzo1z_999_compress_level
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
}
lzo1x_999_compress
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
}
lzo1y_999_compress
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
}
lzo1z_999_compress
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: */