lzfx 0.1.0

data/README.md

@@ -0,0 +1,33 @@
+# Ruby bindings for lzfx
+
+lzfx is a tiny, extremely fast compression library.
+
+## lzfx
+this gem contains lzfx.
+
+* http://code.google.com/p/lzfx/
+
+> LZFX is a small (one C file, 200 non-comment lines) BSD-licensed library designed for very-high-speed compression of redundant data. It is descended from liblzf and is 100% compatible with existing LZF-compressed data.
+
+> LZFX was originally developed as a component of the h5py project, which uses an LZF-based compressor to process scientific data.
+
+## Example
+
+    require 'rubygems'
+    require 'lzfxruby'
+
+    a = "aaaaaaaaabbbbbbbbbbbbabababaccccccccccjshabbbbbbaaa"
+    puts "source: #{a}"
+    puts "source size: #{a.size}"
+
+    b = Lzfx.compress a
+    puts "compressed: #{b}"
+    puts "compressed size: #{b.size}"
+
+    c = Lzfx.decompress b
+    puts "decompressed: #{c}"
+    puts "decompressed size: #{c.size}"
+    puts "source == decompressed: #{a == c}"
+
+## Copyright
+Copyright: (C) 2012 Kengo HAMASAKI <k.hamasaki@gmail.com>

data/ext/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile('lzfx')

data/ext/lzfx-util.c

