lzoruby 0.1.0

data/ext/lzo_util.c

@@ -0,0 +1,165 @@
+/* lzo_util.c -- utilities for the LZO library
+
+   This file is part of the LZO real-time data compression library.
+
+   Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996 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/
+ */
+
+
+#include "lzo_conf.h"
+
+
+/***********************************************************************
+//
+************************************************************************/
+
+/* If you use the LZO library in a product, I would appreciate that you
+ * keep this copyright string in the executable of your product.
+.*/
+
+const char __lzo_copyright[] =
+#if !defined(__LZO_IN_MINLZO)
+    /* save space as some people want a really small decompressor */
+    LZO_VERSION_STRING;
+#else
+    "\r\n\n"
+    "LZO data compression library.\n"
+    "$Copyright: LZO (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Markus Franz Xaver Johannes Oberhumer\n"
+    "<markus@oberhumer.com>\n"
+    "http://www.oberhumer.com $\n\n"
+    "$Id: LZO version: v" LZO_VERSION_STRING ", " LZO_VERSION_DATE " $\n"
+    "$Built: " __DATE__ " " __TIME__ " $\n"
+    "$Info: " LZO_INFO_STRING " $\n";
+#endif
+
+
+LZO_PUBLIC(const lzo_bytep)
+lzo_copyright(void)
+{
+#if (LZO_OS_DOS16 && LZO_CC_TURBOC)
+    return (lzo_voidp) __lzo_copyright;
+#else
+    return (const lzo_bytep) __lzo_copyright;
+#endif
+}
+
+LZO_PUBLIC(unsigned)
+lzo_version(void)
+{
+    return LZO_VERSION;
+}
+
+LZO_PUBLIC(const char *)
+lzo_version_string(void)
+{
+    return LZO_VERSION_STRING;
+}
+
+LZO_PUBLIC(const char *)
+lzo_version_date(void)
+{
+    return LZO_VERSION_DATE;
+}
+
+LZO_PUBLIC(const lzo_charp)
+_lzo_version_string(void)
+{
+    return LZO_VERSION_STRING;
+}
+
+LZO_PUBLIC(const lzo_charp)
+_lzo_version_date(void)
+{
+    return LZO_VERSION_DATE;
+}
+
+
+/***********************************************************************
+// adler32 checksum
+// adapted from free code by Mark Adler <madler@alumni.caltech.edu>
+// see http://www.zlib.org/
+************************************************************************/
+
+#define LZO_BASE 65521u /* largest prime smaller than 65536 */
+#define LZO_NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define LZO_DO1(buf,i)  s1 += buf[i]; s2 += s1
+#define LZO_DO2(buf,i)  LZO_DO1(buf,i); LZO_DO1(buf,i+1);
+#define LZO_DO4(buf,i)  LZO_DO2(buf,i); LZO_DO2(buf,i+2);
+#define LZO_DO8(buf,i)  LZO_DO4(buf,i); LZO_DO4(buf,i+4);
+#define LZO_DO16(buf,i) LZO_DO8(buf,i); LZO_DO8(buf,i+8);
+
+LZO_PUBLIC(lzo_uint32)
+lzo_adler32(lzo_uint32 adler, const lzo_bytep buf, lzo_uint len)
+{
+    lzo_uint32 s1 = adler & 0xffff;
+    lzo_uint32 s2 = (adler >> 16) & 0xffff;
+    unsigned k;
+
+    if (buf == NULL)
+        return 1;
+
+    while (len > 0)
+    {
+        k = len < LZO_NMAX ? (unsigned) len : LZO_NMAX;
+        len -= k;
+        if (k >= 16) do
+        {
+            LZO_DO16(buf,0);
+            buf += 16;
+            k -= 16;
+        } while (k >= 16);
+        if (k != 0) do
+        {
+            s1 += *buf++;
+            s2 += s1;
+        } while (--k > 0);
+        s1 %= LZO_BASE;
+        s2 %= LZO_BASE;
+    }
+    return (s2 << 16) | s1;
+}
+
+#undef LZO_DO1
+#undef LZO_DO2
+#undef LZO_DO4
+#undef LZO_DO8
+#undef LZO_DO16
+
+
+/*
+vi:ts=4:et
+*/

data/ext/lzoruby.c

