| /* lzo1x_9x.c -- implementation of the LZO1X-999 compression algorithm |
| |
| This file is part of the LZO real-time data compression library. |
| |
| Copyright (C) 1996-2014 Markus Franz Xaver Johannes Oberhumer |
| All Rights Reserved. |
| |
| The LZO library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU General Public License as |
| published by the Free Software Foundation; either version 2 of |
| the License, or (at your option) any later version. |
| |
| The LZO library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with the LZO library; see the file COPYING. |
| If not, write to the Free Software Foundation, Inc., |
| 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
| |
| Markus F.X.J. Oberhumer |
| <markus@oberhumer.com> |
| http://www.oberhumer.com/opensource/lzo/ |
| */ |
| |
| |
| #if !defined(LZO1X) && !defined(LZO1Y) && !defined(LZO1Z) |
| # define LZO1X 1 |
| #endif |
| |
| #if defined(LZO1X) |
| # include "config1x.h" |
| #elif defined(LZO1Y) |
| # include "config1y.h" |
| #elif defined(LZO1Z) |
| # include "config1z.h" |
| #else |
| # error |
| #endif |
| |
| |
| /*********************************************************************** |
| // |
| ************************************************************************/ |
| |
| #define SWD_N M4_MAX_OFFSET /* size of ring buffer */ |
| #define SWD_THRESHOLD 1 /* lower limit for match length */ |
| #define SWD_F 2048 /* upper limit for match length */ |
| |
| #define SWD_BEST_OFF (LZO_MAX3( M2_MAX_LEN, M3_MAX_LEN, M4_MAX_LEN ) + 1) |
| |
| #if defined(LZO1X) |
| # define LZO_COMPRESS_T lzo1x_999_t |
| # define lzo_swd_t lzo1x_999_swd_t |
| #elif defined(LZO1Y) |
| # define LZO_COMPRESS_T lzo1y_999_t |
| # define lzo_swd_t lzo1y_999_swd_t |
| # define lzo1x_999_compress_internal lzo1y_999_compress_internal |
| # define lzo1x_999_compress_dict lzo1y_999_compress_dict |
| # define lzo1x_999_compress_level lzo1y_999_compress_level |
| # define lzo1x_999_compress lzo1y_999_compress |
| #elif defined(LZO1Z) |
| # define LZO_COMPRESS_T lzo1z_999_t |
| # define lzo_swd_t lzo1z_999_swd_t |
| # define lzo1x_999_compress_internal lzo1z_999_compress_internal |
| # define lzo1x_999_compress_dict lzo1z_999_compress_dict |
| # define lzo1x_999_compress_level lzo1z_999_compress_level |
| # define lzo1x_999_compress lzo1z_999_compress |
| #else |
| # error |
| #endif |
| |
| #if 0 |
| # define HEAD3(b,p) \ |
| ((((((lzo_xint)b[p]<<3)^b[p+1])<<3)^b[p+2]) & (SWD_HSIZE-1)) |
| #endif |
| #if 0 && (LZO_OPT_UNALIGNED32) && (LZO_ABI_LITTLE_ENDIAN) |
| # define HEAD3(b,p) \ |
| (((* (lzo_uint32_tp) &b[p]) ^ ((* (lzo_uint32_tp) &b[p])>>10)) & (SWD_HSIZE-1)) |
| #endif |
| |
| #include "lzo_mchw.ch" |
| |
| |
| /* this is a public functions, but there is no prototype in a header file */ |
| LZO_EXTERN(int) |
| lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, |
| lzo_bytep out, lzo_uintp out_len, |
| lzo_voidp wrkmem, |
| const lzo_bytep dict, lzo_uint dict_len, |
| lzo_callback_p cb, |
| int try_lazy_parm, |
| lzo_uint good_length, |
| lzo_uint max_lazy, |
| lzo_uint nice_length, |
| lzo_uint max_chain, |
| lzo_uint32_t flags ); |
| |
| |
| /*********************************************************************** |
| // |
| ************************************************************************/ |
| |
| static lzo_bytep |
| code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) |
| { |
| lzo_uint x_len = m_len; |
| lzo_uint x_off = m_off; |
| |
| c->match_bytes += (unsigned long) m_len; |
| |
| #if 0 |
| /* |
| static lzo_uint last_m_len = 0, last_m_off = 0; |
| static lzo_uint prev_m_off[4]; |
| static unsigned prev_m_off_ptr = 0; |
| unsigned i; |
| |
| //if (m_len >= 3 && m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) |
| if (m_len >= 3 && m_len <= M2_MAX_LEN) |
| { |
| //if (m_len == last_m_len && m_off == last_m_off) |
| //printf("last_m_len + last_m_off\n"); |
| //else |
| if (m_off == last_m_off) |
| printf("last_m_off\n"); |
| else |
| { |
| for (i = 0; i < 4; i++) |
| if (m_off == prev_m_off[i]) |
| printf("prev_m_off %u: %5ld\n",i,(long)m_off); |
| } |
| } |
| last_m_len = m_len; |
| last_m_off = prev_m_off[prev_m_off_ptr] = m_off; |
| prev_m_off_ptr = (prev_m_off_ptr + 1) & 3; |
| */ |
| #endif |
| |
| assert(op > c->out); |
| if (m_len == 2) |
| { |
| assert(m_off <= M1_MAX_OFFSET); |
| assert(c->r1_lit > 0); assert(c->r1_lit < 4); |
| m_off -= 1; |
| #if defined(LZO1Z) |
| *op++ = LZO_BYTE(M1_MARKER | (m_off >> 6)); |
| *op++ = LZO_BYTE(m_off << 2); |
| #else |
| *op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2)); |
| *op++ = LZO_BYTE(m_off >> 2); |
| #endif |
| c->m1a_m++; |
| } |
| #if defined(LZO1Z) |
| else if (m_len <= M2_MAX_LEN && (m_off <= M2_MAX_OFFSET || m_off == c->last_m_off)) |
| #else |
| else if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) |
| #endif |
| { |
| assert(m_len >= 3); |
| #if defined(LZO1X) |
| m_off -= 1; |
| *op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2)); |
| *op++ = LZO_BYTE(m_off >> 3); |
| assert(op[-2] >= M2_MARKER); |
| #elif defined(LZO1Y) |
| m_off -= 1; |
| *op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2)); |
| *op++ = LZO_BYTE(m_off >> 2); |
| assert(op[-2] >= M2_MARKER); |
| #elif defined(LZO1Z) |
| if (m_off == c->last_m_off) |
| *op++ = LZO_BYTE(((m_len - 1) << 5) | (0x700 >> 6)); |
| else |
| { |
| m_off -= 1; |
| *op++ = LZO_BYTE(((m_len - 1) << 5) | (m_off >> 6)); |
| *op++ = LZO_BYTE(m_off << 2); |
| } |
| #endif |
| c->m2_m++; |
| } |
| else if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && c->r1_lit >= 4) |
| { |
| assert(m_len == 3); |
| assert(m_off > M2_MAX_OFFSET); |
| m_off -= 1 + M2_MAX_OFFSET; |
| #if defined(LZO1Z) |
| *op++ = LZO_BYTE(M1_MARKER | (m_off >> 6)); |
| *op++ = LZO_BYTE(m_off << 2); |
| #else |
| *op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2)); |
| *op++ = LZO_BYTE(m_off >> 2); |
| #endif |
| c->m1b_m++; |
| } |
| else if (m_off <= M3_MAX_OFFSET) |
| { |
| assert(m_len >= 3); |
| m_off -= 1; |
| if (m_len <= M3_MAX_LEN) |
| *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); |
| else |
| { |
| m_len -= M3_MAX_LEN; |
| *op++ = M3_MARKER | 0; |
| while (m_len > 255) |
| { |
| m_len -= 255; |
| *op++ = 0; |
| } |
| assert(m_len > 0); |
| *op++ = LZO_BYTE(m_len); |
| } |
| #if defined(LZO1Z) |
| *op++ = LZO_BYTE(m_off >> 6); |
| *op++ = LZO_BYTE(m_off << 2); |
| #else |
| *op++ = LZO_BYTE(m_off << 2); |
| *op++ = LZO_BYTE(m_off >> 6); |
| #endif |
| c->m3_m++; |
| } |
| else |
| { |
| lzo_uint k; |
| |
| assert(m_len >= 3); |
| assert(m_off > 0x4000); assert(m_off <= 0xbfff); |
| m_off -= 0x4000; |
| k = (m_off & 0x4000) >> 11; |
| if (m_len <= M4_MAX_LEN) |
| *op++ = LZO_BYTE(M4_MARKER | k | (m_len - 2)); |
| else |
| { |
| m_len -= M4_MAX_LEN; |
| *op++ = LZO_BYTE(M4_MARKER | k | 0); |
| while (m_len > 255) |
| { |
| m_len -= 255; |
| *op++ = 0; |
| } |
| assert(m_len > 0); |
| *op++ = LZO_BYTE(m_len); |
| } |
| #if defined(LZO1Z) |
| *op++ = LZO_BYTE(m_off >> 6); |
| *op++ = LZO_BYTE(m_off << 2); |
| #else |
| *op++ = LZO_BYTE(m_off << 2); |
| *op++ = LZO_BYTE(m_off >> 6); |
| #endif |
| c->m4_m++; |
| } |
| |
| c->last_m_len = x_len; |
| c->last_m_off = x_off; |
| return op; |
| } |
| |
| |
| static lzo_bytep |
| STORE_RUN ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii, lzo_uint t ) |
| { |
| c->lit_bytes += (unsigned long) t; |
| |
| if (op == c->out && t <= 238) |
| { |
| *op++ = LZO_BYTE(17 + t); |
| } |
| else if (t <= 3) |
| { |
| #if defined(LZO1Z) |
| op[-1] = LZO_BYTE(op[-1] | t); |
| #else |
| op[-2] = LZO_BYTE(op[-2] | t); |
| #endif |
| c->lit1_r++; |
| } |
| else if (t <= 18) |
| { |
| *op++ = LZO_BYTE(t - 3); |
| c->lit2_r++; |
| } |
| else |
| { |
| lzo_uint tt = t - 18; |
| |
| *op++ = 0; |
| while (tt > 255) |
| { |
| tt -= 255; |
| *op++ = 0; |
| } |
| assert(tt > 0); |
| *op++ = LZO_BYTE(tt); |
| c->lit3_r++; |
| } |
| do *op++ = *ii++; while (--t > 0); |
| |
| return op; |
| } |
| |
| |
| static lzo_bytep |
| code_run ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii, |
| lzo_uint lit, lzo_uint m_len ) |
| { |
| if (lit > 0) |
| { |
| assert(m_len >= 2); |
| op = STORE_RUN(c,op,ii,lit); |
| c->r1_m_len = m_len; |
| c->r1_lit = lit; |
| } |
| else |
| { |
| assert(m_len >= 3); |
| c->r1_m_len = 0; |
| c->r1_lit = 0; |
| } |
| |
| return op; |
| } |
| |
| |
| /*********************************************************************** |
| // |
| ************************************************************************/ |
| |
| static lzo_uint |
| len_of_coded_match ( lzo_uint m_len, lzo_uint m_off, lzo_uint lit ) |
| { |
| lzo_uint n = 4; |
| |
| if (m_len < 2) |
| return 0; |
| if (m_len == 2) |
| return (m_off <= M1_MAX_OFFSET && lit > 0 && lit < 4) ? 2 : 0; |
| if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) |
| return 2; |
| if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && lit >= 4) |
| return 2; |
| if (m_off <= M3_MAX_OFFSET) |
| { |
| if (m_len <= M3_MAX_LEN) |
| return 3; |
| m_len -= M3_MAX_LEN; |
| while (m_len > 255) |
| { |
| m_len -= 255; |
| n++; |
| } |
| return n; |
| } |
| if (m_off <= M4_MAX_OFFSET) |
| { |
| if (m_len <= M4_MAX_LEN) |
| return 3; |
| m_len -= M4_MAX_LEN; |
| while (m_len > 255) |
| { |
| m_len -= 255; |
| n++; |
| } |
| return n; |
| } |
| return 0; |
| } |
| |
| |
| static lzo_uint |
| min_gain(lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, lzo_uint l1, lzo_uint l2, lzo_uint l3) |
| { |
| lzo_uint lazy_match_min_gain; |
| |
| assert (ahead >= 1); |
| lazy_match_min_gain = ahead; |
| |
| #if 0 |
| if (l3) |
| lit2 -= ahead; |
| #endif |
| |
| if (lit1 <= 3) |
| lazy_match_min_gain += (lit2 <= 3) ? 0 : 2; |
| else if (lit1 <= 18) |
| lazy_match_min_gain += (lit2 <= 18) ? 0 : 1; |
| |
| lazy_match_min_gain += (l2 - l1) * 2; |
| if (l3) |
| lazy_match_min_gain -= (ahead - l3) * 2; |
| |
| if ((lzo_int) lazy_match_min_gain < 0) |
| lazy_match_min_gain = 0; |
| |
| #if 0 |
| if (l1 == 2) |
| if (lazy_match_min_gain == 0) |
| lazy_match_min_gain = 1; |
| #endif |
| |
| return lazy_match_min_gain; |
| } |
| |
| |
| /*********************************************************************** |
| // |
| ************************************************************************/ |
| |
| #if !defined(NDEBUG) |
| static |
| void assert_match( const lzo_swd_p swd, lzo_uint m_len, lzo_uint m_off ) |
| { |
| const LZO_COMPRESS_T *c = swd->c; |
| lzo_uint d_off; |
| |
| assert(m_len >= 2); |
| if (m_off <= (lzo_uint) (c->bp - c->in)) |
| { |
| assert(c->bp - m_off + m_len < c->ip); |
| assert(lzo_memcmp(c->bp, c->bp - m_off, m_len) == 0); |
| } |
| else |
| { |
| assert(swd->dict != NULL); |
| d_off = m_off - (lzo_uint) (c->bp - c->in); |
| assert(d_off <= swd->dict_len); |
| if (m_len > d_off) |
| { |
| assert(lzo_memcmp(c->bp, swd->dict_end - d_off, d_off) == 0); |
| assert(c->in + m_len - d_off < c->ip); |
| assert(lzo_memcmp(c->bp + d_off, c->in, m_len - d_off) == 0); |
| } |
| else |
| { |
| assert(lzo_memcmp(c->bp, swd->dict_end - d_off, m_len) == 0); |
| } |
| } |
| } |
| #else |
| # define assert_match(a,b,c) ((void)0) |
| #endif |
| |
| |
| #if defined(SWD_BEST_OFF) |
| |
| static void |
| better_match ( const lzo_swd_p swd, lzo_uint *m_len, lzo_uint *m_off ) |
| { |
| #if defined(LZO1Z) |
| const LZO_COMPRESS_T *c = swd->c; |
| #endif |
| |
| if (*m_len <= M2_MIN_LEN) |
| return; |
| #if defined(LZO1Z) |
| if (*m_off == c->last_m_off && *m_len <= M2_MAX_LEN) |
| return; |
| #if 1 |
| if (*m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 && |
| c->last_m_off && swd->best_off[*m_len-1] == c->last_m_off) |
| { |
| *m_len = *m_len - 1; |
| *m_off = swd->best_off[*m_len]; |
| return; |
| } |
| #endif |
| #endif |
| |
| if (*m_off <= M2_MAX_OFFSET) |
| return; |
| |
| #if 1 |
| /* M3/M4 -> M2 */ |
| if (*m_off > M2_MAX_OFFSET && |
| *m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 && |
| swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M2_MAX_OFFSET) |
| { |
| *m_len = *m_len - 1; |
| *m_off = swd->best_off[*m_len]; |
| return; |
| } |
| #endif |
| |
| #if 1 |
| /* M4 -> M2 */ |
| if (*m_off > M3_MAX_OFFSET && |
| *m_len >= M4_MAX_LEN + 1 && *m_len <= M2_MAX_LEN + 2 && |
| swd->best_off[*m_len-2] && swd->best_off[*m_len-2] <= M2_MAX_OFFSET) |
| { |
| *m_len = *m_len - 2; |
| *m_off = swd->best_off[*m_len]; |
| return; |
| } |
| #endif |
| |
| #if 1 |
| /* M4 -> M3 */ |
| if (*m_off > M3_MAX_OFFSET && |
| *m_len >= M4_MAX_LEN + 1 && *m_len <= M3_MAX_LEN + 1 && |
| swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M3_MAX_OFFSET) |
| { |
| *m_len = *m_len - 1; |
| *m_off = swd->best_off[*m_len]; |
| } |
| #endif |
| } |
| |
| #endif |
| |
| |
| /*********************************************************************** |
| // |
| ************************************************************************/ |
| |
| LZO_PUBLIC(int) |
| lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, |
| lzo_bytep out, lzo_uintp out_len, |
| lzo_voidp wrkmem, |
| const lzo_bytep dict, lzo_uint dict_len, |
| lzo_callback_p cb, |
| int try_lazy_parm, |
| lzo_uint good_length, |
| lzo_uint max_lazy, |
| lzo_uint nice_length, |
| lzo_uint max_chain, |
| lzo_uint32_t flags ) |
| { |
| lzo_bytep op; |
| const lzo_bytep ii; |
| lzo_uint lit; |
| lzo_uint m_len, m_off; |
| LZO_COMPRESS_T cc; |
| LZO_COMPRESS_T * const c = &cc; |
| lzo_swd_p const swd = (lzo_swd_p) wrkmem; |
| lzo_uint try_lazy; |
| int r; |
| |
| /* sanity check */ |
| #if defined(LZO1X) |
| LZO_COMPILE_TIME_ASSERT(LZO1X_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) |
| #elif defined(LZO1Y) |
| LZO_COMPILE_TIME_ASSERT(LZO1Y_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) |
| #elif defined(LZO1Z) |
| LZO_COMPILE_TIME_ASSERT(LZO1Z_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T) |
| #else |
| # error |
| #endif |
| |
| /* setup parameter defaults */ |
| /* number of lazy match tries */ |
| try_lazy = (lzo_uint) try_lazy_parm; |
| if (try_lazy_parm < 0) |
| try_lazy = 1; |
| /* reduce lazy match search if we already have a match with this length */ |
| if (good_length == 0) |
| good_length = 32; |
| /* do not try a lazy match if we already have a match with this length */ |
| if (max_lazy == 0) |
| max_lazy = 32; |
| /* stop searching for longer matches than this one */ |
| if (nice_length == 0) |
| nice_length = 0; |
| /* don't search more positions than this */ |
| if (max_chain == 0) |
| max_chain = SWD_MAX_CHAIN; |
| |
| c->init = 0; |
| c->ip = c->in = in; |
| c->in_end = in + in_len; |
| c->out = out; |
| c->cb = cb; |
| c->m1a_m = c->m1b_m = c->m2_m = c->m3_m = c->m4_m = 0; |
| c->lit1_r = c->lit2_r = c->lit3_r = 0; |
| |
| op = out; |
| ii = c->ip; /* point to start of literal run */ |
| lit = 0; |
| c->r1_lit = c->r1_m_len = 0; |
| |
| r = init_match(c,swd,dict,dict_len,flags); |
| if (r != 0) |
| return r; |
| if (max_chain > 0) |
| swd->max_chain = max_chain; |
| if (nice_length > 0) |
| swd->nice_length = nice_length; |
| |
| r = find_match(c,swd,0,0); |
| if (r != 0) |
| return r; |
| while (c->look > 0) |
| { |
| lzo_uint ahead; |
| lzo_uint max_ahead; |
| lzo_uint l1, l2, l3; |
| |
| c->codesize = pd(op, out); |
| |
| m_len = c->m_len; |
| m_off = c->m_off; |
| |
| assert(c->bp == c->ip - c->look); |
| assert(c->bp >= in); |
| if (lit == 0) |
| ii = c->bp; |
| assert(ii + lit == c->bp); |
| assert(swd->b_char == *(c->bp)); |
| |
| if ( m_len < 2 || |
| (m_len == 2 && (m_off > M1_MAX_OFFSET || lit == 0 || lit >= 4)) || |
| #if 1 |
| /* Do not accept this match for compressed-data compatibility |
| * with LZO v1.01 and before |
| * [ might be a problem for decompress() and optimize() ] |
| */ |
| (m_len == 2 && op == out) || |
| #endif |
| (op == out && lit == 0)) |
| { |
| /* a literal */ |
| m_len = 0; |
| } |
| else if (m_len == M2_MIN_LEN) |
| { |
| /* compression ratio improves if we code a literal in some cases */ |
| if (m_off > MX_MAX_OFFSET && lit >= 4) |
| m_len = 0; |
| } |
| |
| if (m_len == 0) |
| { |
| /* a literal */ |
| lit++; |
| swd->max_chain = max_chain; |
| r = find_match(c,swd,1,0); |
| assert(r == 0); LZO_UNUSED(r); |
| continue; |
| } |
| |
| /* a match */ |
| #if defined(SWD_BEST_OFF) |
| if (swd->use_best_off) |
| better_match(swd,&m_len,&m_off); |
| #endif |
| assert_match(swd,m_len,m_off); |
| |
| |
| /* shall we try a lazy match ? */ |
| ahead = 0; |
| if (try_lazy == 0 || m_len >= max_lazy) |
| { |
| /* no */ |
| l1 = 0; |
| max_ahead = 0; |
| } |
| else |
| { |
| /* yes, try a lazy match */ |
| l1 = len_of_coded_match(m_len,m_off,lit); |
| assert(l1 > 0); |
| #if 1 |
| max_ahead = LZO_MIN(try_lazy, l1 - 1); |
| #else |
| max_ahead = LZO_MIN3(try_lazy, l1, m_len - 1); |
| #endif |
| } |
| |
| |
| while (ahead < max_ahead && c->look > m_len) |
| { |
| lzo_uint lazy_match_min_gain; |
| |
| if (m_len >= good_length) |
| swd->max_chain = max_chain >> 2; |
| else |
| swd->max_chain = max_chain; |
| r = find_match(c,swd,1,0); |
| ahead++; |
| |
| assert(r == 0); LZO_UNUSED(r); |
| assert(c->look > 0); |
| assert(ii + lit + ahead == c->bp); |
| |
| #if defined(LZO1Z) |
| if (m_off == c->last_m_off && c->m_off != c->last_m_off) |
| if (m_len >= M2_MIN_LEN && m_len <= M2_MAX_LEN) |
| c->m_len = 0; |
| #endif |
| if (c->m_len < m_len) |
| continue; |
| #if 1 |
| if (c->m_len == m_len && c->m_off >= m_off) |
| continue; |
| #endif |
| #if defined(SWD_BEST_OFF) |
| if (swd->use_best_off) |
| better_match(swd,&c->m_len,&c->m_off); |
| #endif |
| l2 = len_of_coded_match(c->m_len,c->m_off,lit+ahead); |
| if (l2 == 0) |
| continue; |
| #if 0 |
| if (c->m_len == m_len && l2 >= l1) |
| continue; |
| #endif |
| |
| |
| #if 1 |
| /* compressed-data compatibility [see above] */ |
| l3 = (op == out) ? 0 : len_of_coded_match(ahead,m_off,lit); |
| #else |
| l3 = len_of_coded_match(ahead,m_off,lit); |
| #endif |
| |
| lazy_match_min_gain = min_gain(ahead,lit,lit+ahead,l1,l2,l3); |
| if (c->m_len >= m_len + lazy_match_min_gain) |
| { |
| c->lazy++; |
| assert_match(swd,c->m_len,c->m_off); |
| |
| if (l3) |
| { |
| /* code previous run */ |
| op = code_run(c,op,ii,lit,ahead); |
| lit = 0; |
| /* code shortened match */ |
| op = code_match(c,op,ahead,m_off); |
| } |
| else |
| { |
| lit += ahead; |
| assert(ii + lit == c->bp); |
| } |
| goto lazy_match_done; |
| } |
| } |
| |
| |
| assert(ii + lit + ahead == c->bp); |
| |
| /* 1 - code run */ |
| op = code_run(c,op,ii,lit,m_len); |
| lit = 0; |
| |
| /* 2 - code match */ |
| op = code_match(c,op,m_len,m_off); |
| swd->max_chain = max_chain; |
| r = find_match(c,swd,m_len,1+ahead); |
| assert(r == 0); LZO_UNUSED(r); |
| |
| lazy_match_done: ; |
| } |
| |
| |
| /* store final run */ |
| if (lit > 0) |
| op = STORE_RUN(c,op,ii,lit); |
| |
| #if defined(LZO_EOF_CODE) |
| *op++ = M4_MARKER | 1; |
| *op++ = 0; |
| *op++ = 0; |
| #endif |
| |
| c->codesize = pd(op, out); |
| assert(c->textsize == in_len); |
| |
| *out_len = pd(op, out); |
| |
| if (c->cb && c->cb->nprogress) |
| (*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0); |
| |
| #if 0 |
| printf("%ld %ld -> %ld %ld: %ld %ld %ld %ld %ld %ld: %ld %ld %ld %ld\n", |
| (long) c->textsize, (long) in_len, (long) c->codesize, |
| c->match_bytes, c->m1a_m, c->m1b_m, c->m2_m, c->m3_m, c->m4_m, |
| c->lit_bytes, c->lit1_r, c->lit2_r, c->lit3_r, c->lazy); |
| #endif |
| assert(c->lit_bytes + c->match_bytes == in_len); |
| |
| return LZO_E_OK; |
| } |
| |
| |
| /*********************************************************************** |
| // |
| ************************************************************************/ |
| |
| LZO_PUBLIC(int) |
| lzo1x_999_compress_level ( const lzo_bytep in , lzo_uint in_len, |
| lzo_bytep out, lzo_uintp out_len, |
| lzo_voidp wrkmem, |
| const lzo_bytep dict, lzo_uint dict_len, |
| lzo_callback_p cb, |
| int compression_level ) |
| { |
| static const struct |
| { |
| int try_lazy_parm; |
| lzo_uint good_length; |
| lzo_uint max_lazy; |
| lzo_uint nice_length; |
| lzo_uint max_chain; |
| lzo_uint32_t flags; |
| } c[9] = { |
| /* faster compression */ |
| { 0, 0, 0, 8, 4, 0 }, |
| { 0, 0, 0, 16, 8, 0 }, |
| { 0, 0, 0, 32, 16, 0 }, |
| { 1, 4, 4, 16, 16, 0 }, |
| { 1, 8, 16, 32, 32, 0 }, |
| { 1, 8, 16, 128, 128, 0 }, |
| { 2, 8, 32, 128, 256, 0 }, |
| { 2, 32, 128, SWD_F, 2048, 1 }, |
| { 2, SWD_F, SWD_F, SWD_F, 4096, 1 } |
| /* max. compression */ |
| }; |
| |
| if (compression_level < 1 || compression_level > 9) |
| return LZO_E_ERROR; |
| |
| compression_level -= 1; |
| return lzo1x_999_compress_internal(in, in_len, out, out_len, wrkmem, |
| dict, dict_len, cb, |
| c[compression_level].try_lazy_parm, |
| c[compression_level].good_length, |
| c[compression_level].max_lazy, |
| #if 0 |
| c[compression_level].nice_length, |
| #else |
| 0, |
| #endif |
| c[compression_level].max_chain, |
| c[compression_level].flags); |
| } |
| |
| |
| /*********************************************************************** |
| // |
| ************************************************************************/ |
| |
| LZO_PUBLIC(int) |
| lzo1x_999_compress_dict ( const lzo_bytep in , lzo_uint in_len, |
| lzo_bytep out, lzo_uintp out_len, |
| lzo_voidp wrkmem, |
| const lzo_bytep dict, lzo_uint dict_len ) |
| { |
| return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem, |
| dict, dict_len, 0, 8); |
| } |
| |
| LZO_PUBLIC(int) |
| lzo1x_999_compress ( const lzo_bytep in , lzo_uint in_len, |
| lzo_bytep out, lzo_uintp out_len, |
| lzo_voidp wrkmem ) |
| { |
| return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem, |
| NULL, 0, (lzo_callback_p) 0, 8); |
| } |
| |
| |
| /* |
| vi:ts=4:et |
| */ |
| |