@@ -0,0 +1,450 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include "lzfx.h"
+#include <errno.h>
+#include <stdint.h>
+
+#define BLOCKSIZE (1024*1024)
+
+typedef unsigned char u8;
+
+typedef enum {
+    MODE_COMPRESS,
+    MODE_DECOMPRESS
+} fx_mode_t;
+
+typedef enum {
+    KIND_FILEHEADER = 0,
+    KIND_COMPRESSED = 1,
+    KIND_UNCOMPRESSED = 2
+} fx_kind_t;
+
+typedef struct {
+    int ifd, ofd;
+    fx_mode_t mode;
+} FX_STATE;
+
+static
+void fx_init(FX_STATE *state, int ifd, int ofd, fx_mode_t mode){
+    state->ifd = ifd;
+    state->ofd = ofd;
+    state->mode = mode;
+}
+
+/*  Read len bytes from the input file.
+
+    buf:    Output buffer
+    len:    # bytes to read
+
+    >=0: bytes read, either 0 (EOF) or len
+     <0: Read error
+*/
+static inline
+int fx_read_bytes(const FX_STATE state, void* buf, const size_t len){
+
+    ssize_t rc = 0;
+    size_t count = 0;
+
+    do {
+        rc = read(state.ifd, ((u8*)buf)+count, len-count);
+        count += rc;
+    } while(rc>0 && count<len);
+
+    if(rc<0){
+        fprintf(stderr, "Read failed: %s\n", strerror(errno));
+        return -1;
+    }
+
+    if(count>0 && count!=len){
+        fprintf(stderr, "Read truncated (%u bytes short)\n", (unsigned int)(len-count));
+        return -1;
+    }
+    return count;
+}
+
+/*  Write len bytes from the buffer to the output file.
+
+    buf:    Input buffer
+    len:    # of bytes in buf
+    
+    >=0:    Bytes written
+     <0:    Write error
+*/
+static inline
+int fx_write_bytes(const FX_STATE state, const void* buf, const size_t len){
+
+    ssize_t rc = 0;
+    size_t count = 0;
+
+    do {
+        rc = write(state.ofd, ((u8*)buf)+count, len-count);
+        count += rc;
+    } while(rc>0 && count<len);
+
+    if(rc<0){
+        fprintf(stderr, "Write failed: %s\n", strerror(errno));
+        return -1;
+    }
+
+    return count;
+}
+
+/* Skip len bytes in the input file.
+
+    len:    # of bytes to skip
+
+      0:    Success
+     <0:    Read error
+*/
+static
+int fx_skip_bytes(const FX_STATE state, const size_t len){
+
+    off_t rc;
+
+    rc = lseek(state.ifd, len, SEEK_CUR);
+    if(rc==((off_t)-1)){
+        fprintf(stderr, "Read error: %s\n", strerror(errno));
+        return -1;
+    }
+
+    return 0;
+}
+
+/*  Read a header from the input stream.
+
+    kind_in:    Will contain the header kind
+    len_in:     Will contain the block length
+
+    >0:     Read success (10)
+     0:     EOF
+    <0:     Read error (message printed)
+*/
+static inline
+int fx_read_header(const FX_STATE state, fx_kind_t *kind_in, uint32_t *len_in){
+
+    int rc;
+    uint16_t kind;
+    uint32_t len;
+    u8 head[10];
+
+    rc = fx_read_bytes(state, head, 10);
+    if(rc<=0) return rc; /* 0 = EOF; <0 = already printed error */
+
+    if(head[0]!='L' || head[1]!='Z' || head[2]!='F' || head[3]!='X'){
+        fprintf(stderr, "Illegal header %X %X %X %X\n",
+                (int)head[0], (int)head[1], (int)head[2], (int)head[3]);
+        return -1;
+    }
+
+    kind = (head[4]<<8) | head[5];
+    len = (head[6]<<24) | (head[7]<<16) | (head[8]<<8) | head[9];
+
+    *kind_in = kind;
+    *len_in = len;
+
+    return rc;
+}
+
+/*  Write a block to output file, adding the header.
+
+    kind_in:    Header kind
+    len:        Block length
+    data:       Block data
+
+     0:     Write success
+    <0:     Write error (message printed)
+*/
+static inline
+int fx_write_block(const FX_STATE state, const fx_kind_t kind_in, 
+                   const uint32_t len, const void* data){
+
+    const uint16_t kind = kind_in;
+    u8 head[] = {'L','Z','F','X',   0, 0,   0, 0, 0, 0};
+
+    head[4] = kind >> 8; head[5] = kind;
+    head[6] = len >> 24; head[7] =  len >> 16;
+    head[8] = len >> 8; head[9] = len;
+
+    if(fx_write_bytes(state, head, 10) < 0) return -1;
+    if(fx_write_bytes(state, data, len) < 0) return -1;
+
+    return 0;
+}
+
+/*  Decompress a block (KIND_COMPRESSED) to the output file.
+
+    ibuf:   The block (including 4-byte leader)
+    len:    Total block length
+
+     0:  Success
+    <0:  Error (message printed)
+*/
+static
+int fx_decompress_block(const FX_STATE state, const u8 *ibuf, const size_t len){
+
+    static u8* obuf;
+    static size_t obuf_len;
+
+    uint32_t usize;
+    unsigned int usize_real;
+    int rc;
+
+    if(len<4){
+        fprintf(stderr, "Compressed size truncated\n");
+        return -2;
+    }
+
+    usize = (ibuf[0]<<24) | (ibuf[1]<<16) | (ibuf[2]<<8) | ibuf[3];
+
+    if(usize>obuf_len){
+        obuf = (u8*)realloc(obuf, usize);
+        if(obuf==NULL) return -1;  /* This leaks but we quit right away */
+        obuf_len = usize;
+    }
+    
+    usize_real = usize;
+
+    rc = lzfx_decompress(ibuf+4, len-4, obuf, &usize_real);
+    if(rc<0){
+        fprintf(stderr, "Decompression failed: code %d\n", rc);
+        return -2;
+    }
+    if(usize_real != usize){
+        fprintf(stderr, "Decompressed data has wrong length (%d vs expected %d)\n", (int)usize_real, (int)usize);
+        return -2;
+    }
+
+    rc = fx_write_bytes(state, obuf, usize);
+    if(rc<0) return -1;
+
+    return 0;
+}
+
+static inline
+int mem_resize(u8** buf, size_t *ilen, const size_t olen){
+    void* tbuf;
+    if(olen>*ilen){
+        tbuf = realloc(*buf, olen);
+        if(tbuf==NULL){
+            fprintf(stderr, "Can't allocate memory (%lu bytes)\n", (unsigned long)olen);
+            return -1;
+        }
+        *buf = tbuf;
+        *ilen = olen;
+    }
+    return 0;
+}
+
+/* Compress a block of raw data and store it in the output file.
+
+    ibuf:   Raw data block to compress
+    ilen:   Length of data block
+
+    0:  Success
+    <0: Error (message printed)
+*/
+static
+int fx_compress_block(const FX_STATE state, const u8* ibuf,
+                      const uint32_t ilen){
+
+    static u8* obuf;
+    static size_t obuf_len;
+
+    unsigned int compressed_len;
+    int rc;
+
+    if(ilen<=4){
+        rc = fx_write_block(state, KIND_UNCOMPRESSED, ilen, ibuf);
+        return rc<0 ? -1 : 0;
+    }
+
+    rc = mem_resize(&obuf, &obuf_len, ilen);
+    if(rc<0) return -1;
+
+    /* 4-byte space to store the usize */
+    compressed_len = ilen - 4; 
+
+    rc = lzfx_compress(ibuf, ilen, obuf+4, &compressed_len);
+    if(rc<0 && rc != LZFX_ESIZE){
+        fprintf(stderr, "Compression error (code %d)\n", rc);
+        return -1;
+    }
+
+    if(rc == LZFX_ESIZE || !compressed_len){
+
+        rc = fx_write_block(state, KIND_UNCOMPRESSED, ilen, ibuf);
+        if(rc<0) return -1;
+    
+    } else {
+        
+        obuf[0] = ilen >> 24;
+        obuf[1] = ilen >> 16;
+        obuf[2] = ilen >> 8;
+        obuf[3] = ilen;
+
+        rc = fx_write_block(state, KIND_COMPRESSED, compressed_len+4, obuf);
+        if(rc<0) return -1;
+    }
+
+    return 0;
+}
+
+
+/*  Compress from input to output file.
+
+    0:  Success
+    <0: Failure (message printed)
+*/
+int fx_create(const FX_STATE state){
+
+    unsigned long blockno = 0;
+    ssize_t rc = 0;
+    size_t count = 0;
+    u8* ibuf = (u8*)malloc(BLOCKSIZE);
+
+    do {
+        rc = 0;
+        count = 0;
+        do {
+            rc = read(state.ifd, ibuf, BLOCKSIZE-count);
+            if(rc<0){
+                fprintf(stderr, "Read error: %s\n", strerror(rc));
+                goto failed;
+            }
+            count += rc;
+        } while(rc > 0 && count < BLOCKSIZE);
+
+        blockno++;
+
+        if(count>0){
+            rc = fx_compress_block(state, ibuf, count);
+            if(rc<0) goto failed;
+        }
+
+    } while(count==BLOCKSIZE);
+
+    free(ibuf);
+    return 0;
+
+failed:
+    fprintf(stderr, "Compression failed at byte %lu\n", blockno*BLOCKSIZE + count);
+    free(ibuf);
+    return -1;
+}
+
+/*  Read an LZFX file
+
+    0: success
+    <0: Failure (message printed)
+*/
+int fx_read(const FX_STATE state){
+
+    int rc;
+    fx_kind_t kind = 0;
+    uint32_t blocksize = 0;
+
+    static u8* ibuf;
+    static size_t ilen;
+
+    while(1){
+        rc = fx_read_header(state, &kind, &blocksize);
+        if(rc==0) break; /* EOF */
+        if(rc<0) return -1;
+        if(blocksize==0) continue;
+
+        switch(kind){
+        
+        case KIND_UNCOMPRESSED:
+            rc = mem_resize(&ibuf, &ilen, blocksize);
+            if(rc<0) return -1;
+
+            rc = fx_read_bytes(state, ibuf, blocksize);
+            if(rc<0) return -1;
+            if(rc==0){
+                fprintf(stderr, "EOF after block header (tried to read %d bytes)\n", blocksize);
+                return -1;
+            }
+
+            rc = fx_write_bytes(state, ibuf, blocksize);
+            if(rc<0) return -1;
+            break;
+
+        case KIND_COMPRESSED:
+            rc = mem_resize(&ibuf, &ilen, blocksize);
+            if(rc<0) return -1;
+
+            rc = fx_read_bytes(state, ibuf, blocksize);
+            if(rc<0) return -1;
+            if(rc==0){
+                fprintf(stderr, "EOF after block header\n");
+                return -1;
+            }
+            rc = fx_decompress_block(state, ibuf, blocksize);
+            if(rc<0) return -1;
+            break;
+
+        default:
+            rc = fx_skip_bytes(state, blocksize);
+            if(rc<0) return -1;
+        }
+    }
+    return 0;
+}
+
+int main(int argc, char* argv[]){
+
+    int rc;
+    int ifd, ofd;
+    fx_mode_t mode;
+    FX_STATE state;
+
+    fprintf(stderr, "LZFX compression utility 0.1\n"
+                    "http://lzfx.googlecode.com\n"
+                    "*********************************\n"
+                    "  THIS IS A DEVELOPMENT RELEASE\n"
+                    "  DO NOT USE ON CRITICAL DATA\n"
+                    "*********************************\n");
+    
+    if(argc!=4){
+        fprintf(stderr, "Syntax is lzfx <namein> <nameout> c|d\n");
+        return 1;
+    }
+
+    ifd = open(argv[1], O_RDONLY);
+    if(ifd<0){
+        fprintf(stderr, "Can't open input file\n");
+        return 1;
+    }
+
+    ofd = open(argv[2], O_CREAT | O_WRONLY | O_TRUNC, 0644);
+    if(ofd<0){
+        fprintf(stderr, "Can't open output file for write\n");
+        return 1;
+    }
+
+    if(!strcmp(argv[3], "c")){
+        mode = MODE_COMPRESS;
+    } else if(!strcmp(argv[3], "d")){
+        mode = MODE_DECOMPRESS;
+    } else {
+        fprintf(stderr, "Illegal mode (must be 'c' or 'd')\n");
+        return 1;
+    }
+
+    fx_init(&state, ifd, ofd, mode);
+
+    switch(mode){
+        case MODE_COMPRESS:
+            rc = fx_create(state);
+            break;
+        case MODE_DECOMPRESS:
+            rc = fx_read(state);
+            break;
+    }
+
+    return rc ? 1 : 0;
+}
+

