release/src/router/lzo/lzotest/wrap.h

   1 /* wrap.h -- wrapper functions
   2
   3    This file is part of the LZO real-time data compression library.
   4
   5    Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer
   6    Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer
   7    Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer
   8    Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
   9    Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
  10    Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
  11    Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
  12    Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
  13    Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
  14    Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
  15    Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
  16    Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
  17    Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
  18    Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
  19    Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
  20    Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer
  21    All Rights Reserved.
  22
  23    The LZO library is free software; you can redistribute it and/or
  24    modify it under the terms of the GNU General Public License as
  25    published by the Free Software Foundation; either version 2 of
  26    the License, or (at your option) any later version.
  27
  28    The LZO library is distributed in the hope that it will be useful,
  29    but WITHOUT ANY WARRANTY; without even the implied warranty of
  30    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  31    GNU General Public License for more details.
  32
  33    You should have received a copy of the GNU General Public License
  34    along with the LZO library; see the file COPYING.
  35    If not, write to the Free Software Foundation, Inc.,
  36    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  37
  38    Markus F.X.J. Oberhumer
  39    <markus@oberhumer.com>
  40    http://www.oberhumer.com/opensource/lzo/
  41  */
  42
  43
  44 /*************************************************************************
  45 // compression levels of LZO1X-999 and LZO1Y-999
  46 **************************************************************************/
  47
  48 #if defined(HAVE_LZO1X_H)
  49
  50 LZO_PRIVATE(int)
  51 lzo1x_999_1_compress    ( const lzo_bytep src, lzo_uint  src_len,
  52                                 lzo_bytep dst, lzo_uintp dst_len,
  53                                 lzo_voidp wrkmem )
  54 {
  55     return lzo1x_999_compress_level(src, src_len, dst, dst_len, wrkmem,
  56                                     dict.ptr, dict.len, 0, 1);
  57 }
  58
  59 LZO_PRIVATE(int)
  60 lzo1x_999_2_compress    ( const lzo_bytep src, lzo_uint  src_len,
  61                                 lzo_bytep dst, lzo_uintp dst_len,
  62                                 lzo_voidp wrkmem )
  63 {
  64     return lzo1x_999_compress_level(src, src_len, dst, dst_len, wrkmem,
  65                                     dict.ptr, dict.len, 0, 2);
  66 }
  67
  68 LZO_PRIVATE(int)
  69 lzo1x_999_3_compress    ( const lzo_bytep src, lzo_uint  src_len,
  70                                 lzo_bytep dst, lzo_uintp dst_len,
  71                                 lzo_voidp wrkmem )
  72 {
  73     return lzo1x_999_compress_level(src, src_len, dst, dst_len, wrkmem,
  74                                     dict.ptr, dict.len, 0, 3);
  75 }
  76
  77 LZO_PRIVATE(int)
  78 lzo1x_999_4_compress    ( const lzo_bytep src, lzo_uint  src_len,
  79                                 lzo_bytep dst, lzo_uintp dst_len,
  80                                 lzo_voidp wrkmem )
  81 {
  82     return lzo1x_999_compress_level(src, src_len, dst, dst_len, wrkmem,
  83                                     dict.ptr, dict.len, 0, 4);
  84 }
  85
  86 LZO_PRIVATE(int)
  87 lzo1x_999_5_compress    ( const lzo_bytep src, lzo_uint  src_len,
  88                                 lzo_bytep dst, lzo_uintp dst_len,
  89                                 lzo_voidp wrkmem )
  90 {
  91     return lzo1x_999_compress_level(src, src_len, dst, dst_len, wrkmem,
  92                                     dict.ptr, dict.len, 0, 5);
  93 }
  94
  95 LZO_PRIVATE(int)
  96 lzo1x_999_6_compress    ( const lzo_bytep src, lzo_uint  src_len,
  97                                 lzo_bytep dst, lzo_uintp dst_len,
  98                                 lzo_voidp wrkmem )
  99 {
 100     return lzo1x_999_compress_level(src, src_len, dst, dst_len, wrkmem,
 101                                     dict.ptr, dict.len, 0, 6);
 102 }
 103
 104 LZO_PRIVATE(int)
 105 lzo1x_999_7_compress    ( const lzo_bytep src, lzo_uint  src_len,
 106                                 lzo_bytep dst, lzo_uintp dst_len,
 107                                 lzo_voidp wrkmem )
 108 {
 109     return lzo1x_999_compress_level(src, src_len, dst, dst_len, wrkmem,
 110                                     dict.ptr, dict.len, 0, 7);
 111 }
 112
 113 LZO_PRIVATE(int)
 114 lzo1x_999_8_compress    ( const lzo_bytep src, lzo_uint  src_len,
 115                                 lzo_bytep dst, lzo_uintp dst_len,
 116                                 lzo_voidp wrkmem )
 117 {
 118     return lzo1x_999_compress_level(src, src_len, dst, dst_len, wrkmem,
 119                                     dict.ptr, dict.len, 0, 8);
 120 }
 121
 122 LZO_PRIVATE(int)
 123 lzo1x_999_9_compress    ( const lzo_bytep src, lzo_uint  src_len,
 124                                 lzo_bytep dst, lzo_uintp dst_len,
 125                                 lzo_voidp wrkmem )
 126 {
 127     return lzo1x_999_compress_level(src, src_len, dst, dst_len, wrkmem,
 128                                     dict.ptr, dict.len, 0, 9);
 129 }
 130
 131 #endif
 132
 133
 134 #if defined(HAVE_LZO1Y_H)
 135
 136 LZO_PRIVATE(int)
 137 lzo1y_999_1_compress    ( const lzo_bytep src, lzo_uint  src_len,
 138                                 lzo_bytep dst, lzo_uintp dst_len,
 139                                 lzo_voidp wrkmem )
 140 {
 141     return lzo1y_999_compress_level(src, src_len, dst, dst_len, wrkmem,
 142                                     dict.ptr, dict.len, 0, 1);
 143 }
 144
 145 LZO_PRIVATE(int)
 146 lzo1y_999_2_compress    ( const lzo_bytep src, lzo_uint  src_len,
 147                                 lzo_bytep dst, lzo_uintp dst_len,
 148                                 lzo_voidp wrkmem )
 149 {
 150     return lzo1y_999_compress_level(src, src_len, dst, dst_len, wrkmem,
 151                                     dict.ptr, dict.len, 0, 2);
 152 }
 153
 154 LZO_PRIVATE(int)
 155 lzo1y_999_3_compress    ( const lzo_bytep src, lzo_uint  src_len,
 156                                 lzo_bytep dst, lzo_uintp dst_len,
 157                                 lzo_voidp wrkmem )
 158 {
 159     return lzo1y_999_compress_level(src, src_len, dst, dst_len, wrkmem,
 160                                     dict.ptr, dict.len, 0, 3);
 161 }
 162
 163 LZO_PRIVATE(int)
 164 lzo1y_999_4_compress    ( const lzo_bytep src, lzo_uint  src_len,
 165                                 lzo_bytep dst, lzo_uintp dst_len,
 166                                 lzo_voidp wrkmem )
 167 {
 168     return lzo1y_999_compress_level(src, src_len, dst, dst_len, wrkmem,
 169                                     dict.ptr, dict.len, 0, 4);
 170 }
 171
 172 LZO_PRIVATE(int)
 173 lzo1y_999_5_compress    ( const lzo_bytep src, lzo_uint  src_len,
 174                                 lzo_bytep dst, lzo_uintp dst_len,
 175                                 lzo_voidp wrkmem )
 176 {
 177     return lzo1y_999_compress_level(src, src_len, dst, dst_len, wrkmem,
 178                                     dict.ptr, dict.len, 0, 5);
 179 }
 180
 181 LZO_PRIVATE(int)
 182 lzo1y_999_6_compress    ( const lzo_bytep src, lzo_uint  src_len,
 183                                 lzo_bytep dst, lzo_uintp dst_len,
 184                                 lzo_voidp wrkmem )
 185 {
 186     return lzo1y_999_compress_level(src, src_len, dst, dst_len, wrkmem,
 187                                     dict.ptr, dict.len, 0, 6);
 188 }
 189
 190 LZO_PRIVATE(int)
 191 lzo1y_999_7_compress    ( const lzo_bytep src, lzo_uint  src_len,
 192                                 lzo_bytep dst, lzo_uintp dst_len,
 193                                 lzo_voidp wrkmem )
 194 {
 195     return lzo1y_999_compress_level(src, src_len, dst, dst_len, wrkmem,
 196                                     dict.ptr, dict.len, 0, 7);
 197 }
 198
 199 LZO_PRIVATE(int)
 200 lzo1y_999_8_compress    ( const lzo_bytep src, lzo_uint  src_len,
 201                                 lzo_bytep dst, lzo_uintp dst_len,
 202                                 lzo_voidp wrkmem )
 203 {
 204     return lzo1y_999_compress_level(src, src_len, dst, dst_len, wrkmem,
 205                                     dict.ptr, dict.len, 0, 8);
 206 }
 207
 208 LZO_PRIVATE(int)
 209 lzo1y_999_9_compress    ( const lzo_bytep src, lzo_uint  src_len,
 210                                 lzo_bytep dst, lzo_uintp dst_len,
 211                                 lzo_voidp wrkmem )
 212 {
 213     return lzo1y_999_compress_level(src, src_len, dst, dst_len, wrkmem,
 214                                     dict.ptr, dict.len, 0, 9);
 215 }
 216
 217 #endif
 218
 219
 220 /*************************************************************************
 221 // other wrappers (pseudo compressors)
 222 **************************************************************************/
 223
 224 LZO_PRIVATE(int)
 225 memcpy_x_compress       ( const lzo_bytep src, lzo_uint  src_len,
 226                                 lzo_bytep dst, lzo_uintp dst_len,
 227                                 lzo_voidp wrkmem )
 228 {
 229     lzo_memcpy(dst,src,src_len);
 230     *dst_len = src_len;
 231     if (wrkmem) wrkmem = 0; /* avoid warning */
 232     return 0;
 233 }
 234
 235
 236 LZO_PRIVATE(int)
 237 memset_x_compress       ( const lzo_bytep src, lzo_uint  src_len,
 238                                 lzo_bytep dst, lzo_uintp dst_len,
 239                                 lzo_voidp wrkmem )
 240 {
 241     lzo_memset(dst,0,src_len);
 242     *dst_len = src_len;
 243     if (src) src = 0;       /* avoid warning */
 244     if (wrkmem) wrkmem = 0; /* avoid warning */
 245     return 0;
 246 }
 247
 248
 249 LZO_PRIVATE(int)
 250 adler32_x_compress      ( const lzo_bytep src, lzo_uint  src_len,
 251                                 lzo_bytep dst, lzo_uintp dst_len,
 252                                 lzo_voidp wrkmem )
 253 {
 254     lzo_uint32 adler;
 255     adler = lzo_adler32(0, NULL, 0);
 256     adler = lzo_adler32(adler, dst, src_len);
 257     *dst_len = src_len;
 258     if (src) src = 0;       /* avoid warning */
 259     if (wrkmem) wrkmem = 0; /* avoid warning */
 260     return 0;
 261 }
 262
 263
 264 LZO_PRIVATE(int)
 265 crc32_x_compress        ( const lzo_bytep src, lzo_uint  src_len,
 266                                 lzo_bytep dst, lzo_uintp dst_len,
 267                                 lzo_voidp wrkmem )
 268 {
 269     lzo_uint32 crc;
 270     crc = lzo_crc32(0, NULL, 0);
 271     crc = lzo_crc32(crc, dst, src_len);
 272     *dst_len = src_len;
 273     if (src) src = 0;       /* avoid warning */
 274     if (wrkmem) wrkmem = 0; /* avoid warning */
 275     return 0;
 276 }
 277
 278
 279 #if defined(__LZO_PROFESSIONAL__)
 280 #  include "lzopro/t_wrap.ch"
 281 #endif
 282
 283
 284 /*
 285 vi:ts=4:et
 286 */
 287