@@ -0,0 +1,149 @@
+/* 
+ Ruby bindings for LZO.
+ LZO is a portable lossless data compression library written in ANSI C.
+
+ Copyright (C) 2008 SUGAWARA Genki <sgwr_dts@yahoo.co.jp>
+*/
+
+#ifdef _WIN32
+__declspec(dllexport) void Init_lzoruby(void);
+#endif
+
+#include "lzo/lzoconf.h"
+#include "lzo/lzo1x.h"
+#include "ruby.h"
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#define VERSION "0.1.0"
+
+static VALUE LZO;
+static VALUE LZO_Error;
+
+/* */
+static VALUE lzoruby_compress(int argc, const VALUE *argv, VALUE self) {
+  const lzo_bytep in;
+  lzo_bytep out;
+  lzo_voidp wrkmem = NULL;
+  lzo_uint in_len;
+  lzo_uint out_len;
+  lzo_uint new_len;
+  VALUE v_in, v_out, v_level;
+  int level, err;
+
+  rb_scan_args(argc, argv, "11", &v_in, &v_level);
+  Check_Type(v_in, T_STRING);
+  level = NIL_P(v_level) ? 1 : NUM2INT(v_level);
+
+  in = RSTRING_PTR(v_in);
+  in_len = RSTRING_LEN(v_in);
+  out_len = in_len + in_len / 64 + 16 + 3;
+  out = xmalloc(5 + out_len);
+  new_len = out_len;
+  wrkmem = xmalloc((level == 1) ? LZO1X_1_MEM_COMPRESS : LZO1X_999_MEM_COMPRESS);
+
+  if (level == 1) {
+    out[0] = 0xf0;
+    err = lzo1x_1_compress(in, in_len, out + 5, &new_len, wrkmem);
+  } else {
+    out[0] = 0xf1;
+    err = lzo1x_999_compress(in, in_len, out + 5, &new_len, wrkmem);
+  }
+
+  xfree(wrkmem);
+
+  if (err != LZO_E_OK || new_len > out_len) {
+    xfree(out);
+    rb_raise(LZO_Error, "Error %d while compressing data", err);
+  }
+
+  out[1] = (unsigned char) ((in_len >> 24) & 0xff);
+  out[2] = (unsigned char) ((in_len >> 16) & 0xff);
+  out[3] = (unsigned char) ((in_len >>  8) & 0xff);
+  out[4] = (unsigned char) ((in_len >>  0) & 0xff);
+  v_out = rb_str_new(out, 5 + new_len);
+  xfree(out);
+
+  return v_out;
+}
+
+/* */
+static VALUE lzoruby_decompress(VALUE self, VALUE v_in) {
+  lzo_bytep in;
+  lzo_bytep out;
+  lzo_uint in_len;
+  lzo_uint out_len;
+  lzo_uint new_len;
+  VALUE v_out;
+  int err;
+
+  Check_Type(v_in, T_STRING);
+
+  in = RSTRING_PTR(v_in);
+  in_len = RSTRING_LEN(v_in);
+
+  if (((int) in_len) < 5 + 3 || in[0] < 0xf0 || in[0] > 0xf1) {
+    rb_raise(LZO_Error, "Header error - invalid compressed data");
+  }
+
+  in_len -= 5;
+  out_len = (in[1] << 24) | (in[2] << 16) | (in[3] << 8) | in[4];
+
+  if (((int) out_len) < 0 || in_len > out_len + out_len / 64 + 16 + 3) {
+    rb_raise(LZO_Error, "Header error - invalid compressed data");
+  }
+
+  out = xmalloc(out_len);
+  new_len = out_len;
+
+  err = lzo1x_decompress_safe(in + 5, in_len, out, &new_len, NULL);
+
+  if (err != LZO_E_OK || new_len != out_len) {
+    xfree(out);
+    rb_raise(LZO_Error, "Compressed data violation %d", err);
+  }
+
+  v_out = rb_str_new(out, new_len);
+  xfree(out);
+
+  return v_out;
+}
+
+/* */
+static VALUE lzoruby_adler32(VALUE self, VALUE v_adler, VALUE v_buf) {
+  lzo_uint32 adler;
+  lzo_bytep buf;
+  lzo_uint len;
+
+  Check_Type(v_adler, T_FIXNUM);
+  Check_Type(v_buf, T_STRING);
+  adler = FIX2LONG(v_adler);
+  buf = RSTRING_PTR(v_buf);
+  len = RSTRING_LEN(v_buf);
+
+  adler = lzo_adler32(adler, buf, len);
+
+  return LONG2FIX(adler);
+}
+
+void Init_lzoruby() {
+  if (lzo_init() != LZO_E_OK) {
+    rb_warn("internal error - lzo_init() failed !!!");
+    return;
+  }
+
+  LZO = rb_define_module("LZO");
+  LZO_Error = rb_define_class_under(LZO, "Error", rb_eStandardError);
+
+  rb_define_const(LZO, "VERSION", rb_str_new2(VERSION));
+  rb_define_const(LZO, "LZO_VERSION", rb_str_new2(lzo_version_string()));
+  rb_define_module_function(LZO, "compress", lzoruby_compress, -1);
+  rb_define_module_function(LZO, "decompress", lzoruby_decompress, 1);
+  rb_define_module_function(LZO, "adler32", lzoruby_adler32, 2);
+}