data/ext/lzfx.c

@@ -0,0 +1,366 @@
+/*
+ * Copyright (c) 2009 Andrew Collette <andrew.collette at gmail.com>
+ * http://lzfx.googlecode.com
+ *
+ * Implements an LZF-compatible compressor/decompressor based on the liblzf
+ * codebase written by Marc Lehmann.  This code is released under the BSD
+ * license.  License and original copyright statement follow.
+ *
+ * 
+ * Copyright (c) 2000-2008 Marc Alexander Lehmann <schmorp@schmorp.de>
+ * 
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ * 
+ *   1.  Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ * 
+ *   2.  Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
+ * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "lzfx.h"
+
+#define LZFX_HSIZE (1 << (LZFX_HLOG))
+
+/* We need this for memset */
+#ifdef __cplusplus
+# include <cstring>
+#else
+# include <string.h>
+#endif
+
+#if __GNUC__ >= 3 && !DISABLE_EXPECT
+# define fx_expect_false(expr)  __builtin_expect((expr) != 0, 0)
+# define fx_expect_true(expr)   __builtin_expect((expr) != 0, 1)
+#else
+# define fx_expect_false(expr)  (expr)
+# define fx_expect_true(expr)   (expr)
+#endif
+
+typedef unsigned char u8;
+typedef const u8 *LZSTATE[LZFX_HSIZE];
+
+/* Define the hash function */
+#define LZFX_FRST(p)     (((p[0]) << 8) | p[1])
+#define LZFX_NEXT(v,p)   (((v) << 8) | p[2])
+#define LZFX_IDX(h)      ((( h >> (3*8 - LZFX_HLOG)) - h  ) & (LZFX_HSIZE - 1))
+
+/* These cannot be changed, as they are related to the compressed format. */
+#define LZFX_MAX_LIT        (1 <<  5)
+#define LZFX_MAX_OFF        (1 << 13)
+#define LZFX_MAX_REF        ((1 << 8) + (1 << 3))
+
+static
+int lzfx_getsize(const void* ibuf, unsigned int ilen, unsigned int *olen);
+
+/* Compressed format
+
+    There are two kinds of structures in LZF/LZFX: literal runs and back
+    references. The length of a literal run is encoded as L - 1, as it must
+    contain at least one byte.  Literals are encoded as follows:
+
+    000LLLLL <L+1 bytes>
+
+    Back references are encoded as follows.  The smallest possible encoded
+    length value is 1, as otherwise the control byte would be recognized as
+    a literal run.  Since at least three bytes must match for a back reference
+    to be inserted, the length is encoded as L - 2 instead of L - 1.  The
+    offset (distance to the desired data in the output buffer) is encoded as
+    o - 1, as all offsets are at least 1.  The binary format is:
+
+    LLLooooo oooooooo           for backrefs of real length < 9   (1 <= L < 7)
+    111ooooo LLLLLLLL oooooooo  for backrefs of real length >= 9  (L > 7)  
+*/
+#include <stdio.h>
+int lzfx_compress(const void *const ibuf, const unsigned int ilen,
+                              void *obuf, unsigned int *const olen){
+
+    /* Hash table; an array of u8*'s which point
+       to various locations in the input buffer */
+    const u8 *htab[LZFX_HSIZE];
+
+    const u8 **hslot;       /* Pointer to entry in hash table */
+    unsigned int hval;      /* Hash value generated by macros above */
+    const u8 *ref;          /* Pointer to candidate match location in input */
+
+    const u8 *ip = (const u8 *)ibuf;
+    const u8 *const in_end = ip + ilen;
+
+    u8 *op = (u8 *)obuf;
+    const u8 *const out_end = (olen == NULL ? NULL : op + *olen);
+
+    int lit;    /* # of bytes in current literal run */
+
+#if defined (WIN32) && defined (_M_X64)
+    unsigned _int64 off; /* workaround for missing POSIX compliance */
+#else
+    unsigned long off;
+#endif
+
+    if(olen == NULL) return LZFX_EARGS;
+    if(ibuf == NULL){
+        if(ilen != 0) return LZFX_EARGS;
+        *olen = 0;
+        return 0;
+    }
+    if(obuf == NULL){
+        if(olen != 0) return LZFX_EARGS;
+        return lzfx_getsize(ibuf, ilen, olen);
+    }
+
+    memset(htab, 0, sizeof(htab));
+
+    /*  Start a literal run.  Whenever we do this the output pointer is
+        advanced because the current byte will hold the encoded length. */
+    lit = 0; op++;
+
+    hval = LZFX_FRST(ip);
+
+    while(ip + 2 < in_end){   /* The NEXT macro reads 2 bytes ahead */
+
+        hval = LZFX_NEXT(hval, ip);
+        hslot = htab + LZFX_IDX(hval);
+
+        ref = *hslot; *hslot = ip;
+
+        if( ref < ip
+        &&  (off = ip - ref - 1) < LZFX_MAX_OFF
+        &&  ip + 4 < in_end  /* Backref takes up to 3 bytes, so don't bother */
+        &&  ref > (u8 *)ibuf
+        &&  ref[0] == ip[0]
+        &&  ref[1] == ip[1]
+        &&  ref[2] == ip[2] ) {
+
+            unsigned int len = 3;   /* We already know 3 bytes match */
+            const unsigned int maxlen = in_end - ip - 2 > LZFX_MAX_REF ?
+                                        LZFX_MAX_REF : in_end - ip - 2;
+
+            /* lit == 0:  op + 3 must be < out_end (because we undo the run)
+               lit != 0:  op + 3 + 1 must be < out_end */
+            if(fx_expect_false(op - !lit + 3 + 1 >= out_end))
+                return LZFX_ESIZE;
+            
+            op [- lit - 1] = lit - 1; /* Terminate literal run */
+            op -= !lit;               /* Undo run if length is zero */
+
+            /*  Start checking at the fourth byte */
+            while (len < maxlen && ref[len] == ip[len])
+                len++;
+
+            len -= 2;  /* We encode the length as #octets - 2 */
+
+            /* Format 1: [LLLooooo oooooooo] */
+            if (len < 7) {
+              *op++ = (off >> 8) + (len << 5);
+              *op++ = off;
+
+            /* Format 2: [111ooooo LLLLLLLL oooooooo] */
+            } else {
+              *op++ = (off >> 8) + (7 << 5);
+              *op++ = len - 7;
+              *op++ = off;
+            }
+
+            lit = 0; op++;
+
+            ip += len + 1;  /* ip = initial ip + #octets -1 */
+
+            if (fx_expect_false (ip + 3 >= in_end)){
+                ip++;   /* Code following expects exit at bottom of loop */
+                break;
+            }
+
+            hval = LZFX_FRST (ip);
+            hval = LZFX_NEXT (hval, ip);
+            htab[LZFX_IDX (hval)] = ip;
+
+            ip++;   /* ip = initial ip + #octets */
+
+        } else {
+              /* Keep copying literal bytes */
+
+              if (fx_expect_false (op >= out_end)) return LZFX_ESIZE;
+
+              lit++; *op++ = *ip++;
+
+              if (fx_expect_false (lit == LZFX_MAX_LIT)) {
+                  op [- lit - 1] = lit - 1; /* stop run */
+                  lit = 0; op++; /* start run */
+              }
+
+        } /* if() found match in htab */
+
+    } /* while(ip < ilen -2) */
+
+    /*  At most 3 bytes remain in input.  We therefore need 4 bytes available
+        in the output buffer to store them (3 data + ctrl byte).*/
+    if (op + 3 > out_end) return LZFX_ESIZE;
+
+    while (ip < in_end) {
+
+        lit++; *op++ = *ip++;
+
+        if (fx_expect_false (lit == LZFX_MAX_LIT)){
+            op [- lit - 1] = lit - 1;
+            lit = 0; op++;
+        }
+    }
+
+    op [- lit - 1] = lit - 1;
+    op -= !lit;
+
+    *olen = op - (u8 *)obuf;
+    return 0;
+}
+
+/* Decompressor */
+int lzfx_decompress(const void* ibuf, unsigned int ilen,
+                          void* obuf, unsigned int *olen){
+
+    u8 const *ip = (const u8 *)ibuf;
+    u8 const *const in_end = ip + ilen;
+    u8 *op = (u8 *)obuf;
+    u8 const *const out_end = (olen == NULL ? NULL : op + *olen);
+    
+    unsigned int remain_len = 0;
+    int rc;
+
+    if(olen == NULL) return LZFX_EARGS;
+    if(ibuf == NULL){
+        if(ilen != 0) return LZFX_EARGS;
+        *olen = 0;
+        return 0;
+    }
+    if(obuf == NULL){
+        if(olen != 0) return LZFX_EARGS;
+        return lzfx_getsize(ibuf, ilen, olen);
+    }
+
+    do {
+        unsigned int ctrl = *ip++;
+
+        /* Format 000LLLLL: a literal byte string follows, of length L+1 */
+        if(ctrl < (1 << 5)) {
+
+            ctrl++;
+
+            if(fx_expect_false(op + ctrl > out_end)){
+                --ip;       /* Rewind to control byte */
+                goto guess;
+            }
+            if(fx_expect_false(ip + ctrl > in_end)) return LZFX_ECORRUPT;
+
+            do
+                *op++ = *ip++;
+            while(--ctrl);
+
+        /*  Format #1 [LLLooooo oooooooo]: backref of length L+1+2
+                          ^^^^^ ^^^^^^^^
+                            A      B
+                   #2 [111ooooo LLLLLLLL oooooooo] backref of length L+7+2
+                          ^^^^^          ^^^^^^^^
+                            A               B
+            In both cases the location of the backref is computed from the
+            remaining part of the data as follows:
+
+                location = op - A*256 - B - 1
+        */
+        } else {
+
+            unsigned int len = (ctrl >> 5);
+            u8 *ref = op - ((ctrl & 0x1f) << 8) -1;
+
+            if(len==7) len += *ip++;    /* i.e. format #2 */
+
+            len += 2;    /* len is now #octets */
+
+            if(fx_expect_false(op + len > out_end)){
+                ip -= (len >= 9) ? 2 : 1;   /* Rewind to control byte */
+                goto guess;
+            }
+            if(fx_expect_false(ip >= in_end)) return LZFX_ECORRUPT;
+
+            ref -= *ip++;
+
+            if(fx_expect_false(ref < (u8*)obuf)) return LZFX_ECORRUPT;
+
+            do
+                *op++ = *ref++;
+            while (--len);
+        }
+
+    } while (ip < in_end);
+
+    *olen = op - (u8 *)obuf;
+
+    return 0;
+
+guess:
+    rc = lzfx_getsize(ip, ilen - (ip-(u8*)ibuf), &remain_len);
+    if(rc>=0) *olen = remain_len + (op - (u8*)obuf);
+    return rc;
+}
+
+/* Guess len. No parameters may be NULL; this is not checked. */
+static
+int lzfx_getsize(const void* ibuf, unsigned int ilen, unsigned int *olen){
+
+    u8 const *ip = (const u8 *)ibuf;
+    u8 const *const in_end = ip + ilen;
+    int tot_len = 0;
+    
+    while (ip < in_end) {
+
+        unsigned int ctrl = *ip++;
+
+        if(ctrl < (1 << 5)) {
+
+            ctrl++;
+
+            if(ip + ctrl > in_end)
+                return LZFX_ECORRUPT;
+
+            tot_len += ctrl;
+            ip += ctrl;
+
+        } else {
+
+            unsigned int len = (ctrl >> 5);
+
+            if(len==7){     /* i.e. format #2 */
+                len += *ip++;
+            }
+
+            len += 2;    /* len is now #octets */
+
+            if(ip >= in_end) return LZFX_ECORRUPT;
+
+            ip++; /* skip the ref byte */
+
+            tot_len += len;
+
+        }
+
+    }
+
+    *olen = tot_len;
+
+    return 0;
+}
+
+
+
+

data/ext/lzfx.h

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2009 Andrew Collette <andrew.collette at gmail.com>
+ * http://lzfx.googlecode.com
+ *
+ * Implements an LZF-compatible compressor/decompressor based on the liblzf
+ * codebase written by Marc Lehmann.  This code is released under the BSD
+ * license.  License and original copyright statement follow.
+ *
+ * 
+ * Copyright (c) 2000-2008 Marc Alexander Lehmann <schmorp@schmorp.de>
+ * 
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ * 
+ *   1.  Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ * 
+ *   2.  Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
+ * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef LZFX_H
+#define LZFX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*  Documented behavior, including function signatures and error codes,
+    is guaranteed to remain unchanged for releases with the same major
+    version number.  Releases of the same major version are also able
+    to read each other's output, although the output itself is not
+    guaranteed to be byte-for-byte identical.
+*/
+#define LZFX_VERSION_MAJOR      0
+#define LZFX_VERSION_MINOR      1
+#define LZFX_VERSION_STRING     "0.1"
+
+/* Hashtable size (2**LZFX_HLOG entries) */
+#ifndef LZFX_HLOG
+# define LZFX_HLOG 16
+#endif
+
+/* Predefined errors. */
+#define LZFX_ESIZE      -1      /* Output buffer too small */
+#define LZFX_ECORRUPT   -2      /* Invalid data for decompression */
+#define LZFX_EARGS      -3      /* Arguments invalid (NULL) */
+
+/*  Buffer-to buffer compression.
+
+    Supply pre-allocated input and output buffers via ibuf and obuf, and
+    their size in bytes via ilen and olen.  Buffers may not overlap.
+
+    On success, the function returns a non-negative value and the argument
+    olen contains the compressed size in bytes.  On failure, a negative
+    value is returned and olen is not modified.
+*/
+int lzfx_compress(const void* ibuf, unsigned int ilen,
+                        void* obuf, unsigned int *olen);
+
+/*  Buffer-to-buffer decompression.
+
+    Supply pre-allocated input and output buffers via ibuf and obuf, and
+    their size in bytes via ilen and olen.  Buffers may not overlap.
+
+    On success, the function returns a non-negative value and the argument
+    olen contains the uncompressed size in bytes.  On failure, a negative
+    value is returned.
+
+    If the failure code is LZFX_ESIZE, olen contains the minimum buffer size
+    required to hold the decompressed data.  Otherwise, olen is not modified.
+
+    Supplying a zero *olen is a valid and supported strategy to determine the
+    required buffer size.  This does not require decompression of the entire
+    stream and is consequently very fast.  Argument obuf may be NULL in
+    this case only.
+*/
+int lzfx_decompress(const void* ibuf, unsigned int ilen,
+                          void* obuf, unsigned int *olen);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

data/ext/lzfxruby.c

@@ -0,0 +1,73 @@
+#include <string.h>
+#include "ruby.h"
+#define COFFICIENT_OF_BUFFER 3
+
+static VALUE rb_lzfx_compress(VALUE self, VALUE input) {
+  unsigned char *compressed, *data;
+  int out_length, data_length;
+  int retcode;
+  VALUE retval;
+
+  Check_Type(input, T_STRING);
+  data = StringValuePtr(input);
+  data_length = RSTRING_LEN(input);
+
+  if (data_length < 1) {
+    return Qnil;
+  }
+
+  out_length = data_length * COFFICIENT_OF_BUFFER;
+  compressed = malloc(out_length);
+
+  retcode = lzfx_compress(data, data_length, compressed, &out_length);
+
+  if(retcode < 0) {
+    ruby_xfree(compressed);
+    return Qnil;
+  }
+
+  retval = rb_str_new(compressed, out_length);
+
+  ruby_xfree(compressed);
+
+  return retval;
+}
+
+static VALUE rb_lzfx_decompress(VALUE self, VALUE input) {
+  unsigned char *decompressed, *data;
+  int out_length, data_length;
+  int retcode;
+  VALUE retval;
+
+  Check_Type(input, T_STRING);
+
+  data = RSTRING_PTR(input);
+  data_length = RSTRING_LEN(input);
+
+  if (data_length < 1) {
+    return Qnil;
+  }
+
+  out_length = data_length * COFFICIENT_OF_BUFFER;
+  decompressed = malloc(out_length);
+
+  retcode = lzfx_decompress(data, data_length, decompressed, &out_length);
+
+  if(retcode < 0) {
+    ruby_xfree(decompressed);
+    return Qnil;
+  }
+
+  retval = rb_str_new(decompressed, out_length);
+
+  ruby_xfree(decompressed);
+
+  return retval;
+}
+
+void Init_lzfx() {
+  VALUE rb_mLzfx;
+  rb_mLzfx = rb_define_module("Lzfx");
+  rb_define_module_function(rb_mLzfx, "compress", rb_lzfx_compress, 1);
+  rb_define_module_function(rb_mLzfx, "decompress", rb_lzfx_decompress, 1);
+}

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: lzfx
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- hmsk
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-06 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: Ruby bindings for lzfx. lzfx is a tiny, extremely fast compression library.
+email: k.hamasaki@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README.md
+files: 
+- ext/lzfx-util.c
+- ext/lzfx.c
+- ext/lzfxruby.c
+- ext/lzfx.h
+- ext/extconf.rb
+- README.md
+has_rdoc: true
+homepage: https://github.com/winebarrel/infra-study/tree/master/4th/gems/lzfx
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- lzfx - Ruby bindings for lzfx.
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Ruby bindings for lzfx.
+test_files: []
+